From 8e6986c561803a89fcee41e34fdcc00dd0899a7d Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:17:51 -0700 Subject: [PATCH 1/7] Add the zero-cost gate scripts/zero-cost-gate.mjs compiles a fixed good-code set (the runtime benchmark workloads, the self-hosted compiler, and the TypeScript corpus) with a baseline and a candidate checkout. It requires byte-identical IR, LLVM and release executables, and names the first differing IR function, LLVM function or executable symbol when something changes. Programs that match the change's pattern signature (--allow) may differ. It also checks compile time (paired builds, bootstrap interval), binary size, optional per-function cachegrind instruction counts, and the two-tier I3 symbol rule: no executable gains dynamic-tier runtime symbols, and fully typed benchmark workloads define none. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 6 + scripts/zero-cost-compare.mjs | 475 ++++++++++++++++++++ scripts/zero-cost-gate.mjs | 647 +++++++++++++++++++++++++++ tests/harness/zero-cost-gate.test.ts | 145 ++++++ 4 files changed, 1273 insertions(+) create mode 100644 scripts/zero-cost-compare.mjs create mode 100644 scripts/zero-cost-gate.mjs create mode 100644 tests/harness/zero-cost-gate.test.ts diff --git a/AGENTS.md b/AGENTS.md index 4d66cb42f..16f90d68e 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -48,6 +48,12 @@ Corpus programs are differential tests against Node: every program runs under No Before opening a PR that adds or changes corpus, diagnostic, or frontend fixtures, run `pnpm test:ts7 --baselines-only`. This fast completeness check uses the same fixture discovery as the parity suite; it does not type-check or replace behavioral parity. Generate missing preflight/order baselines, review their diagnostics and module order, and run the affected `order-parity.test.ts` batches before pushing. Keep existing baseline entries unchanged unless the corresponding behavior intentionally changes. The full `pnpm test:ts7` command also checks completeness before starting its sweep. +A change that must not cost good code anything, such as a compatibility fix that replaces a refusal, proves it with the zero-cost gate. The gate compiles the benchmark workloads, the self-hosted compiler, and the TypeScript corpus with two built checkouts. It requires byte-identical IR, LLVM, and release executables, and compile time within tolerance. `--allow=` names the change's pattern signature: programs whose sources match may differ, and the PR lists them. Any other difference fails the gate, which names the first differing function. `--quick` checks only the benchmarks; `--cachegrind` adds per-function instruction counts for executables that differ. Run it in a Sandbox with both checkouts prepared: + +```bash +node scripts/zero-cost-gate.mjs --baseline=/vercel/sandbox/prev --candidate=. --allow='\barguments\b' +``` + Test location follows scope: - Co-locate white-box unit tests with implementation files under diff --git a/scripts/zero-cost-compare.mjs b/scripts/zero-cost-compare.mjs new file mode 100644 index 000000000..5367c2957 --- /dev/null +++ b/scripts/zero-cost-compare.mjs @@ -0,0 +1,475 @@ +/* Comparison logic for scripts/zero-cost-gate.mjs, kept free of process + * orchestration so tests/harness/zero-cost-gate.test.ts can pin it. + * + * Artifacts are compared as bytes first. Only when they differ are they split + * into named units (IR functions, LLVM functions, executable symbols) to name + * the first unit that differs. The self-hosted compiler's IR and LLVM exceed + * V8's maximum string length, so splitting works on Buffers and hashes each + * unit instead of decoding the artifact. */ +import { createHash } from "node:crypto"; + +const hash = (bytes) => createHash("sha1").update(bytes).digest("hex"); + +/** Named units of an artifact: `order` lists unit keys in artifact order, + * `hashes` maps each key to a content hash, and `module` holds the + * module-level remainder (IR header, LLVM globals and declarations) as a list + * of comparable pieces with their labels. Repeated names get `#n` suffixes. */ +function unitsBuilder() { + const order = []; + const hashes = new Map(); + const seen = new Map(); + return { + order, + hashes, + module: [], + add(name, bytes) { + const count = seen.get(name) ?? 0; + seen.set(name, count + 1); + const key = count === 0 ? name : `${name}#${count + 1}`; + order.push(key); + hashes.set(key, hash(bytes)); + }, + }; +} + +/* ── IR (compact or readable JSON) ─────────────────────────────────────── */ + +function skipString(bytes, index) { + for (index++; index < bytes.length; index++) { + if (bytes[index] === 0x5c) index++; + else if (bytes[index] === 0x22) return index + 1; + } + return bytes.length; +} + +/** Byte ranges of the root object's `"functions"` array elements, or null. */ +export function irFunctionSpans(bytes) { + const key = Buffer.from('"functions"'); + let depth = 0; + for (let index = 0; index < bytes.length;) { + const byte = bytes[index]; + if (byte === 0x22) { + const end = skipString(bytes, index); + if (depth === 1 && end - index === key.length && bytes.subarray(index, end).equals(key)) { + let next = end; + while (next < bytes.length && bytes[next] !== 0x3a) next++; + next++; + while (next < bytes.length && bytes[next] !== 0x5b && bytes[next] <= 0x20) next++; + if (bytes[next] === 0x5b) return elementSpans(bytes, next); + } + index = end; + continue; + } + if (byte === 0x7b || byte === 0x5b) depth++; + else if (byte === 0x7d || byte === 0x5d) depth--; + index++; + } + return null; +} + +function elementSpans(bytes, open) { + const spans = []; + let depth = 0; + let start = -1; + for (let index = open + 1; index < bytes.length;) { + const byte = bytes[index]; + if (byte === 0x22) { + if (start < 0) start = index; + index = skipString(bytes, index); + continue; + } + if (byte === 0x7b || byte === 0x5b) { + if (start < 0) start = index; + depth++; + } else if (byte === 0x7d || byte === 0x5d) { + if (depth === 0) { + if (start >= 0) spans.push([start, trimEnd(bytes, index)]); + return { open, close: index, spans }; + } + depth--; + } else if (byte === 0x2c && depth === 0) { + spans.push([start, trimEnd(bytes, index)]); + start = -1; + } else if (start < 0 && byte > 0x20) start = index; + index++; + } + return null; +} + +function trimEnd(bytes, end) { + while (end > 0 && bytes[end - 1] <= 0x20) end--; + return end; +} + +/** The `name` of one serialized IR function. Functions serialize `name` + * first; anything else is parsed (a single function is small). */ +function irFunctionName(bytes, [start, end]) { + const head = bytes.toString("utf8", start, Math.min(end, start + 4096)); + const match = /^\{\s*"name"\s*:\s*("(?:[^"\\]|\\.)*")/.exec(head); + if (match) return JSON.parse(match[1]); + const fn = JSON.parse(bytes.toString("utf8", start, end)); + return typeof fn?.name === "string" ? fn.name : ""; +} + +/** IR units: one per function, plus the module header split by top-level + * key (and, for arrays, by element) so header differences are named too. */ +export function irUnits(bytes) { + const units = unitsBuilder(); + const located = irFunctionSpans(bytes); + let header; + if (located === null) header = JSON.parse(bytes.toString("utf8")); + else { + for (const span of located.spans) + units.add(irFunctionName(bytes, span), bytes.subarray(span[0], span[1])); + header = JSON.parse( + bytes.toString("utf8", 0, located.open + 1) + bytes.toString("utf8", located.close), + ); + } + for (const [key, value] of Object.entries(header)) { + if (key === "functions" && located !== null) continue; + if (Array.isArray(value)) + value.forEach((item, index) => { + const name = item && typeof item === "object" && "name" in item ? `:${item.name}` : ""; + units.module.push({ label: `${key}[${index}${name}]`, text: JSON.stringify(item) }); + }); + else units.module.push({ label: key, text: JSON.stringify(value) }); + } + return units; +} + +/* ── LLVM text ─────────────────────────────────────────────────────────── */ + +const DEFINE_NAME = /@("(?:[^"\\]|\\.)*"|[-\w$.]+)\s*\(/; + +/** LLVM units: one per `define … { … }` body; every other line is + * module-level text compared line by line. */ +export function llvmUnits(bytes) { + const units = unitsBuilder(); + let fnStart = -1; + let fnName = ""; + let lineNumber = 0; + for (let start = 0; start < bytes.length;) { + let end = bytes.indexOf(10, start); + if (end < 0) end = bytes.length; + lineNumber++; + if (fnStart >= 0) { + if (end - start === 1 && bytes[start] === 0x7d) { + units.add(fnName, bytes.subarray(fnStart, end)); + fnStart = -1; + } + } else if (bytes[start] === 0x64 && bytes.toString("latin1", start, start + 7) === "define ") { + const line = bytes.toString("utf8", start, end); + fnName = DEFINE_NAME.exec(line)?.[1] ?? ``; + fnStart = start; + if (line.endsWith("}")) { + units.add(fnName, bytes.subarray(fnStart, end)); + fnStart = -1; + } + } else if (end > start) { + units.module.push({ label: `line ${lineNumber}`, text: bytes.toString("utf8", start, end) }); + } + start = end + 1; + } + return units; +} + +/* ── unit comparison ───────────────────────────────────────────────────── */ + +const clip = (text, width = 160) => (text.length > width ? `${text.slice(0, width)}…` : text); + +/** Compare two unit sets. `first` names the first difference in baseline + * order: a changed or removed function, then an added one, then the first + * differing module-level piece. */ +export function compareUnits(baseline, candidate) { + const changed = []; + const removed = []; + for (const key of baseline.order) { + const other = candidate.hashes.get(key); + if (other === undefined) removed.push(key); + else if (other !== baseline.hashes.get(key)) changed.push(key); + } + const added = candidate.order.filter((key) => !baseline.hashes.has(key)); + let module = null; + const count = Math.max(baseline.module.length, candidate.module.length); + for (let index = 0; index < count && module === null; index++) { + const a = baseline.module[index]; + const b = candidate.module[index]; + if (a?.text !== b?.text) + module = { + label: (a ?? b).label, + baseline: a === undefined ? null : clip(a.text), + candidate: b === undefined ? null : clip(b.text), + }; + } + const firstFunction = baseline.order.find( + (key) => !candidate.hashes.has(key) || candidate.hashes.get(key) !== baseline.hashes.get(key), + ); + let first = null; + if (firstFunction !== undefined) + first = `${changed.includes(firstFunction) ? "changed" : "removed"} ${firstFunction}`; + else if (added.length > 0) first = `added ${added[0]}`; + else if (module !== null) first = `module ${module.label}`; + else if (baseline.order.join("\n") !== candidate.order.join("\n")) first = "function order"; + return { + identical: first === null, + first, + changed, + added, + removed, + module, + functions: { baseline: baseline.order.length, candidate: candidate.order.length }, + }; +} + +/** Byte-compare an artifact and, when it differs, name what changed. */ +export function compareArtifact(kind, baseline, candidate) { + if (baseline.equals(candidate)) return { identical: true }; + const split = kind === "ir" ? irUnits : llvmUnits; + const result = compareUnits(split(baseline), split(candidate)); + // Equal units with unequal bytes means formatting outside the units. + return { ...result, identical: false, first: result.first ?? "bytes outside named units" }; +} + +/* ── executables ───────────────────────────────────────────────────────── */ + +/** Defined symbols from `nm -S` output (GNU/LLVM nm, address size type + * name) or `nm` output without sizes (Apple, address type name). */ +export function parseNm(text) { + const symbols = []; + for (const line of text.split("\n")) { + const fields = line.trim().split(/\s+/); + if (fields.length === 4 && /^[0-9a-f]+$/i.test(fields[1])) + symbols.push({ + address: BigInt(`0x${fields[0]}`), + size: BigInt(`0x${fields[1]}`), + type: fields[2], + name: fields[3], + }); + else if (fields.length === 3 && /^[0-9a-f]+$/i.test(fields[0])) + symbols.push({ + address: BigInt(`0x${fields[0]}`), + size: null, + type: fields[1], + name: fields[2], + }); + } + return symbols; +} + +/** The virtual address of file offset `offset` in an ELF64 little-endian + * executable, from its PT_LOAD program headers, or null. */ +export function elfOffsetToAddress(bytes, offset) { + if (bytes.length < 64 || bytes.readUInt32BE(0) !== 0x7f454c46 || bytes[4] !== 2) return null; + const phoff = Number(bytes.readBigUInt64LE(0x20)); + const phentsize = bytes.readUInt16LE(0x36); + const phnum = bytes.readUInt16LE(0x38); + for (let index = 0; index < phnum; index++) { + const at = phoff + index * phentsize; + if (bytes.readUInt32LE(at) !== 1) continue; + const fileOffset = bytes.readBigUInt64LE(at + 8); + const address = bytes.readBigUInt64LE(at + 16); + const fileSize = bytes.readBigUInt64LE(at + 32); + const target = BigInt(offset); + if (target >= fileOffset && target < fileOffset + fileSize) + return address + (target - fileOffset); + } + return null; +} + +/** Name what differs between two executables: symbols added, removed or + * resized, then the symbol holding the first differing byte. */ +export function compareExecutables(baseline, candidate, baselineNm, candidateNm) { + if (baseline.equals(candidate)) return { identical: true }; + const before = new Map(parseNm(baselineNm).map((s) => [s.name, s])); + const after = new Map(parseNm(candidateNm).map((s) => [s.name, s])); + const removed = [...before.keys()].filter((name) => !after.has(name)); + const added = [...after.keys()].filter((name) => !before.has(name)); + const resized = [...before.values()] + .filter((s) => after.has(s.name) && s.size !== null && after.get(s.name).size !== s.size) + .map((s) => ({ + name: s.name, + baseline: Number(s.size), + candidate: Number(after.get(s.name).size), + })); + let offset = 0; + const limit = Math.min(baseline.length, candidate.length); + while (offset < limit && baseline[offset] === candidate[offset]) offset++; + const address = elfOffsetToAddress(baseline, offset); + let holder = null; + if (address !== null) + for (const s of before.values()) + if (s.size !== null && address >= s.address && address < s.address + s.size) holder = s.name; + const first = + resized[0] !== undefined + ? `resized ${resized[0].name}` + : removed[0] !== undefined + ? `removed ${removed[0]}` + : added[0] !== undefined + ? `added ${added[0]}` + : holder !== null + ? `bytes in ${holder}` + : `byte offset ${offset}`; + return { identical: false, first, offset, holder, added, removed, resized }; +} + +/* ── dynamic-tier symbols (two-tier design, invariant I3) ────────────────── */ + +/** Runtime symbol prefixes that belong to the dynamic tier: code a fully + * typed program has no reason to reach. A typed program's release binary + * must define none of them. Extend this list as dynamic-tier units land + * (S3/S4 add their scr_js_* families) and as legacy ScrDyn families move. + * The ScrDyn prefixes are the object-model entry points the two-tier audit + * (results/design-two-tier/DESIGN.md §3.2-3.3) lists as dynamic-only. */ +export const DYNAMIC_TIER_PREFIXES = [ + // Dynamic-tier runtime units (scr_js_value, scr_js_object, ...), from S3. + "scr_js_", + // ScrDyn property bags: reads, writes, lookup and key indexing. + "scr_dyn_obj_", + "scr_dyn_find_", + "scr_dyn_index_", + "scr_dyn_key_", + "sc_dyn_key_", + // Descriptors, own-property reflection, prototypes and proxies. + "scr_dyn_property_", + "scr_dyn_define_", + "scr_dyn_descriptor_", + "scr_dyn_own_", + "scr_dyn_get_own_", + "scr_dyn_prototype", + "scr_dyn_proxy_", + // Dynamic calls and the dynamic receiver read. + "scr_dyn_call", + "scr_dyn_apply", + "scr_dyn_invoke", + "scr_dyn_construct", + "scr_dyn_function_apply", + "scr_dyn_fn_get", + "scr_dyn_this_get", + // Dynamic operators and coercions. + "scr_dyn_add_", + "scr_dyn_arithmetic", + "scr_dyn_to_numeric", + "scr_dyn_number_coerce", + "scr_dyn_string_coerce", +]; + +/** Symbols under those prefixes that typed binaries reach today through a + * leak the two-tier design schedules for removal (S1). Remove an entry when + * its leak closes. */ +export const DYNAMIC_TIER_EXEMPT = new Map([ + // §3.3 L10: scr_dyn_release's dispose switch, linked whenever any dyn + // value can be released. + ["scr_dyn_obj_drop_keys", "L10"], +]); + +/** The dynamic-tier symbols among `names`, sorted. */ +export function dynamicTierSymbols(names) { + return [...new Set(names)] + .filter( + (name) => + DYNAMIC_TIER_PREFIXES.some((prefix) => name.startsWith(prefix)) && + !DYNAMIC_TIER_EXEMPT.has(name), + ) + .sort(); +} + +/* ── cachegrind ────────────────────────────────────────────────────────── */ + +/** Background threads whose instruction counts depend on scheduling: the + * allocator's prefault thread. */ +export const CACHEGRIND_EXCLUDED = new Set(["scr_sa_pf_main", "scr_sa_prefault"]); + +/** Per-function instruction counts (Ir) from a cachegrind output file, + * restricted to `keep` (the executable's own defined symbols). Dynamic + * linker and libc/pthread functions are outside `keep`; their counts vary + * run to run with lazy binding and thread wakeups. */ +export function cachegrindCounts(text, keep) { + const counts = new Map(); + let events = null; + let current = null; + for (const line of text.split("\n")) { + if (line.startsWith("events:")) events = line.slice(7).trim().split(/\s+/); + else if (line.startsWith("fn=")) { + const name = line.slice(3).trim(); + current = keep.has(name) && !CACHEGRIND_EXCLUDED.has(name) ? name : null; + } else if (line.startsWith("fl=") || line.startsWith("fi=") || line.startsWith("fe=")) continue; + else if (current !== null && /^\d/.test(line)) { + const fields = line.trim().split(/\s+/); + const column = events === null ? 0 : Math.max(0, events.indexOf("Ir")); + const ir = Number(fields[column + 1] ?? 0); + counts.set(current, (counts.get(current) ?? 0) + ir); + } + } + return counts; +} + +/** Per-function instruction-count deltas, largest absolute first. */ +export function compareCounts(baseline, candidate) { + const names = new Set([...baseline.keys(), ...candidate.keys()]); + const deltas = []; + let totalBaseline = 0; + let totalCandidate = 0; + for (const name of names) { + const a = baseline.get(name) ?? 0; + const b = candidate.get(name) ?? 0; + totalBaseline += a; + totalCandidate += b; + if (a !== b) deltas.push({ name, baseline: a, candidate: b, delta: b - a }); + } + deltas.sort((x, y) => Math.abs(y.delta) - Math.abs(x.delta) || (x.name < y.name ? -1 : 1)); + return { + identical: deltas.length === 0, + total: { baseline: totalBaseline, candidate: totalCandidate }, + deltas, + }; +} + +/* ── verdicts ──────────────────────────────────────────────────────────── */ + +/** One program's verdict from its build results and artifact comparisons. + * `allowed` marks programs that match the change's pattern signature. */ +export function programVerdict({ baseline, candidate, artifacts, allowed }) { + if (!baseline.ok || !candidate.ok) { + if (!baseline.ok && !candidate.ok && baseline.error === candidate.error) + return { verdict: "both-fail", fails: false }; + return { verdict: "build-error", fails: true }; + } + const differing = Object.entries(artifacts).filter(([, r]) => !r.identical); + if (differing.length === 0) return { verdict: "identical", fails: false }; + return allowed ? { verdict: "allowed", fails: false } : { verdict: "differs", fails: true }; +} + +export function median(values) { + const sorted = [...values].sort((a, b) => a - b); + const middle = sorted.length >> 1; + return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2; +} + +export function geomean(values) { + return values.length === 0 + ? 1 + : Math.exp(values.reduce((sum, value) => sum + Math.log(value), 0) / values.length); +} + +/** Compile-time ratio (candidate / baseline) for a set of programs. Each + * row holds paired samples: one baseline and one candidate build that ran + * side by side, so both saw the same machine load. The estimate is the + * geometric mean of each program's median pair ratio, with a 95% bootstrap + * interval over the pairs. Builds on a shared VM vary by 10-20% run to run, + * so the gate judges the interval, not the point estimate. */ +export function timeRatio(rows, resamples = 2000) { + let state = 0x5eed; + const random = () => { + state = (Math.imul(state, 1664525) + 1013904223) >>> 0; + return state / 4294967296; + }; + const pick = (xs) => + Array.from({ length: xs.length }, () => xs[Math.floor(random() * xs.length)]); + const estimate = (draw) => geomean(rows.map((r) => median(draw(r.ratios)))); + const ratios = Array.from({ length: resamples }, () => estimate(pick)).sort((a, b) => a - b); + return { + ratio: estimate((xs) => xs), + low: ratios[Math.floor(resamples * 0.025)], + high: ratios[Math.floor(resamples * 0.975)], + }; +} diff --git a/scripts/zero-cost-gate.mjs b/scripts/zero-cost-gate.mjs new file mode 100644 index 000000000..f5fea63b9 --- /dev/null +++ b/scripts/zero-cost-gate.mjs @@ -0,0 +1,647 @@ +/* Zero-cost gate: prove that a compiler change leaves good code untouched. + * + * Compiles a fixed good-code set with a baseline and a candidate checkout and + * compares IR, LLVM and release executables byte for byte, plus compile time + * and binary size, and optionally per-function cachegrind instruction counts. + * Both checkouts compile the same program files (from --programs, default the + * baseline), so program paths embedded in artifacts match; checkout paths and + * timestamps do not reach the artifacts. Builds bypass the native cache. + * + * The good-code set: the runtime benchmark workloads (and benchmarks/builds + * applications), the self-hosted compiler (IR and LLVM), and the TypeScript + * corpus programs. A program whose sources match --allow (the change's + * pattern signature) may differ; any other difference fails the gate. */ +import assert from "node:assert/strict"; +import { spawn, spawnSync } from "node:child_process"; +import { + existsSync, + mkdirSync, + mkdtempSync, + readFileSync, + readdirSync, + rmSync, + statSync, + writeFileSync, +} from "node:fs"; +import { availableParallelism } from "node:os"; +import { dirname, join, relative, resolve } from "node:path"; +import { fileURLToPath } from "node:url"; +import { parseArgs } from "node:util"; +import { + cachegrindCounts, + compareArtifact, + compareCounts, + compareExecutables, + dynamicTierSymbols, + median, + parseNm, + programVerdict, + timeRatio, +} from "./zero-cost-compare.mjs"; + +const repoRoot = fileURLToPath(new URL("..", import.meta.url)); +const { values } = parseArgs({ + options: { + baseline: { type: "string" }, + candidate: { type: "string", default: repoRoot }, + programs: { type: "string", default: "baseline" }, + set: { type: "string", default: "bench,self,corpus" }, + quick: { type: "boolean", default: false }, + corpus: { type: "string", default: "ts" }, + shard: { type: "string" }, + only: { type: "string" }, + allow: { type: "string" }, + "timing-runs": { type: "string" }, + "self-timing-runs": { type: "string", default: "0" }, + "max-time-growth": { type: "string", default: "2" }, + "max-size-growth": { type: "string", default: "0" }, + cachegrind: { type: "boolean", default: false }, + jobs: { type: "string", default: String(Math.max(1, availableParallelism())) }, + json: { type: "string" }, + keep: { type: "boolean", default: false }, + help: { type: "boolean", default: false }, + }, +}); +if (values.help || values.baseline === undefined) { + console.log(`Usage: node scripts/zero-cost-gate.mjs --baseline= [--candidate=] + [--programs=baseline|candidate|] [--set=bench,self,corpus] [--quick] + [--corpus=ts|all] [--shard=i/n] [--only=] [--allow=] + [--timing-runs=N] [--self-timing-runs=N] [--max-time-growth=2] + [--max-size-growth=0] + [--cachegrind] [--jobs=N] [--json=] [--keep] + +Each checkout must be built (packages/cli/dist/bootstrap.js and this host's +runtime pack). Both compile the same program files, taken from --programs +(default: the baseline checkout). + +--set picks the good-code set: bench (benchmarks/runtime workloads and the +benchmarks/builds applications), self (packages/compiler/src/native/cli.ts, +LLVM only), corpus (tests/corpus TypeScript programs; --corpus=all adds +JavaScript entries). --quick is --set=bench --timing-runs=0, for CI. +--shard=i/n keeps every n-th corpus program; --only filters program ids. + +--allow= is the change's pattern signature: programs whose source +files match it may differ (reported as "allowed"). Any other difference in +IR, LLVM or the release executable fails the gate. + +--timing-runs=N (default 5) times N paired --emit=llvm builds per bench +program, baseline and candidate side by side. The self-hosted compiler's +comparison build is its first pair; --self-timing-runs adds more. The gate +fails when the 95% bootstrap interval of the bench geomean ratio, or of the +self-hosted ratio, lies entirely above --max-time-growth percent; an interval +that straddles it is reported as inconclusive. +--max-size-growth bounds executable growth (percent) of allowed programs. + +Dynamic-tier symbols (two-tier invariant I3): no executable may gain +symbols under DYNAMIC_TIER_PREFIXES (scripts/zero-cost-compare.mjs) unless +it matches --allow, and fully typed bench workloads (all but +DYNAMIC_WORKLOADS in this script) may define none. + +--cachegrind (Linux, valgrind on PATH) runs differing bench executables under +cachegrind and compares instruction counts per function of the executable's +own symbols, excluding the allocator's prefault thread. + +Exit status: 0 when the gate passes, 1 when it fails.`); + process.exit(values.help ? 0 : 2); +} + +const trees = { baseline: resolve(values.baseline), candidate: resolve(values.candidate) }; +for (const [label, root] of Object.entries(trees)) + assert.ok( + existsSync(join(root, "packages/cli/dist/bootstrap.js")), + `${label} checkout ${root} has no built CLI (packages/cli/dist/bootstrap.js)`, + ); +const programsRoot = + values.programs === "baseline" || values.programs === "candidate" + ? trees[values.programs] + : resolve(values.programs); +const sets = new Set((values.quick ? "bench" : values.set).split(",")); +for (const set of sets) assert.ok(["bench", "self", "corpus"].includes(set), `unknown set ${set}`); +const timingRuns = Number(values["timing-runs"] ?? (values.quick ? 0 : 5)); +const selfTimingRuns = Number(values["self-timing-runs"]); +const maxTimeGrowth = Number(values["max-time-growth"]) / 100; +const maxSizeGrowth = Number(values["max-size-growth"]) / 100; +const jobs = Number(values.jobs); +assert.ok(Number.isInteger(timingRuns) && timingRuns >= 0, "--timing-runs must be >= 0"); +assert.ok(Number.isInteger(jobs) && jobs >= 1, "--jobs must be >= 1"); +assert.ok(["ts", "all"].includes(values.corpus), "--corpus must be ts or all"); +const only = values.only ? new RegExp(values.only) : null; +const allow = values.allow ? new RegExp(values.allow, "m") : null; +if (values.cachegrind) + assert.equal( + spawnSync("valgrind", ["--version"]).status, + 0, + "--cachegrind needs valgrind on PATH", + ); + +const work = mkdtempSync("/tmp/scriptc-zero-cost-"); + +/* ── the good-code set ─────────────────────────────────────────────────── */ + +/** Every file a program reads: the entry and its relative imports. */ +function programInputs(entry) { + const files = new Set(); + const pending = [entry]; + while (pending.length > 0) { + const file = pending.pop(); + if (files.has(file)) continue; + files.add(file); + const text = readFileSync(file, "utf8"); + for (const match of text.matchAll( + /(?:from|import|require)\s*\(?\s*["'](\.{1,2}\/[^"']+)["']/g, + )) { + const base = resolve(dirname(file), match[1]); + const stem = base.replace(/\.(m|c)?js$/, ""); + const found = [ + base, + `${stem}.ts`, + `${stem}.mts`, + `${stem}.cts`, + `${base}.ts`, + join(base, "index.ts"), + ].find((candidate) => existsSync(candidate) && statSync(candidate).isFile()); + if (found !== undefined) pending.push(found); + } + } + return [...files]; +} + +function goodCodeSet() { + const programs = []; + if (sets.has("bench")) { + const suite = join(programsRoot, "benchmarks/runtime"); + const manifest = JSON.parse(readFileSync(join(suite, "workloads.json"), "utf8")); + const seen = new Set(); + for (const w of manifest.workloads) { + const entry = join(suite, w.entry); + if (seen.has(entry)) continue; + seen.add(entry); + programs.push({ id: `bench/${w.name}`, entry, kind: "exe", workload: w }); + } + } + if (sets.has("self")) + programs.push({ + id: "self/cli", + entry: join(programsRoot, "packages/compiler/src/native/cli.ts"), + kind: "source", + }); + if (sets.has("corpus")) { + const corpus = join(programsRoot, "tests/corpus"); + const exts = values.corpus === "all" ? ["ts", "js", "mjs", "cjs"] : ["ts"]; + const entries = []; + for (const name of readdirSync(corpus).sort()) { + const path = join(corpus, name); + if (statSync(path).isDirectory()) { + const main = exts.map((ext) => join(path, `main.${ext}`)).find((p) => existsSync(p)); + if (main !== undefined) entries.push(main); + } else if (exts.some((ext) => name.endsWith(`.${ext}`))) entries.push(path); + } + let selected = entries; + if (values.shard) { + const [index, count] = values.shard.split("/").map(Number); + assert.ok(index >= 1 && index <= count, "--shard must be i/n with 1 <= i <= n"); + selected = entries.filter((_, k) => k % count === index - 1); + } + for (const entry of selected) { + const head = readFileSync(entry, "utf8").split("\n", 2); + const speed = head.some((line) => /^\/\/ @optimization:\s*speed\s*$/.test(line)); + programs.push({ + id: `corpus/${relative(corpus, entry)}`, + entry, + kind: "exe", + optimization: speed ? "speed" : "release", + }); + } + } + return programs.filter((p) => only === null || only.test(p.id)); +} + +/* ── builds ────────────────────────────────────────────────────────────── */ + +function exec(command, args, options = {}) { + return new Promise((resolvePromise) => { + const started = process.hrtime.bigint(); + const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"], ...options }); + let stdout = ""; + let stderr = ""; + child.stdout.setEncoding("utf8").on("data", (c) => (stdout += c)); + child.stderr.setEncoding("utf8").on("data", (c) => (stderr += c)); + child.on("close", (status, signal) => + resolvePromise({ + status, + signal, + stdout, + stderr, + ms: Number(process.hrtime.bigint() - started) / 1e6, + }), + ); + }); +} + +function buildEnv() { + const env = { ...process.env, SCRIPTC_NO_CACHE: "1" }; + delete env.SCRIPTC_TIMING; + delete env.SCRIPTC_CACHE_DIR; + return env; +} + +function compile(tree, args) { + return exec( + process.execPath, + ["--max-old-space-size=8192", join(tree, "packages/cli/dist/bootstrap.js"), "build", ...args], + { cwd: programsRoot, env: buildEnv() }, + ); +} + +/** Build one program with one checkout. Executable programs build once, + * keeping the LLVM and IR beside the release executable. The self-hosted + * compiler emits LLVM only: each of its frontend runs takes minutes, and its + * LLVM names the first differing function as well as its IR would. */ +async function buildProgram(program, label) { + const dir = join(work, label, program.id.replace(/[^\w.-]+/g, "_")); + mkdirSync(dir, { recursive: true }); + const tree = trees[label]; + const failure = (result) => ({ + ok: false, + error: (result.stderr || result.stdout || `exit ${result.status ?? result.signal}`) + .replaceAll(dir, "") + .trim() + .slice(0, 4000), + }); + if (program.kind === "source") { + const llvm = join(dir, "program.ll"); + const result = await compile(tree, [program.entry, "--emit=llvm", "-o", llvm]); + if (result.status !== 0) return failure(result); + return { ok: true, dir, llvm, ms: result.ms }; + } + const exe = join(dir, "program"); + const result = await compile(tree, [ + program.entry, + `--optimization=${program.optimization ?? "release"}`, + "--keep-llvm", + "--emit-ir", + "-o", + exe, + ]); + if (result.status !== 0) return failure(result); + const files = readdirSync(dir); + const pick = (suffix) => { + const name = files.find((f) => f.endsWith(suffix)); + return name === undefined ? null : join(dir, name); + }; + return { ok: true, dir, exe, ir: pick(".ir.json"), llvm: pick(".ll"), ms: result.ms }; +} + +const nmCache = new Map(); +function nm(binary) { + if (nmCache.has(binary)) return nmCache.get(binary); + const result = spawnSync("nm", process.platform === "darwin" ? [binary] : ["-S", binary], { + encoding: "utf8", + maxBuffer: 256 * 1024 * 1024, + }); + const text = result.status === 0 ? result.stdout : ""; + nmCache.set(binary, text); + return text; +} + +/** Names of the functions an executable defines. */ +const definedFunctions = (binary) => + parseNm(nm(binary)) + .filter((s) => /^[tTwW]$/.test(s.type)) + .map((s) => s.name); + +/* Bench workloads whose release binaries link dynamic-tier symbols on + * b14377864 (DYNAMIC_TIER_PREFIXES in zero-cost-compare.mjs): JSON.parse + * trees, worker messages, regex exec metadata (two-tier §3.3 L5), and a + * shared scr_dyn_call/scr_dyn_define_property core not yet traced to its + * typed root. Every other bench workload is fully typed and must link none. + * Remove a workload here when a leak fix makes its binary clean. */ +const DYNAMIC_WORKLOADS = new Set([ + "bench/json-records", + "bench/cli-config", + "bench/http-api", + "bench/validate-errors", + "bench/regex-logs", + "bench/atomics-contended", + "bench/intern-table", + "bench/typed-array-scan-workers", + "bench/log-summary", + "bench/inventory-report", +]); + +/** The I3 symbol check. Every executable may not gain dynamic-tier symbols + * over the baseline (unless the program matches --allow); a fully typed + * bench workload may contain none at all. */ +function dynamicTierCheck(program, baseline, candidate, artifacts, allowed) { + if (!baseline.exe || !artifacts.exe) return null; + const typed = program.id.startsWith("bench/") && !DYNAMIC_WORKLOADS.has(program.id); + if (artifacts.exe.identical && !typed) return null; + const after = dynamicTierSymbols(definedFunctions(candidate.exe)); + const before = artifacts.exe.identical + ? after + : dynamicTierSymbols(definedFunctions(baseline.exe)); + const added = after.filter((name) => !before.includes(name)); + const failures = []; + if (typed && after.length > 0) + failures.push( + `fully typed program links dynamic-tier symbols: ${after.slice(0, 5).join(", ")}`, + ); + if (added.length > 0 && !allowed) + failures.push(`gained dynamic-tier symbols: ${added.slice(0, 5).join(", ")}`); + return { typed, count: after.length, added, failures }; +} + +function compareBuilds(baseline, candidate) { + const artifacts = {}; + for (const kind of ["ir", "llvm"]) { + if (!(kind in baseline)) continue; + if (baseline[kind] === null || candidate[kind] === null) { + artifacts[kind] = { identical: false, first: `missing ${kind} artifact` }; + continue; + } + artifacts[kind] = compareArtifact( + kind, + readFileSync(baseline[kind]), + readFileSync(candidate[kind]), + ); + } + if (baseline.exe) { + const a = readFileSync(baseline.exe); + const b = readFileSync(candidate.exe); + artifacts.exe = a.equals(b) + ? { identical: true } + : compareExecutables(a, b, nm(baseline.exe), nm(candidate.exe)); + artifacts.exe.bytes = { baseline: a.length, candidate: b.length }; + } + return artifacts; +} + +/** Run tasks with at most `jobs` at a time; heavy tasks run alone. */ +async function pool(tasks) { + const results = new Array(tasks.length); + let next = 0; + let running = 0; + let heavy = false; + await new Promise((done) => { + const pump = () => { + if (next === tasks.length && running === 0) return done(); + while (next < tasks.length && running < jobs && !heavy) { + const task = tasks[next]; + if (task.heavy && running > 0) break; + const index = next++; + running++; + if (task.heavy) heavy = true; + task.run().then((value) => { + results[index] = value; + running--; + if (task.heavy) heavy = false; + pump(); + }); + } + }; + pump(); + }); + return results; +} + +/* ── cachegrind ────────────────────────────────────────────────────────── */ + +async function instructionCounts(binary, args, out) { + const result = await exec("valgrind", [ + "--tool=cachegrind", + "--cache-sim=no", + `--cachegrind-out-file=${out}`, + binary, + ...args, + ]); + if (result.status !== 0) return null; + return cachegrindCounts(readFileSync(out, "utf8"), new Set(definedFunctions(binary))); +} + +/* ── main ──────────────────────────────────────────────────────────────── */ + +function revision(root) { + const r = spawnSync("git", ["-C", root, "rev-parse", "--short", "HEAD"], { encoding: "utf8" }); + if (r.status !== 0) return null; + const dirty = spawnSync("git", ["-C", root, "status", "--porcelain", "--untracked-files=no"], { + encoding: "utf8", + }); + return r.stdout.trim() + (dirty.stdout.trim() ? "+dirty" : ""); +} + +const fmtMs = (ms) => `${(ms / 1000).toFixed(2)}s`; +const pct = (ratio) => `${ratio >= 1 ? "+" : ""}${((ratio - 1) * 100).toFixed(2)}%`; + +const programs = goodCodeSet(); +assert.ok(programs.length > 0, "the selected good-code set is empty"); +const report = { + schema: 1, + date: new Date().toISOString(), + host: { platform: process.platform, arch: process.arch, node: process.version }, + trees: Object.fromEntries( + Object.entries(trees).map(([label, root]) => [label, { root, revision: revision(root) }]), + ), + programsRoot, + allow: values.allow ?? null, + programs: [], + timing: null, + failures: [], +}; +console.log( + `zero-cost gate: ${programs.length} programs (${[...sets].join(", ")}), ` + + `baseline ${trees.baseline}, candidate ${trees.candidate}, programs from ${programsRoot}`, +); + +let failed = false; +const started = Date.now(); +await pool( + programs.map((program) => ({ + heavy: program.kind === "source", + run: async () => { + const [baseline, candidate] = await Promise.all([ + buildProgram(program, "baseline"), + buildProgram(program, "candidate"), + ]); + const allowed = + allow !== null && + programInputs(program.entry).some((f) => allow.test(readFileSync(f, "utf8"))); + const artifacts = baseline.ok && candidate.ok ? compareBuilds(baseline, candidate) : {}; + const { verdict, fails } = programVerdict({ baseline, candidate, artifacts, allowed }); + const entry = { + id: program.id, + verdict, + allowed, + buildMs: { baseline: baseline.ms ?? null, candidate: candidate.ms ?? null }, + artifacts, + }; + if (!baseline.ok) entry.baselineError = baseline.error; + if (!candidate.ok) entry.candidateError = candidate.error; + const size = artifacts.exe?.bytes; + if (verdict === "allowed" && size && size.candidate > size.baseline * (1 + maxSizeGrowth)) { + entry.sizeFailure = true; + report.failures.push( + `${program.id}: executable grew ${size.baseline} -> ${size.candidate} bytes`, + ); + } + if (fails) report.failures.push(`${program.id}: ${verdict}`); + const symbols = + baseline.ok && candidate.ok + ? dynamicTierCheck(program, baseline, candidate, artifacts, allowed) + : null; + if (symbols !== null) entry.dynamicTier = symbols; + for (const failure of symbols?.failures ?? []) + report.failures.push(`${program.id}: ${failure}`); + if (fails || entry.sizeFailure || symbols?.failures.length) failed = true; + if (values.cachegrind && program.workload && artifacts.exe && !artifacts.exe.identical) { + const w = program.workload; + if (w.kind === "server" || w.args.includes("{input}")) + entry.cachegrind = { skipped: "needs a server client or generated input" }; + else { + const counts = await Promise.all([ + instructionCounts(baseline.exe, w.args, join(baseline.dir, "cg.out")), + instructionCounts(candidate.exe, w.args, join(candidate.dir, "cg.out")), + ]); + entry.cachegrind = counts.includes(null) + ? { skipped: "valgrind run failed" } + : (({ deltas, ...rest }) => ({ ...rest, deltas: deltas.slice(0, 20) }))( + compareCounts(counts[0], counts[1]), + ); + } + } + printProgram(entry); + report.programs.push(entry); + nmCache.delete(baseline.exe); + nmCache.delete(candidate.exe); + if (!values.keep) { + if (baseline.dir) rmSync(baseline.dir, { recursive: true, force: true }); + if (candidate.dir) rmSync(candidate.dir, { recursive: true, force: true }); + } + }, + })), +); + +function printProgram(entry) { + const label = { + identical: "identical", + allowed: "allowed ", + differs: "DIFFERS ", + "build-error": "ERROR ", + "both-fail": "both-fail", + }[entry.verdict]; + const notes = []; + for (const [kind, result] of Object.entries(entry.artifacts)) + if (!result.identical) { + const counts = result.changed + ? ` (${result.changed.length} changed, ${result.added.length} added, ${result.removed.length} removed)` + : ""; + notes.push(`${kind}: ${result.first}${counts}`); + } + const size = entry.artifacts.exe?.bytes; + if (size && size.baseline !== size.candidate) + notes.push( + `size ${size.baseline} -> ${size.candidate} B (${pct(size.candidate / size.baseline)})`, + ); + if (entry.cachegrind?.total) { + const { total, deltas } = entry.cachegrind; + notes.push( + `Ir ${total.baseline} -> ${total.candidate} (${pct(total.candidate / Math.max(1, total.baseline))})` + + (deltas[0] + ? `, largest ${deltas[0].name} ${deltas[0].delta > 0 ? "+" : ""}${deltas[0].delta}` + : ""), + ); + } else if (entry.cachegrind?.skipped) + notes.push(`cachegrind skipped: ${entry.cachegrind.skipped}`); + for (const failure of entry.dynamicTier?.failures ?? []) notes.push(`SYMBOLS: ${failure}`); + if (entry.baselineError) notes.push(`baseline: ${entry.baselineError.split("\n")[0]}`); + if (entry.candidateError) notes.push(`candidate: ${entry.candidateError.split("\n")[0]}`); + console.log(`${label} ${entry.id}${notes.length ? ` ${notes.join("; ")}` : ""}`); +} + +/* Compile time: paired --emit=llvm builds, the baseline and the candidate + * side by side, one program at a time. Identical LLVM means everything after + * emission (LLVM optimization, linking) costs the same, so the timed part is + * the compiler's own work. The self-hosted compiler takes minutes per build; + * its main comparison build is its first pair. */ +if (timingRuns > 0) { + const rows = []; + const pair = async (program) => { + const [baseline, candidate] = await Promise.all( + ["baseline", "candidate"].map((label) => + compile(trees[label], [ + program.entry, + "--emit=llvm", + "-o", + join(work, `timing-${label}.ll`), + ]), + ), + ); + return baseline.status === 0 && candidate.status === 0 ? [baseline.ms, candidate.ms] : null; + }; + for (const program of programs) { + if (program.id.startsWith("corpus/")) continue; + const row = { id: program.id, baselineMs: [], candidateMs: [], ratios: [] }; + const add = (sample) => { + if (sample === null) return; + row.baselineMs.push(Math.round(sample[0])); + row.candidateMs.push(Math.round(sample[1])); + row.ratios.push(sample[1] / sample[0]); + }; + const runs = program.kind === "source" ? selfTimingRuns : timingRuns; + if (program.kind === "source") { + const built = report.programs.find((p) => p.id === program.id)?.buildMs; + if (built?.baseline && built?.candidate) add([built.baseline, built.candidate]); + } + for (let run = 0; run < runs; run++) add(await pair(program)); + if (row.ratios.length === 0) continue; + rows.push(row); + console.log( + `time ${program.id} ${fmtMs(median(row.baselineMs))} -> ${fmtMs(median(row.candidateMs))} ` + + `(${pct(median(row.ratios))}, ${row.ratios.length} pairs)`, + ); + } + report.timing = { runs: timingRuns, maxGrowth: maxTimeGrowth, rows, groups: {} }; + const groups = { + bench: rows.filter((r) => r.id.startsWith("bench/")), + self: rows.filter((r) => r.id === "self/cli"), + }; + for (const [name, group] of Object.entries(groups)) { + if (group.length === 0) continue; + const result = timeRatio(group); + report.timing.groups[name] = result; + const verdict = + result.low > 1 + maxTimeGrowth + ? "SLOWER" + : result.high > 1 + maxTimeGrowth + ? "inconclusive (rerun with more runs)" + : "within tolerance"; + console.log( + `time ${name} ${group.length > 1 ? "geomean " : ""}${pct(result.ratio)} ` + + `[95% CI ${pct(result.low)}, ${pct(result.high)}]: ${verdict}`, + ); + if (result.low > 1 + maxTimeGrowth) { + failed = true; + report.failures.push( + `${name} compile time grew ${pct(result.ratio)} (CI low ${pct(result.low)})`, + ); + } + } +} + +const counts = {}; +for (const p of report.programs) counts[p.verdict] = (counts[p.verdict] ?? 0) + 1; +report.counts = counts; +report.verdict = failed ? "fail" : "pass"; +report.elapsedMs = Date.now() - started; +if (values.json) { + mkdirSync(dirname(resolve(values.json)), { recursive: true }); + writeFileSync(values.json, JSON.stringify(report, null, 2) + "\n"); +} +if (!values.keep) rmSync(work, { recursive: true, force: true }); +else console.log(`artifacts kept in ${work}`); +console.log( + `zero-cost gate: ${failed ? "FAIL" : "PASS"} — ${Object.entries(counts) + .map(([k, v]) => `${v} ${k}`) + .join(", ")} in ${fmtMs(report.elapsedMs)}`, +); +for (const failure of report.failures) console.log(` ${failure}`); +process.exit(failed ? 1 : 0); diff --git a/tests/harness/zero-cost-gate.test.ts b/tests/harness/zero-cost-gate.test.ts new file mode 100644 index 000000000..c75a115c8 --- /dev/null +++ b/tests/harness/zero-cost-gate.test.ts @@ -0,0 +1,145 @@ +import { expect, test } from "vitest"; +import { + cachegrindCounts, + compareArtifact, + compareCounts, + compareExecutables, + dynamicTierSymbols, + programVerdict, +} from "../../scripts/zero-cost-compare.mjs"; + +const ir = (functions: object[], globals: object[]) => + Buffer.from(JSON.stringify({ irVersion: 16, functions, globals, sourceFile: "/p/main.ts" })); + +const llvm = (body: string, extra = "") => + Buffer.from( + [ + "; Generated by scriptc (LLVM backend) from /p/main.ts. Do not edit.", + '@.str = private constant [3 x i8] c"hi\\00"', + "define internal i64 @add(i64 %a, i64 %b) {", + ` ${body}`, + "}", + 'define void @"main.$1"() { ret void }', + extra, + "declare void @scr_print(ptr)", + "", + ].join("\n"), + ); + +test("the zero-cost gate names the first differing IR and LLVM unit", () => { + const f = { name: "f", params: [], body: [{ kind: "return" }] }; + const g = { name: "g", params: [], body: [] }; + const base = ir([f, g, f], [{ name: "a", type: "i64" }]); + expect(compareArtifact("ir", base, Buffer.from(base))).toEqual({ identical: true }); + + const changed = compareArtifact( + "ir", + base, + ir([f, { ...g, params: [1] }, f], [{ name: "a", type: "i64" }]), + ); + expect(changed).toMatchObject({ + identical: false, + first: "changed g", + changed: ["g"], + added: [], + module: null, + }); + + const header = compareArtifact("ir", base, ir([f, g, f], [{ name: "a", type: "f64" }])); + expect(header).toMatchObject({ first: "module globals[0:a]", changed: [] }); + // Repeated names are matched by occurrence, so an insertion shows as added. + expect(compareArtifact("ir", base, ir([f, g, f, f], [{ name: "a", type: "i64" }]))).toMatchObject( + { + first: "added f#3", + }, + ); + + const ll = llvm("%r = add i64 %a, %b\n ret i64 %r"); + expect(compareArtifact("llvm", ll, Buffer.from(ll))).toEqual({ identical: true }); + expect(compareArtifact("llvm", ll, llvm("%r = sub i64 %a, %b\n ret i64 %r"))).toMatchObject({ + first: "changed add", + changed: ["add"], + functions: { baseline: 2, candidate: 2 }, + }); + expect( + compareArtifact( + "llvm", + ll, + llvm("%r = add i64 %a, %b\n ret i64 %r", "define void @new() { ret void }"), + ), + ).toMatchObject({ first: "added new", added: ["new"] }); + const global = compareArtifact("llvm", ll, Buffer.from(ll.toString().replace("hi", "ho"))); + expect(global).toMatchObject({ first: "module line 2", changed: [] }); + expect(global.module.candidate).toContain("ho"); +}); + +test("the zero-cost gate compares executables and instruction counts per function", () => { + const nm = + "0000000000001000 0000000000000010 T main\n0000000000001010 0000000000000020 t scr_add\n"; + const resized = compareExecutables( + Buffer.from("abcd"), + Buffer.from("abXd"), + nm, + nm.replace("0000000000000020 t", "0000000000000030 t"), + ); + expect(resized).toMatchObject({ identical: false, first: "resized scr_add", offset: 2 }); + + const output = (main: number, prefault: number, loader: number) => + [ + "events: Ir", + "fl=???", + "fn=main", + `0 ${main}`, + "fn=scr_sa_prefault", + `0 ${prefault}`, + "fn=_dl_lookup_symbol_x", + `0 ${loader}`, + "fn=scr_add", + "0 7", + "0 3", + ].join("\n"); + const own = new Set(["main", "scr_add", "scr_sa_prefault"]); + const base = cachegrindCounts(output(100, 50, 9000), own); + expect([...base]).toEqual([ + ["main", 100], + ["scr_add", 10], + ]); + expect(compareCounts(base, cachegrindCounts(output(100, 75, 9300), own)).identical).toBe(true); + expect(compareCounts(base, cachegrindCounts(output(104, 50, 9000), own))).toMatchObject({ + identical: false, + total: { baseline: 110, candidate: 114 }, + deltas: [{ name: "main", delta: 4 }], + }); +}); + +test("the zero-cost gate recognizes dynamic-tier runtime symbols", () => { + expect( + dynamicTierSymbols([ + "main", + "scr_dyn_release", + "scr_dyn_obj_drop_keys", + "scr_dyn_this_push_dyn", + "scr_js_load_ic", + "scr_dyn_obj_read", + "scr_dyn_obj_read", + ]), + ).toEqual(["scr_dyn_obj_read", "scr_js_load_ic"]); +}); + +test("the zero-cost gate fails differing programs unless they match the signature", () => { + const ok = { ok: true }; + const same = { ir: { identical: true }, exe: { identical: true } }; + const differs = { ir: { identical: true }, exe: { identical: false } }; + const verdict = ( + artifacts: object, + allowed = false, + baseline: object = ok, + candidate: object = ok, + ) => programVerdict({ baseline, candidate, artifacts, allowed }); + expect(verdict(same)).toEqual({ verdict: "identical", fails: false }); + expect(verdict(differs)).toEqual({ verdict: "differs", fails: true }); + expect(verdict(differs, true)).toEqual({ verdict: "allowed", fails: false }); + const failed = { ok: false, error: "SC1090" }; + expect(verdict({}, false, failed, failed)).toEqual({ verdict: "both-fail", fails: false }); + expect(verdict({}, true, ok, failed)).toEqual({ verdict: "build-error", fails: true }); +}); From 4128e6f6f5feccdc738c0d70097c68a433aa2bb1 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:46:38 -0700 Subject: [PATCH 2/7] Count instructions for differing corpus executables in the zero-cost gate --cachegrind now also runs differing corpus executables (without arguments, accepting intentional non-zero exits), so emitter changes that only touch corpus programs get per-function instruction deltas. AGENTS.md mentions the dynamic-tier symbol rule. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 2 +- scripts/zero-cost-gate.mjs | 16 ++++++++++------ 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 16f90d68e..b94c90067 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -48,7 +48,7 @@ Corpus programs are differential tests against Node: every program runs under No Before opening a PR that adds or changes corpus, diagnostic, or frontend fixtures, run `pnpm test:ts7 --baselines-only`. This fast completeness check uses the same fixture discovery as the parity suite; it does not type-check or replace behavioral parity. Generate missing preflight/order baselines, review their diagnostics and module order, and run the affected `order-parity.test.ts` batches before pushing. Keep existing baseline entries unchanged unless the corresponding behavior intentionally changes. The full `pnpm test:ts7` command also checks completeness before starting its sweep. -A change that must not cost good code anything, such as a compatibility fix that replaces a refusal, proves it with the zero-cost gate. The gate compiles the benchmark workloads, the self-hosted compiler, and the TypeScript corpus with two built checkouts. It requires byte-identical IR, LLVM, and release executables, and compile time within tolerance. `--allow=` names the change's pattern signature: programs whose sources match may differ, and the PR lists them. Any other difference fails the gate, which names the first differing function. `--quick` checks only the benchmarks; `--cachegrind` adds per-function instruction counts for executables that differ. Run it in a Sandbox with both checkouts prepared: +A change that must not cost good code anything, such as a compatibility fix that replaces a refusal, proves it with the zero-cost gate. The gate compiles the benchmark workloads, the self-hosted compiler, and the TypeScript corpus with two built checkouts. It requires byte-identical IR, LLVM, and release executables, and compile time within tolerance. `--allow=` names the change's pattern signature: programs whose sources match may differ, and the PR lists them. Any other difference fails the gate, which names the first differing function. The gate also enforces the two-tier runtime separation: no executable may gain symbols from `DYNAMIC_TIER_PREFIXES` in `scripts/zero-cost-compare.mjs`, and fully typed benchmarks may link none; extend that list as dynamic-tier units land. `--quick` checks only the benchmarks; `--cachegrind` adds per-function instruction counts for executables that differ. Run it in a Sandbox with both checkouts prepared: ```bash node scripts/zero-cost-gate.mjs --baseline=/vercel/sandbox/prev --candidate=. --allow='\barguments\b' diff --git a/scripts/zero-cost-gate.mjs b/scripts/zero-cost-gate.mjs index f5fea63b9..db98bf249 100644 --- a/scripts/zero-cost-gate.mjs +++ b/scripts/zero-cost-gate.mjs @@ -97,9 +97,10 @@ symbols under DYNAMIC_TIER_PREFIXES (scripts/zero-cost-compare.mjs) unless it matches --allow, and fully typed bench workloads (all but DYNAMIC_WORKLOADS in this script) may define none. ---cachegrind (Linux, valgrind on PATH) runs differing bench executables under -cachegrind and compares instruction counts per function of the executable's -own symbols, excluding the allocator's prefault thread. +--cachegrind (Linux, valgrind on PATH) runs differing executables under +cachegrind (bench workloads with their arguments, corpus programs without) +and compares instruction counts per function of the executable's own +symbols, excluding the allocator's prefault thread. Exit status: 0 when the gate passes, 1 when it fails.`); process.exit(values.help ? 0 : 2); @@ -414,7 +415,8 @@ async function instructionCounts(binary, args, out) { binary, ...args, ]); - if (result.status !== 0) return null; + // Corpus programs may exit non-zero on purpose (`// @exit: 1`). + if (result.signal !== null || !existsSync(out)) return null; return cachegrindCounts(readFileSync(out, "utf8"), new Set(definedFunctions(binary))); } @@ -492,8 +494,10 @@ await pool( for (const failure of symbols?.failures ?? []) report.failures.push(`${program.id}: ${failure}`); if (fails || entry.sizeFailure || symbols?.failures.length) failed = true; - if (values.cachegrind && program.workload && artifacts.exe && !artifacts.exe.identical) { - const w = program.workload; + if (values.cachegrind && artifacts.exe && !artifacts.exe.identical) { + // Bench workloads run with their benchmark arguments; corpus + // programs take none. + const w = program.workload ?? { args: [] }; if (w.kind === "server" || w.args.includes("{input}")) entry.cachegrind = { skipped: "needs a server client or generated input" }; else { From d3dba4c07f56b0b719ca37d811d23418708379cf Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 10:59:27 -0500 Subject: [PATCH 3/7] Run module-level before and after hooks node:test changes, matching Node 24.22: - before and after hooks outside any suite run, with the root's context, whose name is "". They did not run before. - A module-level before hook runs at its before() call, as Node runs the hooks of its already-started root at once: its synchronous part runs before the code after the call, and the first top-level test waits for an async hook's promise. Every module-level before hook runs, and an async hook's rejection is not reported as an unhandled rejection. - Module-level after hooks run after the last top-level test or suite. - A throwing root before hook fails each top-level test with the first failure; the test's body and beforeEach hooks do not run, and its afterEach hooks do. Each top-level suite fails with the error, and the tests and suites in it are cancelled before they start: they report without a duration and fail with "test did not finish before its parent and was cancelled", listed in the failing section in completion order. - A throwing root after hook reports the entry file as a failed result, after the top-level results, and lists it in the failing section at the hook's location. It is not counted, and the exit code is unchanged. - Hooks record the "file:line:col" of their call for that location. The root-hooks, root-before-throws and root-after-throws fixtures compare the reporter output, the order of the hooks against the module code, and the exit codes with Node, plain and with SCRIPTC_SAN=1. --- .../limitations/builtin-apis/test-runner.mdx | 1 + .../src/frontend/lowering/lower-test.ts | 2 +- .../compiler/src/ir/builtin-signatures.ts | 3 +- packages/runtime/src/scr_test.c | 147 +++++++++++++++++- packages/runtime/src/scr_test.h | 6 +- .../node-test/cases/root-after-throws.ts | 10 ++ .../node-test/cases/root-before-throws.ts | 30 ++++ tests/fixtures/node-test/cases/root-hooks.ts | 44 ++++++ 8 files changed, 233 insertions(+), 10 deletions(-) create mode 100644 tests/fixtures/node-test/cases/root-after-throws.ts create mode 100644 tests/fixtures/node-test/cases/root-before-throws.ts create mode 100644 tests/fixtures/node-test/cases/root-hooks.ts diff --git a/docs/content/limitations/builtin-apis/test-runner.mdx b/docs/content/limitations/builtin-apis/test-runner.mdx index e1baac963..6583a2873 100644 --- a/docs/content/limitations/builtin-apis/test-runner.mdx +++ b/docs/content/limitations/builtin-apis/test-runner.mdx @@ -2,3 +2,4 @@ - **Snapshots:** `t.assert.snapshot` and `t.assert.fileSnapshot` compile, with Node's default serializer, `JSON.stringify(value, null, 2)`, or an `options.serializers` array literal. A compiled test reads the snapshot file Node writes beside the entry file, `.snapshot`, at the entry file's path when the program was compiled. Running the binary with Node's flag `--test-update-snapshots` as its first argument writes the snapshot files instead; as in Node, the flag is kept out of `process.argv` and appears in `process.execArgv`. Snapshot files are read in the form Node writes them, `` exports[`key`] = `value`; `` statements. The `snapshot.setDefaultSnapshotSerializers` and `snapshot.setResolveSnapshotPath` module functions throw `SC2020`. - **TestContext values:** `t.filePath` is the entry file's path when the program was compiled. `t.attempt` is `0`, since a test runs once. `t.passed` is `false` while the body runs and the test's outcome in its `afterEach` and `t.after` hooks. `t.workerId` is `Number(process.env.NODE_TEST_WORKER_ID) || undefined`, as in Node. `t.tags` is `[]`, since the `tags` test option throws `SC2020`; the array is not frozen as Node's is. - **Suite and hook contexts:** a `describe` body may take its `SuiteContext`, which has `name`, `fullName`, `filePath`, `attempt`, `passed` and `diagnostic`. Hooks may take their context, as in Node: the suite's for `before` and `after`, the test's for `beforeEach`, `afterEach`, `t.before` and `t.after`. The `SuiteContext` `signal` and `log` members, and hook `done` callbacks, throw `SC2020`. +- **Module-level hooks:** `before` hooks outside any suite run at their `before()` call, and the first top-level test waits for the async ones; `after` hooks outside any suite run after the last top-level test. Both get the root's context, named ``. As in Node, a throwing root `before` fails each top-level test with its error, without running its body, and cancels the tests and suites inside each top-level suite. A throwing root `after` reports the entry file as a failed result, and the exit code is unchanged. diff --git a/packages/compiler/src/frontend/lowering/lower-test.ts b/packages/compiler/src/frontend/lowering/lower-test.ts index b9d4e8df1..e36518559 100644 --- a/packages/compiler/src/frontend/lowering/lower-test.ts +++ b/packages/compiler/src/frontend/lowering/lower-test.ts @@ -473,7 +473,7 @@ function lowerHook( return { kind: "libCall", fn: "test.hook", - args: [numLit(which, loc), cb, numLit(flags, loc)], + args: [numLit(which, loc), cb, numLit(flags, loc), strLit(atStringOf(expr), loc)], type: VOID, loc, }; diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 780918333..08c493ae4 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -1438,7 +1438,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ }, // The suite body takes no parameters or its SuiteContext (flag 2). "test.suite": { argTypes: [STRING, F64, STRING, null, STRING, F64, F64], result: VOID }, - "test.hook": { argTypes: [F64, null, F64], result: VOID }, + // The trailing string is the hook call's "file:line:col". + "test.hook": { argTypes: [F64, null, F64, STRING], result: VOID }, "test.sub": { argTypes: [TESTCTX_T, STRING, F64, STRING, null, F64, STRING, F64, F64, F64], result: { kind: "promise", inner: VOID }, diff --git a/packages/runtime/src/scr_test.c b/packages/runtime/src/scr_test.c index cb2c81971..cc52513a6 100644 --- a/packages/runtime/src/scr_test.c +++ b/packages/runtime/src/scr_test.c @@ -80,6 +80,7 @@ enum { typedef struct { ScrClosure *cb; int flags; + ScrStr *at; /* "file:line:col" of the hook call, owned; NULL for t.* hooks */ } ScrTestHook; typedef struct { @@ -123,6 +124,7 @@ struct ScrTestCtx { ScrPromise *slot; /* owned; the parent waiting for its next subtest to finish */ struct ScrMockTimers *mock_timers; /* t.mock.timers, made on first use; freed at exit */ bool passed; /* t.passed: set when the body passes, as Node's pass() does */ + bool listed; /* a suite listed in the failing section (a failing root before) */ }; static SCR_TL ScrTestCtx *scr_test_root = NULL; @@ -136,6 +138,18 @@ static SCR_TL long scr_test_ct_tests = 0, scr_test_ct_suites = 0, scr_test_ct_pa scr_test_ct_todo = 0; static SCR_TL double scr_test_t0 = 0; static SCR_TL bool scr_test_suite_hook_failed = false; +/* The promises of async module-level before hooks, which the runner waits + * for before the first top-level test. */ +static SCR_TL ScrPromise **scr_test_root_pending = NULL; +static SCR_TL size_t scr_test_root_npending = 0, scr_test_root_pending_cap = 0; + +/* A module-level before hook threw or rejected: the first failure is kept + * for the top-level tests and suites, later ones are dropped. */ +static void scr_test_root_before_failed(ScrTestCtx *root) { + if (!scr_exc_pending()) return; + if (!root->before_err) root->before_err = scr_exc_take(); + else scr_exc_clear(); +} /* Above 0 while subtests run concurrently: result lines are held, and the * outermost concurrent parent prints its subtrees in declaration order, * as Node's reporter does, once they all finish. */ @@ -164,7 +178,10 @@ ScrTestCtx *scr_testctx_retain(ScrTestCtx *t) { } static void scr_test_hooks_free(ScrTestHooks *h) { - for (size_t i = 0; i < h->n; i++) scr_closure_release(h->v[i].cb); + for (size_t i = 0; i < h->n; i++) { + scr_closure_release(h->v[i].cb); + scr_str_release(h->v[i].at); + } free(h->v); h->v = NULL; h->n = h->cap = 0; @@ -277,7 +294,9 @@ static void scr_test_indent(int depth) { /* "(1.234567ms)" — durations print microsecond-rounded (Node's hrtime * granularity), not with double noise. */ +/* NaN prints nothing: a test cancelled before it started has no duration. */ static void scr_test_print_dur(double ms) { + if (isnan(ms)) return; char num[32]; fputs(" (", stdout); size_t n = scr_f64_to_str(round(ms * 1e6) / 1e6, num); @@ -409,10 +428,14 @@ static void scr_test_mocks_restore(ScrTestHooks *mocks, bool forget) { /* `ctx` is the context a hook that takes one receives: the suite or test * for its own before/after hooks, the test for the beforeEach/afterEach * chain. */ -static void scr_test_run_hooks_of(ScrTestCtx *owner, int which, ScrTestCtx *ctx) { - for (size_t i = 0; i < owner->hooks[which].n && !scr_exc_pending(); i++) { - scr_test_call(owner->hooks[which].v[i].cb, owner->hooks[which].v[i].flags, ctx, NULL); +static ScrTestHook *scr_test_run_hooks_of(ScrTestCtx *owner, int which, ScrTestCtx *ctx) { + if (scr_exc_pending()) return NULL; /* an earlier hook in the chain threw */ + for (size_t i = 0; i < owner->hooks[which].n; i++) { + ScrTestHook *h = &owner->hooks[which].v[i]; + scr_test_call(h->cb, h->flags, ctx, NULL); + if (scr_exc_pending()) return h; /* the hook that threw */ } + return NULL; } /* Returns whether the chain has any `which` hooks. */ @@ -559,6 +582,36 @@ static void scr_test_finish_concurrent(ScrTestCtx *t) { for (size_t i = 0; i < t->nchildren; i++) scr_test_report_tree(t->children[i]); } +/* A failing root before hook (Node): each top-level test fails with its + * error without running its body or beforeEach hooks, though its + * afterEach hooks run; a top-level suite fails with it, and the tests and + * suites in it are cancelled before they start. */ +static void scr_test_cancel_unrun(ScrTestCtx *c) { + for (size_t i = 0; i < c->nchildren; i++) scr_test_cancel_unrun(c->children[i]); + static const char msg[] = "test did not finish before its parent and was cancelled"; + scr_throw_str(scr_str_new(msg, sizeof msg - 1)); + c->err = scr_exc_take(); + c->listed = true; + c->dur_ms = NAN; + c->state = SCR_TS_CANCELLED; + scr_test_report_result(c); +} + +static void scr_test_fail_unrun(ScrTestCtx *c, ScrCaught *err) { + double start = scr_now_ms(); + c->err = scr_caught_retain(err); + c->listed = true; + if (c->is_suite) { + for (size_t i = 0; i < c->nchildren; i++) scr_test_cancel_unrun(c->children[i]); + } else { + scr_test_run_each_hooks(c, SCR_HOOK_AFTER_EACH, false); + if (scr_exc_pending()) scr_exc_clear(); + } + c->dur_ms = scr_now_ms() - start; + c->state = SCR_TS_FAIL; + scr_test_report_result(c); +} + static void scr_test_run_children(ScrTestCtx *t) { /* `only` at this level: when a child is marked, or contains a marked * test or suite, only those children run. The others are dropped entirely @@ -572,6 +625,10 @@ static void scr_test_run_children(ScrTestCtx *t) { /* Subtests t.test already ran INLINE at their call site, or started on * their own fiber. */ if (c->state != SCR_TS_PENDING || c->done) continue; + if (t == scr_test_root && t->before_err) { + scr_test_fail_unrun(c, t->before_err); + continue; + } if (t->concurrency > 1) scr_test_start(c); else scr_test_run_node(c); } @@ -813,7 +870,7 @@ static void scr_test_print_failures(ScrTestCtx *t, bool *any) { for (size_t i = 0; i < t->nchildren; i++) { ScrTestCtx *c = t->children[i]; scr_test_print_failures(c, any); - if (!c->is_suite && + if ((!c->is_suite || c->listed) && (c->state == SCR_TS_FAIL || c->state == SCR_TS_TODO_FAIL || c->state == SCR_TS_CANCELLED) && c->err) { @@ -1404,7 +1461,41 @@ static void scr_test_runner_entry(ScrFiber *self, void *argpack) { * the first test only after the file's synchronous body completes. */ scr_await_hop(); ScrTestCtx *root = scr_test_root; + /* The root's before hooks ran at their before() calls; the first test + * waits for the async ones. */ + for (size_t i = 0; i < scr_test_root_npending; i++) { + scr_await_void(scr_test_root_pending[i]); + scr_test_root_before_failed(root); + scr_promise_release(scr_test_root_pending[i]); + } + free(scr_test_root_pending); + scr_test_root_pending = NULL; + scr_test_root_npending = scr_test_root_pending_cap = 0; scr_test_run_children(root); + /* Its after hooks: a throw reports the root as "✖ " with the hook's + * location, after the top-level results, without counting it or changing + * the exit code, as Node does. */ + double after_start = scr_now_ms(); + ScrTestHook *after_failed = scr_test_run_hooks_of(root, SCR_HOOK_AFTER, root); + if (scr_exc_pending()) { + root->err = scr_exc_take(); + root->dur_ms = scr_now_ms() - after_start; + root->state = SCR_TS_FAIL; + if (after_failed && after_failed->at) { + root->at = scr_str_retain(after_failed->at); + /* The name is the file: the location without its ":line:col". */ + size_t end = root->at->len; + for (int colons = 0; end > 0 && colons < 2; end--) { + if (root->at->data[end - 1] == ':') colons++; + } + scr_str_release(root->name); + root->name = scr_str_new(root->at->data, end); + } + fputs("\xE2\x9C\x96 ", stdout); + scr_test_print_str(root->name); + scr_test_print_dur(root->dur_ms); + fputc('\n', stdout); + } scr_test_run_done = true; scr_snap_write_all(); scr_test_count(root); @@ -1418,6 +1509,10 @@ static void scr_test_runner_entry(ScrFiber *self, void *argpack) { scr_test_info_line("duration_ms", round((scr_now_ms() - scr_test_t0) * 1e6) / 1e6); bool any = false; scr_test_print_failures(root, &any); + if (root->err) { + if (!any) fputs("\n\xE2\x9C\x96 failing tests:\n", stdout); + scr_test_print_failure(root); + } /* The tree is done reporting: release it (test bodies may still hold * their TestContext refs — the boxes stay alive through those). */ scr_test_reg_parent = NULL; @@ -1534,7 +1629,41 @@ void scr_test_suite(ScrStr *name /*borrowed*/, double mode, ScrStr *msg /*borrow scr_closure_release(cb); } -void scr_test_hook(double which, ScrClosure *cb /*moves*/, double flags) { +/* A module-level before hook runs at its before() call, as Node runs the + * hooks of its already-started root at once: the synchronous part runs + * now, on the caller's stack, and the runner waits for an async hook's + * promise before the first top-level test. The first failure fails the + * top-level tests and suites (scr_test_fail_unrun). */ +static void scr_test_root_before_now(ScrTestCtx *root, ScrClosure *cb, int flags) { + bool takes_ctx = (flags & SCR_TEST_F_CTX) != 0; + if (flags & SCR_TEST_F_ASYNC) { + ScrPromise *p = + takes_ctx + ? ((ScrPromise * (*)(ScrClosure *, ScrTestCtx *)) cb->fn)(cb, scr_testctx_retain(root)) + : ((ScrPromise * (*)(ScrClosure *)) cb->fn)(cb); + if (p && !scr_exc_pending()) { + if (scr_test_root_npending == scr_test_root_pending_cap) { + scr_test_root_pending_cap = scr_test_root_pending_cap ? scr_test_root_pending_cap * 2 : 2; + scr_test_root_pending = realloc(scr_test_root_pending, + scr_test_root_pending_cap * sizeof *scr_test_root_pending); + if (!scr_test_root_pending) scr_test_oom(); + } + /* The runner observes it: a rejection is the hook's failure, not an + * unhandled rejection. */ + scr_promise_mark_handled(p); + scr_test_root_pending[scr_test_root_npending++] = p; + return; + } + scr_promise_release(p); + } else if (takes_ctx) { + ((void (*)(ScrClosure *, ScrTestCtx *))cb->fn)(cb, scr_testctx_retain(root)); + } else { + ((void (*)(ScrClosure *))cb->fn)(cb); + } + scr_test_root_before_failed(root); +} + +void scr_test_hook(double which, ScrClosure *cb /*moves*/, double flags, ScrStr *at) { scr_test_ensure_root(); ScrTestCtx *owner = scr_test_parent_get(); ScrTestHooks *h = &owner->hooks[(int)which]; @@ -1545,7 +1674,10 @@ void scr_test_hook(double which, ScrClosure *cb /*moves*/, double flags) { } h->v[h->n].cb = cb; h->v[h->n].flags = (int)flags; + h->v[h->n].at = at && at->len > 0 ? scr_str_retain(at) : NULL; h->n++; + if ((int)which == SCR_HOOK_BEFORE && owner == scr_test_root) + scr_test_root_before_now(owner, cb, (int)flags); } /* t.test(...): registers under `t` and — because subtests run inline on @@ -1620,6 +1752,7 @@ void scr_test_ctx_hook(ScrTestCtx *t, double which, ScrClosure *cb /*moves*/, do } h->v[h->n].cb = cb; h->v[h->n].flags = (int)flags; + h->v[h->n].at = NULL; h->n++; } @@ -1631,6 +1764,7 @@ static void scr_test_mocks_add(ScrTestHooks *h, ScrClosure *restore /*moves*/) { } h->v[h->n].cb = restore; h->v[h->n].flags = 0; + h->v[h->n].at = NULL; h->n++; } @@ -2172,6 +2306,7 @@ void scr_test_ctx_diagnostic(ScrTestCtx *t, ScrStr *msg /*borrowed*/) { } ScrStr *scr_test_ctx_name(ScrTestCtx *t) { + if (!t->name && !t->parent) return scr_str_new("", 6); /* Node's root test */ return t->name ? scr_str_retain(t->name) : scr_str_new("", 0); } diff --git a/packages/runtime/src/scr_test.h b/packages/runtime/src/scr_test.h index 26f8928f3..64a280bf7 100644 --- a/packages/runtime/src/scr_test.h +++ b/packages/runtime/src/scr_test.h @@ -33,8 +33,10 @@ void scr_test_register(ScrStr *name, double mode, ScrStr *msg, ScrClosure *cb, d void scr_test_suite(ScrStr *name, double mode, ScrStr *msg, ScrClosure *cb, ScrStr *at, double flags, double concurrency); /* before/after/beforeEach/afterEach on the CURRENT registration parent - * (`which`: 0 before, 1 after, 2 beforeEach, 3 afterEach). */ -void scr_test_hook(double which, ScrClosure *cb, double flags); + * (`which`: 0 before, 1 after, 2 beforeEach, 3 afterEach); `at` is the + * hook call's "file:line:col". The root's before and after hooks run + * around the top-level tests. */ +void scr_test_hook(double which, ScrClosure *cb, double flags, ScrStr *at); /* t.test(...): registers under `t`, runs the subtest INLINE on the * runner fiber, and returns the settled promise the `await` consumes (+1). */ ScrPromise *scr_test_sub(ScrTestCtx *t, ScrStr *name, double mode, ScrStr *msg, ScrClosure *cb, double flags, ScrStr *at, diff --git a/tests/fixtures/node-test/cases/root-after-throws.ts b/tests/fixtures/node-test/cases/root-after-throws.ts new file mode 100644 index 000000000..f7c20b9b0 --- /dev/null +++ b/tests/fixtures/node-test/cases/root-after-throws.ts @@ -0,0 +1,10 @@ +// A throwing module-level after hook: the run reports the entry file as a +// failed result with the hook's location, after the top-level results, +// without counting it, and the exit code stays 0, as in Node. +import { after, test } from "node:test"; + +after(() => { + throw new Error("root after failed"); +}); + +test("t", () => {}); diff --git a/tests/fixtures/node-test/cases/root-before-throws.ts b/tests/fixtures/node-test/cases/root-before-throws.ts new file mode 100644 index 000000000..b12c50060 --- /dev/null +++ b/tests/fixtures/node-test/cases/root-before-throws.ts @@ -0,0 +1,30 @@ +// @exit: 1 +// A throwing module-level before hook: each top-level test fails with its +// error without running its body or beforeEach hooks, and each top-level +// suite fails with it while the tests and suites in it are cancelled +// before they start. Later module-level before hooks still run at their +// before() calls, and the first failure is the one reported. +import { before, beforeEach, describe, it, test } from "node:test"; + +before(() => { + throw new Error("root before failed"); +}); +before(async () => { + await Promise.resolve(); + throw new Error("a later failure"); +}); +beforeEach(() => { + throw new Error("beforeEach never runs"); +}); + +describe("s", () => { + it("x", () => {}); + describe("inner", () => { + it("y", () => {}); + }); + it("z", () => {}); +}); + +test("t", () => { + throw new Error("the body never runs"); +}); diff --git a/tests/fixtures/node-test/cases/root-hooks.ts b/tests/fixtures/node-test/cases/root-hooks.ts new file mode 100644 index 000000000..8159aa7bb --- /dev/null +++ b/tests/fixtures/node-test/cases/root-hooks.ts @@ -0,0 +1,44 @@ +// Module-level before hooks run at their before() calls, with the root's +// context (named ""), and the first top-level test waits for the +// async ones; module-level after hooks run after the last top-level test +// or suite, and module-level beforeEach hooks run before each test, with +// that test's context. +import { after, before, beforeEach, describe, it, test } from "node:test"; +import * as assert from "node:assert"; + +const seen: string[] = []; + +before((c) => { + seen.push(`before: ${c.name}`); +}); +seen.push("after the before() call"); +before(async () => { + seen.push("async before starts"); + await new Promise((resolve) => setTimeout(resolve, 5)); + seen.push("async before ends"); +}); +beforeEach((c) => { + seen.push(`beforeEach: ${c.name}`); +}); +after(() => { + // Throws, and so fails the run visibly, unless every hook ran in order. + assert.deepStrictEqual(seen, [ + "before: ", + "after the before() call", + "async before starts", + "suite body", + "async before ends", + "beforeEach: x", + "beforeEach: t", + "report", + ]); +}); + +describe("s", () => { + seen.push("suite body"); + it("x", () => {}); +}); + +test("t", () => { + seen.push("report"); +}); From 571ffb10a9685ed6456025bbc76bbea232dc5b96 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 09:03:08 -0700 Subject: [PATCH 4/7] Refresh the measured corpus costs from recent main runs 298 of the 3008 corpus programs had no measured cost, which left main three unmeasured programs above the shard harness's 90% coverage floor: any PR adding a few corpus programs failed shard.test.ts. Rerun scripts/ci-corpus-costs.mjs over the 120 green Linux corpus shard logs of main runs 39131161610, 39130670620 and 39126633135 (31b52e215, aba3c3a97, 572b26ef8), and drop the entry of the renumbered 5942-local-class-observed-methods.ts. 2989 programs are now measured. Co-Authored-By: Claude Opus 5.5 --- tests/harness/corpus-costs.json | 11330 ++++++++++++++++-------------- 1 file changed, 5944 insertions(+), 5386 deletions(-) diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index 9f3c007f3..dee54f628 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -1,5427 +1,5985 @@ { "note": "Milliseconds per corpus program on a GitHub-hosted ubuntu-24.04 runner: its differential plus llvm-differential case, per flavor (medians of green main runs). scripts/ci-corpus-costs.mjs refreshes it from CI logs.", "plain": { - "001-hello.ts": 3069, - "002-log-args.ts": 2728, - "100-number-format.ts": 3733, - "1000-json-stringify-basics.ts": 4746, - "1001-json-escapes-unicode.ts": 3114, - "1002-json-parse-cast.ts": 4816, - "1003-json-parse-unions.ts": 3373, - "1004-json-parse-errors.ts": 2257, - "1005-json-nested.ts": 3430, - "1006-json-fs-config.ts": 3508, - "1007-json-rc-stress.ts": 4738, - "1008-json-null-arms.ts": 3237, - "1009-json-optional-fields.ts": 3598, - "101-arithmetic.ts": 2904, - "1010-json-stringify-space.ts": 4663, - "1011-json-unknown-typeof.ts": 2914, - "102-comparisons.ts": 2408, - "1020-async-basics.ts": 2514, - "1021-async-ordering.ts": 2150, - "1022-async-exceptions.ts": 2155, - "1023-async-rc-stress.ts": 3249, - "1024-async-pending-exit.ts": 3248, - "1025-async-promise-capture.ts": 4134, - "1026-throw-promise.ts": 2862, - "1027-async-return-promise.ts": 3195, - "1028-async-return-record-literals.ts": 2979, - "1029-async-eager-chains.ts": 3200, - "103-ternary.ts": 2586, - "104-ternary-empty-arrays.ts": 3925, - "1050-comptime-tables.ts": 3449, - "1051-comptime-strings.ts": 4033, - "1052-comptime-records.ts": 4539, - "1053-comptime-json.ts": 2953, - "1054-comptime-modules/main.ts": 2477, - "110-number-radix.ts": 2253, - "111-record-entries.ts": 4124, - "1110-math-members.ts": 3859, - "1111-math-random.ts": 2956, - "1113-string-methods.ts": 3292, - "1114-string-unicode-island.ts": 2830, - "1115-parse-globals.ts": 2990, + "001-hello.ts": 3065, + "002-log-args.ts": 4101, + "100-number-format.ts": 4051, + "1000-json-stringify-basics.ts": 5187, + "1001-json-escapes-unicode.ts": 4569, + "1002-json-parse-cast.ts": 3516, + "1003-json-parse-unions.ts": 3382, + "1004-json-parse-errors.ts": 4383, + "1005-json-nested.ts": 5206, + "1006-json-fs-config.ts": 3979, + "1007-json-rc-stress.ts": 3920, + "1008-json-null-arms.ts": 3823, + "1009-json-optional-fields.ts": 4367, + "101-arithmetic.ts": 3258, + "1010-json-stringify-space.ts": 3979, + "1011-json-unknown-typeof.ts": 4108, + "102-comparisons.ts": 4061, + "1020-async-basics.ts": 3165, + "1021-async-ordering.ts": 3062, + "1022-async-exceptions.ts": 3356, + "1023-async-rc-stress.ts": 3530, + "1024-async-pending-exit.ts": 2901, + "1025-async-promise-capture.ts": 3471, + "1026-throw-promise.ts": 3173, + "1027-async-return-promise.ts": 2405, + "1028-async-return-record-literals.ts": 3561, + "1029-async-eager-chains.ts": 3698, + "103-ternary.ts": 3292, + "104-ternary-empty-arrays.ts": 4072, + "1050-comptime-tables.ts": 3518, + "1051-comptime-strings.ts": 2082, + "1052-comptime-records.ts": 3252, + "1053-comptime-json.ts": 3388, + "1054-comptime-modules/main.ts": 3286, + "110-number-radix.ts": 3749, + "111-record-entries.ts": 4017, + "1110-math-members.ts": 2615, + "1111-math-random.ts": 2691, + "1113-string-methods.ts": 3490, + "1114-string-unicode-island.ts": 2532, + "1115-parse-globals.ts": 2850, "1116-island-static-mix.ts": 3032, - "1117-typeof-static-union.ts": 2965, - "1118-object-spread-conditional.ts": 2667, - "1119-switch-union.ts": 3067, - "112-class-descriptor-key.js": 2522, - "1121-infinity-number-tostring.ts": 3370, - "1122-any-captures.ts": 3176, - "1124-union-narrowed-retag.ts": 2492, - "113-promise-checked-exits.ts": 2859, - "114-live-record-delete.ts": 2500, - "115-array-compound.js": 3135, - "116-text-decoder-runtime.js": 2862, - "117-weak-cache-cycle.js": 2266, - "118-fs-stored-callbacks.cjs": 3485, - "119-native-patterns.js": 3500, - "1200-regex-test-basics.ts": 3223, - "1201-regex-replace.ts": 3086, - "1202-regex-substitutions.ts": 3684, - "1203-regex-split.ts": 3320, - "1204-regex-empty-unicode.ts": 2968, - "1205-regex-rc-stress.ts": 2448, - "1300-errors-basics.ts": 2709, - "1301-errors-subclass.ts": 3447, - "1302-errors-typed-catch.ts": 3128, - "1303-errors-rc-stress.ts": 2776, - "1304-errors-uncaught.ts": 2907, - "1305-errors-async-rejections.ts": 2863, - "1306-errors-runtime-instances.ts": 2803, - "1350-path-normalize-join.ts": 2394, - "1351-path-parts.ts": 2228, - "1352-path-resolve-relative.ts": 3019, - "1353-os-basics.ts": 2682, - "1354-builtin-bare-specifiers.ts": 2284, - "1355-url-parse.ts": 2467, - "1356-url-file-bridge.ts": 3063, - "1357-fsp-roundtrip.ts": 3440, - "1358-crypto-random.ts": 2124, - "1359-json-module/main.ts": 2889, - "1360-spawn-sync.ts": 3158, - "1361-spawn-events.ts": 3000, - "1362-spawn-timers.ts": 8505, - "1363-spawn-unhandled-error.ts": 2724, - "1364-union-truthiness.ts": 2131, - "1365-union-logical.ts": 2948, - "1366-union-equality.ts": 2233, - "1367-destructuring.ts": 3492, - "1368-constructor-functions.ts": 2941, - "1369-promise-union.ts": 2048, - "1370-spread.ts": 2658, - "1371-union-template-tostring.ts": 2681, - "1372-loose-null-tests.ts": 2819, - "1373-union-array-arms.ts": 2414, - "140-bitwise-operators.ts": 3378, - "1400-typedarray-basics.ts": 3056, - "1401-typedarray-slice-set.ts": 2697, - "1402-buffer-encodings.ts": 3146, - "1403-buffer-fs.ts": 3327, - "1404-zlib-crypto-bytes.ts": 3318, - "1405-bytes-unions-arrays.ts": 2463, - "1406-dataview-mp4.ts": 2536, - "1407-dataview-bounds.ts": 3301, - "1408-string-indexing.ts": 2027, - "1409-typedarray-integer-loops.ts": 2940, - "1420-number-statics.ts": 2894, - "1421-number-parse-strings.ts": 2645, - "1422-date-iso.ts": 2686, - "1423-text-codec.ts": 4188, - "1424-fs-options.ts": 2662, - "1425-stdin-tty.ts": 2638, - "1426-stdin-read.ts": 2379, - "1427-fromcharcode-lastindexof.ts": 2109, - "1428-settled-await-order.ts": 2663, - "1429-promise-catch-finally.ts": 3486, - "1430-promise-race.ts": 4032, - "1431-caught-tostring.ts": 2082, - "1432-destructured-params.ts": 3251, - "1433-filter-narrow.ts": 3353, - "1434-async-never.ts": 2711, - "1435-math-spread.ts": 2665, - "1436-default-undef-param.ts": 2896, - "1437-pad-default.ts": 3003, - "1438-promise-all.ts": 6347, - "1440-interval-basics.ts": 3004, - "1441-interval-clear-cross.ts": 5524, - "1442-interval-throw.ts": 3148, - "1443-signal-handlers.ts": 5739, - "1444-exit-listeners.ts": 3270, - "1445-exit-process-exit.ts": 2515, - "1446-exit-uncaught.ts": 2709, - "1447-stdin-closed-events.ts": 2034, - "1448-stream-columns.ts": 2668, - "1450-incdec-expression.ts": 3189, - "1451-instanceof-uint8array-unknown.ts": 3003, - "1452-return-through-finally.ts": 2097, - "1453-pmap-settled.ts": 3863, - "1454-nonnull-narrow-and-fcc-bytes.ts": 2192, - "1455-lambda-union-return-adoption.ts": 3144, - "1460-console-error-warn.ts": 2229, - "1461-process-pid-getuid-kill.ts": 2853, - "1462-exec-sync.ts": 3145, - "1463-timeout-unref.ts": 2935, - "1464-env-writes.ts": 2594, - "1465-env-value.ts": 3233, - "1466-child-containers.ts": 2674, - "1467-string-match.ts": 2677, - "1468-exec-path.ts": 2974, - "1469-remove-listener.ts": 4038, - "1470-child-lifecycle.ts": 1948, - "1471-child-unref.ts": 6913, - "1472-errno-code.ts": 2768, - "1473-promisify-execfile.ts": 3155, - "1474-string-decoder.ts": 3057, - "1475-readline-closed-stdin.ts": 2826, - "1476-assign-expression.ts": 2557, - "1477-in-expressions.ts": 2740, - "1478-promise-reject.ts": 3143, - "1479-destructuring-assign.ts": 2933, - "1480-os-network-interfaces.ts": 3749, - "1481-string-case-static.ts": 1949, - "1482-spawnsync-error.ts": 2332, - "1483-array-slice.ts": 3329, - "1520-fs-wider-surface.ts": 3206, - "1520-string-split-static.ts": 2787, - "1521-fs-lstat-lock.ts": 2868, - "1521-string-trim-pad-static.ts": 2727, - "1522-parseint-static.ts": 2059, - "1522-spawnsync-options.ts": 3990, - "1523-isnan-floor-static.ts": 2552, - "1523-spawn-options.ts": 2955, - "1524-atomics-sleep-static.ts": 3221, - "1524-catch-narrowing.ts": 2221, - "1525-child-exit-signal.ts": 2022, - "1525-unknown-typeof-validation.ts": 2311, - "1526-set-spread.ts": 3277, - "1527-logical-mixed-operands.ts": 2920, - "1528-delete-records-env.ts": 3318, - "1529-class-with-statics.ts": 2626, - "1530-array-push-variadic.ts": 2272, - "1530-spread-override-completion.ts": 2333, - "1531-delete-optional-fields.ts": 2822, - "1531-process-arch-versions.ts": 2409, - "1532-array-splice-shift.ts": 2440, - "1532-union-shared-field-read.ts": 2449, - "1533-bool-equality.ts": 3130, - "1533-path-platform-namespaces.ts": 2472, - "1534-crypto-hash-chain.ts": 3303, - "1534-union-as-arm-cast.ts": 2773, - "1535-spawn-fd-stdio.ts": 3617, - "1535-union-param-defaults.ts": 2848, - "1536-destructuring-defaults.ts": 2783, - "1536-string-array-sweep.ts": 2930, - "1537-chalk-hybrid/main.ts": 3161, - "1537-os-release-spawnsync-stdio.ts": 2411, - "1538-await-promiselike-return.ts": 2433, - "1538-math-static-scalar.ts": 2674, - "1539-readonly-set-map.ts": 2573, - "1539-unknown-truthiness.ts": 2629, - "1540-os-userinfo.ts": 2636, - "1540-void-statement.ts": 2658, - "1541-fs-readdir-dirent.ts": 3093, - "1541-union-keyed-reads.ts": 4144, - "1542-map-promise-values.ts": 2657, - "1542-record-literal-into-union.ts": 3004, - "1543-rest-destructuring.ts": 2897, - "1543-set-server-handles.ts": 2927, - "1544-dyn-json-reads.ts": 3602, - "1544-string-matchall.ts": 2940, - "1545-spread-order-and-optional.ts": 2963, - "1546-union-element-reads.ts": 2716, - "1547-computed-key-fold.ts": 4334, - "1548-boolean-condition-forms.ts": 4675, - "1549-array-isarray-unions.ts": 3420, - "1550-param-defaults-func-set.ts": 3314, - "1551-dyn-receiver-methods.ts": 4271, - "1552-exec-options-record.ts": 3353, - "1553-truthy-hof-predicates.ts": 2475, - "1554-caught-into-unknown.ts": 2996, - "1555-index-spread-into-declared.ts": 3100, - "1556-union-retag-width-arms.ts": 2198, - "1557-url-host.ts": 2745, - "1558-any-joins-and-dyn-validation.ts": 2600, - "1559-conditional-spread-index-merge.ts": 3037, - "1560-forof-homogeneous-tuples.ts": 2478, - "1561-forof-strings.ts": 2503, - "1561-promise-then.ts": 3156, - "1562-optional-chain-tails.ts": 3390, - "1562-spawn-conditional-spread.ts": 3006, - "1563-forof-iterator-projections.ts": 3054, - "1563-string-raw-fold.ts": 2666, - "1564-fs-watch.ts": 3415, - "1564-string-raw.ts": 2651, - "1565-spawn-pipe-streams.ts": 3154, - "1565-union-element-join.ts": 2733, - "1566-child-duck-interface.ts": 2463, - "1567-server-close-override.ts": 2863, - "1568-x509-fingerprint.ts": 2419, - "1569-fsp-mkdir-unlink-chmod.ts": 2704, - "1570-child-unref-kill-reffed.ts": 8818, - "1571-optional-call-tostring-tail.ts": 4280, - "1571-stdin-set-raw-mode-non-tty.ts": 2435, - "1572-promise-reject-all-tuple.ts": 3046, - "1572-x509-validity-date-gettime.ts": 2933, - "1573-promisify-execfile-env-spread.ts": 3140, - "1573-tdz-scalar-forward-capture.ts": 2068, - "1574-dyn-optional-method-number-keys.ts": 3318, - "1574-promise-all-tuple-literal.ts": 3025, - "1575-unknown-assert-into-record.ts": 3248, - "1576-width-coercions.ts": 2888, - "1577-url-hostname.ts": 2352, - "1578-exec-input-optional.ts": 3178, - "1579-matchall-index.ts": 3025, - "1580-exec-env-conditional-spread.ts": 3275, - "1581-declare-const-read.ts": 2341, - "1582-timer-sleep-resolve.ts": 2315, - "1583-loops-and-stream-captures.ts": 3154, - "1584-union-field-unassigned.ts": 2858, - "1585-union-field-conditional-ctor.ts": 2073, - "1586-derived-field-before-super-init.ts": 2823, - "1590-js-unannotated.js": 2965, - "1591-js-closures.js": 2113, - "1592-js-classes.js": 4260, - "1593-js-jsdoc-records.js": 3366, - "1594-js-async.js": 2772, - "1595-js-island-gap/main.js": 2168, - "1596-cjs-modules/main.js": 2751, - "1597-mjs-graph/main.mjs": 2858, - "1598-cjs-builtin-require/main.js": 2109, - "1599-js-uncaught-throw.js": 1870, - "1600-assert-passing.ts": 3321, - "1601-assert-fail-exit.ts": 2842, - "1602-assert-caught-error.ts": 2041, - "1603-assert-scalar-messages.ts": 2650, - "1604-assert-deep-structures.ts": 3035, - "1605-assert-import-forms.ts": 3128, - "1606-assert-strict-module.ts": 2927, - "1607-assert-throws-match.ts": 2731, - "1608-cjs-assert/main.js": 3193, - "1609-assert-async.ts": 1990, - "1610-path-win32-full.ts": 1939, - "1611-url-file-bridge-neutral.ts": 2575, - "1612-cjs-module-globals.cjs": 2846, - "1613-cjs-esm-proxy-named/main.mjs": 2282, - "1614-js-fence-dodges.cjs": 2910, - "1615-cjs-export-shapes/main.cjs": 3349, - "1616-cjs-esm-lexer-invisible/main.mjs": 2499, - "1617-cjs-esm-lexer-visible/main.mjs": 2355, - "1618-cjs-esm-poisoned-tail/main.mjs": 2404, - "1619-cjs-esm-reexport-invisible/main.mjs": 2675, - "1620-cjs-require-effects-order/main.js": 2586, - "1621-cjs-require-cache-hit/main.js": 2101, - "1622-cjs-require-conditional/main.js": 2194, - "1623-cjs-require-diamond/main.js": 2241, - "1624-cjs-require-dir-mid-file/main.js": 2559, - "1625-cjs-require-lazy-fn/main.js": 2333, - "1626-cjs-require-mjs/main.js": 2430, - "1627-mjs-import-cjs-requires/main.mjs": 2803, - "1628-checked-dynamic-builtin-args.cjs": 2085, - "1629-require-main-filename.cjs": 2419, - "1630-inspect-scalars.ts": 2701, - "1630-rmsync-retry-options.cjs": 2427, - "1631-inspect-arrays.ts": 3949, - "1632-inspect-records.ts": 3013, - "1633-inspect-map-set.ts": 2316, - "1634-inspect-classes.ts": 3062, - "1635-inspect-buffer.ts": 2271, - "1636-util-format.ts": 2132, - "1637-inspect-dyn.ts": 3164, - "1638-inspect-cjs.cjs": 2023, - "1639-versions-openssl-probe.ts": 2845, - "1640-fd-read-decode.ts": 3219, - "1641-string-search.ts": 3172, - "1642-object-fromentries-rows.ts": 2713, - "1643-metadata-dyn-return.cjs": 3460, - "1644-ee-basics.ts": 2495, - "1645-ee-extends.ts": 2603, - "1646-ee-once-remove.ts": 2849, - "1647-ee-meta-events.ts": 2040, - "1648-ee-error-event.ts": 2703, - "1649-ee-names-counts.ts": 2487, - "1650-ee-prepend.ts": 2672, - "1651-ee-max-listeners.ts": 2331, - "1652-ee-snapshot.ts": 2031, - "1653-ee-cjs.cjs": 2472, - "1654-ee-namespace.ts": 2390, - "1655-spawnsync-neutral.ts": 4056, - "1656-execsync-neutral.ts": 2824, - "1657-spawn-async-neutral.ts": 3268, - "1660-buffer-read-write-num.ts": 3727, - "1661-buffer-encodings-full.ts": 2670, - "1662-string-decoder-encodings.ts": 2362, - "1663-buffer-compare-search-fill.ts": 3956, - "1664-dyn-fn-boundary.cjs": 2792, - "1665-dyn-fn-mustcall/main.cjs": 2827, - "1666-dyn-fn-identity.ts": 2623, - "1667-dyn-fn-not-callable.cjs": 2618, - "1668-dyn-fn-throws.cjs": 2216, - "1669-symbol-identity.ts": 2335, - "1670-symbol-registry.ts": 1852, - "1671-symbol-typeof.ts": 2343, - "1672-symbol-containers.ts": 2800, - "1673-symbol-cjs.cjs": 2407, - "1674-symbol-inspect.ts": 1818, - "1676-func-array-surface.ts": 2784, - "1677-emitter-listeners.ts": 2400, - "1678-emitter-dyn-listeners.cjs": 2358, - "1679-console-dyn.js": 2880, - "1680-assert-bytes.ts": 3465, - "1681-assert-funcs.ts": 2454, - "1685-stream-readable-basics.ts": 2506, - "1686-stream-readable-paused.ts": 2711, - "1687-stream-readable-flow-control.ts": 2359, - "1688-stream-writable-basics.ts": 2613, - "1689-stream-writable-async-drain.ts": 2671, - "1690-stream-duplex.ts": 2112, - "1691-stream-transform.ts": 1780, - "1692-stream-pipe.ts": 3345, - "1693-stream-pipe-backpressure.ts": 2344, - "1694-stream-destroy.ts": 1870, - "1695-stream-props.ts": 2766, - "1696-stream-read-inside-read.ts": 3023, - "1697-stream-tick-vs-timer.ts": 2275, - "1698-stream-uncaught-error.ts": 2523, - "1699-stream-callback-shapes.ts": 1972, - "1700-mustcall-common/main.cjs": 3401, - "1701-mustcall-exit-report/main.cjs": 3316, - "1702-dyn-proto-dispatch.cjs": 2744, - "1703-arguments-rest-props.cjs": 2431, - "1710-cjs-export-class/main.js": 2997, - "1711-cjs-export-single-values/main.js": 2866, - "1712-field-incdec.ts": 1828, - "1713-js-dyn-fields.js": 2492, - "1720-assert-throws-shape.ts": 2372, - "1721-assert-throws-regex-class.ts": 2125, - "1722-assert-rejects.ts": 2761, - "1723-assert-does-not-reject.ts": 2536, - "1724-assert-iferror.ts": 2883, - "1725-assert-symbols.ts": 2626, - "1726-promise-with-resolvers.ts": 2320, - "1727-assert-throws-shape-exit.ts": 2580, - "1730-countdown-symbol-keys/main.js": 2657, - "1731-symbol-field-shapes.cjs": 3005, - "1732-symbol-field-cross-module/main.js": 2509, - "1740-stream-extends-readable.ts": 2167, - "1741-stream-extends-writable.ts": 2479, - "1742-stream-extends-duplex-transform.ts": 2640, - "1743-stream-extends-vt-dispatch.ts": 2388, - "1744-stream-set-encoding.ts": 2886, - "1745-stream-encoding-js.cjs": 2861, - "1746-stream-for-await.ts": 2864, - "1747-stream-for-await-js.cjs": 2685, - "1750-http-agent-options.ts": 2435, - "1751-options-record-stance.ts": 3010, - "1760-surplus-args-drop.cjs": 2845, - "1761-emitter-special-event-names.cjs": 2672, - "1770-assert-dyn-strict.ts": 2841, - "1771-assert-dyn-deep.ts": 2098, - "1772-assert-dyn-js.cjs": 2493, - "1773-assert-dyn-exit.ts": 2809, - "1780-http-res-surface.ts": 3019, - "1781-http-server-shapes.cjs": 2697, - "1790-computed-key-folds.ts": 2567, - "1791-searchparams-core.ts": 2632, - "1792-searchparams-encoding.ts": 2548, - "1793-searchparams-iteration.ts": 2977, - "1794-searchparams-url-live.ts": 2027, - "1795-dyn-handle-request.cjs": 2079, - "1796-dyn-handle-body.cjs": 3120, - "1797-dyn-handle-socket.cjs": 2724, - "1798-dyn-handle-typed-box.ts": 2104, - "1800-immediate-basics.ts": 2313, - "1801-immediate-handle.ts": 2272, - "1802-immediate-unref-exit.ts": 2368, - "1803-timeout-refresh.ts": 2346, - "1804-timers-module.ts": 2379, - "1805-timer-callback-args.ts": 2475, - "1806-timer-delay-trunc.ts": 2847, - "1810-stream-options-const-record.ts": 2576, - "1811-stream-option-value-callbacks.cjs": 2945, - "1812-stream-super-options-forwarding.cjs": 3075, - "1813-stream-finished.ts": 2644, - "1814-stream-pipeline.cjs": 2915, - "1815-stream-state-reads.cjs": 2499, - "1820-static-block-basics.ts": 2475, - "1821-static-block-order.ts": 2605, - "1822-static-block-js.js": 1831, - "1823-static-instance-method-names.ts": 2522, - "1824-for-of-destructuring-defaults.ts": 2238, - "1825-exhaustive-typeof-switch.ts": 1814, - "1826-settimeout-arguments-callback.js": 2356, - "1830-enum-numeric-basics.ts": 2431, - "1831-enum-string-const-reverse.ts": 2780, - "1832-enum-modules/main.ts": 2343, - "1835-var-basics.ts": 2924, - "1836-var-loop-capture.ts": 2857, - "1837-var-undefined-hoisting.ts": 2785, - "1838-var-modules/main.ts": 2572, - "1839-var-js/main.cjs": 2766, - "1840-jsdoc-import-type-only/main.js": 2328, - "1850-overload-basics.ts": 2354, - "1851-overload-return-narrowing.ts": 2268, - "1852-overload-class-members.ts": 2874, - "1853-overload-modules/main.ts": 2339, - "1854-ambient-declare-fn.ts": 2384, - "1855-ambient-declare-fn-uncaught.ts": 2441, - "1870-unit-type-values.ts": 2730, - "1871-empty-array-never.ts": 2177, - "1872-template-tostring-composite.ts": 2526, - "1880-json-declared-field-order.ts": 2276, - "1881-default-anon/main.ts": 2233, - "1882-default-cjs-interop/main.ts": 2407, - "1883-default-exports/main.ts": 2358, - "1890-ns-imports/main.ts": 2428, - "1891-ns-reexport/main.ts": 2422, - "1940-class-values-basics.ts": 2483, - "1941-class-values-registry.ts": 2632, - "1942-class-expressions.ts": 2765, - "1943-class-statics-expanded.ts": 2459, - "1944-class-values-modules/main.ts": 2440, - "1950-generic-fn-values.ts": 2561, - "1951-generic-classes-basics.ts": 2197, - "1952-generic-class-statics-values.ts": 2662, - "1953-generic-class-hierarchy.ts": 3001, - "1954-generic-modules/main.ts": 2756, - "1960-namespace-basics.ts": 2647, - "1961-namespace-nested.ts": 2257, - "1962-namespace-classes.ts": 2660, - "1963-namespace-aliases.ts": 2070, - "1964-namespace-type-only.ts": 2445, - "1965-namespace-ambient.ts": 2332, - "1966-namespace-modules/main.ts": 2434, - "1967-namespace-alias-typeonly.ts": 2455, - "1968-namespace-import-eq-snapshot.ts": 2251, - "1970-decorators-basics.ts": 2885, - "1971-decorators-rebinding.ts": 2022, - "1972-decorators-throwing.ts": 2312, - "1973-decorators-ambient.ts": 2390, - "1980-primitive-proto-statics.ts": 3122, - "1981-date-utc.ts": 3440, - "1982-freeze-resolve-passthrough.ts": 2302, - "1983-array-tuple-surfaces.ts": 3057, - "1990-labels-basics.ts": 2548, - "1991-for-in-loops.ts": 2966, - "1992-small-syntax.ts": 1927, - "200-strings.ts": 2314, - "2000-generic-methods-basic.ts": 2743, - "2001-generic-methods-generic-class.ts": 2632, - "2002-generic-methods-inheritance.ts": 3264, - "2003-generic-methods-object-literal.ts": 2644, - "2004-generic-methods-statics.ts": 2578, - "201-templates.ts": 2516, - "2010-generators-basics.ts": 1908, - "2011-generators-forof.ts": 2574, - "2012-generators-return-throw.ts": 2779, - "2013-generators-sent-values.ts": 2065, - "2014-generators-values.ts": 2940, - "2015-generators-yieldstar.ts": 1953, - "2016-generators-rc-stress.ts": 2595, - "2017-generators-async.ts": 2715, - "2018-generators-uncaught.ts": 2356, - "2019-generators-loops.ts": 2496, - "2020-generic-value-bindings.ts": 2351, - "2021-generic-value-binding-modules/main.ts": 2687, - "2022-width-index-capture.ts": 2751, - "2023-width-readonly.ts": 2800, - "2024-width-array-elems.ts": 2726, - "2025-width-union-compose.ts": 2851, - "2026-width-spread.ts": 2485, - "2030-width-nested.ts": 2774, - "2031-width-tuples.ts": 2693, - "2032-cjs-export-assigned-class-expression/main.cjs": 2477, - "2033-property-assigned-class-extends.cjs": 2618, - "2035-ternary-array-retag.cjs": 2404, - "2036-evolving-array-decl.cjs": 2542, - "2037-fn-decl-hoisting.cjs": 2645, - "2038-evolving-array-js.cjs": 3054, - "2040-any-bindings.ts": 2984, - "2040-mixin-heritage.ts": 2131, - "2041-any-params-returns.ts": 2687, - "2041-mixin-values.ts": 2744, - "2042-any-flow-loops.ts": 2769, - "2042-mixin-modules/main.ts": 1924, - "2043-any-dom-values.ts": 2778, - "2043-mixin-rc-stress.ts": 2775, - "2044-vtable-sibling-slots.ts": 2571, - "2045-objlit-accessors-basic.ts": 2640, - "2045-parameter-properties.ts": 2113, - "2046-abstract-classes.ts": 3000, - "2046-objlit-accessors-effects.ts": 2795, - "2047-objlit-accessors-shapes.ts": 2983, - "2047-optional-class-fields.ts": 2949, - "2050-dynamic-import-own-module/main.ts": 2608, - "2051-dynamic-import-then/main.ts": 2467, - "2052-dynamic-import-self.ts": 2449, - "2053-typeof-static-fold.ts": 2181, - "2054-destructuring-island-source.ts": 2707, - "2060-empty-tuple.ts": 2373, - "2070-computed-key-folds.ts": 2645, - "2071-integer-key-enumeration-order.ts": 3006, - "2072-expando-function-members.ts": 2512, - "2073-destructuring-assignment.ts": 2535, - "2074-island-destructuring.ts": 2609, - "2075-index-signature-runtime-keys.ts": 1981, - "2080-destructuring-defaults.ts": 2417, - "2081-destructuring-rest.ts": 2774, - "2082-destructuring-assignment.ts": 2489, - "2085-destructuring-heads-rest-params.ts": 2668, - "2087-destructuring-for-heads.ts": 2521, - "2090-index-signature-number-keys.ts": 1958, - "2091-index-signature-string-intersection.ts": 2567, - "2092-package-imports/main.ts": 2340, - "2093-timers-promises.ts": 2743, - "2094-diagnostics-channel.ts": 1983, - "2095-js-catch-unknown.js": 2499, - "2096-os-type.ts": 2709, - "2097-js-evolving-globals.js": 2560, - "210-string-methods.ts": 2593, - "2100-stream-default-hwm.ts": 2961, - "2101-dyn-param-defaults.ts": 2737, - "2102-empty-pattern-decls.ts": 2787, - "2105-computed-key-static-folds.ts": 2507, - "2106-comma-expressions.ts": 2500, - "211-string-unicode.ts": 1823, - "2110-top-object-types.ts": 1971, - "2111-json-stringify-unknown.ts": 2830, - "2112-array-at-findlast.ts": 2001, - "2113-string-index-methods.js": 2989, - "212-string-aliasing-append.ts": 1909, - "2120-package-self-import/main.ts": 1825, - "2121-esm-cycle-inert-backedge/main.ts": 1748, - "2123-ambient-import-crash/main.ts": 1870, - "2124-imports-field-wildcard/main.ts": 2082, - "2140-uri-component-codecs.ts": 1955, - "2160-dc-tracing-channel.cjs": 2212, - "2161-js-object-literal-identity.cjs": 2587, - "2162-js-dyn-destructure.cjs": 2628, - "2163-js-selfref-const.cjs": 2533, - "2164-js-then-dyn-handler.cjs": 2503, - "2165-js-throw-dyn.cjs": 2509, - "2166-cjs-getter-this/main.cjs": 2420, - "2170-island-array-exits.ts": 3096, - "2171-island-json-stringify.ts": 2652, - "2172-island-regexp-boundary.ts": 2763, - "2190-new-object-and-string-wrappers.ts": 1860, - "2191-uri-encoders.ts": 2586, - "2192-object-default-tostring.ts": 2607, - "2193-discarded-stdlib-reads.ts": 2445, - "2194-ambient-undef-chains.ts": 2022, - "2195-require-missing-package/main.mjs": 2412, - "2196-island-computed-key-chain.ts": 2831, - "2210-dyn-promise-crossing.cjs": 1918, - "2211-dc-trace-promise.cjs": 2793, - "2212-unhandled-rejection-listener.cjs": 2511, - "2213-async-local-storage.cjs": 2825, - "2214-dc-bind-store.cjs": 2651, - "2215-process-emit-warning-exit.cjs": 2666, - "2240-width-class-into-record.ts": 2573, - "2241-width-record-into-class.ts": 2686, - "2242-width-statics-into-record.ts": 2654, - "2243-width-assert-satisfies-shapes.ts": 2411, - "2250-tagged-templates.ts": 2617, - "2252-class-iterators.ts": 3448, - "2253-union-coercions.ts": 2899, - "2260-http2-constants.cjs": 2471, - "2280-builtin-namespace-destructure.cjs": 2645, - "2281-domexception-atob-btoa.cjs": 2853, - "2282-queue-microtask.cjs": 2526, - "2283-structured-clone.cjs": 3050, - "2284-regexp-constructor.cjs": 1945, - "2285-iferror-dyn.cjs": 2665, - "2286-dyn-object-walks.cjs": 2662, - "2300-dyn-record-spread-and-keyed-access.cjs": 2261, - "2301-cjs-export-table-dom-attach.cjs": 2384, - "2310-process-next-tick.ts": 2843, - "2311-next-tick-js-callbacks.js": 2254, - "2312-stream-underscore-assign.ts": 2790, - "2313-stream-underscore-assign-js.cjs": 2842, - "2314-process-introspection.ts": 2971, - "2320-await-unit.ts": 2748, - "2321-emitter-static-setmax.cjs": 2272, - "2322-dyn-array-sort.cjs": 1886, - "2323-timer-callback-returns.ts": 2523, - "2330-tls-server-runtime-options.cjs": 2677, - "2331-tls-server-options-typed.ts": 2790, - "2350-nan-global.ts": 2734, - "2351-async-methods.ts": 2622, - "2352-void-coercions.ts": 1788, - "2353-decorators-member-ambient.ts": 2547, - "2354-decorators-expression-ambient.ts": 2465, - "2360-tuple-to-array.ts": 2471, - "2361-assign-index-record.ts": 3021, - "2362-execsync-inherit.ts": 2693, - "2363-nullish-retag.ts": 2801, - "2364-in-runtime-key.ts": 2572, - "2365-dyn-into-island.ts": 1996, - "2366-string-well-formed.ts": 2147, - "2367-regexp-escape.ts": 2470, - "2368-set-methods.ts": 2846, - "2369-promise-try.ts": 2170, - "2370-group-by.ts": 2298, - "2371-iterator-helpers.ts": 2730, - "2380-buffer-module-named-import.ts": 2400, - "2381-builtin-default-imports.js": 2365, - "2382-cycle-two-decl/main.ts": 1682, - "2383-cycle-assertdoc/main.js": 2760, - "2384-cycle-mixed-bindings/main.ts": 1815, - "2385-builtin-reexport-facade/main.ts": 1834, - "2386-string-to-chars.ts": 2748, - "2387-tonumber-argv.ts": 2345, - "2388-tonumber-grammar-zoo.ts": 2619, - "2389-tonumber-unary-plus.ts": 2473, - "2390-dot-requires/main.cjs": 2365, - "2391-default-builtin-imports/main.ts": 3036, - "2392-block-guard-alias-scope.ts": 2477, - "2393-loop-exit-guard-narrow.ts": 2791, - "2394-loop-narrow-containment.ts": 2749, - "2395-while-cond-guard.ts": 2574, - "2396-born-narrowed-decl.ts": 2435, - "2397-branch-kill-merge.ts": 2334, - "2398-switch-arm-kill.ts": 2438, - "2399-reassign-kill-polarity.ts": 2238, - "240-stdout-write.ts": 2820, - "2400-kill-return-edge.ts": 2315, - "2401-kill-break-staging.ts": 2347, - "2402-labeled-break-kill.ts": 2610, - "2403-kill-continue-backedge.ts": 2391, - "2404-kill-throw-catch.ts": 2611, - "2405-sibling-arm-narrow.ts": 2300, - "2406-switch-clause-sibling-narrow.ts": 1885, - "2407-infinite-loop-seal.ts": 2596, - "2408-loop-terminality-reopen.ts": 2452, - "2409-loop-body-return-not-terminal.ts": 1860, - "2410-stacked-cases-terminality.ts": 2588, - "2411-exhaustive-switch-terminality.ts": 2704, - "2412-dowhile-guard-trailing-test.ts": 2401, - "2413-dowhile-kill-renarrow.ts": 2389, - "2414-dowhile-continue-kill.ts": 2546, - "2415-dowhile-break-trailing-test.ts": 2461, - "2416-spread-ternary-positions.ts": 2790, - "2417-ternary-local-inference.ts": 2737, - "2418-wrapped-ternary-arms.ts": 2485, - "2419-selector-ternary-union.ts": 2554, - "2420-nullish-null-identity.ts": 2418, - "2421-float-lane-inference.ts": 2337, - "2422-ieee-div-rem-corners.ts": 2498, - "2423-param-null-reassign.ts": 2447, - "2424-ternary-miss-first-narrowing.ts": 2373, - "2425-elseif-head-exit-narrow.ts": 2194, - "2426-default-snapshot-mutable/main.ts": 2194, - "2427-perf-hooks-now.ts": 2489, - "2428-field-redeclare-inherited.ts": 2204, - "2429-destructure-class-instance.ts": 2362, - "2430-empty-literal-unknown-field.js": 2633, - "2431-primitive-ctor-values.ts": 2702, - "2432-generic-member-fields-async.ts": 2679, - "2433-as-const-command-tables.ts": 2271, - "2434-deferred-init-fields.ts": 2673, - "2435-loose-same-kind-equality.ts": 2441, - "2440-console-inspect-args.ts": 3150, - "2441-console-process-argv.ts": 2027, - "2442-union-literal-arm-widening.ts": 2300, - "2443-union-literal-shadow-narrowing.ts": 2799, - "2444-union-literal-reducer-spread.ts": 2545, - "2445-math-minmax-nary.ts": 2355, - "2446-performance-global.ts": 2453, - "2447-island-boundary-slots/main.ts": 3241, - "2448-entries-null-arms-regex-arrays.ts": 3215, - "2450-private-instance-methods.ts": 2581, - "2451-private-fields.ts": 2918, - "2452-private-statics.ts": 2431, - "2453-private-accessors.ts": 2589, - "2454-private-generator-methods.ts": 2809, - "2455-private-brand-checks.ts": 2369, - "2456-private-async-methods.ts": 2625, - "2457-private-members.js": 2014, - "2460-qs-parse-grammar.ts": 2706, - "2461-qs-parse-options.ts": 2139, - "2462-qs-stringify.ts": 2756, - "2463-qs-escape-unescape.ts": 2677, - "2464-qs-require-forms.cjs": 2768, - "2470-mockable-module-shape.js": 3152, - "2471-record-keyed-write-hasown.js": 2699, - "2472-string-regexp-union.ts": 2532, - "2473-option-table-widths.js": 2095, - "2474-island-literal-forms.ts": 2881, - "2475-variadic-wrapper-island.js": 2240, - "2476-map-regex-values.ts": 2431, - "2480-recursive-record-tree.ts": 2075, - "2481-mutual-recursive-records.ts": 2525, - "2482-recursive-union-tree.ts": 2633, - "2483-recursive-record-cycles.ts": 2479, - "2484-json-stringify-circular.ts": 2869, - "2485-inspect-circular-refs.ts": 2957, - "2486-recursive-record-boundaries.ts": 2857, - "2487-recursive-deep-equal.ts": 2516, - "2488-ast-walker.ts": 2925, - "2490-find-miss-null-compare.ts": 2051, - "2491-strict-unit-compare-no-arm.ts": 2381, - "2492-loose-null-compare-unions.ts": 2451, - "2493-switch-unit-cases.ts": 2503, - "2494-no-arm-compare-effects.ts": 2501, - "2500-net-autosel-timeout.ts": 2202, - "2510-dyn-evolving-array-map.ts": 2611, - "2511-dyn-evolving-array-filter-foreach.ts": 2729, - "2512-dyn-evolving-array-mixed-push.ts": 2656, - "2520-private-statics-class-name-calls.ts": 2568, - "2521-private-statics-class-expression.ts": 2429, - "2522-private-statics-decorated.ts": 2492, - "2523-private-statics-aliased-class.ts": 2618, - "2530-object-destructuring-decl.ts": 2513, - "2531-array-tuple-destructuring-decl.ts": 2504, - "2532-param-destructuring-options.ts": 2714, - "2533-forof-destructuring.ts": 2583, - "2534-object-rest-decl.ts": 2277, - "2535-destructuring-assign-basics.ts": 2758, - "2536-destructuring-assign-nested.ts": 2761, - "2537-destructuring-assign-member-targets.ts": 2552, - "2538-destructuring-assign-class-source.ts": 2658, - "2539-class-instance-rest.ts": 2852, - "2540-accessor-destructuring-defaults.ts": 2732, - "2541-destructuring-eval-order.ts": 2121, - "2550-generics-keyof-pick.ts": 2790, - "2551-generics-value-aliases.ts": 2489, - "2552-generics-iface-methods.ts": 2118, - "2553-generics-signature-bindings.ts": 2838, - "2554-generics-frontier-mix.ts": 2857, - "2555-generics-keyof-writes.ts": 2600, - "2556-crypto-introspection.ts": 2362, - "2556-width-hybrid-shapes.ts": 3063, - "2557-tls-ca-store.ts": 2877, - "2557-width-field-lifts.ts": 2899, - "2558-index-signature-func-values.ts": 2980, - "2558-rejection-events.cjs": 2741, - "2559-index-signature-container-values.ts": 2921, - "2560-arraybuffer-dataview-set.ts": 2985, - "2561-object-is.ts": 3314, - "2562-intl-numberformat-en-us.ts": 1713, - "2563-stream-promises-pipeline.ts": 2673, - "2564-stream-promises-finished.ts": 2596, - "2565-stream-promises-js.cjs": 2121, - "2566-promise-reject-dyn-reason.js": 2527, - "2567-rest-spread-forward.js": 3263, - "2568-rest-spread-forward-dynamic.js": 2990, - "2569-upcast-identity.ts": 1878, - "2570-buffer-arg-validation.cjs": 4190, - "2571-searchparams-arg-validation.cjs": 2897, - "2572-readable-emitted-readable-flag.cjs": 2583, - "2573-fs-url-arg-ladders.cjs": 2789, - "2574-emitter-max-listeners-ladders.cjs": 2728, - "2575-string-destructuring-decl.ts": 2831, - "2576-string-destructuring-assign.ts": 2718, - "2577-builtin-global-destructuring.js": 2482, - "2578-jsval-into-unknown-rows.ts": 2821, - "2579-jsval-object-param-crossing.js": 2723, - "2580-jsval-routed-keyed-ops.js": 2125, - "2581-jsval-routed-calls.js": 3090, - "2582-jsval-object-statics.js": 2972, - "2582-jsval-routed-keyed-ops.js": 2851, - "2583-dyn-nullish-coalesce.js": 2185, - "2583-jsval-routed-calls.js": 2972, - "2584-jsval-object-statics.js": 2832, - "2584-union-dyn-collapse.ts": 2220, - "2585-dyn-nullish-coalesce.js": 2398, - "2585-unknown-array.ts": 2751, - "2586-object-assign-spread.js": 3004, - "2587-array-entries-forof.ts": 2555, - "2588-array-entries-chains.ts": 3001, - "2589-object-create-null.cjs": 2994, - "2590-object-create-dynamic.js": 3188, - "2591-ambient-generic-traps.ts": 2461, - "2592-ambient-trap-uncaught.ts": 2508, - "2593-generic-inert-bindings.ts": 2003, - "2594-nullish-generic-bindings.ts": 2473, - "2595-fs-arg-ladders.cjs": 3590, - "2596-net-arg-ladders.cjs": 2708, - "2597-dgram-send-ladders.cjs": 3185, - "2598-tls-arg-ladders.cjs": 3457, - "2599-stream-arg-ladders.cjs": 2639, - "2600-dyn-keyed-write-harness.js": 2645, - "2601-dyn-keyed-write-ops.js": 2850, - "2602-dyn-array-destructure.js": 3140, - "2603-island-keyed-write-dyn.js": 2307, - "2604-cycle-classes-mutual/main.ts": 2453, - "2605-cycle-three-module/main.ts": 2707, - "2606-dynamic-import-cycle/main.ts": 2783, - "2608-regex-named-groups.ts": 3177, - "2609-regex-named-replace.ts": 2707, - "2610-regex-named-matchall.ts": 2590, - "2611-regex-named-groups-js.cjs": 2302, - "2613-for-init-uninitialized-let.ts": 2413, - "2614-trap-binding-later-writes.ts": 2362, - "2615-nullish-field-record-binding.ts": 2480, - "2616-js-collect-probe-defers.js": 2756, - "2617-enum-static-field-import/main.ts": 2551, - "2618-ee-emit-override.ts": 2613, - "2619-ee-override-chain.ts": 2034, - "2620-ee-override-once-order.ts": 2930, - "2621-ee-override-error-throw.ts": 2533, - "2622-ee-override-filter.ts": 2677, - "2623-ee-job-queue.ts": 2500, - "2624-ee-override-js.cjs": 2183, - "2625-bytes-views.ts": 2152, - "2626-stream-event-names.ts": 2499, - "2627-stream-ticks-are-nextticks.ts": 2708, - "2628-stream-push-encodings.cjs": 2440, - "2629-stream-consumers.ts": 2913, - "2630-stream-consumers-errors.ts": 2991, - "2631-create-require/main.ts": 3044, - "2632-dyn-jsval-iterate.js": 2878, - "2633-island-promise-crossing.js": 3370, - "2634-stream-pipeline-arg-ladders.cjs": 2714, - "2635-trap-binding-unmappable-written.ts": 2160, - "2636-trap-binding-ambient-rooted-rewrite.ts": 2374, - "2637-create-require-bare/main.ts": 2239, - "2638-http-dyn-res-compat.cjs": 3131, - "2639-http-dyn-req-pause.cjs": 2921, - "2640-net-dyn-socket-compat.cjs": 2968, - "2641-http-agent-surface.cjs": 3429, - "2642-http-agent-maxsockets.cjs": 2699, - "2643-or-default-retag.ts": 2845, - "2644-http-client-url-argument.ts": 2453, - "2645-https-client-url-argument.ts": 2836, - "2646-top-level-await.ts": 2403, - "2647-top-level-await-modules/main.ts": 2235, - "2648-top-level-await-rejection.ts": 1959, - "2649-top-level-await-pending.ts": 2384, - "2650-top-level-await-self-import.ts": 1987, - "2651-top-level-await-pending-unhandled.ts": 2002, - "2652-top-level-await-dynamic/main.ts": 2598, - "2653-top-level-await-rejection-stops-loop.ts": 2523, - "2654-top-level-await-unrelated-rejection.ts": 2015, - "2655-top-level-await-cycle/main.ts": 2308, - "2656-top-level-await-cycle-order/main.ts": 4054, - "2657-top-level-await-cycle-dynamic/main.ts": 2392, - "2658-top-level-await-sync-completion/main.ts": 2314, - "2659-top-level-await-dynamic-cycle/main.ts": 2467, - "2660-top-level-await-cycle-rejection/main.ts": 2494, - "2661-top-level-await-dynamic-runtime-root/main.ts": 2327, - "2662-top-level-await-cycle-external-wait/main.ts": 2397, - "2663-top-level-await-dependency-errors/main.ts": 2080, - "2664-top-level-await-same-checkpoint-rejection.ts": 2543, - "2665-top-level-await-unhandled-listener-liveness.ts": 2570, - "2666-array-to-sorted.ts": 6667, - "2668-stored-number-array-iterator.ts": 2876, - "2669-array-copying-methods.ts": 3089, - "2670-uint8array-copy-iterate.ts": 2885, - "2671-array-copying-js.cjs": 2315, - "2672-http-request-response-callback.ts": 2962, - "2673-top-level-await-implicit-module.ts": 2333, - "2674-top-level-for-await-implicit-module.ts": 2353, - "2675-create-require-nested-esm.js": 2188, - "2675-process-self-reexec.ts": 2836, - "2676-indexed-read-strict-equality.ts": 2408, - "2676-record-clone-overrides.ts": 2543, - "2676-top-level-await-ambiguous/main.ts": 2576, - "2677-runtime-optional-closure.ts": 4255, - "2677-top-level-await-module-scope/main.ts": 2463, - "2678-date-instances.ts": 2194, - "2678-large-string-sparse-index.ts": 2586, - "2678-util-parseargs.ts": 4462, - "2679-util-parseargs-cjs.cjs": 4905, - "2680-util-parseargs-default.ts": 1889, - "2681-util-parseargs-dynamic.js": 2618, - "2682-fs-rename.ts": 3414, - "2683-filter-truthy-predicate.ts": 3055, - "2683-fs-rename-js.cjs": 4058, - "2684-filter-no-predicate-dyn.cjs": 2608, - "2684-fs-rename-abort.ts": 2639, - "2685-array-unshift-reverse.ts": 3540, - "2685-fs-write-sync.ts": 2779, - "2686-fs-file-handle.ts": 3096, - "2687-fsp-write-file-options.ts": 2864, - "2687-process-write-args.ts": 2396, - "2688-fs-stats-disk-fields.ts": 3953, - "2689-http-server-timeout-properties.ts": 2717, - "2690-https-server-timeout-option.ts": 2702, - "2691-retained-lowering-record-order.ts": 2988, - "2692-inline-record-assert-index.ts": 2526, - "2692-string-accumulation.ts": 2081, - "2693-math-constants.ts": 1991, - "2700-array-sort-complexity.ts": 2921, - "2700-http-static-trailers.ts": 2864, - "2700-wasi-core.ts": 2423, - "2701-array-sort-snapshot.ts": 2953, - "2701-http-static-trailer-wire.ts": 4541, - "2701-import-meta/main.mjs": 2520, - "2702-http-static-trailer-end.ts": 2827, - "2702-type-import-link-static/main.ts": 2535, - "2702-uint8array-to-sorted.ts": 2284, - "2703-array-sparse-sort.ts": 4504, - "2703-type-import-link-static-reexport/main.ts": 3626, - "2704-array-sparse-to-sorted.ts": 4339, - "2704-type-import-link-static-success/main.ts": 2363, - "2705-array-sparse-sort-append.ts": 4401, - "2705-type-import-link-dynamic/main.ts": 1851, - "2706-array-search-missing-needle.ts": 2603, - "2706-type-import-link-dynamic-success/main.ts": 2413, - "2707-array-search-huge-sparse.ts": 45742, - "2707-type-import-link-static-default-reexport/main.ts": 2437, - "2708-type-import-link-dynamic/main.ts": 2892, - "2720-array-read-parity.ts": 3049, - "2721-array-nested-missing-receiver.ts": 2315, - "2750-array-sparse-foundation.ts": 3742, - "2751-buffer-concat-sparse-list.ts": 4185, - "2752-array-optional-stores.ts": 2347, - "2753-array-optional-method-values.ts": 3965, - "2754-array-property-undefined.ts": 2255, - "2755-array-optional-literal-forwarding.ts": 2583, - "2780-array-parity-composition.ts": 6251, - "2781-array-missing-value-escape.ts": 2554, - "2782-array-sparse-callbacks.ts": 3284, - "2783-array-defaults-rest.ts": 2724, - "2784-array-reduce-missing-result.ts": 2691, - "2785-array-missing-destructuring.ts": 2806, - "2786-array-sparse-serialization.ts": 2888, - "2787-array-missing-string-arithmetic.ts": 1877, - "2788-array-missing-builtin-conversions.ts": 1930, - "2789-array-missing-optional-tostring.ts": 1731, - "2790-dynamic-import-self-name/main.ts": 2308, - "2791-record-optional-keys.ts": 2478, - "2792-record-optional-spread-entries.ts": 2703, - "2793-union-conversion-identity-capture.ts": 1753, - "2794-array-generic-callback-values.ts": 2420, - "2795-array-optional-typedarray-source.ts": 1737, - "2796-array-sparse-class-value-instanceof.ts": 2296, - "2800-array-expression-consumers.ts": 2565, - "2801-array-switch-consumers.ts": 2471, - "2820-array-missing-method-receivers.ts": 2123, - "2821-array-optional-numeric-comparisons.ts": 2408, - "2830-cjs-require-self-name/main.cjs": 2633, - "2840-finally-completions.ts": 2505, - "2841-using-sync.ts": 2632, - "2842-await-using.ts": 1790, - "2843-using-suppressed-error.ts": 2235, - "2844-node-disposable-resources.ts": 2658, - "2845-for-using-of.ts": 4410, - "2846-generator-using.ts": 2392, - "2850-async-generators-protocol.ts": 3002, - "2851-async-generators-values.ts": 4379, - "2852-timers-promises-interval.ts": 2511, - "2854-leading-bom-literals.ts": 2528, - "2855-searchparams-sort-complexity.ts": 2416, - "2856-dynamic-any-local-operators.ts": 1839, - "2857-branded-primitives.ts": 1736, - "2858-import-meta-resolve/main.mjs": 2679, - "2859-import-meta-resolve-dynamic/main.mjs": 2295, - "2860-require-resolve/main.cjs": 2780, - "2861-readable-iterator-close.ts": 3207, - "2862-web-readable-async-iteration.ts": 3375, - "2863-class-async-iterator.ts": 2531, - "2864-array-class-method-receivers.ts": 1837, - "2865-cjs-process-alias.cjs": 2734, - "2866-dyn-switch.ts": 1772, - "2867-array-shift-length.js": 2411, - "2868-empty-record-promise-presence.js": 2531, - "2869-nullish-mixed-lazy.ts": 2433, - "2870-and-dropped-truthy-arm.ts": 2606, - "2871-optional-promise-to-unknown.ts": 2387, - "2872-unobserved-dynamic-event.ts": 2191, - "2873-optional-receiver-loop-lifetime.js": 2453, - "2874-nullable-callback-field-cycle.js": 2707, - "2875-evolving-let-read-before-write.js": 3668, - "2876-class-unknown-roundtrip.ts": 2817, - "2877-child-unknown-roundtrip.ts": 2660, - "2878-class-private-unknown.cjs": 4040, - "2880-cjs-module-graph/main.cjs": 2924, - "2890-crypto-static-utility.ts": 2261, - "2891-json-record-key-escapes.ts": 2705, - "2892-windows-console-unicode.ts": 2266, - "2893-child-stdin-duplex.ts": 3340, - "2894-child-stdin-backpressure.ts": 3131, - "2895-child-stdin-write-after-end.ts": 2384, - "2896-child-stdin-write-after-finish.ts": 2871, - "2897-child-stdin-destroy.ts": 2871, - "2898-child-stdin-spawn-failure.ts": 2549, - "2899-nested-mutual-recursion.ts": 2721, - "2900-float64array-static.ts": 2799, - "2900-void-conditional-arrow.ts": 2537, - "2901-bigint-core.ts": 2424, - "2902-bigint-bytes.ts": 2498, - "2903-bigint-storage.ts": 2708, - "2904-bigint-errors.ts": 2577, - "2905-bigint-edges.ts": 2439, - "2906-bigint-wasi-width.ts": 1786, - "2910-overloaded-callable-alias.ts": 2648, - "2911-execfile-callback.ts": 2191, - "2912-execfile-callback-options.ts": 2127, - "2912-promisify-fs-readfile.ts": 2460, - "2913-builtin-callable-alias.ts": 2481, - "2914-fixed-tuple-call-spread.ts": 2974, - "2915-path-function-values.ts": 2177, - "2916-path-function-values-cjs.ts": 2451, - "2917-builtin-callable-widths.ts": 2149, - "2918-builtin-callable-widths-cjs.ts": 2749, - "2919-fs-function-values.ts": 2635, - "2920-fs-promises-function-values.ts": 1999, - "2921-zlib-callbacks.ts": 2825, - "2922-dyn-bitwise-not.cjs": 2337, - "2923-cjs-factory-export/main.cjs": 2557, - "2930-union-receiver-calls.ts": 3403, - "2931-union-dynamic-field-call.js": 3002, - "2932-create-require-program/main.ts": 2467, - "2933-static-dynamic-import/main.ts": 2896, - "2934-static-import-stored.ts": 2404, - "2935-module-namespace-values/main.ts": 2608, - "2936-static-loose-equality.ts": 3140, - "2937-bitwise-hot-loop.ts": 2268, - "2938-fs-sync-overloads.cjs": 1857, - "2939-child-shell-text.ts": 3041, - "2940-date-parse.ts": 2483, - "2940-fsp-realpath.ts": 2587, - "2941-fsp-lstat-identity.ts": 2657, - "2941-process-exit-code.ts": 1743, - "2942-fsp-readdir-dirent.ts": 2911, - "2942-process-exit-code-override.ts": 1751, - "2943-process-exit-code-invalid.ts": 2583, - "2944-process-exit-code-wrap.ts": 2435, - "2945-url-origin-username.ts": 1863, - "2946-child-fork-ipc/main.ts": 3271, - "2946-url-port-hash.ts": 2587, - "2947-set-readonly-seeds.ts": 2456, - "2948-child-fork-eof-callback/main.ts": 3043, - "2948-stdio-callback-record.ts": 2421, - "2949-child-fork-default/main.mjs": 2736, - "2949-url-password.ts": 2744, - "2950-fs-descriptor-publication.ts": 2681, - "2951-math-static-analytic.ts": 3121, - "2952-math-static-remaining.ts": 2862, - "2953-http-header-validation.ts": 2956, - "2954-http-outgoing-headers.ts": 2822, - "2955-http-static-state.ts": 2955, - "2956-http-static-informational.ts": 3085, - "2957-http-static-response-controls.ts": 2273, - "2961-emitter-computed-names.cjs": 2632, - "2962-emitter-computed-optional.ts": 2051, - "2963-child-fork-dispatch/main.ts": 2809, - "2964-indexed-compound.ts": 2982, - "2966-numeric-array-read-fusion.ts": 2045, - "2967-numeric-array-read-lifetime.ts": 3048, - "2968-numeric-array-borrow.ts": 2914, - "2969-scalar-record-results.ts": 2620, - "2970-constant-numeric-tables.ts": 2078, - "2971-constant-table-modules/main.ts": 2587, - "2972-http-static-distinct-snapshots.ts": 2220, - "2972-math-receiver-borrow.ts": 3503, - "2973-http-static-agent.ts": 3163, - "2973-integer-bitwise-arithmetic.ts": 2756, - "2974-array-search-from-index.ts": 120636, - "2974-http-static-module-values.ts": 2696, - "2974-numeric-remainder.ts": 2784, - "2975-bigint-default-radix.ts": 1741, - "2975-http-static-client-controls.ts": 2204, - "2976-http-static-incoming-state.ts": 2949, - "2976-json-stringify-no-arguments.js": 2583, - "2977-http-static-incoming-timeout.ts": 2724, - "2977-nested-array-binding-defaults.js": 2760, - "2978-http-static-client-timeout.ts": 3060, - "2978-regexp-optional-subject.js": 2540, - "2979-array-search-mixed-needles.js": 2011, - "2979-http-static-server-timeout.ts": 2740, - "2980-http-static-server-timeout-default.ts": 2671, - "2980-string-position-arguments.js": 2246, - "2981-http-static-events.ts": 1817, - "2981-string-optional-positions.ts": 1836, - "2982-http-static-close-all.ts": 2421, - "2982-string-position-coercion-order.js": 3081, - "2983-http-static-close-idle.ts": 2006, - "2984-http-static-close-upgrade.ts": 2129, - "2985-http-static-message-destroy.ts": 2630, - "2986-http-static-client-socket-finish.ts": 1940, - "2987-http-static-timeout-errors.ts": 2737, - "2988-http-static-client-abort.ts": 2025, - "2989-http-static-response-timeout-handled.ts": 2928, - "2990-http-static-request-timeout-handled.ts": 2599, - "2991-array-indexed-equality.ts": 2993, - "2992-stream-rows.ts": 2556, - "2993-fiber-stack-lifetimes.ts": 3202, - "2994-fromcharcode-scalar.ts": 2833, - "2995-math-hyperbolic.ts": 2687, - "2996-math-near-one.ts": 2252, - "2997-math-integer-float.ts": 3190, - "300-if-else.ts": 2219, - "3001-caught-typeof-object.js": 2450, - "3002-promise-then-two.ts": 2484, - "301-while.ts": 2153, - "302-for.ts": 1918, - "3020-string-last-index-position.ts": 2434, - "3021-buffer-union-narrow-callback.ts": 2866, - "3022-string-affix-positions.ts": 2229, - "3023-string-affix-position-coercion.js": 3333, - "3024-string-number-narrow-for-in.ts": 2650, - "3025-string-search-position-coercion.js": 2447, - "3026-array-last-index-of.js": 2579, - "3027-array-last-index-of-records.ts": 2304, - "3028-string-search-dynamic-needle.js": 2564, - "3029-string-search-union-needle.js": 1657, - "303-break-continue.ts": 2442, - "3030-array-search-no-arg.js": 3027, - "3031-array-relative-index-coercion.js": 2940, - "3031-string-last-index-search-value.js": 2407, - "3032-string-search-value.js": 2579, - "3033-string-search-needle-coercion.js": 2232, - "3034-arguments-with-parameters.js": 2126, - "3035-string-positioned-search-value.js": 2449, - "3036-string-object-search-value.js": 1849, - "3037-number-nullish-conversion.js": 2478, - "3038-number-scalar-unions.ts": 1881, - "3039-string-repeat-count.js": 2372, - "304-compound-incdec.ts": 2266, - "3040-string-prototype-call.js": 2389, - "3041-string-prototype-object-call.js": 2679, - "3042-string-padding-coercion.js": 2923, - "3043-string-split-arguments.js": 3247, - "3044-array-slice-splice-positions.js": 2966, - "3045-array-indexed-mutation.js": 2960, - "3046-array-indexed-ref-identity.ts": 2358, - "3047-object-prototype-tag.js": 2265, - "3048-object-own-prototype.ts": 3162, - "3049-array-flat-depth.ts": 2904, - "305-truthiness.ts": 2588, - "3050-array-splice-insert.ts": 2779, - "3051-array-join-default.ts": 2220, - "3052-array-construction.ts": 2520, - "3053-array-construction-js.js": 2821, - "3054-dynamic-abort-record.ts": 2818, - "3055-default-builtin-nodenext/main.ts": 2044, - "3056-default-builtin-bundler/main.ts": 2874, - "3057-default-builtin-nodenext-dynamic/main.ts": 1912, - "3058-optional-array-chain-join.ts": 2986, - "3059-arguments-property-names.ts": 1856, - "3061-concurrent-fiber-stacks.ts": 2766, - "3062-runtime-optional-record-guards.ts": 3210, - "3063-runtime-optional-class-guards.ts": 2677, - "3064-installed-entry-imports/main.ts": 1867, - "3065-installed-entry-js/main.js": 2294, - "3066-source-debugging/main.ts": 2276, - "3067-cjs-function-export-require/main.cjs": 1963, - "3068-debug-variables/main.ts": 2578, - "3068-url-checked-identity.ts": 2207, - "3069-set-checked-seed.js": 2608, - "3069-tuple-spread.ts": 2969, - "3070-checked-object-accessors.js": 2496, - "3070-collection-views.ts": 2799, - "3071-checked-specialization-narrowing.js": 2715, - "3071-map-contextual-record-seeds.ts": 3095, - "3072-optional-union-receivers.ts": 2303, - "3072-weak-process-streams.js": 2885, - "3073-optional-callable-module.js": 2520, - "3073-union-keyed-reads.ts": 2905, - "3074-discriminated-intersections.ts": 2460, - "3075-recursive-contextual-literals.ts": 3335, - "3076-nullish-record-defaults.ts": 2894, - "3077-optional-union-array-reads.ts": 2500, - "3078-forward-mutable-captures.ts": 3097, - "3079-forward-mutable-tdz.ts": 2796, - "3080-exhaustive-never-bindings.ts": 2704, - "3081-recursive-array-destinations.ts": 2667, - "3082-forward-write-unwind.ts": 2538, - "3083-set-string-seed.ts": 2595, - "3084-record-own-membership.ts": 2879, - "3085-conditional-record-construction.ts": 2874, - "3086-error-constructor-options.ts": 2970, - "3087-error-options-lifetime.ts": 2675, - "3088-array-wide-callbacks.ts": 2690, - "3089-array-find-narrowing.ts": 2833, - "3090-json-discriminated-records.ts": 3066, - "3091-json-recursive-discriminants.ts": 2220, - "3092-number-union-predicates.ts": 2324, - "3093-error-option-data.ts": 2104, - "3094-json-replacer-traversal.ts": 2818, - "3095-json-reviver-traversal.ts": 2804, - "3096-json-callback-nonfinite.ts": 2753, - "3097-json-callback-reentrancy.ts": 2198, - "3098-json-callback-space.ts": 2839, - "3099-json-callback-functions.ts": 3102, - "3100-json-callback-holder.js": 2748, - "3101-json-callback-bytes.ts": 2087, - "3102-json-unknown-fields.ts": 2238, - "3103-scalar-record-nested-control-flow.ts": 2806, - "3104-native-analysis-tables-loops.ts": 2680, - "3105-nullable-collections.ts": 2913, - "3106-mixed-insertion-spreads.ts": 3159, - "3107-nullable-collection-lifetimes.ts": 3025, - "3108-for-await-sync-arrays.js": 3537, - "3108-identity-map-keys.ts": 3249, - "3109-destructuring-unknown-defaults.js": 2565, - "3109-identity-union-collections.ts": 3588, - "3110-builtin-error-families.ts": 2812, - "3110-identity-collection-mutation.ts": 2831, - "3111-identity-collection-cycles.ts": 2915, - "3112-union-switch-control-flow.ts": 2075, - "3113-union-array-removal.ts": 3111, - "3114-union-record-field-write.ts": 2886, - "3115-zlib-static-compression-levels.ts": 2667, - "3116-sequence-expression-lifetimes.ts": 2953, - "3117-unknown-switch-control-flow.ts": 2388, - "3118-recursive-union-spread.ts": 3091, - "3119-runtime-optional-spread.ts": 3563, - "3120-dynamic-property-descriptors.js": 2806, - "3120-generator-method-loop-bindings.ts": 2970, - "3120-ir-nonfinite-numbers.ts": 2756, - "3121-compound-assignment-values.js": 2784, - "3121-dynamic-accessor-descriptors.js": 2889, - "3122-dynamic-delete-descriptors.cjs": 2435, - "3122-dynamic-delete-descriptors.js": 2554, - "3122-js-async-class-methods.js": 2294, - "3123-destructured-global-tdz.js": 2755, - "3124-array-prototype-borrow.js": 2322, - "3125-regex-global-match.ts": 2783, - "3126-js-number-radix/main.ts": 2820, - "3127-spawn-runtime-options.ts": 3072, - "3128-regex-last-index.ts": 1823, - "3129-js-token-union/main.ts": 2769, - "3130-child-generic-streams.ts": 2981, - "3131-child-rest-listeners.js": 2627, - "3132-child-generic-stream-completion.ts": 5669, - "3133-text-decoder-streaming.ts": 2916, - "3134-fs-vectors.ts": 2782, - "3135-fs-file-handle-controls.ts": 3077, - "3136-fs-file-handle-options.ts": 3203, - "3137-fs-vector-callbacks.cjs": 3063, - "3138-array-large-storage.ts": 4112, - "3139-regex-native-deep-alternatives.ts": 26910, - "3140-array-dense-access.ts": 3431, - "3141-map-string-key-hash.ts": 3132, - "3150-integer-remainder.ts": 3203, - "3151-array-push-writes.ts": 3025, - "3170-number-conversion-fast-paths.ts": 2101, - "3171-method-census-data-writes.ts": 3216, - "400-fib.ts": 2634, - "401-mutual-recursion.ts": 2541, - "402-string-functions.ts": 2183, - "403-void-and-params.ts": 2239, - "4030-runtime-object-truthiness.ts": 2407, - "4031-event-emitter-long-tuples.ts": 2624, - "4032-inline-rc-fast-paths.ts": 3924, - "404-rc-stress.ts": 2608, - "4040-adapted-function-identity.ts": 3296, - "4041-adapted-function-properties.ts": 2613, - "4042-object-is-union-subclass.ts": 2694, - "4043-nonnull-missing-element.ts": 2672, - "4044-adapted-callback-modules/main.ts": 2828, - "4045-optional-element-projections.ts": 2963, - "4046-captured-parameter-values.ts": 3070, - "4047-captured-parameter-rebinding.ts": 2848, - "405-params-optional.ts": 1924, - "406-params-defaults.ts": 1978, - "4060-cycle-shared-instance/main.ts": 2198, - "4060-stack-union-reads.ts": 3362, - "4061-cycle-evaluation-order/main.ts": 2399, - "4061-nullable-ref-fields.ts": 4246, - "4062-cycle-tdz-read/main.ts": 2254, - "4063-cycle-hoisted-calls/main.ts": 2402, - "4064-cycle-classes-after-init/main.ts": 2048, - "4065-cycle-init-throws/main.ts": 2640, - "4066-cycle-top-level-tdz/main.ts": 2245, - "4067-dynamic-import-cycle-tdz/main.ts": 2515, - "407-params-rest.ts": 2698, - "408-params-ctors-inheritance.ts": 2092, - "4080-optional-read-presence-tests.ts": 2936, - "4080-string-index-bounds.ts": 2863, - "4081-hoisted-function-tdz.ts": 2788, - "4081-string-index-unproven.ts": 2335, - "4082-hoisted-function-tdz-uncaught.ts": 1949, - "4083-dynamic-import-failure/main.ts": 2717, - "4084-record-optional-field-copies.ts": 2527, - "4085-generator-loop-close.ts": 2591, - "4086-optional-capture-defaults.ts": 2395, - "4088-class-static-tdz.ts": 2363, - "4089-class-wrapper-tdz.js": 2402, - "409-params-async-generics.ts": 2098, - "4090-computed-key-tdz.js": 2605, - "4091-class-evaluation-deferred.ts": 2199, - "410-params-rc-stress.ts": 2565, - "4140-array-callback-split-visit.ts": 4386, - "4141-array-callback-ambient-receiver/main.ts": 2299, - "4142-array-callback-factories.ts": 3208, - "4143-union-refinement-intersection-arms.ts": 2685, - "420-dead-strip-modules/main.ts": 2527, - "4290-acyclic-immutable-trees.ts": 3246, - "4291-acyclic-constructor-escapes.ts": 2909, - "4292-acyclic-readonly-bypass.ts": 3024, - "4293-acyclic-dynamic-writes.ts": 2956, - "4294-console-line-sizes.ts": 5873, - "4295-console-template-parts.ts": 2597, - "4296-console-glued-long-parts.ts": 2868, - "4410-inline-object-allocation.ts": 3093, - "4411-nullable-ref-values.ts": 4434, - "4412-nullable-record-values.ts": 3635, - "4413-cycle-old-late-death.ts": 2102, - "4413-nullable-null-and-undefined.ts": 2783, - "4414-cycle-old-weak-keys.ts": 2960, - "4414-nullable-string-values.ts": 3874, - "4415-identity-borrowed-operands.ts": 2087, - "4415-nullable-container-values.ts": 3581, - "4431-exception-pending-contexts.ts": 3035, - "4432-checked-downcast-failures.ts": 3246, - "4451-int32-field-storage.ts": 3457, - "4452-int32-field-dynamic-writes.ts": 3861, - "4453-int32-closed-locals.ts": 2280, - "4471-unassigned-field-reads.ts": 3309, - "4476-string-ascii-header-fact.ts": 2846, - "4477-buffer-write-ascii-runs.ts": 2125, - "4478-string-large-index-reads.ts": 3334, - "4481-array-optional-push.ts": 3059, - "4482-instanceof-static-class-optional.ts": 2994, - "4483-array-splice-statement.ts": 3331, - "4484-array-length-reset.ts": 2664, - "4485-array-splice-optional-item.ts": 2526, - "4486-array-field-element-borrows.ts": 2341, - "4487-array-literal-optional-values.ts": 2248, - "4520-optional-guard-narrowing.ts": 2281, - "4521-array-callback-element-presence.ts": 4131, - "4522-captured-parameter-lifetimes.ts": 2903, - "4523-array-pop-removal.ts": 2536, - "4524-array-callback-supertype-params.ts": 3251, - "4541-nullable-wrap-borrows.ts": 2882, - "4542-preserving-call-borrows.ts": 3130, - "4543-walk-borrowed-locals.ts": 3034, - "4544-checked-cast-aliases.ts": 2574, - "4545-borrowed-returns.ts": 3551, - "4546-rebound-borrowed-params.ts": 2811, - "4560-field-store-borrowed-receivers.ts": 3116, - "4561-virtual-borrowed-parameters.ts": 3237, - "4562-string-self-concat-move.ts": 2061, - "4563-array-read-projection-receivers.ts": 2512, - "4564-literal-choice-strings.ts": 2795, - "4568-for-of-hole-elements.ts": 2661, - "4569-shorthand-missing-elements.ts": 3064, - "4570-map-lookup-default-record.ts": 2901, - "4591-weak-keys-union-records.ts": 2778, - "4592-cycle-const-from-import/main.ts": 2529, - "4593-weak-keys-empty-objects.ts": 2806, - "4594-union-class-field-mixed-types.ts": 3153, - "4595-union-class-field-optional-receiver.ts": 1997, - "4596-error-subclass-int-fields.ts": 2606, - "4596-tdz-nullable-forward-capture.ts": 3433, - "4597-callback-field-method-name.ts": 2519, - "4598-live-array-ref-element-access.ts": 4363, - "4598-map-set-clear-reuse.ts": 4118, - "4598-os-available-parallelism.ts": 2474, - "4598-publish-constructor-stores.ts": 2635, - "4599-construction-only-field-borrows.ts": 3147, - "4600-construction-only-fields-dynamic-writes.ts": 2319, - "4601-cycle-holders.ts": 2904, - "4602-constructor-escape-order.ts": 2703, - "4610-array-ext-dyn-refresh.ts": 3049, - "4620-optional-chain-borrowed-receivers.ts": 3006, - "4621-edge-preserving-callees/main.ts": 2464, - "4630-contract-int32.ts": 2586, - "4630-reference-write-call-arguments.ts": 2892, - "4631-contract-nothrow.ts": 2842, - "4631-reference-write-aliases.ts": 2922, - "4632-contract-immutable.ts": 2582, - "4632-reference-write-loops-and-walks.ts": 2399, - "4633-contract-program-lifetime.ts": 3449, - "4633-reference-write-callbacks-returns.ts": 2678, - "4634-contract-program-lifetime-publish.ts": 4573, - "4634-optional-element-borrowed-returns.ts": 2111, - "4640-bitwise-identity-ranges.ts": 2671, - "4641-nothrow-try-catch.ts": 2141, - "4642-acyclic-contract.ts": 2859, - "4650-stale-property-narrowing.ts": 2759, - "4651-map-string-get-entry.ts": 3114, - "4652-stale-closure-binding-narrowing.ts": 3092, - "4660-typed-rest-spread-forwarding.ts": 2331, - "4671-scoped-array-read-borrows.ts": 2575, - "4690-cycle-bypass-long-lived.ts": 4228, - "4691-publish-constructor-self-alias.ts": 2964, - "4692-borrowed-result-mutating-callees.ts": 2766, - "4720-cold-throw-paths.ts": 3228, - "4721-integer-induction-numbers.ts": 2974, - "4730-touint32-large-magnitudes.ts": 2198, - "4731-string-mixed-ascii-slices.ts": 3160, - "4732-buffer-write-utf16le-runs.ts": 3120, - "4733-typed-array-read-compares.ts": 2977, - "4750-map-string-absent-filter.ts": 3464, - "4751-string-search-multibyte-needles.ts": 2454, - "4795-published-untyped-member-reads.ts": 3340, - "4806-uint32-loop-accumulators.ts": 2740, - "4810-union-identity-retags.ts": 4045, - "4811-union-retag-checked-cast.ts": 2819, - "4812-int32-wrapping-sums.ts": 3339, - "4813-typed-array-read-equality-bindings.ts": 3997, - "4820-sort-comparator-lent-arguments.ts": 2782, - "4821-callback-lent-arguments.ts": 3485, - "4822-stable-capture-reads.ts": 2483, - "4823-array-store-receivers.ts": 2858, - "4830-typed-teardown-chains.ts": 3292, - "4831-cycle-bypass-probe-windows.ts": 3738, - "4840-array-hole-free-prefix.ts": 3550, - "4860-int32-local-storage.ts": 3699, - "4870-array-pipeline-fusion.ts": 6694, - "4871-array-pipeline-analytics.ts": 4274, - "4872-array-pipeline-temporaries.ts": 7763, - "4875-stream-consumers-array-buffer.ts": 3017, - "4876-array-buffer-inspect.ts": 2569, - "4880-await-call-turn-order.ts": 2784, - "4881-await-call-exceptions.ts": 2757, - "4882-await-call-request-chain.ts": 2151, - "4883-await-values-and-hops.ts": 2520, - "4884-await-call-unhandled-sibling.ts": 2379, - "4885-await-call-checkpoints.ts": 2128, - "4890-regex-literal-sites.ts": 3484, - "4891-regex-plain-text-patterns.ts": 2502, - "4892-regex-exec-read-captures.ts": 3120, - "4900-bigint-division-cross-check.ts": 3532, - "4900-console-instances.ts": 3723, - "4901-bigint-radix-text.ts": 3090, - "4901-console-instance-errors.ts": 3055, - "4902-bigint-compound-assign.ts": 2449, - "4903-bigint-fixed-width.ts": 2818, - "4904-bigint-large-products.ts": 2953, - "4905-bigint-fixed-width-fusion.ts": 3047, - "4906-bigint-small-value-trees.ts": 3132, - "4907-bigint-random-trees.ts": 4068, - "4910-hole-free-prefix-upkeep.ts": 3149, - "4920-string-literal-switch.ts": 4588, - "4930-typed-record-reflection.ts": 4183, - "4931-typed-data-generic-walks.ts": 4062, - "4932-typed-json-unknown.ts": 3239, - "4940-async-return-adoption.ts": 2845, - "4941-async-return-adoption-try.ts": 3156, - "4942-async-return-adoption-values.ts": 3620, - "4943-async-return-adoption-interleaved.ts": 2831, - "4950-regex-compiled-captures.ts": 5723, - "4951-regex-compiled-last-index.ts": 3059, - "4952-regex-compiled-anchors-classes.ts": 2426, - "4953-regex-compiled-backtracking.ts": 3365, - "4954-regex-log-report.ts": 3193, - "4955-regex-compiled-differential.ts": 24862, - "4970-int32-call-abi.ts": 2508, - "4980-generator-early-exit-finally.ts": 2836, - "4981-generator-delegation-iterables.ts": 4874, - "4982-generator-sent-values.ts": 2242, - "4983-generator-reuse-iterables.ts": 3066, - "4984-generator-exceptions.ts": 2959, - "4985-generator-lazy-pipeline.ts": 2708, - "4986-generator-default-channels.ts": 3119, - "4987-generator-closures-methods.ts": 2675, - "4988-generator-async-interplay.ts": 2141, - "4989-generator-step-drives.ts": 4185, - "4990-lone-surrogates.ts": 3319, - "4991-lone-surrogate-halves.ts": 2978, - "4992-lone-surrogate-search.ts": 2759, - "4993-lone-surrogate-json.ts": 2994, - "4994-lone-surrogate-uri.ts": 2786, - "4995-lone-surrogate-regex.ts": 3169, - "4996-lone-surrogate-stdio.ts": 2201, - "4997-lone-surrogate-stdout-patch.js": 2754, - "4998-lone-surrogate-buffers.ts": 3060, - "4999-lone-surrogate-io.ts": 4219, - "500-array-basics.ts": 2646, - "501-array-push-pop.ts": 2128, - "5010-lifetime-region-generations.ts": 2950, - "5011-lifetime-region-outside-references.ts": 2816, - "5012-lifetime-region-shapes.ts": 3847, - "5013-lifetime-region-async.ts": 3198, - "5014-lifetime-region-nesting.ts": 2741, - "5015-lifetime-region-publish.ts": 2749, - "5016-lifetime-region-weak-keys.ts": 2541, - "5017-lifetime-region-cycles.ts": 2989, - "5018-lifetime-region-hierarchies.ts": 3642, - "5019-lifetime-region-values.ts": 2516, - "502-array-for-of.ts": 2614, - "5020-lifetime-region-large.ts": 3840, - "5021-lifetime-region-opaque-holders.ts": 2702, - "5022-lifetime-region-workers.ts": 3127, - "503-array-functions.ts": 2610, - "504-array-rc-stress.ts": 2247, - "5040-promise-all-race-turns.ts": 3415, - "5041-promise-all-turns.js": 5156, - "5042-async-generator-return-promise.ts": 3112, - "5043-async-generator-return-forms.ts": 3029, - "5045-generator-delegation-typed-next.ts": 3463, - "5046-generator-delegation-return-throw.ts": 2606, - "5047-generator-delegation-iterables-typed.ts": 4378, - "5048-generator-delegation-async.ts": 4885, - "5049-generator-delegation-edges.ts": 2538, - "5050-inherited-in-membership.ts": 3142, - "5051-typed-record-prototypes.ts": 3140, - "5052-class-for-in-unknown.ts": 2653, - "5053-json-replacer-arrays.ts": 4713, - "5054-required-field-delete.ts": 2632, - "5055-object-create-record-literal.ts": 2065, - "5056-generator-in-unknown.ts": 3903, - "5060-child-fork-exit-after-messages/main.ts": 2572, - "5061-child-fork-local-disconnect/main.ts": 3248, - "5062-child-fork-message-before-eof/main.ts": 4732, - "5065-global-increment-initializers.ts": 3985, - "5066-global-compound-updates.ts": 2635, - "5067-global-updates-in-functions.ts": 2589, - "5068-global-var-let-const-updates.ts": 2726, - "5069-global-update-modules/main.ts": 2372, - "5070-optional-read-bindings.ts": 2144, - "5071-optional-chain-scalars.ts": 2192, - "5072-optional-nullish-ternary.ts": 2587, - "5073-optional-results.ts": 2727, - "5074-optional-pop-shift.ts": 2568, - "5075-optional-reads-unchecked/main.ts": 4996, - "5076-optional-escapes.ts": 2735, - "5080-boolean-array-storage.ts": 5236, - "5081-boolean-array-dynamic-views.ts": 2815, - "5085-promise-allsettled-turns.ts": 3332, - "5086-promise-any-turns.ts": 3297, - "5087-promise-allsettled-any-dyn.js": 3767, - "5088-promise-combinator-thenables.js": 4248, - "5089-promise-settled-records.ts": 3528, - "5090-generator-finished-result-value.ts": 2964, - "5091-generator-delegation-arrays-strings.ts": 2768, - "5092-generator-delegation-sets-maps.ts": 3565, - "5095-console-count-group.ts": 2753, - "5096-console-assert-dir.ts": 4648, - "5097-console-table.ts": 2620, - "5098-console-time-warnings.ts": 6302, - "5099-console-methods-dynamic.cjs": 2644, - "510-array-map-filter-foreach.ts": 2991, - "511-array-indexof-includes.ts": 2657, - "5110-var-hoisting-early-reads.ts": 2806, - "5111-var-hoisting-closures-classes.ts": 2117, - "5112-var-hoisting-function-scope.ts": 2614, - "5113-tdz-let-const-class.ts": 3154, - "5114-var-hoisting-js.js": 4536, - "5115-regex-replace-compiled.ts": 2608, - "5116-regex-capture-reads.ts": 3064, - "5117-regex-log-report-spans.ts": 3404, - "5118-regex-replace-char-chains.ts": 2444, - "512-array-join-chains.ts": 2376, - "5120-frame-records.ts": 2615, - "5121-frame-objects.ts": 2616, - "5122-frame-result-slots.ts": 2622, - "5123-frame-reassigned.ts": 2564, - "5124-frame-objects-control.ts": 3061, - "5125-frame-mutating-methods.ts": 2527, - "5126-frame-returned-params.ts": 2697, - "5127-frame-loop-bindings.ts": 2824, - "513-array-methods-rc-stress.ts": 2641, - "5130-event-target-dispatch.js": 3752, - "5131-event-target-listener-errors.js": 3003, - "5132-event-target-typed.ts": 3341, - "5133-abort-signal-event-target.ts": 3302, - "5134-events-error-monitor.ts": 2664, - "5135-event-target-warnings.js": 2890, - "5136-events-error-monitor-string-name.ts": 2380, - "5137-events-error-monitor-computed-name.js": 3077, - "5138-events-error-monitor-shared-listener.ts": 2001, - "5139-event-target-listener-throw.ts": 1965, - "514-array-find-some-every.ts": 2998, - "5140-os-host-facts.ts": 3248, - "5141-os-constants.ts": 2402, - "5142-path-parse-format.ts": 2850, - "5145-path-matches-glob-basics.ts": 2904, - "5146-path-matches-glob-braces.ts": 4866, - "5147-path-matches-glob-extglob.ts": 2653, - "5148-path-matches-glob-classes.ts": 2765, - "5149-path-matches-glob-win32.ts": 2754, - "515-array-flatmap.ts": 3015, - "5150-small-array-inline-slots.ts": 3276, - "5155-cycle-header-types.ts": 3561, - "516-array-reduce.ts": 3293, - "5160-field-callback-receiver.ts": 3482, - "5161-field-callback-receiver-escape.ts": 2665, - "5162-field-method-reference-receiver.ts": 2779, - "5163-field-callback-receiver.cjs": 2875, - "5164-worker-field-callback-receiver.ts": 3147, - "5165-interface-method-dispatch.ts": 2641, - "5166-interface-method-values.ts": 4036, - "5167-interface-method-order.ts": 3679, - "5168-interface-method-hierarchy.ts": 4400, - "5169-interface-method-chains.ts": 2934, - "517-array-hof-index-args.ts": 2918, - "5170-string-scan-eviction.ts": 2885, - "5171-lone-surrogate-replace-seams.ts": 3463, - "5175-forin-typed-as-unknown.ts": 3333, - "5176-object-keys-typed-as-unknown.ts": 3148, - "5177-forin-dynamic-objects.ts": 2926, - "5178-forin-keys-js.js": 2135, - "5179-forin-typed-shapes.ts": 3197, - "518-array-sort.ts": 2699, - "518-promise-void-union-callbacks.ts": 1929, - "5180-interface-arrays.ts": 3267, - "5181-interface-array-methods.ts": 7443, - "5182-interface-array-boundaries.ts": 3225, - "5183-interface-property-reads.ts": 3018, - "5184-interface-property-objects.ts": 3161, - "5185-util-inherits.cjs": 3120, - "5186-util-inherits.ts": 3012, - "5187-util-deprecate.cjs": 3705, - "5188-util-deprecate-flags.cjs": 2866, - "5189-util-deprecate.ts": 2361, - "519-array-from-length.ts": 3817, - "519-promise-union-await-values.ts": 2296, - "5190-util-callbackify.cjs": 3512, - "5191-util-callbackify.ts": 2893, - "5192-util-debuglog.cjs": 3224, - "5193-util-debuglog.ts": 4346, - "5194-process-emit-warning-tick.cjs": 2199, - "5195-object-entries-typed-as-unknown.ts": 2787, - "5196-object-values-typed-as-unknown.ts": 2984, - "5197-object-entries-dynamic-objects.ts": 3371, - "5198-object-entries-values-js.js": 2819, - "5199-object-entries-identity.ts": 3133, - "520-map-basics.ts": 2629, - "5200-array-sort-keyed-numbers.ts": 3636, - "5201-array-sort-keyed-records.ts": 3559, - "5202-array-sort-keyed-lookalikes.ts": 3148, - "5203-typed-array-sort-default.ts": 6169, - "5204-typed-array-sort-comparators.ts": 4152, - "521-map-number-keys.ts": 2529, - "5210-process-memory-usage.ts": 3044, - "5211-process-identity.ts": 2815, - "5212-perf-marks-measures.ts": 2925, - "5213-perf-timing-errors.ts": 3203, - "5214-perf-entry-inspect.ts": 3164, - "5215-perf-timing-validation.js": 4384, - "5216-perf-spread-arguments.js": 3711, - "5217-perf-spread-typed.ts": 3324, - "522-map-foreach.ts": 2813, - "5220-url-parse-warnings.ts": 2906, - "5221-url-parse-shapes.ts": 2400, - "5222-url-parse-hosts.ts": 2972, - "5223-url-parse-query.ts": 2190, - "5224-url-format-objects.ts": 2681, - "5225-url-format-whatwg.ts": 2885, - "5226-url-resolve.ts": 2184, - "5227-url-legacy-dependency/main.ts": 3291, - "5228-url-domain-conversion.ts": 2624, - "5229-url-legacy-errors.cjs": 3698, - "523-map-ref-values.ts": 2904, - "5230-inline-union-fields.ts": 2318, - "5231-inline-union-field-kinds.ts": 3614, - "5232-inline-union-fields-dynamic.ts": 3502, - "5233-inline-union-fields-shapes.ts": 3338, - "5234-inline-union-class-fields.ts": 4285, - "5235-inline-union-fields-publish.ts": 2840, - "5236-inline-union-unchecked-reads.ts": 1998, - "5237-inline-union-frame-objects.ts": 2284, - "524-map-cycles.ts": 3272, - "5240-event-target-subclass.ts": 3668, - "5241-event-subclass.ts": 4201, - "5242-event-target-subclass-hierarchy.ts": 2218, - "5243-event-target-subclass-dynamic.ts": 2613, - "5244-event-target-subclass.js": 3715, - "5245-event-target-subclass-signals.ts": 3077, - "5246-event-target-subclass-listener-throw.ts": 2770, - "5247-event-target-subclass-lifetimes.ts": 3603, - "5248-event-target-subclass-warnings.ts": 2743, - "5249-event-target-subclass-unconstructed.ts": 1632, - "525-map-rc-stress.ts": 3853, - "526-set-basics.ts": 1919, - "5260-record-unknown-identity.ts": 2937, - "5261-optional-field-identity.ts": 2860, - "5262-record-unknown-many.ts": 2984, - "527-set-foreach.ts": 3210, - "5270-url-parse-no-deprecation.cjs": 3158, - "5271-url-parse-throw-deprecation.cjs": 2975, - "5275-http-end-callback-order.ts": 2389, - "5276-style-text-hex-colors.cjs": 2820, - "5277-fs-read-file-buffer-option.cjs": 2710, - "5278-host-null-bytes.cjs": 2114, - "5279-search-params-null-init.cjs": 1781, - "528-set-seeded.ts": 2610, - "5285-blob-construct.ts": 2681, - "5286-blob-readers.ts": 3079, - "5287-blob-inspect.ts": 3817, - "5288-blob-validation.js": 3803, - "5289-blob-read-order.ts": 2829, - "529-map-seeded.ts": 2574, - "5290-blob-dynamic.js": 2354, - "5295-readline-promises-question.ts": 3709, - "5296-readline-lines.ts": 2760, - "5297-readline-callback-events.cjs": 2472, - "5298-readline-abort.cjs": 2757, - "5299-readline-stdin.ts": 3087, - "530-record-arrays.ts": 2787, - "5300-stream-add-abort-signal.ts": 3027, - "5301-stream-add-abort-signal-errors.cjs": 2717, - "5302-stream-promises-options.ts": 3120, - "5303-stream-finished-callback-opts.cjs": 2705, - "5305-json-stringify-typed-arrays.ts": 3153, - "531-record-array-hofs.ts": 2832, - "5315-map-iterate-after-front-deletes.ts": 3911, - "5316-map-lru-eviction.ts": 2782, - "5317-map-iterate-while-mutating.ts": 2769, - "5318-set-iterate-after-deletes.ts": 2291, - "5319-map-iteration-values.ts": 2689, - "532-record-arrays-rc-stress.ts": 2437, - "5320-map-iterate-across-compaction.ts": 3526, - "5325-record-boundary-returns.ts": 1763, - "5326-record-boundary-params.ts": 2634, - "5327-record-boundary-identity.ts": 2323, - "5328-record-boundary-open.ts": 2561, - "5329-record-boundary-recursion.ts": 2680, - "533-array-element-cycles.ts": 2932, - "5330-record-boundary-fields.ts": 1977, - "5331-record-boundary-methods.ts": 3130, - "5333-record-boundary-nullable-argument.ts": 3012, - "5334-fetch-mentions-without-calls.ts": 2532, - "5335-top-level-await-pending-exit-code.ts": 1919, - "5336-top-level-await-pending-exit-listener.ts": 3734, - "5337-dc-subscriber-throw-next-tick.cjs": 2604, - "5338-js-tdz-function-element.js": 2562, - "5339-array-buffer-constructor.js": 2502, - "534-record-width-subtyping.ts": 2615, - "5345-object-values-for-of-unknown.ts": 3008, - "5346-object-values-length-dynamic.ts": 3055, - "5347-object-values-loop-control.ts": 3030, - "5348-object-values-for-of-js.js": 2732, - "5349-object-entries-values-optional.ts": 2083, - "535-object-statics.ts": 2312, - "5350-object-values-wide-record.ts": 2790, - "5351-object-values-methods-index.ts": 3275, - "536-map-seed-array.ts": 2712, - "5360-array-sort-comparator-calls.ts": 3175, - "5361-array-sort-inconsistent-comparators.ts": 3161, - "5362-array-sort-comparator-throws.ts": 2896, - "5363-array-sort-comparator-writes.ts": 6813, - "5364-array-sort-union-and-boolean-elements.ts": 8514, - "5365-array-sort-dynamic-values.js": 2402, - "537-map-iter-drains.ts": 2867, - "538-map-set-for-of.ts": 2756, - "5390-interface-loop-element-lifetimes.ts": 2999, - "5391-interface-dispatch-hierarchies.ts": 3168, - "5392-interface-receiver-bindings.ts": 2015, - "5393-interface-array-holes.ts": 2530, - "5394-interface-implementers.ts": 2992, - "5395-locale-compare-ascii.ts": 3026, - "5396-locale-compare-latin.ts": 3119, - "5397-locale-compare-sorting.ts": 3179, - "540-tuples-basics.ts": 2776, - "5400-json-parse-typed-keys.ts": 3131, - "5405-buffer-arraybuffer-window.ts": 2729, - "5406-util-types-keys.ts": 2747, - "5407-http-header-field-limit.ts": 2785, - "5408-http-unread-request-end.ts": 3226, - "5409-http-held-request-body.ts": 3218, - "541-ref-array-json.ts": 3099, - "5410-inspect-class-values.ts": 1875, - "5411-inspect-class-hierarchies.ts": 2712, - "5412-inspect-dynamic-collections.ts": 2792, - "5413-inspect-class-values.cjs": 3020, - "542-union-element-arrays.ts": 2846, - "5430-dyn-number-string-boxes.ts": 3059, - "5435-crypto-hash-algorithms.ts": 2030, - "5436-crypto-hash-names.js": 2098, - "5437-crypto-hmac-algorithms.ts": 2699, - "5438-crypto-kdf-digests.ts": 2741, - "5439-crypto-kdf-callbacks.js": 2685, - "5440-crypto-hash-encodings.js": 4004, - "5441-crypto-hash-output-length.ts": 3671, - "5442-crypto-random-values.ts": 3947, - "5443-crypto-random-arguments.js": 3548, - "5444-crypto-timing-safe-equal.js": 3213, - "5445-crypto-secret-key-objects.ts": 3869, - "5445-stream-buffer-chunks.ts": 2881, - "5446-crypto-secret-key-errors.js": 3035, - "5446-stream-buffer-chunks-dynamic.js": 2859, - "5447-fs-readdir-order.ts": 2639, - "5448-fs-glob-patterns.ts": 2837, - "5449-fs-glob-options.ts": 3025, - "5450-fs-glob-validation.js": 3327, - "5451-fs-promises-glob.ts": 3059, - "5452-fs-glob-callback.ts": 2936, - "5455-power-of-two-remainder.ts": 2837, - "5456-remainder-large-integer-dividends.ts": 2786, - "5457-lcg-modulus.ts": 1426, - "5458-fractional-remainder.ts": 1394, - "5460-locale-compare-contractions.ts": 2979, - "5461-locale-compare-equivalents.ts": 2661, - "5462-locale-compare-probe-sweep.ts": 3400, - "5463-locale-compare-combining-letters.ts": 2733, - "5464-locale-compare-fractions.ts": 2833, - "5470-strip-vt-osc.cjs": 2497, - "5471-strip-vt-csi.cjs": 2651, - "5472-strip-vt-random.cjs": 2375, - "5473-strip-vt-unterminated.cjs": 3521, - "5474-strip-vt-surrogates.ts": 2534, - "5540-fs-callback-forms.cjs": 3233, - "5541-fs-stats-fields.cjs": 3564, - "5542-fs-promises-parity.cjs": 3940, - "5543-fs-promises-typed.ts": 1655, - "5544-fs-opendir.cjs": 3024, - "5545-fs-options-encoding.cjs": 2994, - "5548-fs-callback-arguments.cjs": 4041, - "5549-fs-callback-option-checks.cjs": 3738, - "5550-locale-compare-ascii-words.ts": 2509, - "5551-array-search-references.ts": 3475, - "5552-string-appends.ts": 2703, - "5553-string-append-char-code.ts": 2870, - "5565-fs-dirent-untyped.mjs": 2600, - "5566-fs-dirent-dyn-boundaries/main.mjs": 2607, - "5585-record-results-inlined.ts": 2922, - "5595-net-ref-unref.ts": 2593, + "1117-typeof-static-union.ts": 3626, + "1118-object-spread-conditional.ts": 2554, + "1119-switch-union.ts": 2726, + "112-class-descriptor-key.js": 2549, + "1121-infinity-number-tostring.ts": 3208, + "1122-any-captures.ts": 3054, + "1124-union-narrowed-retag.ts": 3578, + "113-promise-checked-exits.ts": 3586, + "114-live-record-delete.ts": 3626, + "115-array-compound.js": 3341, + "116-text-decoder-runtime.js": 2988, + "117-weak-cache-cycle.js": 2923, + "118-fs-stored-callbacks.cjs": 4172, + "119-native-patterns.js": 3825, + "1200-regex-test-basics.ts": 3353, + "1201-regex-replace.ts": 3417, + "1202-regex-substitutions.ts": 2747, + "1203-regex-split.ts": 3543, + "1204-regex-empty-unicode.ts": 3255, + "1205-regex-rc-stress.ts": 3482, + "1300-errors-basics.ts": 4832, + "1301-errors-subclass.ts": 1974, + "1302-errors-typed-catch.ts": 3160, + "1303-errors-rc-stress.ts": 3496, + "1304-errors-uncaught.ts": 2419, + "1305-errors-async-rejections.ts": 3908, + "1306-errors-runtime-instances.ts": 3226, + "1350-path-normalize-join.ts": 3294, + "1351-path-parts.ts": 3299, + "1352-path-resolve-relative.ts": 3380, + "1353-os-basics.ts": 3216, + "1354-builtin-bare-specifiers.ts": 3413, + "1355-url-parse.ts": 3188, + "1356-url-file-bridge.ts": 3020, + "1357-fsp-roundtrip.ts": 3377, + "1358-crypto-random.ts": 3134, + "1359-json-module/main.ts": 3195, + "1360-spawn-sync.ts": 3446, + "1361-spawn-events.ts": 3606, + "1362-spawn-timers.ts": 9552, + "1363-spawn-unhandled-error.ts": 3308, + "1364-union-truthiness.ts": 2872, + "1365-union-logical.ts": 3452, + "1366-union-equality.ts": 2813, + "1367-destructuring.ts": 3209, + "1368-constructor-functions.ts": 1858, + "1369-promise-union.ts": 2635, + "1370-spread.ts": 2894, + "1371-union-template-tostring.ts": 3244, + "1372-loose-null-tests.ts": 3198, + "1373-union-array-arms.ts": 3455, + "140-bitwise-operators.ts": 3457, + "1400-typedarray-basics.ts": 2651, + "1401-typedarray-slice-set.ts": 4371, + "1402-buffer-encodings.ts": 3496, + "1403-buffer-fs.ts": 3517, + "1404-zlib-crypto-bytes.ts": 3174, + "1405-bytes-unions-arrays.ts": 4083, + "1406-dataview-mp4.ts": 3511, + "1407-dataview-bounds.ts": 2861, + "1408-string-indexing.ts": 3596, + "1409-typedarray-integer-loops.ts": 3161, + "1420-number-statics.ts": 1931, + "1421-number-parse-strings.ts": 2420, + "1422-date-iso.ts": 3107, + "1423-text-codec.ts": 4835, + "1424-fs-options.ts": 3321, + "1425-stdin-tty.ts": 2403, + "1426-stdin-read.ts": 3082, + "1427-fromcharcode-lastindexof.ts": 3173, + "1428-settled-await-order.ts": 1798, + "1429-promise-catch-finally.ts": 3573, + "1430-promise-race.ts": 3479, + "1431-caught-tostring.ts": 3384, + "1432-destructured-params.ts": 2875, + "1433-filter-narrow.ts": 3756, + "1434-async-never.ts": 3046, + "1435-math-spread.ts": 2761, + "1436-default-undef-param.ts": 2349, + "1437-pad-default.ts": 3147, + "1438-promise-all.ts": 6716, + "1440-interval-basics.ts": 2538, + "1441-interval-clear-cross.ts": 6428, + "1442-interval-throw.ts": 3155, + "1443-signal-handlers.ts": 5897, + "1444-exit-listeners.ts": 2050, + "1445-exit-process-exit.ts": 3031, + "1446-exit-uncaught.ts": 3104, + "1447-stdin-closed-events.ts": 2554, + "1448-stream-columns.ts": 2939, + "1450-incdec-expression.ts": 3366, + "1451-instanceof-uint8array-unknown.ts": 3581, + "1452-return-through-finally.ts": 2366, + "1453-pmap-settled.ts": 3689, + "1454-nonnull-narrow-and-fcc-bytes.ts": 3631, + "1455-lambda-union-return-adoption.ts": 3317, + "1460-console-error-warn.ts": 2928, + "1461-process-pid-getuid-kill.ts": 2613, + "1462-exec-sync.ts": 3611, + "1463-timeout-unref.ts": 2351, + "1464-env-writes.ts": 2366, + "1465-env-value.ts": 3573, + "1466-child-containers.ts": 3261, + "1467-string-match.ts": 2763, + "1468-exec-path.ts": 1874, + "1469-remove-listener.ts": 3366, + "1470-child-lifecycle.ts": 3503, + "1471-child-unref.ts": 7428, + "1472-errno-code.ts": 3503, + "1473-promisify-execfile.ts": 3923, + "1474-string-decoder.ts": 3543, + "1475-readline-closed-stdin.ts": 2561, + "1476-assign-expression.ts": 2094, + "1477-in-expressions.ts": 2351, + "1478-promise-reject.ts": 3535, + "1479-destructuring-assign.ts": 3422, + "1480-os-network-interfaces.ts": 3878, + "1481-string-case-static.ts": 1956, + "1482-spawnsync-error.ts": 3384, + "1483-array-slice.ts": 2259, + "1520-fs-wider-surface.ts": 2338, + "1520-string-split-static.ts": 2323, + "1521-fs-lstat-lock.ts": 2828, + "1521-string-trim-pad-static.ts": 3386, + "1522-parseint-static.ts": 3245, + "1522-spawnsync-options.ts": 5207, + "1523-isnan-floor-static.ts": 2460, + "1523-spawn-options.ts": 3155, + "1524-atomics-sleep-static.ts": 3514, + "1524-catch-narrowing.ts": 3000, + "1525-child-exit-signal.ts": 3280, + "1525-unknown-typeof-validation.ts": 3939, + "1526-set-spread.ts": 3125, + "1527-logical-mixed-operands.ts": 3109, + "1528-delete-records-env.ts": 3666, + "1529-class-with-statics.ts": 2773, + "1530-array-push-variadic.ts": 2981, + "1530-spread-override-completion.ts": 2727, + "1531-delete-optional-fields.ts": 3366, + "1531-process-arch-versions.ts": 3284, + "1532-array-splice-shift.ts": 3298, + "1532-union-shared-field-read.ts": 3134, + "1533-bool-equality.ts": 2685, + "1533-path-platform-namespaces.ts": 2976, + "1534-crypto-hash-chain.ts": 3181, + "1534-union-as-arm-cast.ts": 1932, + "1535-spawn-fd-stdio.ts": 2678, + "1535-union-param-defaults.ts": 3163, + "1536-destructuring-defaults.ts": 2281, + "1536-string-array-sweep.ts": 2437, + "1537-chalk-hybrid/main.ts": 2748, + "1537-os-release-spawnsync-stdio.ts": 1762, + "1538-await-promiselike-return.ts": 3032, + "1538-math-static-scalar.ts": 3194, + "1539-readonly-set-map.ts": 2459, + "1539-unknown-truthiness.ts": 3106, + "1540-os-userinfo.ts": 3344, + "1540-void-statement.ts": 2967, + "1541-fs-readdir-dirent.ts": 3638, + "1541-union-keyed-reads.ts": 3287, + "1542-map-promise-values.ts": 2441, + "1542-record-literal-into-union.ts": 3261, + "1543-rest-destructuring.ts": 2933, + "1543-set-server-handles.ts": 1958, + "1544-dyn-json-reads.ts": 2284, + "1544-string-matchall.ts": 2886, + "1545-spread-order-and-optional.ts": 3651, + "1546-union-element-reads.ts": 3172, + "1547-computed-key-fold.ts": 3047, + "1548-boolean-condition-forms.ts": 2170, + "1549-array-isarray-unions.ts": 3931, + "1550-param-defaults-func-set.ts": 2398, + "1551-dyn-receiver-methods.ts": 3835, + "1552-exec-options-record.ts": 3202, + "1553-truthy-hof-predicates.ts": 3421, + "1554-caught-into-unknown.ts": 3543, + "1555-index-spread-into-declared.ts": 3633, + "1556-union-retag-width-arms.ts": 2627, + "1557-url-host.ts": 2357, + "1558-any-joins-and-dyn-validation.ts": 3196, + "1559-conditional-spread-index-merge.ts": 3131, + "1560-forof-homogeneous-tuples.ts": 3159, + "1561-forof-strings.ts": 2864, + "1561-promise-then.ts": 2385, + "1562-optional-chain-tails.ts": 3642, + "1562-spawn-conditional-spread.ts": 3319, + "1563-forof-iterator-projections.ts": 2786, + "1563-string-raw-fold.ts": 2587, + "1564-fs-watch.ts": 3261, + "1564-string-raw.ts": 2451, + "1565-spawn-pipe-streams.ts": 3391, + "1565-union-element-join.ts": 2486, + "1566-child-duck-interface.ts": 2840, + "1567-server-close-override.ts": 3237, + "1568-x509-fingerprint.ts": 3907, + "1569-fsp-mkdir-unlink-chmod.ts": 2903, + "1570-child-unref-kill-reffed.ts": 8636, + "1571-optional-call-tostring-tail.ts": 2889, + "1571-stdin-set-raw-mode-non-tty.ts": 2975, + "1572-promise-reject-all-tuple.ts": 3556, + "1572-x509-validity-date-gettime.ts": 3310, + "1573-promisify-execfile-env-spread.ts": 2814, + "1573-tdz-scalar-forward-capture.ts": 1712, + "1574-dyn-optional-method-number-keys.ts": 3878, + "1574-promise-all-tuple-literal.ts": 2253, + "1575-unknown-assert-into-record.ts": 1861, + "1576-width-coercions.ts": 2898, + "1577-url-hostname.ts": 2901, + "1578-exec-input-optional.ts": 3273, + "1579-matchall-index.ts": 3564, + "1580-exec-env-conditional-spread.ts": 2271, + "1581-declare-const-read.ts": 3037, + "1582-timer-sleep-resolve.ts": 3206, + "1583-loops-and-stream-captures.ts": 3193, + "1584-union-field-unassigned.ts": 3119, + "1585-union-field-conditional-ctor.ts": 3101, + "1586-derived-field-before-super-init.ts": 2618, + "1590-js-unannotated.js": 2053, + "1591-js-closures.js": 2387, + "1592-js-classes.js": 4973, + "1593-js-jsdoc-records.js": 3116, + "1594-js-async.js": 2589, + "1595-js-island-gap/main.js": 3108, + "1596-cjs-modules/main.js": 3096, + "1597-mjs-graph/main.mjs": 2863, + "1598-cjs-builtin-require/main.js": 2598, + "1599-js-uncaught-throw.js": 1785, + "1600-assert-passing.ts": 3203, + "1601-assert-fail-exit.ts": 2955, + "1602-assert-caught-error.ts": 2978, + "1603-assert-scalar-messages.ts": 3055, + "1604-assert-deep-structures.ts": 3591, + "1605-assert-import-forms.ts": 2429, + "1606-assert-strict-module.ts": 3039, + "1607-assert-throws-match.ts": 2826, + "1608-cjs-assert/main.js": 3263, + "1609-assert-async.ts": 3342, + "1610-path-win32-full.ts": 2405, + "1611-url-file-bridge-neutral.ts": 2476, + "1612-cjs-module-globals.cjs": 2856, + "1613-cjs-esm-proxy-named/main.mjs": 2613, + "1614-js-fence-dodges.cjs": 1967, + "1615-cjs-export-shapes/main.cjs": 2975, + "1616-cjs-esm-lexer-invisible/main.mjs": 2660, + "1617-cjs-esm-lexer-visible/main.mjs": 3090, + "1618-cjs-esm-poisoned-tail/main.mjs": 2780, + "1619-cjs-esm-reexport-invisible/main.mjs": 2185, + "1620-cjs-require-effects-order/main.js": 1410, + "1621-cjs-require-cache-hit/main.js": 2836, + "1622-cjs-require-conditional/main.js": 2564, + "1623-cjs-require-diamond/main.js": 2652, + "1624-cjs-require-dir-mid-file/main.js": 2573, + "1625-cjs-require-lazy-fn/main.js": 2246, + "1626-cjs-require-mjs/main.js": 2951, + "1627-mjs-import-cjs-requires/main.mjs": 2683, + "1628-checked-dynamic-builtin-args.cjs": 1896, + "1629-require-main-filename.cjs": 2867, + "1630-inspect-scalars.ts": 2361, + "1630-rmsync-retry-options.cjs": 2984, + "1631-inspect-arrays.ts": 3811, + "1632-inspect-records.ts": 4779, + "1633-inspect-map-set.ts": 3008, + "1634-inspect-classes.ts": 3344, + "1635-inspect-buffer.ts": 2898, + "1636-util-format.ts": 2261, + "1637-inspect-dyn.ts": 2934, + "1638-inspect-cjs.cjs": 3133, + "1639-versions-openssl-probe.ts": 2209, + "1640-fd-read-decode.ts": 3309, + "1641-string-search.ts": 2951, + "1642-object-fromentries-rows.ts": 3231, + "1643-metadata-dyn-return.cjs": 3375, + "1644-ee-basics.ts": 3158, + "1645-ee-extends.ts": 2448, + "1646-ee-once-remove.ts": 2581, + "1647-ee-meta-events.ts": 2563, + "1648-ee-error-event.ts": 2097, + "1649-ee-names-counts.ts": 2941, + "1650-ee-prepend.ts": 3190, + "1651-ee-max-listeners.ts": 2691, + "1652-ee-snapshot.ts": 2882, + "1653-ee-cjs.cjs": 2645, + "1654-ee-namespace.ts": 2314, + "1655-spawnsync-neutral.ts": 4787, + "1656-execsync-neutral.ts": 3015, + "1657-spawn-async-neutral.ts": 3128, + "1660-buffer-read-write-num.ts": 2511, + "1661-buffer-encodings-full.ts": 3466, + "1662-string-decoder-encodings.ts": 3207, + "1663-buffer-compare-search-fill.ts": 3063, + "1664-dyn-fn-boundary.cjs": 2280, + "1665-dyn-fn-mustcall/main.cjs": 2798, + "1666-dyn-fn-identity.ts": 3303, + "1667-dyn-fn-not-callable.cjs": 2431, + "1668-dyn-fn-throws.cjs": 3052, + "1669-symbol-identity.ts": 3194, + "1670-symbol-registry.ts": 2198, + "1671-symbol-typeof.ts": 2786, + "1672-symbol-containers.ts": 2209, + "1673-symbol-cjs.cjs": 2979, + "1674-symbol-inspect.ts": 2795, + "1676-func-array-surface.ts": 2945, + "1677-emitter-listeners.ts": 4548, + "1678-emitter-dyn-listeners.cjs": 3185, + "1679-console-dyn.js": 2910, + "1680-assert-bytes.ts": 3154, + "1681-assert-funcs.ts": 1828, + "1685-stream-readable-basics.ts": 2976, + "1686-stream-readable-paused.ts": 2831, + "1687-stream-readable-flow-control.ts": 2863, + "1688-stream-writable-basics.ts": 2245, + "1689-stream-writable-async-drain.ts": 1562, + "1690-stream-duplex.ts": 3124, + "1691-stream-transform.ts": 2070, + "1692-stream-pipe.ts": 2661, + "1693-stream-pipe-backpressure.ts": 2944, + "1694-stream-destroy.ts": 2243, + "1695-stream-props.ts": 2801, + "1696-stream-read-inside-read.ts": 2398, + "1697-stream-tick-vs-timer.ts": 2703, + "1698-stream-uncaught-error.ts": 2045, + "1699-stream-callback-shapes.ts": 2523, + "1700-mustcall-common/main.cjs": 3695, + "1701-mustcall-exit-report/main.cjs": 4202, + "1702-dyn-proto-dispatch.cjs": 3277, + "1703-arguments-rest-props.cjs": 2983, + "1710-cjs-export-class/main.js": 3030, + "1711-cjs-export-single-values/main.js": 2594, + "1712-field-incdec.ts": 1845, + "1713-js-dyn-fields.js": 2654, + "1720-assert-throws-shape.ts": 2898, + "1721-assert-throws-regex-class.ts": 3751, + "1722-assert-rejects.ts": 2848, + "1723-assert-does-not-reject.ts": 3358, + "1724-assert-iferror.ts": 1705, + "1725-assert-symbols.ts": 2141, + "1726-promise-with-resolvers.ts": 2575, + "1727-assert-throws-shape-exit.ts": 2905, + "1730-countdown-symbol-keys/main.js": 2273, + "1731-symbol-field-shapes.cjs": 2895, + "1732-symbol-field-cross-module/main.js": 2678, + "1740-stream-extends-readable.ts": 2983, + "1741-stream-extends-writable.ts": 2337, + "1742-stream-extends-duplex-transform.ts": 3417, + "1743-stream-extends-vt-dispatch.ts": 2520, + "1744-stream-set-encoding.ts": 3582, + "1745-stream-encoding-js.cjs": 2993, + "1746-stream-for-await.ts": 4666, + "1747-stream-for-await-js.cjs": 3552, + "1750-http-agent-options.ts": 2667, + "1751-options-record-stance.ts": 3044, + "1760-surplus-args-drop.cjs": 2775, + "1761-emitter-special-event-names.cjs": 2427, + "1770-assert-dyn-strict.ts": 3393, + "1771-assert-dyn-deep.ts": 3639, + "1772-assert-dyn-js.cjs": 2854, + "1773-assert-dyn-exit.ts": 2368, + "1780-http-res-surface.ts": 2318, + "1781-http-server-shapes.cjs": 3339, + "1790-computed-key-folds.ts": 2833, + "1791-searchparams-core.ts": 2212, + "1792-searchparams-encoding.ts": 2305, + "1793-searchparams-iteration.ts": 3412, + "1794-searchparams-url-live.ts": 2492, + "1795-dyn-handle-request.cjs": 3337, + "1796-dyn-handle-body.cjs": 3287, + "1797-dyn-handle-socket.cjs": 2497, + "1798-dyn-handle-typed-box.ts": 2870, + "1800-immediate-basics.ts": 2802, + "1801-immediate-handle.ts": 2655, + "1802-immediate-unref-exit.ts": 2450, + "1803-timeout-refresh.ts": 2797, + "1804-timers-module.ts": 2773, + "1805-timer-callback-args.ts": 2736, + "1806-timer-delay-trunc.ts": 2060, + "1810-stream-options-const-record.ts": 2542, + "1811-stream-option-value-callbacks.cjs": 2462, + "1812-stream-super-options-forwarding.cjs": 3383, + "1813-stream-finished.ts": 2720, + "1814-stream-pipeline.cjs": 3409, + "1815-stream-state-reads.cjs": 2880, + "1820-static-block-basics.ts": 1635, + "1821-static-block-order.ts": 2551, + "1822-static-block-js.js": 2387, + "1823-static-instance-method-names.ts": 1936, + "1824-for-of-destructuring-defaults.ts": 2145, + "1825-exhaustive-typeof-switch.ts": 2973, + "1826-settimeout-arguments-callback.js": 2489, + "1830-enum-numeric-basics.ts": 2207, + "1831-enum-string-const-reverse.ts": 1943, + "1832-enum-modules/main.ts": 2350, + "1835-var-basics.ts": 2804, + "1836-var-loop-capture.ts": 3197, + "1837-var-undefined-hoisting.ts": 2836, + "1838-var-modules/main.ts": 2550, + "1839-var-js/main.cjs": 2492, + "1840-jsdoc-import-type-only/main.js": 1919, + "1850-overload-basics.ts": 2640, + "1851-overload-return-narrowing.ts": 1736, + "1852-overload-class-members.ts": 2774, + "1853-overload-modules/main.ts": 2509, + "1854-ambient-declare-fn.ts": 2603, + "1855-ambient-declare-fn-uncaught.ts": 1999, + "1870-unit-type-values.ts": 2905, + "1871-empty-array-never.ts": 2516, + "1872-template-tostring-composite.ts": 1682, + "1880-json-declared-field-order.ts": 3529, + "1881-default-anon/main.ts": 2084, + "1882-default-cjs-interop/main.ts": 2606, + "1883-default-exports/main.ts": 2612, + "1890-ns-imports/main.ts": 2704, + "1891-ns-reexport/main.ts": 2129, + "1940-class-values-basics.ts": 2668, + "1941-class-values-registry.ts": 2870, + "1942-class-expressions.ts": 2682, + "1943-class-statics-expanded.ts": 2734, + "1944-class-values-modules/main.ts": 2146, + "1950-generic-fn-values.ts": 2755, + "1951-generic-classes-basics.ts": 3235, + "1952-generic-class-statics-values.ts": 2233, + "1953-generic-class-hierarchy.ts": 2990, + "1954-generic-modules/main.ts": 2377, + "1960-namespace-basics.ts": 2728, + "1961-namespace-nested.ts": 2156, + "1962-namespace-classes.ts": 2835, + "1963-namespace-aliases.ts": 2550, + "1964-namespace-type-only.ts": 2471, + "1965-namespace-ambient.ts": 2707, + "1966-namespace-modules/main.ts": 2766, + "1967-namespace-alias-typeonly.ts": 2273, + "1968-namespace-import-eq-snapshot.ts": 2594, + "1970-decorators-basics.ts": 2916, + "1971-decorators-rebinding.ts": 2369, + "1972-decorators-throwing.ts": 2667, + "1973-decorators-ambient.ts": 2709, + "1980-primitive-proto-statics.ts": 3013, + "1981-date-utc.ts": 2644, + "1982-freeze-resolve-passthrough.ts": 3023, + "1983-array-tuple-surfaces.ts": 3232, + "1990-labels-basics.ts": 2990, + "1991-for-in-loops.ts": 3611, + "1992-small-syntax.ts": 3054, + "200-strings.ts": 1903, + "2000-generic-methods-basic.ts": 2832, + "2001-generic-methods-generic-class.ts": 2741, + "2002-generic-methods-inheritance.ts": 2972, + "2003-generic-methods-object-literal.ts": 3023, + "2004-generic-methods-statics.ts": 2292, + "201-templates.ts": 2534, + "2010-generators-basics.ts": 1525, + "2011-generators-forof.ts": 2217, + "2012-generators-return-throw.ts": 3262, + "2013-generators-sent-values.ts": 2117, + "2014-generators-values.ts": 2991, + "2015-generators-yieldstar.ts": 2892, + "2016-generators-rc-stress.ts": 2942, + "2017-generators-async.ts": 1965, + "2018-generators-uncaught.ts": 2403, + "2019-generators-loops.ts": 2116, + "2020-generic-value-bindings.ts": 3355, + "2021-generic-value-binding-modules/main.ts": 2720, + "2022-width-index-capture.ts": 2258, + "2023-width-readonly.ts": 2519, + "2024-width-array-elems.ts": 2776, + "2025-width-union-compose.ts": 3243, + "2026-width-spread.ts": 1625, + "2030-width-nested.ts": 3160, + "2031-width-tuples.ts": 2019, + "2032-cjs-export-assigned-class-expression/main.cjs": 2230, + "2033-property-assigned-class-extends.cjs": 2058, + "2035-ternary-array-retag.cjs": 2602, + "2036-evolving-array-decl.cjs": 2125, + "2037-fn-decl-hoisting.cjs": 1595, + "2038-evolving-array-js.cjs": 2965, + "2040-any-bindings.ts": 3143, + "2040-mixin-heritage.ts": 3206, + "2041-any-params-returns.ts": 2996, + "2041-mixin-values.ts": 3090, + "2042-any-flow-loops.ts": 3104, + "2042-mixin-modules/main.ts": 2762, + "2043-any-dom-values.ts": 3345, + "2043-mixin-rc-stress.ts": 2605, + "2044-vtable-sibling-slots.ts": 3123, + "2045-objlit-accessors-basic.ts": 2774, + "2045-parameter-properties.ts": 3393, + "2046-abstract-classes.ts": 2184, + "2046-objlit-accessors-effects.ts": 2948, + "2047-objlit-accessors-shapes.ts": 1767, + "2047-optional-class-fields.ts": 2566, + "2050-dynamic-import-own-module/main.ts": 2384, + "2051-dynamic-import-then/main.ts": 2679, + "2052-dynamic-import-self.ts": 2722, + "2053-typeof-static-fold.ts": 2817, + "2054-destructuring-island-source.ts": 2995, + "2060-empty-tuple.ts": 2635, + "2070-computed-key-folds.ts": 2872, + "2071-integer-key-enumeration-order.ts": 3125, + "2072-expando-function-members.ts": 2341, + "2073-destructuring-assignment.ts": 2794, + "2074-island-destructuring.ts": 2364, + "2075-index-signature-runtime-keys.ts": 2866, + "2080-destructuring-defaults.ts": 1887, + "2081-destructuring-rest.ts": 3136, + "2082-destructuring-assignment.ts": 2594, + "2085-destructuring-heads-rest-params.ts": 2973, + "2087-destructuring-for-heads.ts": 2753, + "2090-index-signature-number-keys.ts": 2175, + "2091-index-signature-string-intersection.ts": 2763, + "2092-package-imports/main.ts": 2350, + "2093-timers-promises.ts": 2872, + "2094-diagnostics-channel.ts": 2689, + "2095-js-catch-unknown.js": 2633, + "2096-os-type.ts": 1968, + "2097-js-evolving-globals.js": 2880, + "210-string-methods.ts": 2798, + "2100-stream-default-hwm.ts": 2089, + "2101-dyn-param-defaults.ts": 2260, + "2102-empty-pattern-decls.ts": 1677, + "2105-computed-key-static-folds.ts": 2815, + "2106-comma-expressions.ts": 2657, + "211-string-unicode.ts": 2741, + "2110-top-object-types.ts": 2919, + "2111-json-stringify-unknown.ts": 2401, + "2112-array-at-findlast.ts": 1741, + "2113-string-index-methods.js": 1867, + "212-string-aliasing-append.ts": 2513, + "2120-package-self-import/main.ts": 2334, + "2121-esm-cycle-inert-backedge/main.ts": 2266, + "2123-ambient-import-crash/main.ts": 2890, + "2124-imports-field-wildcard/main.ts": 2153, + "2140-uri-component-codecs.ts": 2446, + "2160-dc-tracing-channel.cjs": 2881, + "2161-js-object-literal-identity.cjs": 2928, + "2162-js-dyn-destructure.cjs": 2896, + "2163-js-selfref-const.cjs": 2717, + "2164-js-then-dyn-handler.cjs": 2572, + "2165-js-throw-dyn.cjs": 2672, + "2166-cjs-getter-this/main.cjs": 2899, + "2170-island-array-exits.ts": 2722, + "2171-island-json-stringify.ts": 2071, + "2172-island-regexp-boundary.ts": 2828, + "2190-new-object-and-string-wrappers.ts": 2625, + "2191-uri-encoders.ts": 2849, + "2192-object-default-tostring.ts": 2537, + "2193-discarded-stdlib-reads.ts": 2594, + "2194-ambient-undef-chains.ts": 1718, + "2195-require-missing-package/main.mjs": 2757, + "2196-island-computed-key-chain.ts": 2575, + "2210-dyn-promise-crossing.cjs": 2319, + "2211-dc-trace-promise.cjs": 1935, + "2212-unhandled-rejection-listener.cjs": 2879, + "2213-async-local-storage.cjs": 2883, + "2214-dc-bind-store.cjs": 2240, + "2215-process-emit-warning-exit.cjs": 3330, + "2240-width-class-into-record.ts": 2571, + "2241-width-record-into-class.ts": 2500, + "2242-width-statics-into-record.ts": 1787, + "2243-width-assert-satisfies-shapes.ts": 2738, + "2250-tagged-templates.ts": 2408, + "2252-class-iterators.ts": 3611, + "2253-union-coercions.ts": 2810, + "2260-http2-constants.cjs": 2702, + "2280-builtin-namespace-destructure.cjs": 2594, + "2281-domexception-atob-btoa.cjs": 2615, + "2282-queue-microtask.cjs": 2780, + "2283-structured-clone.cjs": 3105, + "2284-regexp-constructor.cjs": 2648, + "2285-iferror-dyn.cjs": 2717, + "2286-dyn-object-walks.cjs": 3110, + "2300-dyn-record-spread-and-keyed-access.cjs": 2464, + "2301-cjs-export-table-dom-attach.cjs": 2425, + "2310-process-next-tick.ts": 2609, + "2311-next-tick-js-callbacks.js": 2450, + "2312-stream-underscore-assign.ts": 2473, + "2313-stream-underscore-assign-js.cjs": 3017, + "2314-process-introspection.ts": 3479, + "2320-await-unit.ts": 2334, + "2321-emitter-static-setmax.cjs": 2697, + "2322-dyn-array-sort.cjs": 3014, + "2323-timer-callback-returns.ts": 3852, + "2330-tls-server-runtime-options.cjs": 2565, + "2331-tls-server-options-typed.ts": 1980, + "2350-nan-global.ts": 3180, + "2351-async-methods.ts": 2138, + "2352-void-coercions.ts": 2843, + "2353-decorators-member-ambient.ts": 3089, + "2354-decorators-expression-ambient.ts": 1841, + "2360-tuple-to-array.ts": 2335, + "2361-assign-index-record.ts": 3492, + "2362-execsync-inherit.ts": 2484, + "2363-nullish-retag.ts": 2875, + "2364-in-runtime-key.ts": 2156, + "2365-dyn-into-island.ts": 2339, + "2366-string-well-formed.ts": 2760, + "2367-regexp-escape.ts": 2791, + "2368-set-methods.ts": 3237, + "2369-promise-try.ts": 2605, + "2370-group-by.ts": 3569, + "2371-iterator-helpers.ts": 3561, + "2380-buffer-module-named-import.ts": 2746, + "2381-builtin-default-imports.js": 2945, + "2382-cycle-two-decl/main.ts": 2560, + "2383-cycle-assertdoc/main.js": 3011, + "2384-cycle-mixed-bindings/main.ts": 2477, + "2385-builtin-reexport-facade/main.ts": 2948, + "2386-string-to-chars.ts": 2475, + "2387-tonumber-argv.ts": 3071, + "2388-tonumber-grammar-zoo.ts": 3157, + "2389-tonumber-unary-plus.ts": 2176, + "2390-dot-requires/main.cjs": 2329, + "2391-default-builtin-imports/main.ts": 2387, + "2392-block-guard-alias-scope.ts": 2363, + "2393-loop-exit-guard-narrow.ts": 2936, + "2394-loop-narrow-containment.ts": 2244, + "2395-while-cond-guard.ts": 2443, + "2396-born-narrowed-decl.ts": 2276, + "2397-branch-kill-merge.ts": 2681, + "2398-switch-arm-kill.ts": 3027, + "2399-reassign-kill-polarity.ts": 2662, + "240-stdout-write.ts": 1918, + "2400-kill-return-edge.ts": 2414, + "2401-kill-break-staging.ts": 2162, + "2402-labeled-break-kill.ts": 2493, + "2403-kill-continue-backedge.ts": 2457, + "2404-kill-throw-catch.ts": 1792, + "2405-sibling-arm-narrow.ts": 1781, + "2406-switch-clause-sibling-narrow.ts": 2641, + "2407-infinite-loop-seal.ts": 2308, + "2408-loop-terminality-reopen.ts": 2756, + "2409-loop-body-return-not-terminal.ts": 2759, + "2410-stacked-cases-terminality.ts": 2830, + "2411-exhaustive-switch-terminality.ts": 2112, + "2412-dowhile-guard-trailing-test.ts": 2230, + "2413-dowhile-kill-renarrow.ts": 2630, + "2414-dowhile-continue-kill.ts": 2624, + "2415-dowhile-break-trailing-test.ts": 2524, + "2416-spread-ternary-positions.ts": 2956, + "2417-ternary-local-inference.ts": 2300, + "2418-wrapped-ternary-arms.ts": 2768, + "2419-selector-ternary-union.ts": 2727, + "2420-nullish-null-identity.ts": 2533, + "2421-float-lane-inference.ts": 2620, + "2422-ieee-div-rem-corners.ts": 2629, + "2423-param-null-reassign.ts": 2622, + "2424-ternary-miss-first-narrowing.ts": 2228, + "2425-elseif-head-exit-narrow.ts": 2186, + "2426-default-snapshot-mutable/main.ts": 2520, + "2427-perf-hooks-now.ts": 2346, + "2428-field-redeclare-inherited.ts": 2882, + "2429-destructure-class-instance.ts": 2852, + "2430-empty-literal-unknown-field.js": 2190, + "2431-primitive-ctor-values.ts": 2149, + "2432-generic-member-fields-async.ts": 3225, + "2433-as-const-command-tables.ts": 3139, + "2434-deferred-init-fields.ts": 2789, + "2435-loose-same-kind-equality.ts": 2652, + "2440-console-inspect-args.ts": 3314, + "2441-console-process-argv.ts": 2095, + "2442-union-literal-arm-widening.ts": 2062, + "2443-union-literal-shadow-narrowing.ts": 2856, + "2444-union-literal-reducer-spread.ts": 2705, + "2445-math-minmax-nary.ts": 2093, + "2446-performance-global.ts": 2484, + "2447-island-boundary-slots/main.ts": 3456, + "2448-entries-null-arms-regex-arrays.ts": 2911, + "2450-private-instance-methods.ts": 2310, + "2451-private-fields.ts": 2058, + "2452-private-statics.ts": 2844, + "2453-private-accessors.ts": 2851, + "2454-private-generator-methods.ts": 2328, + "2455-private-brand-checks.ts": 2840, + "2456-private-async-methods.ts": 2932, + "2457-private-members.js": 2832, + "2460-qs-parse-grammar.ts": 2844, + "2461-qs-parse-options.ts": 2944, + "2462-qs-stringify.ts": 3219, + "2463-qs-escape-unescape.ts": 2133, + "2464-qs-require-forms.cjs": 2362, + "2470-mockable-module-shape.js": 3020, + "2471-record-keyed-write-hasown.js": 2921, + "2472-string-regexp-union.ts": 1528, + "2473-option-table-widths.js": 2792, + "2474-island-literal-forms.ts": 2730, + "2475-variadic-wrapper-island.js": 2962, + "2476-map-regex-values.ts": 1895, + "2480-recursive-record-tree.ts": 2781, + "2481-mutual-recursive-records.ts": 2829, + "2482-recursive-union-tree.ts": 2626, + "2483-recursive-record-cycles.ts": 2385, + "2484-json-stringify-circular.ts": 1936, + "2485-inspect-circular-refs.ts": 3139, + "2486-recursive-record-boundaries.ts": 3118, + "2487-recursive-deep-equal.ts": 2998, + "2488-ast-walker.ts": 3274, + "2490-find-miss-null-compare.ts": 2608, + "2491-strict-unit-compare-no-arm.ts": 2376, + "2492-loose-null-compare-unions.ts": 2805, + "2493-switch-unit-cases.ts": 2280, + "2494-no-arm-compare-effects.ts": 2159, + "2500-net-autosel-timeout.ts": 2195, + "2510-dyn-evolving-array-map.ts": 1961, + "2511-dyn-evolving-array-filter-foreach.ts": 2859, + "2512-dyn-evolving-array-mixed-push.ts": 1607, + "2520-private-statics-class-name-calls.ts": 2420, + "2521-private-statics-class-expression.ts": 1848, + "2522-private-statics-decorated.ts": 3008, + "2523-private-statics-aliased-class.ts": 2743, + "2530-object-destructuring-decl.ts": 2036, + "2531-array-tuple-destructuring-decl.ts": 2908, + "2532-param-destructuring-options.ts": 2917, + "2533-forof-destructuring.ts": 2821, + "2534-object-rest-decl.ts": 2914, + "2535-destructuring-assign-basics.ts": 2888, + "2536-destructuring-assign-nested.ts": 2697, + "2537-destructuring-assign-member-targets.ts": 1747, + "2538-destructuring-assign-class-source.ts": 2594, + "2539-class-instance-rest.ts": 2144, + "2540-accessor-destructuring-defaults.ts": 2790, + "2541-destructuring-eval-order.ts": 2901, + "2550-generics-keyof-pick.ts": 2724, + "2551-generics-value-aliases.ts": 2899, + "2552-generics-iface-methods.ts": 2924, + "2553-generics-signature-bindings.ts": 1690, + "2554-generics-frontier-mix.ts": 2607, + "2555-generics-keyof-writes.ts": 2074, + "2556-crypto-introspection.ts": 2165, + "2556-width-hybrid-shapes.ts": 1904, + "2557-tls-ca-store.ts": 3159, + "2557-width-field-lifts.ts": 3231, + "2558-index-signature-func-values.ts": 2869, + "2558-rejection-events.cjs": 1923, + "2559-index-signature-container-values.ts": 2319, + "2560-arraybuffer-dataview-set.ts": 3376, + "2561-object-is.ts": 3499, + "2562-intl-numberformat-en-us.ts": 2371, + "2563-stream-promises-pipeline.ts": 3059, + "2564-stream-promises-finished.ts": 1663, + "2565-stream-promises-js.cjs": 2464, + "2566-promise-reject-dyn-reason.js": 2041, + "2567-rest-spread-forward.js": 3238, + "2568-rest-spread-forward-dynamic.js": 2074, + "2569-upcast-identity.ts": 2471, + "2570-buffer-arg-validation.cjs": 4288, + "2571-searchparams-arg-validation.cjs": 2294, + "2572-readable-emitted-readable-flag.cjs": 2792, + "2573-fs-url-arg-ladders.cjs": 3144, + "2574-emitter-max-listeners-ladders.cjs": 2768, + "2575-string-destructuring-decl.ts": 3093, + "2576-string-destructuring-assign.ts": 1948, + "2577-builtin-global-destructuring.js": 1471, + "2578-jsval-into-unknown-rows.ts": 2895, + "2579-jsval-object-param-crossing.js": 2920, + "2580-jsval-routed-keyed-ops.js": 2793, + "2581-jsval-routed-calls.js": 2527, + "2582-jsval-object-statics.js": 3114, + "2582-jsval-routed-keyed-ops.js": 3012, + "2583-dyn-nullish-coalesce.js": 2872, + "2583-jsval-routed-calls.js": 3060, + "2584-jsval-object-statics.js": 3017, + "2584-union-dyn-collapse.ts": 3110, + "2585-dyn-nullish-coalesce.js": 3233, + "2585-unknown-array.ts": 3147, + "2586-object-assign-spread.js": 3063, + "2587-array-entries-forof.ts": 2868, + "2588-array-entries-chains.ts": 2948, + "2589-object-create-null.cjs": 2175, + "2590-object-create-dynamic.js": 2548, + "2591-ambient-generic-traps.ts": 2668, + "2592-ambient-trap-uncaught.ts": 2071, + "2593-generic-inert-bindings.ts": 2582, + "2594-nullish-generic-bindings.ts": 2649, + "2595-fs-arg-ladders.cjs": 3450, + "2596-net-arg-ladders.cjs": 3163, + "2597-dgram-send-ladders.cjs": 3471, + "2598-tls-arg-ladders.cjs": 2644, + "2599-stream-arg-ladders.cjs": 2952, + "2600-dyn-keyed-write-harness.js": 3162, + "2601-dyn-keyed-write-ops.js": 2780, + "2602-dyn-array-destructure.js": 2123, + "2603-island-keyed-write-dyn.js": 2776, + "2604-cycle-classes-mutual/main.ts": 2653, + "2605-cycle-three-module/main.ts": 2386, + "2606-dynamic-import-cycle/main.ts": 2580, + "2608-regex-named-groups.ts": 3189, + "2609-regex-named-replace.ts": 2460, + "2610-regex-named-matchall.ts": 1815, + "2611-regex-named-groups-js.cjs": 3151, + "2613-for-init-uninitialized-let.ts": 2759, + "2614-trap-binding-later-writes.ts": 1833, + "2615-nullish-field-record-binding.ts": 2522, + "2616-js-collect-probe-defers.js": 2932, + "2617-enum-static-field-import/main.ts": 2674, + "2618-ee-emit-override.ts": 2416, + "2619-ee-override-chain.ts": 2759, + "2620-ee-override-once-order.ts": 2863, + "2621-ee-override-error-throw.ts": 2669, + "2622-ee-override-filter.ts": 2972, + "2623-ee-job-queue.ts": 2457, + "2624-ee-override-js.cjs": 2851, + "2625-bytes-views.ts": 1866, + "2626-stream-event-names.ts": 3082, + "2627-stream-ticks-are-nextticks.ts": 2115, + "2628-stream-push-encodings.cjs": 2780, + "2629-stream-consumers.ts": 3333, + "2630-stream-consumers-errors.ts": 2597, + "2631-create-require/main.ts": 3215, + "2632-dyn-jsval-iterate.js": 3094, + "2633-island-promise-crossing.js": 2715, + "2634-stream-pipeline-arg-ladders.cjs": 2970, + "2635-trap-binding-unmappable-written.ts": 2644, + "2636-trap-binding-ambient-rooted-rewrite.ts": 2711, + "2637-create-require-bare/main.ts": 2926, + "2638-http-dyn-res-compat.cjs": 3551, + "2639-http-dyn-req-pause.cjs": 2114, + "2640-net-dyn-socket-compat.cjs": 3221, + "2641-http-agent-surface.cjs": 3393, + "2642-http-agent-maxsockets.cjs": 2445, + "2643-or-default-retag.ts": 2951, + "2644-http-client-url-argument.ts": 3003, + "2645-https-client-url-argument.ts": 1965, + "2646-top-level-await.ts": 1994, + "2647-top-level-await-modules/main.ts": 2883, + "2648-top-level-await-rejection.ts": 2548, + "2649-top-level-await-pending.ts": 2420, + "2650-top-level-await-self-import.ts": 2738, + "2651-top-level-await-pending-unhandled.ts": 1959, + "2652-top-level-await-dynamic/main.ts": 1976, + "2653-top-level-await-rejection-stops-loop.ts": 2530, + "2654-top-level-await-unrelated-rejection.ts": 2557, + "2655-top-level-await-cycle/main.ts": 2575, + "2656-top-level-await-cycle-order/main.ts": 2788, + "2657-top-level-await-cycle-dynamic/main.ts": 1945, + "2658-top-level-await-sync-completion/main.ts": 2486, + "2659-top-level-await-dynamic-cycle/main.ts": 2311, + "2660-top-level-await-cycle-rejection/main.ts": 1648, + "2661-top-level-await-dynamic-runtime-root/main.ts": 2615, + "2662-top-level-await-cycle-external-wait/main.ts": 2307, + "2663-top-level-await-dependency-errors/main.ts": 2145, + "2664-top-level-await-same-checkpoint-rejection.ts": 2652, + "2665-top-level-await-unhandled-listener-liveness.ts": 3003, + "2666-array-to-sorted.ts": 5347, + "2668-stored-number-array-iterator.ts": 2840, + "2669-array-copying-methods.ts": 2792, + "2670-uint8array-copy-iterate.ts": 2664, + "2671-array-copying-js.cjs": 2591, + "2672-http-request-response-callback.ts": 2953, + "2673-top-level-await-implicit-module.ts": 1743, + "2674-top-level-for-await-implicit-module.ts": 2697, + "2675-create-require-nested-esm.js": 2199, + "2675-process-self-reexec.ts": 2588, + "2676-indexed-read-strict-equality.ts": 2188, + "2676-record-clone-overrides.ts": 2426, + "2676-top-level-await-ambiguous/main.ts": 2482, + "2677-runtime-optional-closure.ts": 3477, + "2677-top-level-await-module-scope/main.ts": 2623, + "2678-date-instances.ts": 3208, + "2678-large-string-sparse-index.ts": 2981, + "2678-util-parseargs.ts": 5281, + "2679-util-parseargs-cjs.cjs": 3377, + "2680-util-parseargs-default.ts": 2722, + "2681-util-parseargs-dynamic.js": 1944, + "2682-fs-rename.ts": 3375, + "2683-filter-truthy-predicate.ts": 2838, + "2683-fs-rename-js.cjs": 1913, + "2684-filter-no-predicate-dyn.cjs": 2576, + "2684-fs-rename-abort.ts": 2742, + "2685-array-unshift-reverse.ts": 2654, + "2685-fs-write-sync.ts": 2517, + "2686-fs-file-handle.ts": 3648, + "2687-fsp-write-file-options.ts": 2384, + "2687-process-write-args.ts": 2846, + "2688-fs-stats-disk-fields.ts": 2938, + "2689-http-server-timeout-properties.ts": 3060, + "2690-https-server-timeout-option.ts": 2700, + "2691-retained-lowering-record-order.ts": 4234, + "2692-inline-record-assert-index.ts": 2826, + "2692-string-accumulation.ts": 2691, + "2693-math-constants.ts": 2761, + "2700-array-sort-complexity.ts": 2705, + "2700-http-static-trailers.ts": 2446, + "2700-wasi-core.ts": 2208, + "2701-array-sort-snapshot.ts": 2717, + "2701-http-static-trailer-wire.ts": 2689, + "2701-import-meta/main.mjs": 2846, + "2702-http-static-trailer-end.ts": 2522, + "2702-type-import-link-static/main.ts": 1984, + "2702-uint8array-to-sorted.ts": 2225, + "2703-array-sparse-sort.ts": 5044, + "2703-type-import-link-static-reexport/main.ts": 2359, + "2704-array-sparse-to-sorted.ts": 4461, + "2704-type-import-link-static-success/main.ts": 2324, + "2705-array-sparse-sort-append.ts": 5020, + "2705-type-import-link-dynamic/main.ts": 2074, + "2706-array-search-missing-needle.ts": 1941, + "2706-type-import-link-dynamic-success/main.ts": 2411, + "2707-array-search-huge-sparse.ts": 45551, + "2707-type-import-link-static-default-reexport/main.ts": 2522, + "2708-type-import-link-dynamic/main.ts": 2609, + "2720-array-read-parity.ts": 1979, + "2721-array-nested-missing-receiver.ts": 2483, + "2750-array-sparse-foundation.ts": 2217, + "2751-buffer-concat-sparse-list.ts": 2792, + "2752-array-optional-stores.ts": 2339, + "2753-array-optional-method-values.ts": 2060, + "2754-array-property-undefined.ts": 2275, + "2755-array-optional-literal-forwarding.ts": 2382, + "2780-array-parity-composition.ts": 6446, + "2781-array-missing-value-escape.ts": 1639, + "2782-array-sparse-callbacks.ts": 3365, + "2783-array-defaults-rest.ts": 2775, + "2784-array-reduce-missing-result.ts": 2916, + "2785-array-missing-destructuring.ts": 2952, + "2786-array-sparse-serialization.ts": 3296, + "2787-array-missing-string-arithmetic.ts": 2457, + "2788-array-missing-builtin-conversions.ts": 2610, + "2789-array-missing-optional-tostring.ts": 2734, + "2790-dynamic-import-self-name/main.ts": 2631, + "2791-record-optional-keys.ts": 1771, + "2792-record-optional-spread-entries.ts": 2836, + "2793-union-conversion-identity-capture.ts": 1991, + "2794-array-generic-callback-values.ts": 2454, + "2795-array-optional-typedarray-source.ts": 2778, + "2796-array-sparse-class-value-instanceof.ts": 1902, + "2800-array-expression-consumers.ts": 2537, + "2801-array-switch-consumers.ts": 2609, + "2820-array-missing-method-receivers.ts": 1866, + "2821-array-optional-numeric-comparisons.ts": 2322, + "2830-cjs-require-self-name/main.cjs": 1845, + "2840-finally-completions.ts": 2496, + "2841-using-sync.ts": 2927, + "2842-await-using.ts": 2618, + "2843-using-suppressed-error.ts": 2318, + "2844-node-disposable-resources.ts": 2824, + "2845-for-using-of.ts": 2486, + "2846-generator-using.ts": 2761, + "2850-async-generators-protocol.ts": 3258, + "2851-async-generators-values.ts": 2768, + "2852-timers-promises-interval.ts": 2398, + "2854-leading-bom-literals.ts": 1935, + "2855-searchparams-sort-complexity.ts": 2792, + "2856-dynamic-any-local-operators.ts": 2781, + "2857-branded-primitives.ts": 2351, + "2858-import-meta-resolve/main.mjs": 1967, + "2859-import-meta-resolve-dynamic/main.mjs": 1446, + "2860-require-resolve/main.cjs": 2029, + "2861-readable-iterator-close.ts": 3028, + "2862-web-readable-async-iteration.ts": 3505, + "2863-class-async-iterator.ts": 2866, + "2864-array-class-method-receivers.ts": 2760, + "2865-cjs-process-alias.cjs": 2491, + "2866-dyn-switch.ts": 1865, + "2867-array-shift-length.js": 1558, + "2868-empty-record-promise-presence.js": 2022, + "2869-nullish-mixed-lazy.ts": 2676, + "2870-and-dropped-truthy-arm.ts": 2329, + "2871-optional-promise-to-unknown.ts": 2191, + "2872-unobserved-dynamic-event.ts": 2513, + "2873-optional-receiver-loop-lifetime.js": 1923, + "2874-nullable-callback-field-cycle.js": 2614, + "2875-evolving-let-read-before-write.js": 2456, + "2876-class-unknown-roundtrip.ts": 2982, + "2877-child-unknown-roundtrip.ts": 2124, + "2878-class-private-unknown.cjs": 2900, + "2880-cjs-module-graph/main.cjs": 2229, + "2890-crypto-static-utility.ts": 3535, + "2891-json-record-key-escapes.ts": 3128, + "2892-windows-console-unicode.ts": 2483, + "2893-child-stdin-duplex.ts": 3150, + "2894-child-stdin-backpressure.ts": 2319, + "2895-child-stdin-write-after-end.ts": 3184, + "2896-child-stdin-write-after-finish.ts": 2909, + "2897-child-stdin-destroy.ts": 3007, + "2898-child-stdin-spawn-failure.ts": 2417, + "2899-nested-mutual-recursion.ts": 2782, + "2900-float64array-static.ts": 2797, + "2900-void-conditional-arrow.ts": 2455, + "2901-bigint-core.ts": 2012, + "2902-bigint-bytes.ts": 2175, + "2903-bigint-storage.ts": 2677, + "2904-bigint-errors.ts": 2992, + "2905-bigint-edges.ts": 2250, + "2906-bigint-wasi-width.ts": 2455, + "2910-overloaded-callable-alias.ts": 2480, + "2911-execfile-callback.ts": 2820, + "2912-execfile-callback-options.ts": 2673, + "2912-promisify-fs-readfile.ts": 1599, + "2913-builtin-callable-alias.ts": 2823, + "2914-fixed-tuple-call-spread.ts": 2909, + "2915-path-function-values.ts": 2957, + "2916-path-function-values-cjs.ts": 2512, + "2917-builtin-callable-widths.ts": 3024, + "2918-builtin-callable-widths-cjs.ts": 2656, + "2919-fs-function-values.ts": 3021, + "2920-fs-promises-function-values.ts": 2741, + "2921-zlib-callbacks.ts": 3153, + "2922-dyn-bitwise-not.cjs": 2708, + "2923-cjs-factory-export/main.cjs": 2093, + "2930-union-receiver-calls.ts": 2543, + "2931-union-dynamic-field-call.js": 2484, + "2932-create-require-program/main.ts": 2505, + "2933-static-dynamic-import/main.ts": 2593, + "2934-static-import-stored.ts": 2045, + "2935-module-namespace-values/main.ts": 2788, + "2936-static-loose-equality.ts": 3392, + "2937-bitwise-hot-loop.ts": 2487, + "2938-fs-sync-overloads.cjs": 1878, + "2939-child-shell-text.ts": 3433, + "2940-date-parse.ts": 2705, + "2940-fsp-realpath.ts": 2908, + "2941-fsp-lstat-identity.ts": 3091, + "2941-process-exit-code.ts": 2544, + "2942-fsp-readdir-dirent.ts": 3069, + "2942-process-exit-code-override.ts": 2534, + "2943-process-exit-code-invalid.ts": 2277, + "2944-process-exit-code-wrap.ts": 1815, + "2945-url-origin-username.ts": 2639, + "2946-child-fork-ipc/main.ts": 3716, + "2946-url-port-hash.ts": 1906, + "2947-set-readonly-seeds.ts": 2763, + "2948-child-fork-eof-callback/main.ts": 2163, + "2948-stdio-callback-record.ts": 2566, + "2949-child-fork-default/main.mjs": 3027, + "2949-url-password.ts": 1993, + "2950-fs-descriptor-publication.ts": 2687, + "2951-math-static-analytic.ts": 3185, + "2952-math-static-remaining.ts": 2865, + "2953-http-header-validation.ts": 2969, + "2954-http-outgoing-headers.ts": 3565, + "2955-http-static-state.ts": 2954, + "2956-http-static-informational.ts": 2194, + "2957-http-static-response-controls.ts": 3186, + "2961-emitter-computed-names.cjs": 1565, + "2962-emitter-computed-optional.ts": 2714, + "2963-child-fork-dispatch/main.ts": 3146, + "2964-indexed-compound.ts": 3331, + "2966-numeric-array-read-fusion.ts": 3033, + "2967-numeric-array-read-lifetime.ts": 2835, + "2968-numeric-array-borrow.ts": 2871, + "2969-scalar-record-results.ts": 2889, + "2970-constant-numeric-tables.ts": 3083, + "2971-constant-table-modules/main.ts": 2199, + "2972-http-static-distinct-snapshots.ts": 3234, + "2972-math-receiver-borrow.ts": 3625, + "2973-http-static-agent.ts": 2730, + "2973-integer-bitwise-arithmetic.ts": 2687, + "2974-array-search-from-index.ts": 104135, + "2974-http-static-module-values.ts": 2450, + "2974-numeric-remainder.ts": 3031, + "2975-bigint-default-radix.ts": 2379, + "2975-http-static-client-controls.ts": 2663, + "2976-http-static-incoming-state.ts": 2293, + "2976-json-stringify-no-arguments.js": 2688, + "2977-http-static-incoming-timeout.ts": 2143, + "2977-nested-array-binding-defaults.js": 2455, + "2978-http-static-client-timeout.ts": 2987, + "2978-regexp-optional-subject.js": 2083, + "2979-array-search-mixed-needles.js": 2924, + "2979-http-static-server-timeout.ts": 2502, + "2980-http-static-server-timeout-default.ts": 2655, + "2980-string-position-arguments.js": 2015, + "2981-http-static-events.ts": 2563, + "2981-string-optional-positions.ts": 2841, + "2982-http-static-close-all.ts": 1931, + "2982-string-position-coercion-order.js": 2986, + "2983-http-static-close-idle.ts": 2485, + "2984-http-static-close-upgrade.ts": 2815, + "2985-http-static-message-destroy.ts": 2511, + "2986-http-static-client-socket-finish.ts": 2889, + "2987-http-static-timeout-errors.ts": 2695, + "2988-http-static-client-abort.ts": 2770, + "2989-http-static-response-timeout-handled.ts": 2973, + "2990-http-static-request-timeout-handled.ts": 3045, + "2991-array-indexed-equality.ts": 3039, + "2992-stream-rows.ts": 1990, + "2993-fiber-stack-lifetimes.ts": 3353, + "2994-fromcharcode-scalar.ts": 2251, + "2995-math-hyperbolic.ts": 3028, + "2996-math-near-one.ts": 2750, + "2997-math-integer-float.ts": 2792, + "300-if-else.ts": 2615, + "3001-caught-typeof-object.js": 2565, + "3002-promise-then-two.ts": 3076, + "301-while.ts": 2690, + "302-for.ts": 2617, + "3020-string-last-index-position.ts": 2669, + "3021-buffer-union-narrow-callback.ts": 3133, + "3022-string-affix-positions.ts": 2471, + "3023-string-affix-position-coercion.js": 2793, + "3024-string-number-narrow-for-in.ts": 2773, + "3025-string-search-position-coercion.js": 2152, + "3026-array-last-index-of.js": 2967, + "3027-array-last-index-of-records.ts": 1994, + "3028-string-search-dynamic-needle.js": 2238, + "3029-string-search-union-needle.js": 2519, + "303-break-continue.ts": 2536, + "3030-array-search-no-arg.js": 2653, + "3031-array-relative-index-coercion.js": 3093, + "3031-string-last-index-search-value.js": 1619, + "3032-string-search-value.js": 2450, + "3033-string-search-needle-coercion.js": 2494, + "3034-arguments-with-parameters.js": 3025, + "3035-string-positioned-search-value.js": 3075, + "3036-string-object-search-value.js": 2233, + "3037-number-nullish-conversion.js": 2181, + "3038-number-scalar-unions.ts": 2410, + "3039-string-repeat-count.js": 2478, + "304-compound-incdec.ts": 2719, + "3040-string-prototype-call.js": 3243, + "3041-string-prototype-object-call.js": 2455, + "3042-string-padding-coercion.js": 3099, + "3043-string-split-arguments.js": 2355, + "3044-array-slice-splice-positions.js": 2214, + "3045-array-indexed-mutation.js": 3434, + "3046-array-indexed-ref-identity.ts": 2361, + "3047-object-prototype-tag.js": 3196, + "3048-object-own-prototype.ts": 3472, + "3049-array-flat-depth.ts": 1949, + "305-truthiness.ts": 2568, + "3050-array-splice-insert.ts": 3099, + "3051-array-join-default.ts": 1846, + "3052-array-construction.ts": 3399, + "3053-array-construction-js.js": 1676, + "3054-dynamic-abort-record.ts": 1731, + "3055-default-builtin-nodenext/main.ts": 2687, + "3056-default-builtin-bundler/main.ts": 2789, + "3057-default-builtin-nodenext-dynamic/main.ts": 2579, + "3058-optional-array-chain-join.ts": 2967, + "3059-arguments-property-names.ts": 2947, + "3061-concurrent-fiber-stacks.ts": 2717, + "3062-runtime-optional-record-guards.ts": 3531, + "3063-runtime-optional-class-guards.ts": 3234, + "3064-installed-entry-imports/main.ts": 2104, + "3065-installed-entry-js/main.js": 2454, + "3066-source-debugging/main.ts": 2680, + "3067-cjs-function-export-require/main.cjs": 2781, + "3068-debug-variables/main.ts": 2201, + "3068-url-checked-identity.ts": 3005, + "3069-set-checked-seed.js": 3167, + "3069-tuple-spread.ts": 3057, + "3070-checked-object-accessors.js": 3314, + "3070-collection-views.ts": 2586, + "3071-checked-specialization-narrowing.js": 2429, + "3071-map-contextual-record-seeds.ts": 2886, + "3072-optional-union-receivers.ts": 3001, + "3072-weak-process-streams.js": 2971, + "3073-optional-callable-module.js": 2030, + "3073-union-keyed-reads.ts": 3228, + "3074-discriminated-intersections.ts": 3008, + "3075-recursive-contextual-literals.ts": 3333, + "3076-nullish-record-defaults.ts": 3030, + "3077-optional-union-array-reads.ts": 2968, + "3078-forward-mutable-captures.ts": 1926, + "3079-forward-mutable-tdz.ts": 2889, + "3080-exhaustive-never-bindings.ts": 2787, + "3081-recursive-array-destinations.ts": 2576, + "3082-forward-write-unwind.ts": 2875, + "3083-set-string-seed.ts": 2684, + "3084-record-own-membership.ts": 3102, + "3085-conditional-record-construction.ts": 1925, + "3086-error-constructor-options.ts": 3227, + "3087-error-options-lifetime.ts": 2113, + "3088-array-wide-callbacks.ts": 2993, + "3089-array-find-narrowing.ts": 3128, + "3090-json-discriminated-records.ts": 3480, + "3091-json-recursive-discriminants.ts": 2300, + "3092-number-union-predicates.ts": 2639, + "3093-error-option-data.ts": 2191, + "3094-json-replacer-traversal.ts": 2898, + "3095-json-reviver-traversal.ts": 2824, + "3096-json-callback-nonfinite.ts": 1927, + "3097-json-callback-reentrancy.ts": 3321, + "3098-json-callback-space.ts": 2551, + "3099-json-callback-functions.ts": 3507, + "3100-json-callback-holder.js": 3048, + "3101-json-callback-bytes.ts": 2658, + "3102-json-unknown-fields.ts": 2725, + "3103-scalar-record-nested-control-flow.ts": 3195, + "3104-native-analysis-tables-loops.ts": 1557, + "3105-nullable-collections.ts": 1888, + "3106-mixed-insertion-spreads.ts": 3368, + "3107-nullable-collection-lifetimes.ts": 3149, + "3108-for-await-sync-arrays.js": 4447, + "3108-identity-map-keys.ts": 3401, + "3109-destructuring-unknown-defaults.js": 2735, + "3109-identity-union-collections.ts": 3270, + "3110-builtin-error-families.ts": 2441, + "3110-identity-collection-mutation.ts": 2906, + "3111-identity-collection-cycles.ts": 3069, + "3112-union-switch-control-flow.ts": 2641, + "3113-union-array-removal.ts": 3416, + "3114-union-record-field-write.ts": 3033, + "3115-zlib-static-compression-levels.ts": 2443, + "3116-sequence-expression-lifetimes.ts": 3044, + "3117-unknown-switch-control-flow.ts": 2684, + "3118-recursive-union-spread.ts": 2422, + "3119-runtime-optional-spread.ts": 2447, + "3120-dynamic-property-descriptors.js": 3293, + "3120-generator-method-loop-bindings.ts": 3248, + "3120-ir-nonfinite-numbers.ts": 3000, + "3121-compound-assignment-values.js": 2549, + "3121-dynamic-accessor-descriptors.js": 3250, + "3122-dynamic-delete-descriptors.cjs": 2600, + "3122-dynamic-delete-descriptors.js": 2091, + "3122-js-async-class-methods.js": 2297, + "3123-destructured-global-tdz.js": 2836, + "3124-array-prototype-borrow.js": 3537, + "3125-regex-global-match.ts": 2402, + "3126-js-number-radix/main.ts": 3052, + "3127-spawn-runtime-options.ts": 3285, + "3128-regex-last-index.ts": 3076, + "3129-js-token-union/main.ts": 2700, + "3130-child-generic-streams.ts": 3044, + "3131-child-rest-listeners.js": 2943, + "3132-child-generic-stream-completion.ts": 6235, + "3133-text-decoder-streaming.ts": 2265, + "3134-fs-vectors.ts": 2815, + "3135-fs-file-handle-controls.ts": 2278, + "3136-fs-file-handle-options.ts": 3814, + "3137-fs-vector-callbacks.cjs": 3509, + "3138-array-large-storage.ts": 4245, + "3139-regex-native-deep-alternatives.ts": 27587, + "3140-array-dense-access.ts": 3800, + "3141-map-string-key-hash.ts": 2566, + "3150-integer-remainder.ts": 3289, + "3151-array-push-writes.ts": 3227, + "3170-number-conversion-fast-paths.ts": 2553, + "3171-method-census-data-writes.ts": 3442, + "400-fib.ts": 2589, + "401-mutual-recursion.ts": 2527, + "402-string-functions.ts": 2176, + "403-void-and-params.ts": 2350, + "4030-runtime-object-truthiness.ts": 2749, + "4031-event-emitter-long-tuples.ts": 2083, + "4032-inline-rc-fast-paths.ts": 4192, + "404-rc-stress.ts": 2456, + "4040-adapted-function-identity.ts": 2867, + "4041-adapted-function-properties.ts": 2991, + "4042-object-is-union-subclass.ts": 2310, + "4043-nonnull-missing-element.ts": 2433, + "4044-adapted-callback-modules/main.ts": 2886, + "4045-optional-element-projections.ts": 3138, + "4046-captured-parameter-values.ts": 3423, + "4047-captured-parameter-rebinding.ts": 2500, + "405-params-optional.ts": 2755, + "406-params-defaults.ts": 2105, + "4060-cycle-shared-instance/main.ts": 2837, + "4060-stack-union-reads.ts": 3299, + "4061-cycle-evaluation-order/main.ts": 2712, + "4061-nullable-ref-fields.ts": 4653, + "4062-cycle-tdz-read/main.ts": 1857, + "4063-cycle-hoisted-calls/main.ts": 2616, + "4064-cycle-classes-after-init/main.ts": 2926, + "4065-cycle-init-throws/main.ts": 2592, + "4066-cycle-top-level-tdz/main.ts": 1456, + "4067-dynamic-import-cycle-tdz/main.ts": 2785, + "407-params-rest.ts": 2693, + "408-params-ctors-inheritance.ts": 2837, + "4080-optional-read-presence-tests.ts": 2357, + "4080-string-index-bounds.ts": 2174, + "4081-hoisted-function-tdz.ts": 3131, + "4081-string-index-unproven.ts": 2850, + "4082-hoisted-function-tdz-uncaught.ts": 2634, + "4083-dynamic-import-failure/main.ts": 2355, + "4084-record-optional-field-copies.ts": 2952, + "4085-generator-loop-close.ts": 3078, + "4086-optional-capture-defaults.ts": 2684, + "4088-class-static-tdz.ts": 2183, + "4089-class-wrapper-tdz.js": 2911, + "409-params-async-generics.ts": 1894, + "4090-computed-key-tdz.js": 2483, + "4091-class-evaluation-deferred.ts": 3134, + "410-params-rc-stress.ts": 1591, + "4140-array-callback-split-visit.ts": 4467, + "4141-array-callback-ambient-receiver/main.ts": 2178, + "4142-array-callback-factories.ts": 3521, + "4143-union-refinement-intersection-arms.ts": 3254, + "420-dead-strip-modules/main.ts": 2523, + "4290-acyclic-immutable-trees.ts": 3062, + "4291-acyclic-constructor-escapes.ts": 2390, + "4292-acyclic-readonly-bypass.ts": 1956, + "4293-acyclic-dynamic-writes.ts": 3149, + "4294-console-line-sizes.ts": 5491, + "4295-console-template-parts.ts": 3025, + "4296-console-glued-long-parts.ts": 4102, + "4410-inline-object-allocation.ts": 3371, + "4411-nullable-ref-values.ts": 3446, + "4412-nullable-record-values.ts": 3505, + "4413-cycle-old-late-death.ts": 3210, + "4413-nullable-null-and-undefined.ts": 3960, + "4414-cycle-old-weak-keys.ts": 2210, + "4414-nullable-string-values.ts": 3960, + "4415-identity-borrowed-operands.ts": 2923, + "4415-nullable-container-values.ts": 4078, + "4431-exception-pending-contexts.ts": 3547, + "4432-checked-downcast-failures.ts": 3362, + "4451-int32-field-storage.ts": 3587, + "4452-int32-field-dynamic-writes.ts": 2629, + "4453-int32-closed-locals.ts": 2708, + "4454-int32-field-reflection-reads.ts": 3626, + "4455-live-view-reads-without-stores.ts": 3673, + "4471-unassigned-field-reads.ts": 3063, + "4476-string-ascii-header-fact.ts": 3053, + "4477-buffer-write-ascii-runs.ts": 1845, + "4478-string-large-index-reads.ts": 2385, + "4481-array-optional-push.ts": 2921, + "4482-instanceof-static-class-optional.ts": 2110, + "4483-array-splice-statement.ts": 3260, + "4484-array-length-reset.ts": 2963, + "4485-array-splice-optional-item.ts": 3033, + "4486-array-field-element-borrows.ts": 2099, + "4487-array-literal-optional-values.ts": 2387, + "4520-optional-guard-narrowing.ts": 3290, + "4521-array-callback-element-presence.ts": 4205, + "4522-captured-parameter-lifetimes.ts": 3072, + "4523-array-pop-removal.ts": 2939, + "4524-array-callback-supertype-params.ts": 4250, + "4541-nullable-wrap-borrows.ts": 2850, + "4542-preserving-call-borrows.ts": 3298, + "4543-walk-borrowed-locals.ts": 3324, + "4544-checked-cast-aliases.ts": 2878, + "4545-borrowed-returns.ts": 3935, + "4546-rebound-borrowed-params.ts": 2128, + "4560-field-store-borrowed-receivers.ts": 3268, + "4561-virtual-borrowed-parameters.ts": 2119, + "4562-string-self-concat-move.ts": 2875, + "4563-array-read-projection-receivers.ts": 2961, + "4564-literal-choice-strings.ts": 3091, + "4568-for-of-hole-elements.ts": 3194, + "4569-shorthand-missing-elements.ts": 2799, + "4570-map-lookup-default-record.ts": 2885, + "4591-weak-keys-union-records.ts": 3283, + "4592-cycle-const-from-import/main.ts": 2283, + "4593-weak-keys-empty-objects.ts": 1759, + "4594-union-class-field-mixed-types.ts": 3165, + "4595-union-class-field-optional-receiver.ts": 2742, + "4596-error-subclass-int-fields.ts": 2574, + "4596-tdz-nullable-forward-capture.ts": 3762, + "4597-callback-field-method-name.ts": 3397, + "4598-live-array-ref-element-access.ts": 4852, + "4598-map-set-clear-reuse.ts": 4729, + "4598-os-available-parallelism.ts": 2510, + "4598-publish-constructor-stores.ts": 1852, + "4599-construction-only-field-borrows.ts": 3236, + "4600-construction-only-fields-dynamic-writes.ts": 3072, + "4601-cycle-holders.ts": 2734, + "4602-constructor-escape-order.ts": 2610, + "4610-array-ext-dyn-refresh.ts": 2862, + "4620-optional-chain-borrowed-receivers.ts": 3224, + "4621-edge-preserving-callees/main.ts": 3365, + "4630-contract-int32.ts": 2754, + "4630-reference-write-call-arguments.ts": 3053, + "4631-contract-nothrow.ts": 2070, + "4631-reference-write-aliases.ts": 2695, + "4632-contract-immutable.ts": 2863, + "4632-reference-write-loops-and-walks.ts": 3098, + "4633-contract-program-lifetime.ts": 3689, + "4633-reference-write-callbacks-returns.ts": 3144, + "4634-contract-program-lifetime-publish.ts": 4904, + "4634-optional-element-borrowed-returns.ts": 2709, + "4640-bitwise-identity-ranges.ts": 2778, + "4641-nothrow-try-catch.ts": 2708, + "4642-acyclic-contract.ts": 3288, + "4650-stale-property-narrowing.ts": 3851, + "4651-map-string-get-entry.ts": 3371, + "4652-stale-closure-binding-narrowing.ts": 3495, + "4660-typed-rest-spread-forwarding.ts": 2766, + "4671-scoped-array-read-borrows.ts": 3085, + "4690-cycle-bypass-long-lived.ts": 2735, + "4691-publish-constructor-self-alias.ts": 3219, + "4692-borrowed-result-mutating-callees.ts": 2601, + "4720-cold-throw-paths.ts": 3390, + "4721-integer-induction-numbers.ts": 2467, + "4730-touint32-large-magnitudes.ts": 3097, + "4731-string-mixed-ascii-slices.ts": 2704, + "4732-buffer-write-utf16le-runs.ts": 1998, + "4733-typed-array-read-compares.ts": 3234, + "4750-map-string-absent-filter.ts": 3594, + "4751-string-search-multibyte-needles.ts": 2725, + "4795-published-untyped-member-reads.ts": 3268, + "4806-uint32-loop-accumulators.ts": 3231, + "4810-union-identity-retags.ts": 4620, + "4811-union-retag-checked-cast.ts": 3091, + "4812-int32-wrapping-sums.ts": 3463, + "4813-typed-array-read-equality-bindings.ts": 4674, + "4820-sort-comparator-lent-arguments.ts": 4000, + "4821-callback-lent-arguments.ts": 2333, + "4822-stable-capture-reads.ts": 2409, + "4823-array-store-receivers.ts": 2969, + "4830-typed-teardown-chains.ts": 2905, + "4831-cycle-bypass-probe-windows.ts": 2840, + "4840-array-hole-free-prefix.ts": 2459, + "4860-int32-local-storage.ts": 4170, + "4870-array-pipeline-fusion.ts": 7346, + "4871-array-pipeline-analytics.ts": 4533, + "4872-array-pipeline-temporaries.ts": 7994, + "4875-stream-consumers-array-buffer.ts": 3281, + "4876-array-buffer-inspect.ts": 2814, + "4880-await-call-turn-order.ts": 1921, + "4881-await-call-exceptions.ts": 3225, + "4882-await-call-request-chain.ts": 3022, + "4883-await-values-and-hops.ts": 2825, + "4884-await-call-unhandled-sibling.ts": 2163, + "4885-await-call-checkpoints.ts": 2954, + "4890-regex-literal-sites.ts": 3163, + "4891-regex-plain-text-patterns.ts": 2001, + "4892-regex-exec-read-captures.ts": 3652, + "4900-bigint-division-cross-check.ts": 3357, + "4900-console-instances.ts": 3637, + "4901-bigint-radix-text.ts": 2779, + "4901-console-instance-errors.ts": 3196, + "4902-bigint-compound-assign.ts": 1706, + "4903-bigint-fixed-width.ts": 3128, + "4904-bigint-large-products.ts": 3340, + "4905-bigint-fixed-width-fusion.ts": 3031, + "4906-bigint-small-value-trees.ts": 3759, + "4907-bigint-random-trees.ts": 5188, + "4910-hole-free-prefix-upkeep.ts": 3084, + "4920-string-literal-switch.ts": 3310, + "4930-typed-record-reflection.ts": 4737, + "4931-typed-data-generic-walks.ts": 4118, + "4932-typed-json-unknown.ts": 3475, + "4940-async-return-adoption.ts": 3491, + "4941-async-return-adoption-try.ts": 3096, + "4942-async-return-adoption-values.ts": 2964, + "4943-async-return-adoption-interleaved.ts": 2876, + "4950-regex-compiled-captures.ts": 4852, + "4951-regex-compiled-last-index.ts": 2706, + "4952-regex-compiled-anchors-classes.ts": 2724, + "4953-regex-compiled-backtracking.ts": 4297, + "4954-regex-log-report.ts": 3687, + "4955-regex-compiled-differential.ts": 13757, + "4970-int32-call-abi.ts": 3580, + "4980-generator-early-exit-finally.ts": 3050, + "4981-generator-delegation-iterables.ts": 4127, + "4982-generator-sent-values.ts": 2957, + "4983-generator-reuse-iterables.ts": 3475, + "4984-generator-exceptions.ts": 3390, + "4985-generator-lazy-pipeline.ts": 3419, + "4986-generator-default-channels.ts": 3152, + "4987-generator-closures-methods.ts": 3151, + "4988-generator-async-interplay.ts": 2316, + "4989-generator-step-drives.ts": 3427, + "4990-lone-surrogates.ts": 3491, + "4991-lone-surrogate-halves.ts": 3293, + "4992-lone-surrogate-search.ts": 2456, + "4993-lone-surrogate-json.ts": 3728, + "4994-lone-surrogate-uri.ts": 1777, + "4995-lone-surrogate-regex.ts": 2799, + "4996-lone-surrogate-stdio.ts": 3100, + "4997-lone-surrogate-stdout-patch.js": 1716, + "4998-lone-surrogate-buffers.ts": 3414, + "4999-lone-surrogate-io.ts": 2886, + "500-array-basics.ts": 2955, + "501-array-push-pop.ts": 1902, + "5010-lifetime-region-generations.ts": 3477, + "5011-lifetime-region-outside-references.ts": 2843, + "5012-lifetime-region-shapes.ts": 4150, + "5013-lifetime-region-async.ts": 3814, + "5014-lifetime-region-nesting.ts": 2997, + "5015-lifetime-region-publish.ts": 2741, + "5016-lifetime-region-weak-keys.ts": 3235, + "5017-lifetime-region-cycles.ts": 3057, + "5018-lifetime-region-hierarchies.ts": 4043, + "5019-lifetime-region-values.ts": 2895, + "502-array-for-of.ts": 2808, + "5020-lifetime-region-large.ts": 3808, + "5021-lifetime-region-opaque-holders.ts": 3422, + "5022-lifetime-region-workers.ts": 2531, + "503-array-functions.ts": 2837, + "504-array-rc-stress.ts": 2722, + "5040-promise-all-race-turns.ts": 3860, + "5041-promise-all-turns.js": 3644, + "5042-async-generator-return-promise.ts": 3304, + "5043-async-generator-return-forms.ts": 3190, + "5045-generator-delegation-typed-next.ts": 3751, + "5046-generator-delegation-return-throw.ts": 2749, + "5047-generator-delegation-iterables-typed.ts": 4798, + "5048-generator-delegation-async.ts": 3315, + "5049-generator-delegation-edges.ts": 3539, + "5050-inherited-in-membership.ts": 3427, + "5051-typed-record-prototypes.ts": 2418, + "5052-class-for-in-unknown.ts": 3692, + "5053-json-replacer-arrays.ts": 3781, + "5054-required-field-delete.ts": 2108, + "5055-object-create-record-literal.ts": 2773, + "5056-generator-in-unknown.ts": 2634, + "5060-child-fork-exit-after-messages/main.ts": 2129, + "5061-child-fork-local-disconnect/main.ts": 3136, + "5062-child-fork-message-before-eof/main.ts": 3024, + "5065-global-increment-initializers.ts": 2900, + "5066-global-compound-updates.ts": 3224, + "5067-global-updates-in-functions.ts": 2208, + "5068-global-var-let-const-updates.ts": 2542, + "5069-global-update-modules/main.ts": 1962, + "5070-optional-read-bindings.ts": 2623, + "5071-optional-chain-scalars.ts": 2743, + "5072-optional-nullish-ternary.ts": 2840, + "5073-optional-results.ts": 3242, + "5074-optional-pop-shift.ts": 2144, + "5075-optional-reads-unchecked/main.ts": 3167, + "5076-optional-escapes.ts": 2155, + "5080-boolean-array-storage.ts": 4783, + "5081-boolean-array-dynamic-views.ts": 2550, + "5085-promise-allsettled-turns.ts": 4142, + "5086-promise-any-turns.ts": 3722, + "5087-promise-allsettled-any-dyn.js": 5509, + "5088-promise-combinator-thenables.js": 4706, + "5089-promise-settled-records.ts": 3855, + "5090-generator-finished-result-value.ts": 2787, + "5091-generator-delegation-arrays-strings.ts": 4059, + "5092-generator-delegation-sets-maps.ts": 3822, + "5095-console-count-group.ts": 3219, + "5096-console-assert-dir.ts": 3665, + "5097-console-table.ts": 2407, + "5098-console-time-warnings.ts": 5609, + "5099-console-methods-dynamic.cjs": 3155, + "510-array-map-filter-foreach.ts": 2313, + "511-array-indexof-includes.ts": 2884, + "5110-var-hoisting-early-reads.ts": 2759, + "5111-var-hoisting-closures-classes.ts": 2869, + "5112-var-hoisting-function-scope.ts": 2697, + "5113-tdz-let-const-class.ts": 2402, + "5114-var-hoisting-js.js": 2192, + "5115-regex-replace-compiled.ts": 2826, + "5116-regex-capture-reads.ts": 3329, + "5117-regex-log-report-spans.ts": 3686, + "5118-regex-replace-char-chains.ts": 2917, + "512-array-join-chains.ts": 1729, + "5120-frame-records.ts": 2763, + "5121-frame-objects.ts": 2346, + "5122-frame-result-slots.ts": 3086, + "5123-frame-reassigned.ts": 2807, + "5124-frame-objects-control.ts": 2789, + "5125-frame-mutating-methods.ts": 2122, + "5126-frame-returned-params.ts": 2597, + "5127-frame-loop-bindings.ts": 2498, + "513-array-methods-rc-stress.ts": 3202, + "5130-event-target-dispatch.js": 4435, + "5131-event-target-listener-errors.js": 1856, + "5132-event-target-typed.ts": 2296, + "5133-abort-signal-event-target.ts": 3474, + "5134-events-error-monitor.ts": 2972, + "5135-event-target-warnings.js": 2909, + "5136-events-error-monitor-string-name.ts": 2529, + "5137-events-error-monitor-computed-name.js": 3132, + "5138-events-error-monitor-shared-listener.ts": 2744, + "5139-event-target-listener-throw.ts": 2800, + "514-array-find-some-every.ts": 3281, + "5140-os-host-facts.ts": 3044, + "5141-os-constants.ts": 3300, + "5142-path-parse-format.ts": 2224, + "5145-path-matches-glob-basics.ts": 2906, + "5146-path-matches-glob-braces.ts": 5151, + "5147-path-matches-glob-extglob.ts": 2798, + "5148-path-matches-glob-classes.ts": 2450, + "5149-path-matches-glob-win32.ts": 3351, + "515-array-flatmap.ts": 3014, + "5150-small-array-inline-slots.ts": 3873, + "5155-cycle-header-types.ts": 3715, + "516-array-reduce.ts": 3532, + "5160-field-callback-receiver.ts": 3321, + "5161-field-callback-receiver-escape.ts": 2766, + "5162-field-method-reference-receiver.ts": 2634, + "5163-field-callback-receiver.cjs": 3329, + "5164-worker-field-callback-receiver.ts": 3447, + "5165-interface-method-dispatch.ts": 3406, + "5166-interface-method-values.ts": 4300, + "5167-interface-method-order.ts": 3903, + "5168-interface-method-hierarchy.ts": 5186, + "5169-interface-method-chains.ts": 2434, + "517-array-hof-index-args.ts": 3100, + "5170-string-scan-eviction.ts": 1929, + "5171-lone-surrogate-replace-seams.ts": 2824, + "5175-forin-typed-as-unknown.ts": 2364, + "5176-object-keys-typed-as-unknown.ts": 1967, + "5177-forin-dynamic-objects.ts": 2917, + "5178-forin-keys-js.js": 3039, + "5179-forin-typed-shapes.ts": 3389, + "518-array-sort.ts": 3117, + "518-promise-void-union-callbacks.ts": 2562, + "5180-interface-arrays.ts": 3202, + "5181-interface-array-methods.ts": 6982, + "5182-interface-array-boundaries.ts": 3287, + "5183-interface-property-reads.ts": 3238, + "5184-interface-property-objects.ts": 3177, + "5185-util-inherits.cjs": 3654, + "5186-util-inherits.ts": 3139, + "5187-util-deprecate.cjs": 2383, + "5188-util-deprecate-flags.cjs": 2907, + "5189-util-deprecate.ts": 2180, + "519-array-from-length.ts": 2896, + "519-promise-union-await-values.ts": 2702, + "5190-util-callbackify.cjs": 3059, + "5191-util-callbackify.ts": 3126, + "5192-util-debuglog.cjs": 3809, + "5193-util-debuglog.ts": 2614, + "5194-process-emit-warning-tick.cjs": 2394, + "5195-object-entries-typed-as-unknown.ts": 3883, + "5196-object-values-typed-as-unknown.ts": 3399, + "5197-object-entries-dynamic-objects.ts": 3397, + "5198-object-entries-values-js.js": 2635, + "5199-object-entries-identity.ts": 3121, + "520-map-basics.ts": 2823, + "5200-array-sort-keyed-numbers.ts": 4287, + "5201-array-sort-keyed-records.ts": 4564, + "5202-array-sort-keyed-lookalikes.ts": 3516, + "5203-typed-array-sort-default.ts": 6009, + "5204-typed-array-sort-comparators.ts": 4333, + "521-map-number-keys.ts": 2785, + "5210-process-memory-usage.ts": 2299, + "5211-process-identity.ts": 3103, + "5212-perf-marks-measures.ts": 3829, + "5213-perf-timing-errors.ts": 3477, + "5214-perf-entry-inspect.ts": 4088, + "5215-perf-timing-validation.js": 3386, + "5216-perf-spread-arguments.js": 4128, + "5217-perf-spread-typed.ts": 3454, + "522-map-foreach.ts": 2702, + "5220-url-parse-warnings.ts": 2881, + "5221-url-parse-shapes.ts": 1930, + "5222-url-parse-hosts.ts": 3064, + "5223-url-parse-query.ts": 3104, + "5224-url-format-objects.ts": 3496, + "5225-url-format-whatwg.ts": 2608, + "5226-url-resolve.ts": 2695, + "5227-url-legacy-dependency/main.ts": 2825, + "5228-url-domain-conversion.ts": 2843, + "5229-url-legacy-errors.cjs": 3833, + "523-map-ref-values.ts": 3192, + "5230-inline-union-fields.ts": 2629, + "5231-inline-union-field-kinds.ts": 2513, + "5232-inline-union-fields-dynamic.ts": 3917, + "5233-inline-union-fields-shapes.ts": 3689, + "5234-inline-union-class-fields.ts": 3417, + "5235-inline-union-fields-publish.ts": 2910, + "5236-inline-union-unchecked-reads.ts": 2919, + "5237-inline-union-frame-objects.ts": 2775, + "524-map-cycles.ts": 2820, + "5240-event-target-subclass.ts": 4712, + "5241-event-subclass.ts": 3442, + "5242-event-target-subclass-hierarchy.ts": 3429, + "5243-event-target-subclass-dynamic.ts": 3827, + "5244-event-target-subclass.js": 3772, + "5245-event-target-subclass-signals.ts": 3197, + "5246-event-target-subclass-listener-throw.ts": 1982, + "5247-event-target-subclass-lifetimes.ts": 4315, + "5248-event-target-subclass-warnings.ts": 2798, + "5249-event-target-subclass-unconstructed.ts": 2600, + "525-map-rc-stress.ts": 2751, + "5250-cipher-aes-gcm.ts": 6095, + "5251-cipher-aes-cbc.ts": 3544, + "5252-cipher-aes-ctr.ts": 2536, + "5253-cipher-chacha20-poly1305.ts": 3577, + "5254-cipher-errors.js": 3835, + "5255-cipher-encodings.cjs": 3839, + "5256-cipher-deprecation.cjs": 3149, + "5257-cipher-vectors.ts": 3374, + "5258-cipher-handles.js": 2798, + "5259-cipher-chunked.ts": 3781, + "526-set-basics.ts": 2514, + "5260-record-unknown-identity.ts": 3342, + "5261-optional-field-identity.ts": 2813, + "5262-record-unknown-many.ts": 2768, + "527-set-foreach.ts": 2947, + "5270-url-parse-no-deprecation.cjs": 3204, + "5271-url-parse-throw-deprecation.cjs": 3229, + "5275-http-end-callback-order.ts": 3224, + "5276-style-text-hex-colors.cjs": 2193, + "5277-fs-read-file-buffer-option.cjs": 1864, + "5278-host-null-bytes.cjs": 2972, + "5279-search-params-null-init.cjs": 1662, + "528-set-seeded.ts": 1937, + "5285-blob-construct.ts": 3802, + "5286-blob-readers.ts": 2609, + "5287-blob-inspect.ts": 2930, + "5288-blob-validation.js": 4282, + "5289-blob-read-order.ts": 3276, + "529-map-seeded.ts": 2575, + "5290-blob-dynamic.js": 3409, + "5295-readline-promises-question.ts": 2860, + "5296-readline-lines.ts": 3085, + "5297-readline-callback-events.cjs": 2092, + "5298-readline-abort.cjs": 3384, + "5299-readline-stdin.ts": 2909, + "530-record-arrays.ts": 3090, + "5300-stream-add-abort-signal.ts": 2505, + "5301-stream-add-abort-signal-errors.cjs": 3168, + "5302-stream-promises-options.ts": 2812, + "5303-stream-finished-callback-opts.cjs": 2840, + "5305-json-stringify-typed-arrays.ts": 4425, + "531-record-array-hofs.ts": 3107, + "5315-map-iterate-after-front-deletes.ts": 3372, + "5316-map-lru-eviction.ts": 2980, + "5317-map-iterate-while-mutating.ts": 3025, + "5318-set-iterate-after-deletes.ts": 2325, + "5319-map-iteration-values.ts": 2767, + "532-record-arrays-rc-stress.ts": 2605, + "5320-map-iterate-across-compaction.ts": 3341, + "5321-integer-closed-arithmetic-loops.ts": 2935, + "5321-json-parse-cycles.ts": 2739, + "5322-integer-variable-step-loops.ts": 2732, + "5322-json-stringify-parsed-trees.ts": 3539, + "5323-dyn-numeric-index-reads.ts": 1771, + "5323-int32-nonnegative-slot-facts.ts": 2925, + "5324-int32-initializer-locals.ts": 2126, + "5324-structured-clone-documents.ts": 3093, + "5325-record-boundary-returns.ts": 2952, + "5326-record-boundary-params.ts": 3045, + "5327-record-boundary-identity.ts": 2913, + "5328-record-boundary-open.ts": 2787, + "5329-record-boundary-recursion.ts": 2543, + "533-array-element-cycles.ts": 2595, + "5330-record-boundary-fields.ts": 2690, + "5331-record-boundary-methods.ts": 2941, + "5332-int32-narrowed-slot-facts.ts": 3036, + "5333-integer-guarded-while-counters.ts": 2907, + "5333-record-boundary-nullable-argument.ts": 3066, + "5334-fetch-mentions-without-calls.ts": 2537, + "5335-stream-operators-values.ts": 3463, + "5335-top-level-await-pending-exit-code.ts": 2626, + "5336-stream-operators-promise-timing.ts": 3056, + "5336-top-level-await-pending-exit-listener.ts": 2547, + "5337-dc-subscriber-throw-next-tick.cjs": 2655, + "5337-stream-operators-concurrency.ts": 2539, + "5338-js-tdz-function-element.js": 2247, + "5338-stream-operators-checks.cjs": 3619, + "5339-array-buffer-constructor.js": 3106, + "5339-stream-for-await-hops.ts": 2525, + "534-record-width-subtyping.ts": 2764, + "5340-readable-from-options.ts": 3427, + "5341-compound-any-operand.ts": 3571, + "5341-generator-callback-params.ts": 3696, + "5341-integer-recursion-boundaries.ts": 2410, + "5341-readable-from-dynamic.cjs": 3652, + "5342-compound-any-operand.cjs": 2807, + "5342-generator-scalar-channels.ts": 2386, + "5342-integer-recursion-stack-and-mutual.ts": 2999, + "5342-stream-compose.ts": 3332, + "5343-any-flow-compound.ts": 1598, + "5343-integer-recursion-array-index.ts": 3219, + "5343-iterator-result-records.ts": 2018, + "5343-stream-compose-edges.ts": 3167, + "5344-json-parse-undeclared-keys.ts": 4016, + "5344-stream-pipeline-timing.ts": 3216, + "5345-object-values-for-of-unknown.ts": 2662, + "5346-object-values-length-dynamic.ts": 3253, + "5347-object-values-loop-control.ts": 3534, + "5348-object-values-for-of-js.js": 3133, + "5349-object-entries-values-optional.ts": 3434, + "535-object-statics.ts": 3684, + "5350-object-values-wide-record.ts": 3383, + "5351-object-values-methods-index.ts": 4044, + "5352-final-field-loop-reads.ts": 2982, + "5353-captured-const-values.ts": 3255, + "5354-captured-const-tdz.ts": 1913, + "5355-captured-function-declarations.ts": 2960, + "5356-captured-tdz-ordering.ts": 2164, + "5357-init-only-module-bindings.ts": 3203, + "536-map-seed-array.ts": 2803, + "5360-array-sort-comparator-calls.ts": 2961, + "5361-array-sort-inconsistent-comparators.ts": 2659, + "5362-array-sort-comparator-throws.ts": 2991, + "5363-array-sort-comparator-writes.ts": 5900, + "5364-array-sort-union-and-boolean-elements.ts": 10497, + "5365-array-sort-dynamic-values.js": 3189, + "537-map-iter-drains.ts": 2987, + "5370-zlib-stream-roundtrip.ts": 3454, + "5371-zlib-stream-chunking.cjs": 3925, + "5372-zlib-stream-errors.cjs": 2700, + "5373-zlib-stream-options.cjs": 3872, + "5374-zlib-stream-flush-params.ts": 3102, + "5375-zlib-stream-promises.ts": 2399, + "5376-zlib-constants.cjs": 2483, + "5377-zlib-stream-backpressure.cjs": 3427, + "5378-zlib-sync-options.cjs": 2176, + "5379-zlib-callback-options.ts": 3566, + "538-map-set-for-of.ts": 2976, + "5390-interface-loop-element-lifetimes.ts": 3153, + "5391-interface-dispatch-hierarchies.ts": 3899, + "5392-interface-receiver-bindings.ts": 3131, + "5393-interface-array-holes.ts": 3093, + "5394-interface-implementers.ts": 3579, + "5395-locale-compare-ascii.ts": 2963, + "5396-locale-compare-latin.ts": 1885, + "5397-locale-compare-sorting.ts": 3156, + "540-tuples-basics.ts": 2555, + "5400-json-parse-typed-keys.ts": 3448, + "5405-buffer-arraybuffer-window.ts": 3039, + "5406-util-types-keys.ts": 2823, + "5407-http-header-field-limit.ts": 3316, + "5408-http-unread-request-end.ts": 3667, + "5409-http-held-request-body.ts": 2506, + "541-ref-array-json.ts": 2521, + "5410-inspect-class-values.ts": 2528, + "5411-inspect-class-hierarchies.ts": 3094, + "5412-inspect-dynamic-collections.ts": 3071, + "5413-inspect-class-values.cjs": 3263, + "5415-zlib-dynamic-inputs.cjs": 2520, + "542-union-element-arrays.ts": 2223, + "5420-readable-from-generators.ts": 3661, + "5421-readable-from-generators.cjs": 3036, + "5422-stream-async-push-wakeup.ts": 3138, + "5423-stream-end-and-eos-timing.ts": 3247, + "5424-stream-write-buffer-encoding.ts": 2663, + "5425-pipeline-generator-stage.ts": 2060, + "5426-pipeline-generator-errors.ts": 3490, + "5427-pipeline-generator-backpressure.ts": 2729, + "5428-pipeline-generator-stages.cjs": 3499, + "5429-pipeline-generator-buffers.ts": 3223, + "5430-dyn-number-string-boxes.ts": 3048, + "5435-crypto-hash-algorithms.ts": 2461, + "5436-crypto-hash-names.js": 3064, + "5437-crypto-hmac-algorithms.ts": 3107, + "5438-crypto-kdf-digests.ts": 3109, + "5439-crypto-kdf-callbacks.js": 2368, + "5440-crypto-hash-encodings.js": 4093, + "5441-crypto-hash-output-length.ts": 3652, + "5442-crypto-random-values.ts": 4190, + "5443-crypto-random-arguments.js": 3529, + "5444-crypto-timing-safe-equal.js": 3508, + "5445-crypto-secret-key-objects.ts": 3186, + "5445-stream-buffer-chunks.ts": 3012, + "5446-crypto-secret-key-errors.js": 3785, + "5446-stream-buffer-chunks-dynamic.js": 3127, + "5447-fs-readdir-order.ts": 2143, + "5448-fs-glob-patterns.ts": 3113, + "5449-fs-glob-options.ts": 3649, + "5450-fs-glob-validation.js": 2855, + "5451-fs-promises-glob.ts": 3569, + "5452-fs-glob-callback.ts": 2885, + "5455-power-of-two-remainder.ts": 3093, + "5456-remainder-large-integer-dividends.ts": 2991, + "5457-lcg-modulus.ts": 2871, + "5458-fractional-remainder.ts": 2988, + "5460-locale-compare-contractions.ts": 2881, + "5461-locale-compare-equivalents.ts": 2942, + "5462-locale-compare-probe-sweep.ts": 2752, + "5463-locale-compare-combining-letters.ts": 3006, + "5464-locale-compare-fractions.ts": 2946, + "5465-dyn-index-read-arrays.ts": 3424, + "5466-dyn-index-read-special.ts": 2632, + "5470-strip-vt-osc.cjs": 2376, + "5471-strip-vt-csi.cjs": 2167, + "5472-strip-vt-random.cjs": 3001, + "5473-strip-vt-unterminated.cjs": 3560, + "5474-strip-vt-surrogates.ts": 3301, + "5510-assert-error-properties.js": 3653, + "5511-assert-error-class.ts": 3637, + "5512-assert-error-options.js": 3115, + "5513-assert-deep-equal-loose.js": 3866, + "5514-assert-deep-equal-typed.ts": 3778, + "5515-assert-deep-strict-typed-messages.ts": 1850, + "5516-assert-deep-equal-edges.js": 3662, + "5517-assert-partial-deep-equal.js": 2640, + "5518-assert-partial-deep-typed.ts": 3542, + "5519-assert-partial-deep-typed-edges.ts": 3280, + "5520-assert-record-literal-failures.ts": 3499, + "5520-dyn-property-read-receivers.ts": 3367, + "5521-assert-empty-message.js": 3321, + "5521-dyn-property-read-keys.ts": 2391, + "5522-assert-throws-failure-properties.ts": 3436, + "5523-assert-class-options.js": 3102, + "5524-assert-class-skip-prototype.ts": 3823, + "5530-buffer-pool.ts": 3971, + "5531-buffer-pool-first-slab.ts": 5569, + "5532-buffer-pool-first-slab-untyped.mjs": 40038, + "5540-fs-callback-forms.cjs": 3631, + "5541-fs-stats-fields.cjs": 3800, + "5542-fs-promises-parity.cjs": 3962, + "5543-fs-promises-typed.ts": 2212, + "5544-fs-opendir.cjs": 3332, + "5545-fs-options-encoding.cjs": 4482, + "5546-fs-read-stream.cjs": 4502, + "5547-fs-write-stream.cjs": 5101, + "5548-fs-callback-arguments.cjs": 4306, + "5549-fs-callback-option-checks.cjs": 4187, + "5550-locale-compare-ascii-words.ts": 2669, + "5551-array-search-references.ts": 3663, + "5552-string-appends.ts": 3195, + "5553-string-append-char-code.ts": 2446, + "5554-fs-streams-typed.ts": 3785, + "5555-fs-callback-turns.cjs": 3093, + "5555-http-server-close-keep-alive.ts": 7242, + "5556-http-client-agent-connection.ts": 2788, + "5557-http-outgoing-header-values.ts": 3401, + "5558-http-incoming-duplicate-headers.ts": 2354, + "5559-http-expect-header.ts": 3766, + "5560-http-response-framing.ts": 4849, + "5561-http-max-header-size.ts": 3443, + "5562-https-verify-errors.ts": 3494, + "5563-http-keep-alive-timeout.ts": 11607, + "5564-http-request-signal.ts": 3916, + "5565-fs-dirent-untyped.mjs": 3810, + "5566-fs-dirent-dyn-boundaries/main.mjs": 3533, + "5567-fs-cpsync.ts": 3626, + "5568-fs-cp-errors.js": 3163, + "5569-fs-cp-symlinks.ts": 3704, + "5570-fs-cp-async.ts": 3480, + "5571-fs-cp-deep.ts": 4934, + "5585-record-results-inlined.ts": 3154, + "5595-net-ref-unref.ts": 2641, + "5600-dyn-cycle-self.ts": 2124, + "5601-dyn-cycle-mutual.ts": 3279, + "5602-dyn-cycle-arrays.ts": 2568, + "5603-dyn-cycle-identity.ts": 2702, + "5604-dyn-cycle-checks.ts": 3057, + "5605-dyn-cycle-containers.ts": 3526, + "5606-dyn-cycle-capsules.ts": 1609, + "5610-readable-from-sets-and-views.ts": 3539, + "5611-readable-from-class-iterables.ts": 2637, + "5612-readable-from-iterables.cjs": 4089, + "5613-readable-from-iterable-timing.cjs": 4101, + "5614-readable-from-iterable-errors.cjs": 4082, + "5615-next-tick-callback-phases.ts": 3272, + "5616-next-tick-callback-phases.cjs": 2953, + "5617-pipeline-function-ends.ts": 2551, + "5618-pipeline-function-ends-errors.ts": 3775, + "5619-pipeline-function-ends.cjs": 2549, + "5620-timers-promises-values.ts": 3225, + "5621-util-format-float.ts": 2907, + "5622-events-once.mjs": 3347, + "5623-events-once.ts": 2334, + "5624-timers-promises-unawaited.ts": 3127, + "5625-promisify-exec.ts": 7142, + "5626-promisify-forms.ts": 2175, "5627-exec-callback.ts": 1900, + "5628-promisify-timers.ts": 3185, + "5629-promisify-stream.ts": 3048, + "5630-promisify-zlib.ts": 1934, "5631-promisify-crypto.ts": 2200, "5632-promisify-dns.ts": 1700, - "5644-net-socket-addresses.ts": 2220, - "5645-net-socket-callbacks.ts": 2442, - "5646-net-server-connections.ts": 2389, - "5647-net-is-ip.ts": 2776, - "5648-dns-lookup-forms.ts": 2992, - "5649-dns-service-servers.ts": 2712, - "5650-dns-lookup-errors-untyped.cjs": 2822, - "5681-array-pop-and-length.ts": 3754, - "5800-broadcast-channel.ts": 2899, - "5801-broadcast-channel.cjs": 2727, - "5802-broadcast-channel-workers.ts": 2809, - "5803-worker-environment-data.ts": 2748, - "5804-worker-environment-data.cjs": 2469, - "5805-worker-receive-message-parent-port.ts": 2839, - "5806-worker-resource-limits.ts": 3153, - "5807-worker-error-values.ts": 3304, - "5808-worker-unhandled-rejections.ts": 3430, - "5809-process-exit-and-rejections.cjs": 3294, - "5810-mock-method-records.ts": 3976, - "5811-mock-tracker-restore.ts": 3698, - "5812-dyn-box-async-fields.ts": 3522, - "5813-mock-timers-module.ts": 3766, - "5814-mock-timers-date.ts": 3760, - "5831-util-types-brands.ts": 3347, - "5832-util-types-brands-dynamic.js": 3250, - "5833-url-search-params-iterators.ts": 2678, - "5834-url-search-params-iterators-dynamic.mjs": 2696, - "5835-util-format-integer-specifiers.ts": 2534, - "5836-url-search-params-tuple-pairs.ts": 2118, - "5837-util-format-json-circular.ts": 3117, - "5838-qs-stringify-bigint.ts": 2207, - "5841-json-typed-dyn-members.ts": 5467, - "5842-qs-parse-null-prototype.ts": 1774, - "5843-qs-parse-null-prototype-js.mjs": 1559, - "5844-date-unknown-values.ts": 3969, + "5644-net-socket-addresses.ts": 3275, + "5645-net-socket-callbacks.ts": 3377, + "5646-net-server-connections.ts": 2448, + "5647-net-is-ip.ts": 2731, + "5648-dns-lookup-forms.ts": 3763, + "5649-dns-service-servers.ts": 2892, + "5650-dns-lookup-errors-untyped.cjs": 2811, + "5651-tls-socket-protocol.ts": 3198, + "5652-http-client-trailer-overflow.ts": 2916, + "5653-net-socket-read-ahead.ts": 4816, + "5654-https-empty-servername.ts": 3117, + "5655-dgram-socket-options.ts": 3309, + "5656-dgram-option-states.ts": 3364, + "5657-net-reset-and-address.ts": 2680, + "5658-net-reset-dynamic.cjs": 2474, + "5659-net-blocklist-socketaddress.ts": 4089, + "5664-tls-client-identity.ts": 2704, + "5674-union-instanceof-array-arms.ts": 3663, + "5680-array-growth-after-copy.ts": 3726, + "5681-array-pop-and-length.ts": 4270, + "5682-publish-wide-objects.ts": 3077, + "5700-cycle-release-retained.ts": 2148, + "5701-cycle-release-old-edges.ts": 2696, + "5702-publish-candidate-buffers.ts": 2775, + "5703-lifetime-region-debug.ts": 2224, + "5704-publish-refused-restores-counts.ts": 3329, + "5710-map-number-keys-hashed.ts": 3647, + "5711-map-number-write-after-read.ts": 2210, + "5712-map-number-overwrite-at-growth.ts": 3023, + "5714-cycle-large-candidate-buffers.ts": 2468, + "5715-json-parse-fitted-tables.ts": 3870, + "5717-set-prototype-of-primitives.ts": 2889, + "5719-int32-fields-dynamic-operators.ts": 3112, + "5720-intern-table-basics.ts": 3730, + "5721-intern-table-values.ts": 3508, + "5722-intern-table-workers.ts": 2907, + "5723-intern-table-shared-types.ts": 4686, + "5724-intern-table-array-keys.ts": 3089, + "5725-intern-table-callbacks.ts": 3280, + "5726-intern-table-key-limits.ts": 2828, + "5740-atomics-operation-semantics.ts": 4575, + "5741-atomics-contended-counters.ts": 2574, + "5742-atomics-lock-ordering.ts": 3308, + "5743-atomics-wait-notify.ts": 3213, + "5744-atomics-ring-buffer.ts": 2799, + "5745-atomics-semaphore-stress.ts": 3529, + "5746-shared-bulk-operations.ts": 3548, + "5747-fs-stat-throw-if-no-entry.ts": 2061, + "5748-fs-stat-throw-if-no-entry-js.cjs": 3369, + "5752-string-number-concat.ts": 1990, + "5760-crypto-hash-stream.ts": 3142, + "5761-crypto-hash-stream-states.ts": 3329, + "5762-crypto-hash-stream.cjs": 3414, + "5763-crypto-sha-blocks.ts": 3741, + "5764-class-structural-view-writes.ts": 3376, + "5764-crypto-hmac-edges.cjs": 2142, + "5765-class-structural-view-identity.ts": 3439, + "5766-class-structural-view-callbacks.ts": 2597, + "5767-class-opaque-accessor-view.ts": 3393, + "5776-power-of-two-remainder-integer-path.ts": 2953, + "5780-readline-history-options.ts": 2935, + "5781-readline-history-options.cjs": 2270, + "5782-readline-terminal-editing.ts": 3076, + "5783-readline-terminal-completion.cjs": 5270, + "5784-readline-terminal-promises.ts": 2520, + "5785-readline-terminal-keys.ts": 3009, + "5786-readline-terminal-history.cjs": 2912, + "5787-readline-cursor-helpers.cjs": 1948, + "5788-readline-promises-readline.ts": 3069, + "5789-readline-cursor-pos.cjs": 2494, + "5790-readline-keypress-events.ts": 3064, + "5791-dyn-constant-key-read-sites.ts": 3916, + "5791-readline-keypress-interfaces.cjs": 3122, + "5792-json-parse-repeated-layouts.ts": 3794, + "5792-readline-keypress-listeners.ts": 2820, + "5793-worker-message-channel.ts": 2538, + "5794-worker-message-port-close-order.ts": 2834, + "5795-worker-message-port-batches.ts": 2254, + "5796-worker-message-channel.cjs": 3566, + "5797-worker-message-port-transfer.ts": 3180, + "5800-broadcast-channel.ts": 3206, + "5801-broadcast-channel.cjs": 3035, + "5802-broadcast-channel-workers.ts": 3120, + "5803-worker-environment-data.ts": 3113, + "5804-worker-environment-data.cjs": 3000, + "5805-worker-receive-message-parent-port.ts": 3259, + "5806-worker-resource-limits.ts": 3191, + "5807-worker-error-values.ts": 3239, + "5808-worker-unhandled-rejections.ts": 3439, + "5809-process-exit-and-rejections.cjs": 3393, + "5810-mock-method-records.ts": 3670, + "5811-mock-tracker-restore.ts": 3216, + "5812-dyn-box-async-fields.ts": 2941, + "5813-mock-timers-module.ts": 3052, + "5814-mock-timers-date.ts": 3365, + "5830-timers-promises-signal.ts": 3771, + "5831-util-types-brands.ts": 3300, + "5832-util-types-brands-dynamic.js": 3811, + "5833-url-search-params-iterators.ts": 3578, + "5834-url-search-params-iterators-dynamic.mjs": 3566, + "5835-util-format-integer-specifiers.ts": 2544, + "5836-url-search-params-tuple-pairs.ts": 2830, + "5837-util-format-json-circular.ts": 2387, + "5838-qs-stringify-bigint.ts": 3072, + "5839-timers-promises-scheduler.ts": 2609, + "5840-promise-with-resolvers-js.js": 2922, + "5841-json-typed-dyn-members.ts": 3536, + "5842-qs-parse-null-prototype.ts": 3138, + "5843-qs-parse-null-prototype-js.mjs": 2658, + "5844-date-unknown-values.ts": 3255, + "5845-groupby-null-prototype.ts": 3675, "5846-events-esm-default-max.ts": 2633, "5847-events-cjs-default-max.cjs": 2823, - "5857-regexp-unicode-sets.ts": 3350, - "5858-disposable-stack.ts": 3050, - "5859-disposable-stack-js.js": 3100, - "5870-worker-thread-names.ts": 3106, - "5871-worker-untransferable.cjs": 2786, - "5874-worker-stdio-streams.ts": 2839, - "5875-worker-stdout-pipe.cjs": 2740, - "5879-worker-stdin.ts": 3158, - "5881-inspect-weak-collections.ts": 2615, - "5882-string-decoder-runtime-encoding.ts": 2541, - "5883-os-set-priority.ts": 2380, - "5884-inspect-layout-options.ts": 3108, - "5886-inspect-dates.ts": 2559, - "5887-inspect-typed-arrays.ts": 3448, - "5888-inspect-sorted.ts": 2998, - "5900-float16-array.ts": 3000, - "5901-float16-array-js.js": 2900, - "5904-async-generator-completion.ts": 2950, - "5905-array-from-async-generator.ts": 2750, - "5906-array-from-async-generator-js.js": 2950, + "5849-class-view-observations.ts": 2583, + "5850-using-disposable-values.ts": 3206, + "5851-using-suppressed-error-values.ts": 3035, + "5852-using-disposable-values-js.js": 1792, + "5853-set-methods-map-arguments.ts": 2849, + "5854-array-from-async.ts": 3165, + "5855-array-from-async-js.js": 3186, + "5856-error-is-error.ts": 3631, + "5857-regexp-unicode-sets.ts": 2021, + "5858-disposable-stack.ts": 4753, + "5859-disposable-stack-js.js": 3636, + "5860-url-ipv4-hosts.ts": 3030, + "5870-worker-thread-names.ts": 3457, + "5871-worker-untransferable.cjs": 2368, + "5872-readline-positional-create-interface.mjs": 2993, + "5873-readline-promises-namespace.cjs": 2951, + "5874-worker-stdio-streams.ts": 2974, + "5875-worker-stdout-pipe.cjs": 3115, + "5879-worker-stdin.ts": 3644, + "5880-emitter-leak-warning-delivery.ts": 2660, + "5881-inspect-weak-collections.ts": 2621, + "5882-string-decoder-runtime-encoding.ts": 2742, + "5883-os-set-priority.ts": 2927, + "5884-inspect-layout-options.ts": 3552, + "5885-events-max-listener-helpers.ts": 3645, + "5886-inspect-dates.ts": 2931, + "5887-inspect-typed-arrays.ts": 2476, + "5888-inspect-sorted.ts": 3227, + "5889-timers-scheduler-signal.ts": 2549, + "5890-while-string-length-counters.ts": 3080, + "5892-buffer-write-utf16le-runs.ts": 3098, + "5900-float16-array.ts": 3586, + "5901-float16-array-js.js": 3449, + "5904-async-generator-completion.ts": 5816, + "5905-array-from-async-generator.ts": 2793, + "5906-array-from-async-generator-js.js": 3377, "5907-regex-groups-match-rows.ts": 3150, - "5910-set-prototype-of-primitive-object-kinds.ts": 2719, - "5911-dyn-class-to-primitive.ts": 2850, - "5912-dyn-class-conversion-methods.ts": 3251, - "5913-prototype-type-error-messages.ts": 2484, - "5914-dyn-in-class-prototype-members.ts": 3169, - "5915-dyn-error-string-conversions.ts": 3200, - "5922-matchall-groups-callbacks.ts": 3650, - "5923-matchall-groups-js.js": 3970, + "5910-set-prototype-of-primitive-object-kinds.ts": 2148, + "5911-dyn-class-to-primitive.ts": 6231, + "5912-dyn-class-conversion-methods.ts": 4317, + "5913-prototype-type-error-messages.ts": 2831, + "5914-dyn-in-class-prototype-members.ts": 2811, + "5915-dyn-error-string-conversions.ts": 3158, + "5920-promise-try-args.ts": 3150, + "5921-promise-try-args-js.js": 2112, + "5922-matchall-groups-callbacks.ts": 4259, + "5923-matchall-groups-js.js": 4523, + "5924-js-literal-identity.js": 3064, + "5925-class-view-identity-observers.ts": 2653, + "5926-class-view-switch-js.js": 1690, + "5927-switch-object-identity.ts": 2783, + "5928-groupby-iterables.ts": 3526, + "5929-groupby-js.js": 1756, + "5930-contract-int32-arrays.ts": 3803, + "5930-method-census-asserted-number-keys.ts": 2348, + "5931-asserted-reads-keep-number-parameters.ts": 2715, + "5932-generic-class-observed-methods.ts": 4825, + "5933-class-fields-unknown-object.ts": 3920, + "5934-js-class-fields-property-order.js": 4713, + "5935-js-subclass-fields-and-element-calls.js": 3523, + "5936-checked-js-class-types.js": 2384, + "5937-override-narrowed-union-returns.ts": 3039, "5938-object-literal-computed-keys-keep-methods.ts": 3195, - "5939-js-let-object-reassigned-wider.js": 1945, + "5939-js-let-object-reassigned-wider.js": 2362, + "5940-callback-helper-specialization.ts": 3130, + "5941-callback-specialization-recursion.ts": 3996, + "5942-callback-specialization-throws.ts": 2908, "5943-fields-read-before-assignment.ts": 6856, "5944-js-fields-read-before-assignment.js": 4247, "5945-local-class-observed-methods.ts": 5063, "5946-nested-record-field-optional-writes.ts": 6045, - "5950-tuple-predicate-methods.ts": 5990, - "5951-result-never-widening.ts": 4710, + "5950-tuple-predicate-methods.ts": 3865, + "5951-result-never-widening.ts": 3022, "5952-record-missing-keys.ts": 6090, "5953-nan-coded-method-returns.ts": 4100, - "5955-any-promise-methods.js": 3940, - "5956-erased-generic-members.ts": 6730, - "5958-asserted-union-receiver.ts": 2430, - "5959-date-to-json.ts": 3330, - "5960-generic-mapped-types.ts": 2540, - "5970-net-connect-host-name.ts": 2400, - "5971-buffer-chunks-to-string.ts": 2700, - "5972-net-set-encoding-listeners.ts": 2550, - "5974-typeof-module-exports.cjs": 2000, + "5955-any-promise-methods.js": 3111, + "5956-erased-generic-members.ts": 5669, + "5958-asserted-union-receiver.ts": 1929, + "5959-date-to-json.ts": 2922, + "5960-generic-mapped-types.ts": 3167, + "5970-net-connect-host-name.ts": 1992, + "5971-buffer-chunks-to-string.ts": 3183, + "5972-net-set-encoding-listeners.ts": 2129, + "5974-typeof-module-exports.cjs": 2008, "5975-zlib-class-values.ts": 2800, - "5990-worker-uncloneable.mjs": 3283, - "5991-worker-async-dispose.mjs": 5699, - "5992-worker-thread-name-lifetime.mjs": 2687, - "600-closures-basic.ts": 2349, - "601-closures-loops.ts": 1788, - "602-closures-identity-recursion.ts": 2372, - "6020-class-extends-function-constructor.js": 4300, + "5990-worker-uncloneable.mjs": 3202, + "5991-worker-async-dispose.mjs": 5853, + "5992-worker-thread-name-lifetime.mjs": 2058, + "600-closures-basic.ts": 2637, + "601-closures-loops.ts": 2250, + "602-closures-identity-recursion.ts": 2821, + "6020-class-extends-function-constructor.js": 3026, "6021-asserted-literal-union-arm.ts": 3400, - "603-closures-rc-stress.ts": 1832, - "604-closures-for-of.ts": 2639, - "605-closures-forward-capture-tdz.ts": 3277, - "700-classes-basic.ts": 2530, - "701-classes-composition.ts": 2357, - "702-classes-this-capture.ts": 2140, - "703-classes-rc-stress.ts": 2186, - "710-inheritance-basics.ts": 2728, - "711-inheritance-dispatch.ts": 2360, - "712-inheritance-instanceof.ts": 2715, - "713-inheritance-rc-stress.ts": 2448, - "720-accessors-basics.ts": 2562, - "721-accessors-eval-order.ts": 2406, - "722-accessors-inheritance.ts": 2543, - "723-accessors-rc-stress.ts": 2054, - "750-cycle-closure-box.ts": 2227, - "751-cycle-records-mutual.ts": 2118, - "752-cycle-classes.ts": 2207, - "753-cycle-owned-arrays.ts": 2148, - "754-cycle-external-ref.ts": 2118, - "755-cycle-async-promise.ts": 2303, - "756-cycle-inheritance.ts": 2162, - "757-cycle-cross-generation.ts": 2893, - "762-any-boundary.ts": 2310, - "764-any-async.ts": 2553, - "765-any-optional-chain.ts": 2593, - "766-any-union-boundary.ts": 3292, - "767-string-literal-keys.ts": 2238, - "768-any-uninitialized.ts": 2264, - "800-switch-basics.ts": 2244, - "801-switch-lazy-tests.ts": 2610, - "802-switch-loops.ts": 2329, - "803-switch-rc-stress.ts": 2314, - "804-switch-braced-blocks.ts": 2594, - "810-do-while.ts": 2658, - "820-multi-decl.ts": 2315, - "830-let-uninitialized.ts": 2519, - "900-records-basics.ts": 2736, - "901-records-eval-order.ts": 2544, - "902-records-functions-closures.ts": 2645, - "903-records-rc-stress.ts": 2871, - "904-records-optional-fields.ts": 1801, - "905-records-optional-rc-stress.ts": 2425, - "906-records-utility-types.ts": 2878, - "907-records-utility-generics.ts": 2738, - "908-records-index-signatures.ts": 2545, - "909-records-index-json.ts": 2019, - "910-records-index-rc-stress.ts": 1878, - "911-records-index-dot-access.ts": 3510, - "912-unknown-slots.ts": 2427, - "913-records-index-iteration.ts": 3462, - "914-records-from-entries.ts": 3129, - "915-unknown-tostring-eq.ts": 3072, - "916-unknown-bytes.ts": 2767, - "917-record-array-index-dot.ts": 2445, - "950-modules-basic/main.ts": 2473, - "951-modules-diamond/main.ts": 1969, - "952-modules-cross/main.ts": 2427, - "953-modules-default/main.ts": 2409, - "954-modules-reexport/main.ts": 2586, - "957-builtins-namespace.ts": 2102, - "960-generics-basics.ts": 2487, - "961-generics-recursion.ts": 2589, - "962-generics-closures.ts": 2098, - "963-generics-modules/main.ts": 2726, - "964-generics-rc-stress.ts": 2825, - "965-generics-async.ts": 2802, - "965-unions-retag.ts": 2772, - "966-unions-retag-rc-stress.ts": 2336, - "967-record-field-widening.ts": 2097, - "969-unions-arm-matrix.ts": 2419, - "970-unions-basics.ts": 2692, - "971-unions-switch.ts": 2491, - "972-unions-nested.ts": 3069, - "973-unions-rc-stress.ts": 2478, - "974-unions-modules/main.ts": 2052, - "975-unions-undefined.ts": 2811, - "976-unions-null.ts": 2344, - "977-unions-unit-rc-stress.ts": 2013, - "978-unions-nullish.ts": 2330, - "979-unions-optional-chaining.ts": 2341, - "980-exceptions-basics.ts": 1988, - "981-exceptions-values.ts": 2615, - "982-exceptions-rc-stress.ts": 2259, - "983-exceptions-control-flow.ts": 2004, - "984-exceptions-finally.ts": 2140, - "985-exceptions-call-chains.ts": 2787, - "986-exceptions-uncaught.ts": 2529, - "987-exceptions-result-unions.ts": 2390, - "990-process-basics.ts": 2623, - "991-process-exit.ts": 2155, - "992-fs-roundtrip.ts": 2680, - "993-fs-readdir.ts": 2781, - "994-fs-errors.ts": 2322, - "995-fs-uncaught.ts": 2134, - "996-fs-rc-stress.ts": 2214, - "997-fs-modules/main.ts": 2230, - "998-process-env.ts": 2196, - "abstract-property-dispatch.ts": 2956, - "arguments-arrow-capture.mjs": 2802, - "arguments-reexport/main.ts": 2655, - "array-argument-lifetimes-exits.ts": 2164, - "array-argument-lifetimes-mutation.ts": 2547, - "array-argument-lifetimes-strings.ts": 2738, - "array-argument-lifetimes-values.ts": 3081, - "array-buffer-conversions.js": 1978, - "array-buffer-storage.ts": 3147, - "array-checked-callback-results.mjs": 3053, - "array-checked-constructor.js": 3001, - "array-concat-widening.ts": 2947, - "array-element-compound-updates.ts": 3325, - "array-fill-unit-values.ts": 2281, - "array-from-checked.js": 3228, - "array-from-value.mjs": 2658, - "array-isarray-value/main.js": 2180, - "array-numeric-own-keys.ts": 2770, - "array-optional-number-write-index.ts": 2584, - "array-primitive-ordering.ts": 3806, - "array-read-helper-effects.ts": 3223, - "array-refined-storage.ts": 3132, - "array-sort-dense-effects.ts": 2813, - "array-sort-dense-values.ts": 3705, - "array-sort-holes-published.ts": 6604, - "array-sort-runs.ts": 5713, - "array-sort-runtime-comparator.ts": 5050, - "array-sort-unknown-comparator.ts": 1888, - "array-storage-transitions.ts": 3122, - "array-truncate-reuse.ts": 2475, - "async-backend-factory.mjs": 2638, - "async-local-typed-results.ts": 2579, - "atomics-integer-operations.ts": 3320, - "bigint-checked-casts.ts": 2572, - "bigint-checked-storage.js": 3519, - "bigint-union-conversion.ts": 2774, - "boxed-error-rethrows.mjs": 2034, - "buffer-codec-boundaries.ts": 3206, - "buffer-primitive-predicate.ts": 2712, - "builtin-prototype-method-values.mjs": 3158, - "byte-loop-bounds.ts": 2922, - "byte-number-pipeline.ts": 2738, - "byte-record-windows.ts": 2668, - "call-lifetimes-argument-order.ts": 1933, - "call-lifetimes-control-flow.ts": 2653, - "call-lifetimes-owned-boundaries.ts": 2979, - "call-lifetimes-projections.ts": 3011, - "call-lifetimes-union-values.ts": 2366, - "call-lifetimes-virtual-optionals.ts": 2747, - "callable-module-members.mjs": 2647, - "callable-properties.mjs": 3266, - "callable-property-cycles.js": 2241, - "callable-reexport/main.ts": 2809, - "captured-class-refinement.ts": 2580, - "catch-capture.ts": 2050, - "caught-class-identity.ts": 3173, - "caught-standalone-class.ts": 2858, - "caught-system-error-fields.ts": 2612, + "603-closures-rc-stress.ts": 2800, + "604-closures-for-of.ts": 1980, + "605-closures-forward-capture-tdz.ts": 2765, + "700-classes-basic.ts": 1650, + "701-classes-composition.ts": 2262, + "702-classes-this-capture.ts": 1945, + "703-classes-rc-stress.ts": 2498, + "710-inheritance-basics.ts": 1936, + "711-inheritance-dispatch.ts": 2643, + "712-inheritance-instanceof.ts": 2608, + "713-inheritance-rc-stress.ts": 2855, + "720-accessors-basics.ts": 2703, + "721-accessors-eval-order.ts": 2000, + "722-accessors-inheritance.ts": 2558, + "723-accessors-rc-stress.ts": 2721, + "750-cycle-closure-box.ts": 2521, + "751-cycle-records-mutual.ts": 2024, + "752-cycle-classes.ts": 2646, + "753-cycle-owned-arrays.ts": 2810, + "754-cycle-external-ref.ts": 2655, + "755-cycle-async-promise.ts": 2228, + "756-cycle-inheritance.ts": 2657, + "757-cycle-cross-generation.ts": 2901, + "762-any-boundary.ts": 2854, + "764-any-async.ts": 2890, + "765-any-optional-chain.ts": 2394, + "766-any-union-boundary.ts": 2672, + "767-string-literal-keys.ts": 2479, + "768-any-uninitialized.ts": 2844, + "800-switch-basics.ts": 2758, + "801-switch-lazy-tests.ts": 2588, + "802-switch-loops.ts": 1780, + "803-switch-rc-stress.ts": 2015, + "804-switch-braced-blocks.ts": 2537, + "810-do-while.ts": 1969, + "820-multi-decl.ts": 1629, + "830-let-uninitialized.ts": 2899, + "900-records-basics.ts": 2778, + "901-records-eval-order.ts": 2686, + "902-records-functions-closures.ts": 2628, + "903-records-rc-stress.ts": 2550, + "904-records-optional-fields.ts": 3083, + "905-records-optional-rc-stress.ts": 2791, + "906-records-utility-types.ts": 1783, + "907-records-utility-generics.ts": 2604, + "908-records-index-signatures.ts": 2041, + "909-records-index-json.ts": 3081, + "910-records-index-rc-stress.ts": 2746, + "911-records-index-dot-access.ts": 3174, + "912-unknown-slots.ts": 2915, + "913-records-index-iteration.ts": 3669, + "914-records-from-entries.ts": 3427, + "915-unknown-tostring-eq.ts": 3373, + "916-unknown-bytes.ts": 2791, + "917-record-array-index-dot.ts": 2745, + "950-modules-basic/main.ts": 2721, + "951-modules-diamond/main.ts": 1492, + "952-modules-cross/main.ts": 1431, + "953-modules-default/main.ts": 2552, + "954-modules-reexport/main.ts": 2362, + "957-builtins-namespace.ts": 2216, + "960-generics-basics.ts": 2982, + "961-generics-recursion.ts": 2893, + "962-generics-closures.ts": 2684, + "963-generics-modules/main.ts": 2595, + "964-generics-rc-stress.ts": 3029, + "965-generics-async.ts": 3085, + "965-unions-retag.ts": 2457, + "966-unions-retag-rc-stress.ts": 2098, + "967-record-field-widening.ts": 2939, + "969-unions-arm-matrix.ts": 2998, + "970-unions-basics.ts": 2779, + "971-unions-switch.ts": 2261, + "972-unions-nested.ts": 2825, + "973-unions-rc-stress.ts": 2576, + "974-unions-modules/main.ts": 2186, + "975-unions-undefined.ts": 2396, + "976-unions-null.ts": 2274, + "977-unions-unit-rc-stress.ts": 2486, + "978-unions-nullish.ts": 2487, + "979-unions-optional-chaining.ts": 2987, + "980-exceptions-basics.ts": 2385, + "981-exceptions-values.ts": 2867, + "982-exceptions-rc-stress.ts": 1550, + "983-exceptions-control-flow.ts": 2778, + "984-exceptions-finally.ts": 2144, + "985-exceptions-call-chains.ts": 3115, + "986-exceptions-uncaught.ts": 2615, + "987-exceptions-result-unions.ts": 1576, + "990-process-basics.ts": 2148, + "991-process-exit.ts": 2021, + "992-fs-roundtrip.ts": 2662, + "993-fs-readdir.ts": 2790, + "994-fs-errors.ts": 2954, + "995-fs-uncaught.ts": 2485, + "996-fs-rc-stress.ts": 2801, + "997-fs-modules/main.ts": 1791, + "998-process-env.ts": 2322, + "abstract-property-dispatch.ts": 3676, + "arguments-arrow-capture.mjs": 2969, + "arguments-reexport/main.ts": 2670, + "array-argument-lifetimes-exits.ts": 3229, + "array-argument-lifetimes-mutation.ts": 2355, + "array-argument-lifetimes-strings.ts": 2875, + "array-argument-lifetimes-values.ts": 3135, + "array-buffer-conversions.js": 2768, + "array-buffer-storage.ts": 2184, + "array-checked-callback-results.mjs": 3207, + "array-checked-constructor.js": 2168, + "array-concat-widening.ts": 3084, + "array-deque-unshift.ts": 3209, + "array-element-compound-updates.ts": 4339, + "array-fill-unit-values.ts": 2510, + "array-from-checked.js": 4274, + "array-from-value.mjs": 3224, + "array-isarray-value/main.js": 2742, + "array-numeric-own-keys.ts": 1884, + "array-optional-number-write-index.ts": 2617, + "array-primitive-ordering.ts": 2544, + "array-queue-head-room.ts": 3344, + "array-read-helper-effects.ts": 2217, + "array-refined-storage.ts": 2827, + "array-sort-dense-effects.ts": 3621, + "array-sort-dense-values.ts": 3004, + "array-sort-holes-published.ts": 7729, + "array-sort-runs.ts": 4117, + "array-sort-runtime-comparator.ts": 4714, + "array-sort-unknown-comparator.ts": 2824, + "array-storage-transitions.ts": 3984, + "array-truncate-reuse.ts": 2234, + "async-backend-factory.mjs": 1807, + "async-local-typed-results.ts": 2185, + "atomics-integer-operations.ts": 2603, + "bigint-checked-casts.ts": 2636, + "bigint-checked-storage.js": 3528, + "bigint-union-conversion.ts": 2763, + "boxed-error-rethrows.mjs": 2627, + "buffer-codec-boundaries.ts": 2453, + "buffer-primitive-predicate.ts": 2183, + "builtin-prototype-method-values.mjs": 3361, + "byte-loop-bounds.ts": 3029, + "byte-number-pipeline.ts": 3197, + "byte-record-windows.ts": 2142, + "call-lifetimes-argument-order.ts": 2451, + "call-lifetimes-control-flow.ts": 2879, + "call-lifetimes-owned-boundaries.ts": 3007, + "call-lifetimes-projections.ts": 1722, + "call-lifetimes-union-values.ts": 2751, + "call-lifetimes-virtual-optionals.ts": 3153, + "callable-module-members.mjs": 2485, + "callable-properties.mjs": 3432, + "callable-property-cycles.js": 3096, + "callable-reexport/main.ts": 3039, + "captured-class-refinement.ts": 3032, + "catch-capture.ts": 2928, + "caught-class-identity.ts": 2572, + "caught-standalone-class.ts": 3034, + "caught-system-error-fields.ts": 2540, "checked-addition.js": 2460, - "checked-any-addition.ts": 2551, - "checked-array-assignment.ts": 2273, - "checked-array-flat/main.ts": 2256, - "checked-bitwise/main.js": 2560, - "checked-builder-cycles.js": 3055, - "checked-byte-storage/main.ts": 3171, - "checked-callback-options.ts": 2385, - "checked-class-descriptors.mjs": 3021, - "checked-class-factory.mjs": 2266, - "checked-collection-iterators.ts": 2906, - "checked-collection-symbol-methods.ts": 2575, - "checked-dispatch-input-lifetimes.js": 3038, - "checked-increment/main.js": 2332, - "checked-inherited-fields.ts": 2382, - "checked-iterator-consumption.js": 3603, - "checked-numeric-arithmetic.js": 2783, - "checked-object-module-alias.js": 2898, - "checked-optional-calls.mjs": 2763, - "checked-promise-recovery.ts": 2689, - "checked-proxy-callback/main.ts": 2754, - "checked-record-constructor.ts": 2506, - "checked-renderer-defaults.js": 2308, - "checked-rest-function-adapters.js": 2312, - "checked-storage-transitions.js": 2557, - "checked-symbol-array.ts": 1859, - "checked-value-input-lifetimes.ts": 2728, - "class-accessor-returned-function.js": 2068, - "class-array-optional-return.ts": 2589, - "class-bracket-method-calls.js": 2833, - "class-brand-overload.js": 2700, - "class-callback-replacement.js": 3640, - "class-callback-storage.ts": 3803, - "class-checked-composites.ts": 2846, - "class-checked-upcast.ts": 2625, - "class-collection-insertion.ts": 3901, - "class-computed-presence.ts": 3018, - "class-computed-symbols.js": 3495, - "class-covariant-returns.ts": 3069, - "class-curried-factory.mjs": 3062, - "class-data-descriptors.js": 3732, - "class-factory-inherited-statics.mjs": 2710, - "class-factory-parameter-base.mjs": 2492, - "class-factory-record-base.mjs": 4680, - "class-factory-recursive-statics.mjs": 2820, - "class-factory-static-members.mjs": 2990, - "class-function-base/main.js": 2706, - "class-instance-constructor.js": 2628, - "class-interface-protocols.ts": 3911, - "class-interface-refinements.ts": 2967, - "class-json-checked.ts": 2638, - "class-local-function-base.mjs": 2970, - "class-method-spreads.ts": 3142, - "class-narrowed-views.ts": 2862, - "class-property-call-values.mjs": 3343, - "class-prototype-data.js": 3393, - "class-prototype-descriptor-copy.mjs": 3870, - "class-specialized-computed-base.mjs": 3439, - "class-static-data.js": 2153, - "class-subclass-assertions.ts": 2814, - "class-super-surplus-spread.mjs": 2024, - "class-symbol-accessors.ts": 2458, - "class-symbol-cache.mjs": 2883, - "class-value-constructor-exceptions.ts": 2222, - "closure-nullable-union-return.ts": 2472, - "closure-union-locals.ts": 2465, - "collection-array-cycles.ts": 2552, - "collection-array-maps.ts": 3481, - "collection-array-missing.ts": 2873, - "collection-array-sets.ts": 3383, - "collection-copy-identities.ts": 2585, - "collection-data-unions.ts": 2565, - "collection-ingestion-mappers.ts": 3262, - "collection-ingestion-protocol/main.ts": 3814, - "collection-ingestion-references.ts": 3375, - "collection-ingestion.ts": 3053, - "collection-storage-copies.ts": 3096, - "collection-value-keys.ts": 3176, - "compound-field-receivers.ts": 2272, - "compound-presence-guards.ts": 3094, - "conditional-tuple-destructuring.ts": 2487, - "console-imports.cjs": 2314, - "console-native-value.js": 2165, - "const-enum-module-cycle/main.ts": 2618, - "constant-callback-dispatch.ts": 2539, - "constant-module-globals/main.ts": 2455, - "constant-number-remainders.ts": 2350, - "constructed-class-dispatch.ts": 3014, - "contextual-array-union-write.ts": 5379, - "contextual-return-layouts.ts": 2919, - "counted-loop-numbers.ts": 2515, - "counted-loop-storage.ts": 2556, - "crypto-hash-optional-input.ts": 2860, - "cycle-generations-long-lived.ts": 2691, - "cycle-growth-yield.ts": 2929, - "date-checked-native.js": 2323, - "declared-index-spread.ts": 2660, - "deep-reference-teardown.ts": 3136, - "default-undefined-parameters.ts": 2589, - "deferred-field-updates.ts": 2347, - "deferred-registry-many.ts": 2661, - "derived-numeric-updates.ts": 1907, - "destructure-call-assignment.js": 2267, - "destructure-inferred-row-defaults.js": 2538, - "destructure-union-arrays.ts": 2379, - "dynamic-function-descriptors.js": 2763, - "error-cause-writes.js": 2954, - "error-inherited-message.mjs": 2631, - "error-inherited-name.mjs": 2285, - "error-property-writes.mjs": 2636, - "error-prototype-tostring.js": 3155, - "error-stack-frames.ts": 2206, - "error-stack-limit.ts": 2510, - "error-tostring-overrides.ts": 2305, - "error-values-inspect.ts": 2398, - "exact-index-round-trip.ts": 2801, - "expression-runtime-values.ts": 2027, - "fiber-switch-stress.ts": 2898, - "fiberless-async-ordering.ts": 2908, - "fiberless-async-unhandled.ts": 2133, - "field-assignment-values.ts": 2107, - "file-handle-values.ts": 2357, - "file-read-storage.ts": 2439, - "file-url-percent-decoding.ts": 2222, - "final-field-borrows.ts": 2890, - "for-multiple-bindings.ts": 2286, - "for-multiple-lexical-bindings.ts": 2283, - "for-of-checked-iterator.js": 3511, - "for-of-subclass-elements.ts": 2219, - "forward-generic-signatures.ts": 2294, - "fresh-array-union-layout.js": 2480, - "frozen-checked-dictionaries.mjs": 2629, - "fs-native-realpath.ts": 2351, - "fs-read-encodings.ts": 2505, - "fs-remove-readonly.ts": 2354, - "fs-write-string-bytes-union.ts": 2286, - "function-apply-value.mjs": 2558, - "function-constructor-global.mjs": 1848, - "function-constructor-kinds/main.js": 2532, - "function-custom-prototype.js": 2604, - "function-custom-to-string.mjs": 2607, - "function-object-assign.js": 2509, - "function-own-prototype/main.js": 2423, - "generator-checked-protocol.ts": 2631, - "generator-checked-return.js": 2326, - "generator-custom-delegation/main.ts": 3343, - "generator-default-return-pattern.ts": 2653, - "generator-delegation-values.ts": 2368, - "generator-inferred-date.js": 2465, - "generator-mixed-checked-channels.ts": 2662, - "generator-untyped-consumer/main.ts": 2958, - "generic-base-specializations.ts": 2073, - "generic-binding-ownership.ts": 2817, - "generic-class-js-functions/main.ts": 2051, - "generic-class-recovery.ts": 2415, - "generic-namespace-factories/main.ts": 2073, - "generic-nullable-collections.ts": 2677, - "generic-pattern-bindings.ts": 2698, - "generic-record-index.ts": 2753, - "generic-visitor-void.ts": 2405, - "global-error-subclasses.ts": 1773, - "global-runtime-probes.js": 2288, - "global-stored-probes.js": 2726, - "global-string-cache/main.js": 1889, - "global-symbol-cache/main.js": 3399, - "guarded-native-iterables.ts": 2496, - "heap-input-aliases.ts": 2746, - "heap-input-collections.ts": 2558, - "in-array-runtime-index.ts": 2579, - "indexed-assignment-values.js": 2971, - "indexed-assignment-values.ts": 1852, - "indexed-element-field-reads.ts": 2452, - "inferred-array-assignment-values.mjs": 2352, - "inferred-class-default.mjs": 2460, - "inferred-compound-values.mjs": 2473, - "inferred-conditional-class.mjs": 2635, - "inferred-error-fields.js": 2509, - "inferred-map-patterns.mjs": 2353, - "inferred-method-override.js": 2137, - "inferred-partial-destructuring.mjs": 2205, - "inferred-primitive-properties.mjs": 2135, - "inferred-record-return.mjs": 1793, - "inferred-recursive-record.mjs": 1833, - "inferred-undefined-field.mjs": 1777, - "input-lifetime-intervals.ts": 2714, - "input-lifetimes-modules/main.ts": 3258, - "instanceof-class-record-union.ts": 2400, - "integer-flow-arithmetic.ts": 3652, - "integer-loop-forms.ts": 2368, - "integer-view-control.ts": 1809, - "integer-view-numbers.ts": 2394, - "integer-view-storage.ts": 2439, - "intl-grapheme-conformance/main.ts": 3718, - "intl-grapheme.ts": 2449, - "iterator-typed-returns.ts": 3400, - "js-abort-portable.js": 2829, - "js-array-constructor.js": 3163, - "js-array-default-buffer.js": 2537, - "js-array-iterators.js": 2559, - "js-arrow-bind.cjs": 3343, - "js-buffer-callback-brand.cjs": 2262, - "js-callable-proxy.js": 3516, - "js-chained-native-results.mjs": 2641, - "js-checked-array-iterator.js": 2670, - "js-checked-array-reference.js": 2270, - "js-checked-number-negation.mjs": 1915, - "js-checked-sort-result.js": 2373, - "js-child-error-listener.cjs": 2357, - "js-cjs-callable-snapshots/main.cjs": 1981, - "js-class-added-parameters.js": 2472, - "js-class-checked-overrides.js": 2571, - "js-class-computed-fields.js": 1830, - "js-class-enumeration.js": 3296, - "js-class-field-accessor-override.js": 2567, - "js-class-fluent-overrides.js": 2822, - "js-class-late-method-values.js": 2309, - "js-class-member-dispatch.js": 3016, - "js-class-return-shapes.js": 2231, - "js-class-shadowed-methods.js": 2942, - "js-class-stored-method-receiver.js": 2382, - "js-class-subclass-properties.js": 3695, - "js-class-symbol-spread.cjs": 2704, - "js-computed-prototype-additions.js": 3142, - "js-constructor-returned-callable.js": 2605, - "js-constructor-spread.js": 2289, - "js-dataview-dispatch.js": 2273, - "js-declared-fields.cjs": 3263, - "js-default-listener-arguments.cjs": 2549, - "js-default-options/main.ts": 3044, - "js-deferred-field-initializers.js": 2121, - "js-deferred-registry-effects.js": 2381, - "js-derived-constructor-hoisting.js": 1805, - "js-dormant-array-write.js": 1888, - "js-dormant-overrides.js": 2569, - "js-expando-records.js": 2454, - "js-implicit-call-results.js": 3064, - "js-inferred-callback-exports/main.js": 3830, - "js-inferred-class-array-return.js": 2570, - "js-inferred-object-values.js": 2380, - "js-inherited-field-storage.js": 3121, - "js-inherited-parameter-abi.js": 2210, - "js-iterable-spread.js": 2950, - "js-loose-dynamic-primitives.js": 1960, - "js-map-object-seeds.js": 2610, - "js-member-increment.js": 2926, - "js-module-function-values.js": 2014, - "js-mutable-null-members.js": 2370, - "js-nested-native-descriptors.js": 2412, - "js-normalize-dispatch.js": 2793, - "js-nullish-inherited-fields.mjs": 2710, - "js-object-receiver-storage.js": 2613, - "js-object-returning-constructors.mjs": 2186, - "js-object-shared-arrays.js": 2465, - "js-omitted-typed-arguments.js": 2236, - "js-open-binding-writes.js": 1787, - "js-optional-class-fields.js": 2266, - "js-optional-member-call.js": 1883, - "js-primitive-union-addition.js": 2256, - "js-promise-all-values.js": 3079, - "js-promise-catch-handler.js": 1749, - "js-promise-finally-order.js": 1913, - "js-promise-pending-reactions.js": 2644, - "js-prototype-host-boundary.js": 2224, - "js-reflect-receivers.js": 3119, - "js-regex-record-captures.js": 2010, - "js-scalar-iterables.js": 2477, - "js-shared-method-dispatch.js": 2033, - "js-specialized-field-method.js": 2335, - "js-static-accessors.js": 2520, - "js-static-method-values.js": 2194, - "js-static-registries.cjs": 2703, - "js-super-accessor-initialization.js": 2100, - "js-uninitialized-native-fields.js": 2180, - "json-guarded-map-values.ts": 2374, - "json-output-bulk.ts": 2827, - "json-runtime-options.mjs": 1997, - "json-stringify-value.js": 2563, - "json-typed-parse-direct.ts": 2355, - "literal-switch-dispatch.ts": 2500, - "live-reference-shared-converters.ts": 2552, - "llvm-read-receiver-lifetime.ts": 2343, - "local-class-call-spreads.js": 3208, - "local-class-declaration.ts": 2486, - "local-class-evaluation.ts": 2605, - "local-class-inheritance.ts": 2327, - "local-class-lifetimes.ts": 2376, - "local-class-namespace/main.js": 2940, - "local-class-prototype-data.js": 2781, - "local-class-specialization.js": 2399, - "local-class-unknown.ts": 2443, - "local-class-values.ts": 1784, - "local-union-storage.ts": 2967, - "locale-compare-root-order.ts": 2518, - "logical-assignment-dynamic.js": 2592, - "logical-assignment-values.ts": 2497, - "logical-runtime-optional-record.ts": 2944, - "loop-reference-lifetimes.ts": 2542, - "map-checked-boundary/main.ts": 2629, - "map-checked-seed.js": 3013, - "map-number-keys-dense.ts": 2562, - "map-read-lifetimes-exits.ts": 2227, - "map-read-lifetimes.ts": 2725, - "map-seeds-and-spreads.ts": 2719, - "map-typed-array-values.ts": 2850, - "math-function-values.js": 2367, - "missing-read-lambda-results.ts": 2379, - "missing-read-narrowed-storage.ts": 2498, - "missing-read-number-conversions.ts": 2181, - "module-byte-loops.ts": 2636, - "module-fallback-functions/main.js": 2148, - "narrowed-nullish-values.ts": 2410, - "native-any-timer-callback.ts": 1834, - "native-array-borrowed-find-last.js": 2515, - "native-array-borrowed-slice.js": 2404, - "native-array-copying-methods.js": 2076, - "native-array-fill-copywithin.js": 2636, - "native-array-frozen-noops.js": 2476, - "native-array-index-boundaries.js": 1913, - "native-array-integrity.js": 2429, - "native-array-length.js": 2568, - "native-array-named-properties.js": 2390, - "native-array-prototype/main.js": 2161, - "native-array-read-lifetimes.ts": 2771, - "native-array-reduce-find-last.js": 2375, - "native-array-search-from-index.js": 1823, - "native-array-splice-coercion.js": 2296, - "native-array-splice-flat.js": 1933, - "native-buffer-coercion.js": 2389, - "native-callback-dispatch.ts": 3007, - "native-class-array-boundaries.ts": 2676, - "native-class-cache.js": 3391, - "native-class-properties.cjs": 3541, - "native-class-property-cycles.cjs": 2291, - "native-class-property-order.cjs": 1867, - "native-class-type-predicates.ts": 2386, - "native-factory-records.js": 2851, - "native-method-values.js": 2903, - "native-method-values.ts": 2495, - "native-npm-imports/main.ts": 2716, - "native-object-descriptors.js": 2717, - "native-object-for-in-minimal.js": 2536, - "native-object-property-attributes.js": 3149, - "native-object-prototype.js": 3180, - "native-property-names.ts": 1827, - "native-proxy-env.js": 3519, - "native-worker-arena-reuse.ts": 4699, - "native-worker-bounded-errors.ts": 2268, - "native-worker-buffer-consumers.ts": 2531, - "native-worker-cancel-hot.ts": 2446, - "native-worker-class-fields.ts": 2650, - "native-worker-clone-errors.ts": 2347, - "native-worker-commonjs.cjs": 2188, - "native-worker-delayed-messages.ts": 3114, - "native-worker-discarded-heaps.ts": 4430, - "native-worker-environment.ts": 3538, - "native-worker-error.ts": 2810, - "native-worker-exception-state.ts": 3938, - "native-worker-exit-listeners.ts": 2965, - "native-worker-io.ts": 3018, - "native-worker-loop-cancellation.ts": 2773, - "native-worker-message-graphs.ts": 2440, - "native-worker-messages.ts": 2911, - "native-worker-poll-exceptions.ts": 2706, - "native-worker-port-lifetime.ts": 3175, - "native-worker-process-exit.ts": 2168, - "native-worker-publish-classes.ts": 2797, - "native-worker-publish-refusals.ts": 2330, - "native-worker-published-graphs.ts": 3411, - "native-worker-references.ts": 2156, - "native-worker-roots/main.ts": 2962, - "native-worker-shared-views.ts": 2377, - "native-worker-stack-overflow.ts": 2443, - "native-worker-terminate-exception-state.ts": 3368, - "native-worker-terminate-loop.ts": 1929, - "native-worker-terminate-recursion.ts": 2935, - "native-worker-terminate-suspended.ts": 2843, - "native-worker-terminate-tested-loops.ts": 3082, - "native-worker-terminate-wait.ts": 2267, - "native-worker-typed-arrays.ts": 2361, - "nested-map-cycles.ts": 2306, - "nested-map-values.ts": 2038, - "never-returning-calls.ts": 2680, - "next-tick-commonjs-entry.cjs": 1924, - "node24-buffer-encoding-errors.ts": 2742, - "node24-buffer-encoding.ts": 2822, - "node24-crypto-kdf-errors.ts": 2607, - "node24-crypto-kdf-options.ts": 1925, - "node24-crypto-kdf.ts": 3401, - "node24-crypto-sha2.ts": 2336, - "node24-deep-equality-properties.js": 2551, - "node24-deep-equality.cjs": 2373, - "node24-deep-equality.ts": 3193, - "node24-env-files-errors.ts": 2555, - "node24-env-files.ts": 2556, - "node24-env-imports.cjs": 2518, - "node24-env-parse-errors.ts": 2083, - "node24-env-parse.ts": 2189, - "node24-esm-metadata/main.mjs": 2257, - "node24-file-url-buffer.ts": 1904, - "node24-file-url-errors.js": 2838, - "node24-file-url-options.ts": 2563, - "node24-fs-links-callbacks.cjs": 2964, - "node24-fs-links-errors.cjs": 2795, - "node24-fs-links-options.cjs": 3096, - "node24-fs-links-promise-errors.cjs": 2481, - "node24-fs-links-promises.ts": 2014, - "node24-fs-links.ts": 3060, - "node24-fs-statfs-callbacks.cjs": 2761, - "node24-fs-statfs-errors.cjs": 3068, - "node24-fs-statfs-options.cjs": 2927, - "node24-fs-statfs.ts": 2192, - "node24-fs-timestamps-callbacks.cjs": 2865, - "node24-fs-timestamps-errors.cjs": 2733, - "node24-fs-timestamps-promises.ts": 2476, - "node24-fs-timestamps-symlinks.ts": 2406, - "node24-fs-timestamps.ts": 2758, - "node24-no-error-assertions-coercion.js": 2950, - "node24-no-error-assertions.cjs": 2361, - "node24-no-error-assertions.ts": 2895, - "node24-parseargs.js": 3512, - "node24-string-decoder.ts": 2569, - "node24-style-text-environment.js": 2370, - "node24-style-text-validation.js": 2999, - "node24-style-text.cjs": 1883, - "node24-style-text.ts": 2102, - "node24-system-error-validation.js": 2003, - "node24-system-errors.cjs": 2247, - "node24-system-errors.ts": 2302, - "node24-text-codec-properties.ts": 2178, - "node24-text-encode-into.ts": 2427, - "node24-text-utilities-coercion.js": 2867, - "node24-text-utilities-validation.js": 1874, - "node24-text-utilities.cjs": 2132, - "node24-text-utilities.ts": 2215, - "node24-url-authority-coercion.js": 2529, - "node24-url-authority.ts": 2720, - "node24-url-factories.ts": 2586, - "node24-url-factory-errors.ts": 1931, - "node24-url-mutation-coercion.js": 2518, - "node24-url-mutation.ts": 2194, - "node24-util-types.cjs": 3057, - "node24-util-types.js": 1900, - "node24-util-types.ts": 2935, - "non-null-class-iteration.ts": 2350, - "nonnull-element-arguments.ts": 2545, - "nonnull-forwarded-class-values.ts": 2532, - "nullable-object-extension.mjs": 1922, - "nullish-asserted-class-arms.ts": 2485, - "nullish-assignment-values.ts": 1745, - "nullish-long-chain.ts": 2326, - "number-parse-statics.ts": 2443, - "number-predicates-unknown.ts": 2375, - "numeric-call-specialization.ts": 2588, - "object-enumeration-array-reads.ts": 1967, - "object-from-checked-entries.js": 2542, - "object-inherited-to-string.js": 2670, - "object-key-indexes.js": 2753, - "object-prototype-identity.mjs": 2064, - "object-reexport/main.js": 2482, - "object-spread-computed.ts": 2578, - "opentui-byte-queue.js": 2802, - "optional-callback-arity.ts": 2348, - "optional-class-flows.ts": 2247, - "optional-element-defaults.ts": 2052, - "optional-flag-comparisons.ts": 2527, - "optional-native-callables.js": 2309, - "optional-node-list-iteration.ts": 2316, - "optional-string-index/main.ts": 2950, - "path-to-file-url-options.ts": 2299, - "performance-presence.ts": 2043, - "primitive-and-function-descriptors.js": 2222, - "primitive-union-string.ts": 2856, - "process-builtin-values.js": 2616, - "process-constrained-memory.ts": 2105, - "process-env-computed-keys.js": 2252, - "process-hrtime.js": 2596, - "process-named-signals.cjs": 2604, - "process-uncaught-handler-throws.cjs": 2306, - "process-uncaught-loop.cjs": 2320, - "process-uncaught-module.mjs": 1832, - "process-uncaught-monitor.cjs": 2077, - "process-uncaught-rejection.cjs": 2431, - "process-uncaught-sync.cjs": 2425, - "process-version-pin.ts": 2418, - "process-versions-storage.ts": 2051, - "projected-collection-lifetimes.ts": 2409, - "promise-checked-rejections.ts": 1985, - "promise-resolve-void.ts": 2341, - "prototype-method-overrides.mjs": 4870, - "prototype-named-data-records.ts": 2513, - "record-field-presence.ts": 3025, - "record-key-order.ts": 2807, - "record-optional-json-presence.ts": 2623, - "record-presence-copies.ts": 2693, - "record-presence-delete-json.ts": 2748, - "record-unchecked-read-presence.ts": 2103, - "record-unknown-values.ts": 3450, - "reflect-own-keys.mjs": 2583, - "reflect-record-union-keys.mjs": 2454, - "reflect-typed-record-keys.ts": 1855, - "regex-callback-replacements.ts": 2492, - "regex-callback-values.js": 2733, - "regex-checked-casts.ts": 2350, - "regex-checked-storage.js": 2669, - "regex-exec-long-subject.ts": 4533, - "regex-input-lifetimes.ts": 2535, - "regex-native-matcher.ts": 3683, - "regex-optional-captures.ts": 2606, - "regex-optional-templates.ts": 2338, - "regex-split-captures.ts": 2583, - "regex-text-paths.ts": 2889, - "regexp-constructor-repeat.ts": 2351, - "regexp-optional-constructor.ts": 2315, - "regexp-string-coercion.js": 1897, - "renderer-export-dictionaries.js": 2582, - "renderer-null-state.js": 2185, - "renderer-specializations.js": 2653, - "repeat-and-typed-read-errors.ts": 2751, - "rest-optional-array-arguments.ts": 2671, - "rest-optional-elements.ts": 2289, - "return-void-through-finally.ts": 2486, - "runtime-optional-string-flows.ts": 2406, - "scalar-string-slices.ts": 2175, - "set-checked-methods.js": 2631, - "set-checked-storage.ts": 2064, - "set-iterator-seed-references.ts": 2863, - "set-iterator-seeds.ts": 2896, - "set-optional-seeds.ts": 2121, - "small-collection-transitions.ts": 2645, - "stack-depth-async-bodies.ts": 1910, - "stack-overflow-async.ts": 2447, - "stack-overflow-caught.ts": 2424, - "stack-overflow-finally.ts": 2613, - "stack-overflow-shapes.ts": 2534, - "stack-overflow-uncaught.ts": 2317, - "static-field-updates/main.ts": 2050, - "static-method-receivers.ts": 2243, - "stdio-values.mjs": 2578, - "stdio-write-errors.mjs": 1977, - "stdio-write-overrides.mjs": 2495, - "stored-native-builtins.js": 2831, - "stored-object-helpers.js": 2747, - "string-char-code-integer-loops.ts": 2495, - "string-code-points.ts": 1970, - "string-concat-number-parts.ts": 2044, - "string-construction-order.ts": 2502, - "string-lifetimes-boundaries.ts": 2481, - "string-lifetimes-evaluation.ts": 2486, - "string-lifetimes-iteration.ts": 2043, - "string-lifetimes-operations.ts": 2490, - "string-normalize.ts": 2391, - "string-pattern-replacement.ts": 3527, - "string-scan-fast-paths.ts": 2272, - "string-split-checked-separator.mjs": 2144, - "string-split-traversal.ts": 3038, - "structural-class-properties.ts": 2610, - "structured-text-boundaries.js": 2792, - "structured-text-storage.ts": 2942, - "switch-integer-dispatch.ts": 2290, - "symbol-checked-boundary/main.ts": 2273, - "symbol-class-fields.ts": 2065, - "symbol-class-fields/main.cjs": 2595, - "symbol-class-methods/main.ts": 1855, - "symbol-fields-deferred-factory.ts": 2253, - "symbol-fields-inferred.js": 2329, - "symbol-object-properties/main.js": 2835, - "synchronous-callback-lifetimes.ts": 2768, - "terminal-stream-properties.ts": 2586, - "text-codec-values/main.ts": 2158, - "text-codec-var.ts": 2182, - "text-encode-into-boundaries.ts": 1971, - "timers-clear-many.ts": 2704, - "tuple-and-string-search.ts": 2663, - "tuple-array-union.ts": 2706, - "tuple-callback-visitation.ts": 3464, - "tuple-forof-visitation.ts": 2357, - "typed-array-bulk-conversion.mjs": 3837, - "typed-array-byte-io.js": 2552, - "typed-array-checked-index.js": 2420, - "typed-array-constructor-alias.ts": 2507, - "typed-array-constructor-identity.js": 2453, - "typed-array-constructor-union.ts": 2428, - "typed-array-constructor-values.mjs": 2571, - "typed-array-dynamic-methods.js": 2604, - "typed-array-integer-widths.ts": 2747, - "typed-array-nan-coded-reads.ts": 2921, - "typed-array-numeric-import.ts": 2450, - "typed-array-present-reads.ts": 2582, - "typed-array-reversed-storage.ts": 2168, - "typed-array-unknown.ts": 2500, - "typed-collection-iterator-references.ts": 3186, - "typed-collection-iterators.ts": 2946, - "typed-collection-views/main.ts": 2523, - "typed-index-arguments.ts": 2494, - "typed-prototype-methods.ts": 2527, - "typed-rest-callables.ts": 2391, - "typed-rest-filtered-return.ts": 2578, - "typedarray-native-inputs.js": 3104, - "typeof-checked-comparison.js": 2116, - "uint8array-sort-domains.ts": 2494, - "unicode-case-paths.ts": 2356, - "unicode-process-argv.ts": 2569, - "union-discriminant-width.ts": 2670, - "union-literal-scalar-discriminants.ts": 2869, - "union-literal-slot-conversion.ts": 2792, - "union-nested-layout-discriminant.ts": 2120, - "union-optional-semantic-identity.ts": 2455, - "union-record-clone.ts": 2790, - "union-record-structural-copy.ts": 2905, - "union-reference-comparison.ts": 2401, - "unknown-array-holes.ts": 1853, - "unknown-collections.ts": 3166, - "unknown-object-enumeration.ts": 3783, - "unknown-record-views.ts": 3243, - "url-runtime-base.ts": 2584, - "utf8-span-decoding.ts": 2564, - "util-parseargs-wrapped/main.ts": 2257, - "virtual-runtime-optional-returns.ts": 2981, - "weak-map-array-buffer.ts": 2435, - "weak-map-fresh-array.js": 2341, - "weak-map-native.js": 3068, - "weak-native-class-identity.ts": 2403, - "weak-set-native.js": 2924, - "worker-class-instance-clone.ts": 3052 + "checked-any-addition.ts": 2597, + "checked-array-assignment.ts": 1938, + "checked-array-flat/main.ts": 2376, + "checked-bitwise/main.js": 2931, + "checked-builder-cycles.js": 2124, + "checked-byte-storage/main.ts": 2136, + "checked-callback-options.ts": 2655, + "checked-class-descriptors.mjs": 3730, + "checked-class-factory.mjs": 2259, + "checked-collection-iterators.ts": 3189, + "checked-collection-symbol-methods.ts": 2758, + "checked-dispatch-input-lifetimes.js": 3290, + "checked-increment/main.js": 2209, + "checked-inherited-fields.ts": 1885, + "checked-iterator-consumption.js": 3562, + "checked-numeric-arithmetic.js": 2775, + "checked-object-module-alias.js": 2993, + "checked-optional-calls.mjs": 2857, + "checked-promise-recovery.ts": 2965, + "checked-proxy-callback/main.ts": 2460, + "checked-record-constructor.ts": 2536, + "checked-renderer-defaults.js": 2974, + "checked-rest-function-adapters.js": 2402, + "checked-storage-transitions.js": 3227, + "checked-symbol-array.ts": 2138, + "checked-value-input-lifetimes.ts": 2968, + "class-accessor-returned-function.js": 2548, + "class-array-optional-return.ts": 2505, + "class-bracket-method-calls.js": 3232, + "class-brand-overload.js": 2772, + "class-callback-replacement.js": 4256, + "class-callback-storage.ts": 3103, + "class-checked-composites.ts": 2644, + "class-checked-upcast.ts": 2728, + "class-collection-insertion.ts": 4030, + "class-computed-presence.ts": 3380, + "class-computed-symbols.js": 2436, + "class-covariant-returns.ts": 3091, + "class-curried-factory.mjs": 3427, + "class-data-descriptors.js": 3815, + "class-factory-inherited-statics.mjs": 3016, + "class-factory-parameter-base.mjs": 3162, + "class-factory-record-base.mjs": 5127, + "class-factory-recursive-statics.mjs": 2561, + "class-factory-static-members.mjs": 3200, + "class-function-base/main.js": 3392, + "class-instance-constructor.js": 3735, + "class-interface-protocols.ts": 5264, + "class-interface-refinements.ts": 2054, + "class-json-checked.ts": 2470, + "class-local-function-base.mjs": 3094, + "class-method-spreads.ts": 4098, + "class-narrowed-views.ts": 1811, + "class-property-call-values.mjs": 3042, + "class-prototype-data.js": 2959, + "class-prototype-descriptor-copy.mjs": 3884, + "class-specialized-computed-base.mjs": 3695, + "class-static-data.js": 2083, + "class-subclass-assertions.ts": 2716, + "class-super-surplus-spread.mjs": 3129, + "class-symbol-accessors.ts": 2288, + "class-symbol-cache.mjs": 3599, + "class-value-constructor-exceptions.ts": 2725, + "closed-virtual-dispatch-modules/main.ts": 2752, + "closed-virtual-dispatch.ts": 3200, + "closure-nullable-union-return.ts": 2492, + "closure-union-locals.ts": 2959, + "collection-array-cycles.ts": 3095, + "collection-array-maps.ts": 3559, + "collection-array-missing.ts": 3686, + "collection-array-sets.ts": 3501, + "collection-copy-identities.ts": 2360, + "collection-data-unions.ts": 3003, + "collection-ingestion-mappers.ts": 2535, + "collection-ingestion-protocol/main.ts": 3823, + "collection-ingestion-references.ts": 2342, + "collection-ingestion.ts": 3093, + "collection-storage-copies.ts": 2080, + "collection-value-keys.ts": 2956, + "compound-field-receivers.ts": 1671, + "compound-presence-guards.ts": 3200, + "conditional-tuple-destructuring.ts": 2750, + "console-imports.cjs": 1673, + "console-native-value.js": 2807, + "const-enum-module-cycle/main.ts": 2704, + "constant-callback-dispatch.ts": 1960, + "constant-module-globals/main.ts": 1705, + "constant-number-remainders.ts": 2349, + "constructed-class-dispatch.ts": 3130, + "contextual-array-union-write.ts": 6681, + "contextual-return-layouts.ts": 3422, + "counted-loop-numbers.ts": 2709, + "counted-loop-storage.ts": 2965, + "crypto-hash-optional-input.ts": 2865, + "cycle-generations-long-lived.ts": 2572, + "cycle-growth-yield.ts": 3019, + "date-checked-native.js": 2742, + "declared-index-spread.ts": 3806, + "deep-reference-teardown.ts": 3156, + "default-undefined-parameters.ts": 2963, + "deferred-field-updates.ts": 1865, + "deferred-registry-many.ts": 3051, + "derived-numeric-updates.ts": 1958, + "destructure-call-assignment.js": 2640, + "destructure-inferred-row-defaults.js": 2122, + "destructure-union-arrays.ts": 2784, + "dynamic-function-descriptors.js": 2749, + "error-cause-writes.js": 2022, + "error-inherited-message.mjs": 2684, + "error-inherited-name.mjs": 2378, + "error-property-writes.mjs": 2676, + "error-prototype-tostring.js": 3103, + "error-stack-frames.ts": 2531, + "error-stack-limit.ts": 2338, + "error-tostring-overrides.ts": 2421, + "error-values-inspect.ts": 2394, + "exact-index-round-trip.ts": 2708, + "expression-runtime-values.ts": 2672, + "fiber-switch-stress.ts": 2404, + "fiberless-async-ordering.ts": 2698, + "fiberless-async-unhandled.ts": 2605, + "field-assignment-values.ts": 2753, + "file-handle-values.ts": 2888, + "file-read-storage.ts": 3335, + "file-url-percent-decoding.ts": 1678, + "final-field-borrows.ts": 2810, + "for-multiple-bindings.ts": 2621, + "for-multiple-lexical-bindings.ts": 2696, + "for-of-checked-iterator.js": 2735, + "for-of-subclass-elements.ts": 2538, + "forward-generic-signatures.ts": 1734, + "fresh-array-union-layout.js": 2661, + "frozen-checked-dictionaries.mjs": 2513, + "fs-native-realpath.ts": 2900, + "fs-null-byte-paths-js.cjs": 2166, + "fs-null-byte-paths.ts": 3560, + "fs-read-encodings.ts": 2192, + "fs-read-utf8-edges.ts": 3494, + "fs-read-utf8-handle-forms.ts": 1894, + "fs-remove-readonly.ts": 2005, + "fs-write-string-bytes-union.ts": 2781, + "function-apply-value.mjs": 2795, + "function-constructor-global.mjs": 2338, + "function-constructor-kinds/main.js": 3030, + "function-custom-prototype.js": 2801, + "function-custom-to-string.mjs": 1937, + "function-object-assign.js": 1754, + "function-own-prototype/main.js": 2470, + "generator-checked-protocol.ts": 2909, + "generator-checked-return.js": 3084, + "generator-custom-delegation/main.ts": 5038, + "generator-default-return-pattern.ts": 2685, + "generator-delegation-values.ts": 1962, + "generator-inferred-date.js": 3181, + "generator-mixed-checked-channels.ts": 2887, + "generator-untyped-consumer/main.ts": 2216, + "generic-base-specializations.ts": 2930, + "generic-binding-ownership.ts": 2565, + "generic-class-js-functions/main.ts": 2055, + "generic-class-recovery.ts": 2723, + "generic-namespace-factories/main.ts": 2103, + "generic-nullable-collections.ts": 2282, + "generic-pattern-bindings.ts": 2536, + "generic-record-index.ts": 2488, + "generic-visitor-void.ts": 2848, + "global-accumulator-loops.ts": 2271, + "global-error-subclasses.ts": 1850, + "global-runtime-probes.js": 3085, + "global-stored-probes.js": 3029, + "global-string-cache/main.js": 2487, + "global-symbol-cache/main.js": 2631, + "guarded-native-iterables.ts": 2969, + "heap-input-aliases.ts": 2864, + "heap-input-collections.ts": 2900, + "in-array-runtime-index.ts": 3065, + "indexed-assignment-values.js": 2826, + "indexed-assignment-values.ts": 1639, + "indexed-element-field-reads.ts": 1506, + "inferred-array-assignment-values.mjs": 2520, + "inferred-class-default.mjs": 2339, + "inferred-compound-values.mjs": 2708, + "inferred-conditional-class.mjs": 2429, + "inferred-error-fields.js": 2383, + "inferred-map-patterns.mjs": 2476, + "inferred-method-override.js": 2284, + "inferred-partial-destructuring.mjs": 1972, + "inferred-primitive-properties.mjs": 2268, + "inferred-record-return.mjs": 2543, + "inferred-recursive-record.mjs": 2822, + "inferred-undefined-field.mjs": 2615, + "input-lifetime-intervals.ts": 2188, + "input-lifetimes-modules/main.ts": 2672, + "instanceof-class-record-union.ts": 2441, + "integer-flow-arithmetic.ts": 1990, + "integer-loop-forms.ts": 2426, + "integer-view-control.ts": 2085, + "integer-view-numbers.ts": 2088, + "integer-view-storage.ts": 2560, + "intl-grapheme-conformance/main.ts": 4354, + "intl-grapheme.ts": 1787, + "iterator-typed-returns.ts": 2556, + "js-abort-portable.js": 3289, + "js-array-constructor.js": 3326, + "js-array-default-buffer.js": 2785, + "js-array-iterators.js": 2367, + "js-arrow-bind.cjs": 3832, + "js-buffer-callback-brand.cjs": 2996, + "js-callable-proxy.js": 3619, + "js-chained-native-results.mjs": 2794, + "js-checked-array-iterator.js": 2235, + "js-checked-array-reference.js": 3562, + "js-checked-number-negation.mjs": 2819, + "js-checked-sort-result.js": 2743, + "js-child-error-listener.cjs": 2228, + "js-cjs-callable-snapshots/main.cjs": 2256, + "js-class-added-parameters.js": 2567, + "js-class-checked-overrides.js": 2547, + "js-class-computed-fields.js": 2943, + "js-class-enumeration.js": 3714, + "js-class-field-accessor-override.js": 3000, + "js-class-fluent-overrides.js": 2749, + "js-class-late-method-values.js": 2358, + "js-class-member-dispatch.js": 3594, + "js-class-return-shapes.js": 3435, + "js-class-shadowed-methods.js": 3639, + "js-class-stored-method-receiver.js": 2943, + "js-class-subclass-properties.js": 3662, + "js-class-symbol-spread.cjs": 2503, + "js-computed-prototype-additions.js": 2456, + "js-constructor-returned-callable.js": 2517, + "js-constructor-spread.js": 3593, + "js-dataview-dispatch.js": 2188, + "js-declared-fields.cjs": 4540, + "js-default-listener-arguments.cjs": 2448, + "js-default-options/main.ts": 3104, + "js-deferred-field-initializers.js": 2710, + "js-deferred-registry-effects.js": 2361, + "js-derived-constructor-hoisting.js": 2306, + "js-dormant-array-write.js": 2104, + "js-dormant-overrides.js": 1741, + "js-expando-records.js": 2473, + "js-implicit-call-results.js": 2893, + "js-inferred-callback-exports/main.js": 4125, + "js-inferred-class-array-return.js": 2816, + "js-inferred-object-values.js": 2369, + "js-inherited-field-storage.js": 3308, + "js-inherited-parameter-abi.js": 2238, + "js-iterable-spread.js": 2086, + "js-loose-dynamic-primitives.js": 2810, + "js-map-object-seeds.js": 2592, + "js-member-increment.js": 3352, + "js-module-function-values.js": 2994, + "js-mutable-null-members.js": 2723, + "js-nested-native-descriptors.js": 2548, + "js-normalize-dispatch.js": 2929, + "js-nullish-inherited-fields.mjs": 2189, + "js-object-receiver-storage.js": 2175, + "js-object-returning-constructors.mjs": 2945, + "js-object-shared-arrays.js": 2935, + "js-omitted-typed-arguments.js": 2736, + "js-open-binding-writes.js": 2167, + "js-optional-class-fields.js": 3219, + "js-optional-member-call.js": 3110, + "js-primitive-union-addition.js": 2549, + "js-promise-all-values.js": 3527, + "js-promise-catch-handler.js": 2649, + "js-promise-finally-order.js": 2445, + "js-promise-pending-reactions.js": 2595, + "js-prototype-host-boundary.js": 2723, + "js-reflect-receivers.js": 3391, + "js-regex-record-captures.js": 3115, + "js-scalar-iterables.js": 2746, + "js-shared-method-dispatch.js": 2796, + "js-specialized-field-method.js": 2049, + "js-static-accessors.js": 3053, + "js-static-method-values.js": 2375, + "js-static-registries.cjs": 2790, + "js-super-accessor-initialization.js": 2104, + "js-uninitialized-native-fields.js": 1764, + "json-guarded-map-values.ts": 3144, + "json-output-bulk.ts": 2572, + "json-runtime-options.mjs": 2583, + "json-stringify-value.js": 2182, + "json-typed-parse-direct.ts": 3644, + "json-typed-parse-index-signatures.ts": 4122, + "json-typed-parse-optional-members.ts": 3273, + "json-typed-parse-union-members.ts": 3078, + "literal-switch-dispatch.ts": 2252, + "live-reference-shared-converters.ts": 3470, + "llvm-read-receiver-lifetime.ts": 3118, + "local-class-call-spreads.js": 2490, + "local-class-declaration.ts": 2302, + "local-class-evaluation.ts": 2915, + "local-class-inheritance.ts": 2396, + "local-class-lifetimes.ts": 2780, + "local-class-namespace/main.js": 3248, + "local-class-prototype-data.js": 3273, + "local-class-specialization.js": 2054, + "local-class-unknown.ts": 1964, + "local-class-values.ts": 2059, + "local-union-storage.ts": 2500, + "locale-compare-root-order.ts": 2609, + "logical-assignment-dynamic.js": 2892, + "logical-assignment-values.ts": 2287, + "logical-runtime-optional-record.ts": 2390, + "loop-reference-lifetimes.ts": 2959, + "map-checked-boundary/main.ts": 2651, + "map-checked-seed.js": 1821, + "map-get-set-fusion.ts": 3131, + "map-number-keys-dense.ts": 2480, + "map-read-lifetimes-exits.ts": 2004, + "map-read-lifetimes.ts": 2956, + "map-seeds-and-spreads.ts": 2807, + "map-typed-array-values.ts": 2864, + "math-function-values.js": 2704, + "missing-read-lambda-results.ts": 2964, + "missing-read-narrowed-storage.ts": 2975, + "missing-read-number-conversions.ts": 2247, + "module-byte-loops.ts": 2710, + "module-fallback-functions/main.js": 2953, + "narrowed-nullish-values.ts": 2689, + "native-any-timer-callback.ts": 2256, + "native-array-borrowed-find-last.js": 2331, + "native-array-borrowed-slice.js": 2738, + "native-array-copying-methods.js": 2547, + "native-array-fill-copywithin.js": 2422, + "native-array-frozen-noops.js": 1940, + "native-array-index-boundaries.js": 1855, + "native-array-integrity.js": 3078, + "native-array-length.js": 2779, + "native-array-named-properties.js": 2991, + "native-array-prototype/main.js": 1536, + "native-array-read-lifetimes.ts": 3338, + "native-array-reduce-find-last.js": 2328, + "native-array-search-from-index.js": 2430, + "native-array-splice-coercion.js": 2633, + "native-array-splice-flat.js": 2555, + "native-buffer-coercion.js": 2993, + "native-callback-dispatch.ts": 3551, + "native-class-array-boundaries.ts": 2938, + "native-class-cache.js": 4207, + "native-class-properties.cjs": 3301, + "native-class-property-cycles.cjs": 2085, + "native-class-property-order.cjs": 2417, + "native-class-type-predicates.ts": 2597, + "native-factory-records.js": 2167, + "native-method-values.js": 3675, + "native-method-values.ts": 2504, + "native-npm-imports/main.ts": 3572, + "native-object-descriptors.js": 2795, + "native-object-for-in-minimal.js": 2689, + "native-object-property-attributes.js": 2700, + "native-object-prototype.js": 2600, + "native-property-names.ts": 2409, + "native-proxy-env.js": 3746, + "native-worker-arena-reuse.ts": 4764, + "native-worker-bounded-errors.ts": 3072, + "native-worker-buffer-consumers.ts": 2989, + "native-worker-cancel-hot.ts": 2633, + "native-worker-class-fields.ts": 3458, + "native-worker-clone-errors.ts": 2734, + "native-worker-commonjs.cjs": 2159, + "native-worker-delayed-messages.ts": 2169, + "native-worker-discarded-heaps.ts": 5523, + "native-worker-environment.ts": 3190, + "native-worker-error.ts": 2740, + "native-worker-exception-state.ts": 4140, + "native-worker-exit-listeners.ts": 2056, + "native-worker-io.ts": 2596, + "native-worker-loop-cancellation.ts": 2554, + "native-worker-message-graphs.ts": 3182, + "native-worker-messages.ts": 2651, + "native-worker-poll-exceptions.ts": 3212, + "native-worker-port-lifetime.ts": 3033, + "native-worker-process-exit.ts": 2692, + "native-worker-publish-classes.ts": 4065, + "native-worker-publish-refusals.ts": 3039, + "native-worker-published-graphs.ts": 3663, + "native-worker-references.ts": 2640, + "native-worker-roots/main.ts": 3080, + "native-worker-shared-views.ts": 3041, + "native-worker-stack-overflow.ts": 2862, + "native-worker-terminate-exception-state.ts": 3985, + "native-worker-terminate-loop.ts": 2725, + "native-worker-terminate-recursion.ts": 3128, + "native-worker-terminate-suspended.ts": 2867, + "native-worker-terminate-tested-loops.ts": 3161, + "native-worker-terminate-wait.ts": 1905, + "native-worker-typed-arrays.ts": 2971, + "nested-map-cycles.ts": 2802, + "nested-map-values.ts": 3022, + "never-returning-calls.ts": 2411, + "next-tick-commonjs-entry.cjs": 2251, + "node24-buffer-encoding-errors.ts": 2393, + "node24-buffer-encoding.ts": 2789, + "node24-crypto-kdf-errors.ts": 2833, + "node24-crypto-kdf-options.ts": 2131, + "node24-crypto-kdf.ts": 4066, + "node24-crypto-sha2.ts": 1593, + "node24-deep-equality-properties.js": 2924, + "node24-deep-equality.cjs": 2596, + "node24-deep-equality.ts": 3235, + "node24-env-files-errors.ts": 2781, + "node24-env-files.ts": 2586, + "node24-env-imports.cjs": 1729, + "node24-env-parse-errors.ts": 2642, + "node24-env-parse.ts": 2636, + "node24-esm-metadata/main.mjs": 2627, + "node24-file-url-buffer.ts": 2669, + "node24-file-url-errors.js": 2467, + "node24-file-url-options.ts": 3030, + "node24-fs-links-callbacks.cjs": 3015, + "node24-fs-links-errors.cjs": 2843, + "node24-fs-links-options.cjs": 3229, + "node24-fs-links-promise-errors.cjs": 2844, + "node24-fs-links-promises.ts": 2107, + "node24-fs-links.ts": 1958, + "node24-fs-statfs-callbacks.cjs": 2203, + "node24-fs-statfs-errors.cjs": 2705, + "node24-fs-statfs-options.cjs": 2846, + "node24-fs-statfs.ts": 2174, + "node24-fs-timestamps-callbacks.cjs": 2972, + "node24-fs-timestamps-errors.cjs": 1969, + "node24-fs-timestamps-promises.ts": 2959, + "node24-fs-timestamps-symlinks.ts": 2931, + "node24-fs-timestamps.ts": 1989, + "node24-no-error-assertions-coercion.js": 3207, + "node24-no-error-assertions.cjs": 1972, + "node24-no-error-assertions.ts": 2214, + "node24-parseargs.js": 4158, + "node24-string-decoder.ts": 2635, + "node24-style-text-environment.js": 2062, + "node24-style-text-validation.js": 3237, + "node24-style-text.cjs": 2491, + "node24-style-text.ts": 2829, + "node24-system-error-validation.js": 2660, + "node24-system-errors.cjs": 2361, + "node24-system-errors.ts": 2897, + "node24-text-codec-properties.ts": 2383, + "node24-text-encode-into.ts": 2992, + "node24-text-utilities-coercion.js": 2902, + "node24-text-utilities-validation.js": 2997, + "node24-text-utilities.cjs": 2432, + "node24-text-utilities.ts": 1910, + "node24-url-authority-coercion.js": 2861, + "node24-url-authority.ts": 2689, + "node24-url-factories.ts": 1863, + "node24-url-factory-errors.ts": 1955, + "node24-url-mutation-coercion.js": 2400, + "node24-url-mutation.ts": 2663, + "node24-util-types.cjs": 3712, + "node24-util-types.js": 2869, + "node24-util-types.ts": 3395, + "non-null-class-iteration.ts": 2220, + "nonnull-element-arguments.ts": 2568, + "nonnull-forwarded-class-values.ts": 2603, + "nullable-object-extension.mjs": 2408, + "nullish-asserted-class-arms.ts": 2116, + "nullish-assignment-values.ts": 2517, + "nullish-long-chain.ts": 2430, + "number-parse-statics.ts": 1887, + "number-predicates-unknown.ts": 1974, + "numeric-call-specialization.ts": 2627, + "object-enumeration-array-reads.ts": 2586, + "object-from-checked-entries.js": 2775, + "object-inherited-to-string.js": 2674, + "object-key-indexes.js": 2909, + "object-prototype-identity.mjs": 2317, + "object-reexport/main.js": 2625, + "object-spread-computed.ts": 2429, + "opentui-byte-queue.js": 3139, + "optional-callback-arity.ts": 2294, + "optional-class-flows.ts": 2613, + "optional-element-defaults.ts": 2793, + "optional-flag-comparisons.ts": 2714, + "optional-native-callables.js": 2344, + "optional-node-list-iteration.ts": 2344, + "optional-string-index/main.ts": 2788, + "path-to-file-url-options.ts": 2568, + "performance-presence.ts": 2450, + "primitive-and-function-descriptors.js": 2677, + "primitive-union-string.ts": 1777, + "process-builtin-values.js": 3974, + "process-constrained-memory.ts": 1850, + "process-env-computed-keys.js": 2019, + "process-hrtime.js": 2975, + "process-named-signals.cjs": 2191, + "process-uncaught-handler-throws.cjs": 2460, + "process-uncaught-loop.cjs": 2411, + "process-uncaught-module.mjs": 1942, + "process-uncaught-monitor.cjs": 1718, + "process-uncaught-rejection.cjs": 2645, + "process-uncaught-sync.cjs": 2436, + "process-version-pin.ts": 1717, + "process-versions-storage.ts": 2502, + "projected-collection-lifetimes.ts": 2791, + "promise-checked-rejections.ts": 2434, + "promise-resolve-void.ts": 2330, + "prototype-method-overrides.mjs": 4995, + "prototype-named-data-records.ts": 2858, + "rc-last-use-moves.ts": 2819, + "rc-private-array-writes.ts": 2121, + "record-field-presence.ts": 3356, + "record-key-order.ts": 2943, + "record-optional-json-presence.ts": 2861, + "record-presence-copies.ts": 2372, + "record-presence-delete-json.ts": 3243, + "record-unchecked-read-presence.ts": 2717, + "record-unknown-values.ts": 3976, + "reflect-own-keys.mjs": 2238, + "reflect-record-union-keys.mjs": 2626, + "reflect-typed-record-keys.ts": 2852, + "regex-callback-replacements.ts": 2111, + "regex-callback-values.js": 2464, + "regex-checked-casts.ts": 2160, + "regex-checked-storage.js": 2310, + "regex-exec-long-subject.ts": 4567, + "regex-exec-result-arrays.ts": 3123, + "regex-fs-text-surfaces.ts": 2847, + "regex-input-lifetimes.ts": 2221, + "regex-native-matcher.ts": 4414, + "regex-optional-captures.ts": 3043, + "regex-optional-templates.ts": 2695, + "regex-split-captures.ts": 2413, + "regex-text-paths.ts": 3078, + "regexp-constructor-repeat.ts": 2829, + "regexp-optional-constructor.ts": 2162, + "regexp-string-coercion.js": 2219, + "renderer-export-dictionaries.js": 2331, + "renderer-null-state.js": 1751, + "renderer-specializations.js": 2860, + "repeat-and-typed-read-errors.ts": 2689, + "rest-optional-array-arguments.ts": 2219, + "rest-optional-elements.ts": 2503, + "return-void-through-finally.ts": 2582, + "runtime-optional-string-flows.ts": 2381, + "scalar-string-slices.ts": 2256, + "set-checked-methods.js": 2598, + "set-checked-storage.ts": 2088, + "set-iterator-seed-references.ts": 2454, + "set-iterator-seeds.ts": 3016, + "set-optional-seeds.ts": 2563, + "small-collection-transitions.ts": 2967, + "speculative-integer-globals.ts": 2480, + "speculative-integer-loops.ts": 3219, + "speculative-integer-reads.ts": 2852, + "stack-depth-async-bodies.ts": 2421, + "stack-overflow-async.ts": 1922, + "stack-overflow-caught.ts": 2542, + "stack-overflow-finally.ts": 2607, + "stack-overflow-shapes.ts": 3083, + "stack-overflow-uncaught.ts": 2465, + "stackless-async-concurrency.ts": 2441, + "stackless-async-context.ts": 2934, + "stackless-async-exceptions.ts": 2936, + "stackless-async-ordering.ts": 2618, + "stackless-async-unhandled.ts": 2477, + "static-field-updates/main.ts": 2461, + "static-method-receivers.ts": 1849, + "stdio-values.mjs": 2236, + "stdio-write-errors.mjs": 2342, + "stdio-write-overrides.mjs": 2002, + "stored-native-builtins.js": 2708, + "stored-object-helpers.js": 2808, + "stream-dynamic-entry-kinds.cjs": 3015, + "stream-dynamic-entry-kinds.ts": 1582, + "stream-encoded-from-entries.cjs": 3058, + "stream-encoded-from-entries.ts": 2590, + "string-char-code-integer-loops.ts": 2802, + "string-code-points.ts": 2658, + "string-concat-number-parts.ts": 2339, + "string-construction-order.ts": 2902, + "string-field-append.ts": 3251, + "string-lifetimes-boundaries.ts": 2858, + "string-lifetimes-evaluation.ts": 1805, + "string-lifetimes-iteration.ts": 2235, + "string-lifetimes-operations.ts": 2468, + "string-normalize.ts": 2348, + "string-pattern-replacement.ts": 1662, + "string-scan-fast-paths.ts": 2133, + "string-split-checked-separator.mjs": 2285, + "string-split-traversal.ts": 1939, + "structural-class-properties.ts": 3139, + "structured-text-boundaries.js": 3111, + "structured-text-storage.ts": 2912, + "switch-integer-dispatch.ts": 2264, + "symbol-checked-boundary/main.ts": 2800, + "symbol-class-fields.ts": 2364, + "symbol-class-fields/main.cjs": 2507, + "symbol-class-methods/main.ts": 2255, + "symbol-fields-deferred-factory.ts": 2386, + "symbol-fields-inferred.js": 2386, + "symbol-object-properties/main.js": 3085, + "synchronous-callback-lifetimes.ts": 2296, + "terminal-stream-properties.ts": 2094, + "text-codec-values/main.ts": 2338, + "text-codec-var.ts": 2708, + "text-encode-into-boundaries.ts": 2679, + "timers-clear-many.ts": 2665, + "tuple-and-string-search.ts": 2567, + "tuple-array-union.ts": 2150, + "tuple-callback-visitation.ts": 3321, + "tuple-forof-visitation.ts": 2818, + "typed-array-bulk-conversion.mjs": 4061, + "typed-array-byte-io.js": 3073, + "typed-array-checked-index.js": 2572, + "typed-array-constructor-alias.ts": 2243, + "typed-array-constructor-identity.js": 2693, + "typed-array-constructor-union.ts": 2646, + "typed-array-constructor-values.mjs": 2380, + "typed-array-dynamic-methods.js": 2112, + "typed-array-integer-widths.ts": 2661, + "typed-array-nan-coded-reads.ts": 3761, + "typed-array-numeric-import.ts": 2783, + "typed-array-present-reads.ts": 3074, + "typed-array-reversed-storage.ts": 2650, + "typed-array-unknown.ts": 2830, + "typed-collection-iterator-references.ts": 3315, + "typed-collection-iterators.ts": 3098, + "typed-collection-views/main.ts": 1720, + "typed-index-arguments.ts": 2531, + "typed-prototype-methods.ts": 3386, + "typed-rest-callables.ts": 2393, + "typed-rest-filtered-return.ts": 2745, + "typedarray-native-inputs.js": 3102, + "typeof-checked-comparison.js": 2558, + "uint8array-sort-domains.ts": 2057, + "unicode-case-paths.ts": 2222, + "unicode-process-argv.ts": 2491, + "union-discriminant-width.ts": 2970, + "union-literal-scalar-discriminants.ts": 3053, + "union-literal-slot-conversion.ts": 2820, + "union-nested-layout-discriminant.ts": 1976, + "union-optional-semantic-identity.ts": 3464, + "union-record-clone.ts": 2368, + "union-record-structural-copy.ts": 3130, + "union-reference-comparison.ts": 2882, + "unknown-array-holes.ts": 1889, + "unknown-collections.ts": 3133, + "unknown-object-enumeration.ts": 4341, + "unknown-record-views.ts": 3288, + "url-runtime-base.ts": 2471, + "utf8-span-decoding.ts": 2821, + "util-parseargs-wrapped/main.ts": 2971, + "virtual-runtime-optional-returns.ts": 3001, + "weak-map-array-buffer.ts": 1951, + "weak-map-fresh-array.js": 2498, + "weak-map-native.js": 3238, + "weak-native-class-identity.ts": 2197, + "weak-set-native.js": 2814, + "worker-class-instance-clone.ts": 3421 }, "san": { - "001-hello.ts": 38244, - "002-log-args.ts": 31270, - "100-number-format.ts": 45195, - "1000-json-stringify-basics.ts": 46332, - "1001-json-escapes-unicode.ts": 4513, - "1002-json-parse-cast.ts": 35521, - "1003-json-parse-unions.ts": 3512, - "1004-json-parse-errors.ts": 3903, - "1005-json-nested.ts": 3425, - "1006-json-fs-config.ts": 3347, - "1007-json-rc-stress.ts": 34305, - "1008-json-null-arms.ts": 3422, - "1009-json-optional-fields.ts": 4004, - "101-arithmetic.ts": 4655, - "1010-json-stringify-space.ts": 45417, - "1011-json-unknown-typeof.ts": 4001, - "102-comparisons.ts": 3774, - "1020-async-basics.ts": 3697, - "1021-async-ordering.ts": 3078, - "1022-async-exceptions.ts": 3780, - "1023-async-rc-stress.ts": 3889, - "1024-async-pending-exit.ts": 3389, - "1025-async-promise-capture.ts": 42296, - "1026-throw-promise.ts": 4482, - "1027-async-return-promise.ts": 3534, - "1028-async-return-record-literals.ts": 3843, - "1029-async-eager-chains.ts": 4890, - "103-ternary.ts": 3470, - "104-ternary-empty-arrays.ts": 7056, - "1050-comptime-tables.ts": 4643, - "1051-comptime-strings.ts": 42895, - "1052-comptime-records.ts": 44375, - "1053-comptime-json.ts": 4497, - "1054-comptime-modules/main.ts": 4326, - "110-number-radix.ts": 3100, - "111-record-entries.ts": 7961, - "1110-math-members.ts": 3457, - "1111-math-random.ts": 4321, - "1113-string-methods.ts": 23286, - "1114-string-unicode-island.ts": 45718, - "1115-parse-globals.ts": 3277, - "1116-island-static-mix.ts": 3738, - "1117-typeof-static-union.ts": 4351, - "1118-object-spread-conditional.ts": 3602, - "1119-switch-union.ts": 4833, - "112-class-descriptor-key.js": 4674, - "1121-infinity-number-tostring.ts": 4470, - "1122-any-captures.ts": 7125, - "1124-union-narrowed-retag.ts": 3484, - "113-promise-checked-exits.ts": 4562, - "114-live-record-delete.ts": 3572, - "115-array-compound.js": 6457, - "116-text-decoder-runtime.js": 33483, - "117-weak-cache-cycle.js": 5789, - "118-fs-stored-callbacks.cjs": 52946, - "119-native-patterns.js": 6101, - "1200-regex-test-basics.ts": 47554, - "1201-regex-replace.ts": 3959, - "1202-regex-substitutions.ts": 3855, - "1203-regex-split.ts": 31517, - "1204-regex-empty-unicode.ts": 4662, - "1205-regex-rc-stress.ts": 36658, - "1300-errors-basics.ts": 4354, - "1301-errors-subclass.ts": 4687, - "1302-errors-typed-catch.ts": 4229, - "1303-errors-rc-stress.ts": 3431, - "1304-errors-uncaught.ts": 3763, - "1305-errors-async-rejections.ts": 4254, - "1306-errors-runtime-instances.ts": 4140, - "1350-path-normalize-join.ts": 4224, - "1351-path-parts.ts": 4167, - "1352-path-resolve-relative.ts": 4382, - "1353-os-basics.ts": 4007, - "1354-builtin-bare-specifiers.ts": 3999, - "1355-url-parse.ts": 3346, - "1356-url-file-bridge.ts": 3553, - "1357-fsp-roundtrip.ts": 4325, - "1358-crypto-random.ts": 3398, - "1359-json-module/main.ts": 4414, - "1360-spawn-sync.ts": 4387, - "1361-spawn-events.ts": 4260, - "1362-spawn-timers.ts": 9971, - "1363-spawn-unhandled-error.ts": 3744, - "1364-union-truthiness.ts": 3907, - "1365-union-logical.ts": 4258, - "1366-union-equality.ts": 3058, - "1367-destructuring.ts": 5461, - "1368-constructor-functions.ts": 3781, - "1369-promise-union.ts": 3864, - "1370-spread.ts": 3429, - "1371-union-template-tostring.ts": 3265, - "1372-loose-null-tests.ts": 3885, - "1373-union-array-arms.ts": 3435, - "140-bitwise-operators.ts": 4527, - "1400-typedarray-basics.ts": 5395, - "1401-typedarray-slice-set.ts": 3626, - "1402-buffer-encodings.ts": 4871, - "1403-buffer-fs.ts": 4268, - "1404-zlib-crypto-bytes.ts": 5331, - "1405-bytes-unions-arrays.ts": 3838, - "1406-dataview-mp4.ts": 3661, - "1407-dataview-bounds.ts": 5553, - "1408-string-indexing.ts": 5392, - "1409-typedarray-integer-loops.ts": 4558, - "1420-number-statics.ts": 3886, - "1421-number-parse-strings.ts": 4644, - "1422-date-iso.ts": 4015, - "1423-text-codec.ts": 38476, - "1424-fs-options.ts": 3473, - "1425-stdin-tty.ts": 4093, - "1426-stdin-read.ts": 3982, - "1427-fromcharcode-lastindexof.ts": 2946, - "1428-settled-await-order.ts": 3794, - "1429-promise-catch-finally.ts": 4465, - "1430-promise-race.ts": 4414, - "1431-caught-tostring.ts": 2971, - "1432-destructured-params.ts": 3941, - "1433-filter-narrow.ts": 3907, - "1434-async-never.ts": 3465, - "1435-math-spread.ts": 3652, - "1436-default-undef-param.ts": 3877, - "1437-pad-default.ts": 3475, - "1438-promise-all.ts": 7297, - "1440-interval-basics.ts": 4144, - "1441-interval-clear-cross.ts": 7176, - "1442-interval-throw.ts": 3609, - "1443-signal-handlers.ts": 7600, - "1444-exit-listeners.ts": 4768, - "1445-exit-process-exit.ts": 5403, - "1446-exit-uncaught.ts": 4319, - "1447-stdin-closed-events.ts": 4894, - "1448-stream-columns.ts": 4014, - "1450-incdec-expression.ts": 3639, - "1451-instanceof-uint8array-unknown.ts": 3654, - "1452-return-through-finally.ts": 4057, - "1453-pmap-settled.ts": 4531, - "1454-nonnull-narrow-and-fcc-bytes.ts": 3459, - "1455-lambda-union-return-adoption.ts": 3583, - "1460-console-error-warn.ts": 3484, - "1461-process-pid-getuid-kill.ts": 3345, - "1462-exec-sync.ts": 5307, - "1463-timeout-unref.ts": 3316, - "1464-env-writes.ts": 3946, - "1465-env-value.ts": 3554, - "1466-child-containers.ts": 4064, - "1467-string-match.ts": 3329, - "1468-exec-path.ts": 3588, - "1469-remove-listener.ts": 5747, - "1470-child-lifecycle.ts": 2972, - "1471-child-unref.ts": 8472, - "1472-errno-code.ts": 3388, - "1473-promisify-execfile.ts": 5200, - "1474-string-decoder.ts": 3868, - "1475-readline-closed-stdin.ts": 3587, - "1476-assign-expression.ts": 4319, - "1477-in-expressions.ts": 3951, - "1478-promise-reject.ts": 4331, - "1479-destructuring-assign.ts": 3821, - "1480-os-network-interfaces.ts": 4186, - "1481-string-case-static.ts": 2782, - "1482-spawnsync-error.ts": 2721, - "1483-array-slice.ts": 52661, - "1520-fs-wider-surface.ts": 3691, - "1520-string-split-static.ts": 3432, - "1521-fs-lstat-lock.ts": 3409, - "1521-string-trim-pad-static.ts": 4078, - "1522-parseint-static.ts": 3461, - "1522-spawnsync-options.ts": 5773, - "1523-isnan-floor-static.ts": 3552, - "1523-spawn-options.ts": 5294, - "1524-atomics-sleep-static.ts": 4028, - "1524-catch-narrowing.ts": 2626, - "1525-child-exit-signal.ts": 3477, - "1525-unknown-typeof-validation.ts": 2889, - "1526-set-spread.ts": 3802, - "1527-logical-mixed-operands.ts": 4773, - "1528-delete-records-env.ts": 3621, - "1529-class-with-statics.ts": 3381, - "1530-array-push-variadic.ts": 2970, - "1530-spread-override-completion.ts": 2499, - "1531-delete-optional-fields.ts": 3623, - "1531-process-arch-versions.ts": 2740, - "1532-array-splice-shift.ts": 4204, - "1532-union-shared-field-read.ts": 2834, - "1533-bool-equality.ts": 4076, - "1533-path-platform-namespaces.ts": 3406, - "1534-crypto-hash-chain.ts": 4097, - "1534-union-as-arm-cast.ts": 45787, - "1535-spawn-fd-stdio.ts": 3840, - "1535-union-param-defaults.ts": 4358, - "1536-destructuring-defaults.ts": 3812, - "1536-string-array-sweep.ts": 3859, - "1537-chalk-hybrid/main.ts": 4683, - "1537-os-release-spawnsync-stdio.ts": 2674, - "1538-await-promiselike-return.ts": 2642, - "1538-math-static-scalar.ts": 3735, - "1539-readonly-set-map.ts": 3299, - "1539-unknown-truthiness.ts": 3045, - "1540-os-userinfo.ts": 4119, - "1540-void-statement.ts": 2941, - "1541-fs-readdir-dirent.ts": 5432, - "1541-union-keyed-reads.ts": 4646, - "1542-map-promise-values.ts": 33000, - "1542-record-literal-into-union.ts": 2885, - "1543-rest-destructuring.ts": 3500, - "1543-set-server-handles.ts": 6770, - "1544-dyn-json-reads.ts": 4863, - "1544-string-matchall.ts": 4770, - "1545-spread-order-and-optional.ts": 4536, - "1546-union-element-reads.ts": 4536, - "1547-computed-key-fold.ts": 3960, - "1548-boolean-condition-forms.ts": 4649, - "1549-array-isarray-unions.ts": 4084, - "1550-param-defaults-func-set.ts": 3020, - "1551-dyn-receiver-methods.ts": 3403, - "1552-exec-options-record.ts": 2877, - "1553-truthy-hof-predicates.ts": 3895, - "1554-caught-into-unknown.ts": 3417, - "1555-index-spread-into-declared.ts": 4534, - "1556-union-retag-width-arms.ts": 3587, - "1557-url-host.ts": 2566, - "1558-any-joins-and-dyn-validation.ts": 33883, - "1559-conditional-spread-index-merge.ts": 3282, - "1560-forof-homogeneous-tuples.ts": 3680, - "1561-forof-strings.ts": 2878, - "1561-promise-then.ts": 3851, - "1562-optional-chain-tails.ts": 4618, - "1562-spawn-conditional-spread.ts": 4043, - "1563-forof-iterator-projections.ts": 3930, - "1563-string-raw-fold.ts": 3100, - "1564-fs-watch.ts": 4051, - "1564-string-raw.ts": 3075, - "1565-spawn-pipe-streams.ts": 3895, - "1565-union-element-join.ts": 4167, - "1566-child-duck-interface.ts": 3875, - "1567-server-close-override.ts": 3304, - "1568-x509-fingerprint.ts": 2839, - "1569-fsp-mkdir-unlink-chmod.ts": 3012, - "1570-child-unref-kill-reffed.ts": 9046, - "1571-optional-call-tostring-tail.ts": 26380, - "1571-stdin-set-raw-mode-non-tty.ts": 4151, - "1572-promise-reject-all-tuple.ts": 4201, - "1572-x509-validity-date-gettime.ts": 3944, - "1573-promisify-execfile-env-spread.ts": 4480, - "1573-tdz-scalar-forward-capture.ts": 2862, - "1574-dyn-optional-method-number-keys.ts": 3192, - "1574-promise-all-tuple-literal.ts": 4410, - "1575-unknown-assert-into-record.ts": 3424, - "1576-width-coercions.ts": 4144, - "1577-url-hostname.ts": 4030, - "1578-exec-input-optional.ts": 4028, - "1579-matchall-index.ts": 4108, - "1580-exec-env-conditional-spread.ts": 3516, - "1581-declare-const-read.ts": 3997, - "1582-timer-sleep-resolve.ts": 4177, - "1583-loops-and-stream-captures.ts": 4450, - "1584-union-field-unassigned.ts": 3964, - "1585-union-field-conditional-ctor.ts": 3070, - "1586-derived-field-before-super-init.ts": 4073, - "1590-js-unannotated.js": 4738, - "1591-js-closures.js": 3535, - "1592-js-classes.js": 7400, - "1593-js-jsdoc-records.js": 4695, - "1594-js-async.js": 3836, - "1595-js-island-gap/main.js": 3139, - "1596-cjs-modules/main.js": 3283, - "1597-mjs-graph/main.mjs": 3605, - "1598-cjs-builtin-require/main.js": 2977, - "1599-js-uncaught-throw.js": 3196, - "1600-assert-passing.ts": 4333, - "1601-assert-fail-exit.ts": 3725, - "1602-assert-caught-error.ts": 3373, - "1603-assert-scalar-messages.ts": 5128, - "1604-assert-deep-structures.ts": 4364, - "1605-assert-import-forms.ts": 4371, - "1606-assert-strict-module.ts": 2984, - "1607-assert-throws-match.ts": 4301, - "1608-cjs-assert/main.js": 3820, - "1609-assert-async.ts": 2695, - "1610-path-win32-full.ts": 2757, - "1611-url-file-bridge-neutral.ts": 4375, - "1612-cjs-module-globals.cjs": 3706, - "1613-cjs-esm-proxy-named/main.mjs": 3290, - "1614-js-fence-dodges.cjs": 2861, - "1615-cjs-export-shapes/main.cjs": 4723, - "1616-cjs-esm-lexer-invisible/main.mjs": 2991, - "1617-cjs-esm-lexer-visible/main.mjs": 3860, - "1618-cjs-esm-poisoned-tail/main.mjs": 3236, - "1619-cjs-esm-reexport-invisible/main.mjs": 3244, - "1620-cjs-require-effects-order/main.js": 2604, - "1621-cjs-require-cache-hit/main.js": 3531, - "1622-cjs-require-conditional/main.js": 3501, - "1623-cjs-require-diamond/main.js": 4051, - "1624-cjs-require-dir-mid-file/main.js": 2658, - "1625-cjs-require-lazy-fn/main.js": 3635, - "1626-cjs-require-mjs/main.js": 2942, - "1627-mjs-import-cjs-requires/main.mjs": 3236, - "1628-checked-dynamic-builtin-args.cjs": 2968, - "1629-require-main-filename.cjs": 2826, - "1630-inspect-scalars.ts": 3908, - "1630-rmsync-retry-options.cjs": 3797, - "1631-inspect-arrays.ts": 4065, - "1632-inspect-records.ts": 4843, - "1633-inspect-map-set.ts": 3133, - "1634-inspect-classes.ts": 3805, - "1635-inspect-buffer.ts": 3530, - "1636-util-format.ts": 2945, - "1637-inspect-dyn.ts": 3297, - "1638-inspect-cjs.cjs": 3549, - "1639-versions-openssl-probe.ts": 3544, - "1640-fd-read-decode.ts": 2932, - "1641-string-search.ts": 3476, - "1642-object-fromentries-rows.ts": 3699, - "1643-metadata-dyn-return.cjs": 4074, - "1644-ee-basics.ts": 4205, - "1645-ee-extends.ts": 3512, - "1646-ee-once-remove.ts": 3828, - "1647-ee-meta-events.ts": 3673, - "1648-ee-error-event.ts": 3271, - "1649-ee-names-counts.ts": 3057, - "1650-ee-prepend.ts": 3927, - "1651-ee-max-listeners.ts": 4648, - "1652-ee-snapshot.ts": 4220, - "1653-ee-cjs.cjs": 3230, - "1654-ee-namespace.ts": 3631, - "1655-spawnsync-neutral.ts": 5393, - "1656-execsync-neutral.ts": 3546, - "1657-spawn-async-neutral.ts": 3320, - "1660-buffer-read-write-num.ts": 4303, - "1661-buffer-encodings-full.ts": 3877, - "1662-string-decoder-encodings.ts": 3423, - "1663-buffer-compare-search-fill.ts": 4770, - "1664-dyn-fn-boundary.cjs": 3405, - "1665-dyn-fn-mustcall/main.cjs": 2819, - "1666-dyn-fn-identity.ts": 2740, - "1667-dyn-fn-not-callable.cjs": 3303, - "1668-dyn-fn-throws.cjs": 3745, - "1669-symbol-identity.ts": 3617, - "1670-symbol-registry.ts": 4207, - "1671-symbol-typeof.ts": 3400, - "1672-symbol-containers.ts": 3581, - "1673-symbol-cjs.cjs": 3624, - "1674-symbol-inspect.ts": 2758, - "1676-func-array-surface.ts": 2900, - "1677-emitter-listeners.ts": 4932, - "1678-emitter-dyn-listeners.cjs": 3287, - "1679-console-dyn.js": 3576, - "1680-assert-bytes.ts": 3903, - "1681-assert-funcs.ts": 3918, - "1685-stream-readable-basics.ts": 6503, - "1686-stream-readable-paused.ts": 6965, - "1687-stream-readable-flow-control.ts": 3669, - "1688-stream-writable-basics.ts": 3711, - "1689-stream-writable-async-drain.ts": 6004, - "1690-stream-duplex.ts": 6220, - "1691-stream-transform.ts": 6193, - "1692-stream-pipe.ts": 6662, - "1693-stream-pipe-backpressure.ts": 3700, - "1694-stream-destroy.ts": 3259, - "1695-stream-props.ts": 4843, - "1696-stream-read-inside-read.ts": 3524, - "1697-stream-tick-vs-timer.ts": 3256, - "1698-stream-uncaught-error.ts": 4826, - "1699-stream-callback-shapes.ts": 3791, - "1700-mustcall-common/main.cjs": 4329, - "1701-mustcall-exit-report/main.cjs": 3995, - "1702-dyn-proto-dispatch.cjs": 4694, - "1703-arguments-rest-props.cjs": 3485, - "1710-cjs-export-class/main.js": 2945, - "1711-cjs-export-single-values/main.js": 3527, - "1712-field-incdec.ts": 3301, - "1713-js-dyn-fields.js": 3702, - "1720-assert-throws-shape.ts": 3665, - "1721-assert-throws-regex-class.ts": 3205, - "1722-assert-rejects.ts": 3941, - "1723-assert-does-not-reject.ts": 3991, - "1724-assert-iferror.ts": 2922, - "1725-assert-symbols.ts": 4117, - "1726-promise-with-resolvers.ts": 3773, - "1727-assert-throws-shape-exit.ts": 4180, - "1730-countdown-symbol-keys/main.js": 3717, - "1731-symbol-field-shapes.cjs": 4041, - "1732-symbol-field-cross-module/main.js": 3671, - "1740-stream-extends-readable.ts": 5413, - "1741-stream-extends-writable.ts": 6469, - "1742-stream-extends-duplex-transform.ts": 6437, - "1743-stream-extends-vt-dispatch.ts": 7212, - "1744-stream-set-encoding.ts": 3635, - "1745-stream-encoding-js.cjs": 2973, - "1746-stream-for-await.ts": 4707, - "1747-stream-for-await-js.cjs": 4902, - "1750-http-agent-options.ts": 7371, - "1751-options-record-stance.ts": 4112, - "1760-surplus-args-drop.cjs": 3672, - "1761-emitter-special-event-names.cjs": 5508, - "1770-assert-dyn-strict.ts": 4072, - "1771-assert-dyn-deep.ts": 3521, - "1772-assert-dyn-js.cjs": 3744, - "1773-assert-dyn-exit.ts": 3156, - "1780-http-res-surface.ts": 7173, - "1781-http-server-shapes.cjs": 3500, - "1790-computed-key-folds.ts": 3641, - "1791-searchparams-core.ts": 3206, - "1792-searchparams-encoding.ts": 3500, - "1793-searchparams-iteration.ts": 3620, - "1794-searchparams-url-live.ts": 3114, - "1795-dyn-handle-request.cjs": 6764, - "1796-dyn-handle-body.cjs": 6226, - "1797-dyn-handle-socket.cjs": 3886, - "1798-dyn-handle-typed-box.ts": 6248, - "1800-immediate-basics.ts": 3211, - "1801-immediate-handle.ts": 3455, - "1802-immediate-unref-exit.ts": 3001, - "1803-timeout-refresh.ts": 3714, - "1804-timers-module.ts": 3580, - "1805-timer-callback-args.ts": 3293, - "1806-timer-delay-trunc.ts": 3354, - "1810-stream-options-const-record.ts": 4095, - "1811-stream-option-value-callbacks.cjs": 3113, - "1812-stream-super-options-forwarding.cjs": 3239, - "1813-stream-finished.ts": 3753, - "1814-stream-pipeline.cjs": 3633, - "1815-stream-state-reads.cjs": 3723, - "1820-static-block-basics.ts": 3496, - "1821-static-block-order.ts": 3121, - "1822-static-block-js.js": 2926, - "1823-static-instance-method-names.ts": 2971, - "1824-for-of-destructuring-defaults.ts": 3389, - "1825-exhaustive-typeof-switch.ts": 2558, - "1826-settimeout-arguments-callback.js": 3292, - "1830-enum-numeric-basics.ts": 3721, - "1831-enum-string-const-reverse.ts": 3386, - "1832-enum-modules/main.ts": 3491, - "1835-var-basics.ts": 3090, - "1836-var-loop-capture.ts": 4227, - "1837-var-undefined-hoisting.ts": 3129, - "1838-var-modules/main.ts": 3442, - "1839-var-js/main.cjs": 2943, - "1840-jsdoc-import-type-only/main.js": 3153, - "1850-overload-basics.ts": 3527, - "1851-overload-return-narrowing.ts": 3485, - "1852-overload-class-members.ts": 3165, - "1853-overload-modules/main.ts": 3369, - "1854-ambient-declare-fn.ts": 3339, - "1855-ambient-declare-fn-uncaught.ts": 2825, - "1870-unit-type-values.ts": 3760, - "1871-empty-array-never.ts": 2995, - "1872-template-tostring-composite.ts": 3281, - "1880-json-declared-field-order.ts": 3669, - "1881-default-anon/main.ts": 3229, - "1882-default-cjs-interop/main.ts": 3282, - "1883-default-exports/main.ts": 3775, - "1890-ns-imports/main.ts": 3324, - "1891-ns-reexport/main.ts": 3059, - "1940-class-values-basics.ts": 3481, - "1941-class-values-registry.ts": 3018, - "1942-class-expressions.ts": 2837, - "1943-class-statics-expanded.ts": 3294, - "1944-class-values-modules/main.ts": 3634, - "1950-generic-fn-values.ts": 3713, - "1951-generic-classes-basics.ts": 3449, - "1952-generic-class-statics-values.ts": 3863, - "1953-generic-class-hierarchy.ts": 3771, - "1954-generic-modules/main.ts": 3506, - "1960-namespace-basics.ts": 3039, - "1961-namespace-nested.ts": 2879, - "1962-namespace-classes.ts": 3820, - "1963-namespace-aliases.ts": 2943, - "1964-namespace-type-only.ts": 3637, - "1965-namespace-ambient.ts": 3549, - "1966-namespace-modules/main.ts": 3116, - "1967-namespace-alias-typeonly.ts": 2879, - "1968-namespace-import-eq-snapshot.ts": 3284, - "1970-decorators-basics.ts": 3029, - "1971-decorators-rebinding.ts": 3079, - "1972-decorators-throwing.ts": 2634, - "1973-decorators-ambient.ts": 3508, - "1980-primitive-proto-statics.ts": 3768, - "1981-date-utc.ts": 3681, - "1982-freeze-resolve-passthrough.ts": 3352, - "1983-array-tuple-surfaces.ts": 3130, - "1990-labels-basics.ts": 3662, - "1991-for-in-loops.ts": 4312, - "1992-small-syntax.ts": 3036, - "200-strings.ts": 3188, - "2000-generic-methods-basic.ts": 3233, - "2001-generic-methods-generic-class.ts": 3654, - "2002-generic-methods-inheritance.ts": 3883, - "2003-generic-methods-object-literal.ts": 4002, - "2004-generic-methods-statics.ts": 2781, - "201-templates.ts": 3259, - "2010-generators-basics.ts": 2930, - "2011-generators-forof.ts": 3439, - "2012-generators-return-throw.ts": 3077, - "2013-generators-sent-values.ts": 3157, - "2014-generators-values.ts": 3230, - "2015-generators-yieldstar.ts": 2691, - "2016-generators-rc-stress.ts": 3408, - "2017-generators-async.ts": 3645, - "2018-generators-uncaught.ts": 3372, - "2019-generators-loops.ts": 3684, - "2020-generic-value-bindings.ts": 4814, - "2021-generic-value-binding-modules/main.ts": 2613, - "2022-width-index-capture.ts": 4066, - "2023-width-readonly.ts": 3988, - "2024-width-array-elems.ts": 3088, - "2025-width-union-compose.ts": 3148, - "2026-width-spread.ts": 3721, - "2030-width-nested.ts": 3956, - "2031-width-tuples.ts": 3454, - "2032-cjs-export-assigned-class-expression/main.cjs": 3771, - "2033-property-assigned-class-extends.cjs": 2857, - "2035-ternary-array-retag.cjs": 3742, - "2036-evolving-array-decl.cjs": 3733, - "2037-fn-decl-hoisting.cjs": 3504, - "2038-evolving-array-js.cjs": 4258, - "2040-any-bindings.ts": 3664, - "2040-mixin-heritage.ts": 3192, - "2041-any-params-returns.ts": 3362, - "2041-mixin-values.ts": 3893, - "2042-any-flow-loops.ts": 3770, - "2042-mixin-modules/main.ts": 3144, - "2043-any-dom-values.ts": 3779, - "2043-mixin-rc-stress.ts": 4190, - "2044-vtable-sibling-slots.ts": 4054, - "2045-objlit-accessors-basic.ts": 3443, - "2045-parameter-properties.ts": 3049, - "2046-abstract-classes.ts": 4183, - "2046-objlit-accessors-effects.ts": 3215, - "2047-objlit-accessors-shapes.ts": 3091, - "2047-optional-class-fields.ts": 4146, - "2050-dynamic-import-own-module/main.ts": 3451, - "2051-dynamic-import-then/main.ts": 3601, - "2052-dynamic-import-self.ts": 3591, - "2053-typeof-static-fold.ts": 3479, - "2054-destructuring-island-source.ts": 3225, - "2060-empty-tuple.ts": 3198, - "2070-computed-key-folds.ts": 3432, - "2071-integer-key-enumeration-order.ts": 3897, - "2072-expando-function-members.ts": 3830, - "2073-destructuring-assignment.ts": 3540, - "2074-island-destructuring.ts": 3784, - "2075-index-signature-runtime-keys.ts": 2791, - "2080-destructuring-defaults.ts": 3781, - "2081-destructuring-rest.ts": 3728, - "2082-destructuring-assignment.ts": 3505, - "2085-destructuring-heads-rest-params.ts": 3490, - "2087-destructuring-for-heads.ts": 3190, - "2090-index-signature-number-keys.ts": 2803, - "2091-index-signature-string-intersection.ts": 2723, - "2092-package-imports/main.ts": 2857, - "2093-timers-promises.ts": 4034, - "2094-diagnostics-channel.ts": 3375, - "2095-js-catch-unknown.js": 3448, - "2096-os-type.ts": 3784, - "2097-js-evolving-globals.js": 3531, - "210-string-methods.ts": 3602, - "2100-stream-default-hwm.ts": 3572, - "2101-dyn-param-defaults.ts": 2799, - "2102-empty-pattern-decls.ts": 3305, - "2105-computed-key-static-folds.ts": 3458, - "2106-comma-expressions.ts": 3662, - "211-string-unicode.ts": 2722, - "2110-top-object-types.ts": 2930, - "2111-json-stringify-unknown.ts": 2894, - "2112-array-at-findlast.ts": 3347, - "2113-string-index-methods.js": 2954, - "212-string-aliasing-append.ts": 2936, - "2120-package-self-import/main.ts": 2637, - "2121-esm-cycle-inert-backedge/main.ts": 2688, - "2123-ambient-import-crash/main.ts": 2830, - "2124-imports-field-wildcard/main.ts": 2779, - "2140-uri-component-codecs.ts": 3028, - "2160-dc-tracing-channel.cjs": 3125, - "2161-js-object-literal-identity.cjs": 3710, - "2162-js-dyn-destructure.cjs": 2745, - "2163-js-selfref-const.cjs": 4243, - "2164-js-then-dyn-handler.cjs": 4454, - "2165-js-throw-dyn.cjs": 3859, - "2166-cjs-getter-this/main.cjs": 3481, - "2170-island-array-exits.ts": 5249, - "2171-island-json-stringify.ts": 3408, - "2172-island-regexp-boundary.ts": 4656, - "2190-new-object-and-string-wrappers.ts": 2892, - "2191-uri-encoders.ts": 2460, - "2192-object-default-tostring.ts": 3152, - "2193-discarded-stdlib-reads.ts": 3436, - "2194-ambient-undef-chains.ts": 3329, - "2195-require-missing-package/main.mjs": 3396, - "2196-island-computed-key-chain.ts": 4364, - "2210-dyn-promise-crossing.cjs": 3412, - "2211-dc-trace-promise.cjs": 4496, - "2212-unhandled-rejection-listener.cjs": 3503, - "2213-async-local-storage.cjs": 3304, - "2214-dc-bind-store.cjs": 4372, - "2215-process-emit-warning-exit.cjs": 4385, - "2240-width-class-into-record.ts": 3816, - "2241-width-record-into-class.ts": 3107, - "2242-width-statics-into-record.ts": 3187, - "2243-width-assert-satisfies-shapes.ts": 3725, - "2250-tagged-templates.ts": 2802, - "2252-class-iterators.ts": 4024, - "2253-union-coercions.ts": 2969, - "2260-http2-constants.cjs": 2611, - "2280-builtin-namespace-destructure.cjs": 2964, - "2281-domexception-atob-btoa.cjs": 3116, - "2282-queue-microtask.cjs": 3672, - "2283-structured-clone.cjs": 3661, - "2284-regexp-constructor.cjs": 2921, - "2285-iferror-dyn.cjs": 2815, - "2286-dyn-object-walks.cjs": 2814, - "2300-dyn-record-spread-and-keyed-access.cjs": 3340, - "2301-cjs-export-table-dom-attach.cjs": 2994, - "2310-process-next-tick.ts": 3462, - "2311-next-tick-js-callbacks.js": 3541, - "2312-stream-underscore-assign.ts": 4210, - "2313-stream-underscore-assign-js.cjs": 3281, - "2314-process-introspection.ts": 4007, - "2320-await-unit.ts": 2773, - "2321-emitter-static-setmax.cjs": 3576, - "2322-dyn-array-sort.cjs": 2683, - "2323-timer-callback-returns.ts": 3611, - "2330-tls-server-runtime-options.cjs": 22007, - "2331-tls-server-options-typed.ts": 22550, - "2350-nan-global.ts": 3586, - "2351-async-methods.ts": 3496, - "2352-void-coercions.ts": 2875, - "2353-decorators-member-ambient.ts": 2855, - "2354-decorators-expression-ambient.ts": 2445, - "2360-tuple-to-array.ts": 3725, - "2361-assign-index-record.ts": 3918, - "2362-execsync-inherit.ts": 3204, - "2363-nullish-retag.ts": 3277, - "2364-in-runtime-key.ts": 3653, - "2365-dyn-into-island.ts": 2967, - "2366-string-well-formed.ts": 3530, - "2367-regexp-escape.ts": 3537, - "2368-set-methods.ts": 3321, - "2369-promise-try.ts": 3477, - "2370-group-by.ts": 3834, - "2371-iterator-helpers.ts": 3503, - "2380-buffer-module-named-import.ts": 3337, - "2381-builtin-default-imports.js": 3386, - "2382-cycle-two-decl/main.ts": 2540, - "2383-cycle-assertdoc/main.js": 3635, - "2384-cycle-mixed-bindings/main.ts": 2680, - "2385-builtin-reexport-facade/main.ts": 2415, - "2386-string-to-chars.ts": 3358, - "2387-tonumber-argv.ts": 3189, - "2388-tonumber-grammar-zoo.ts": 2478, - "2389-tonumber-unary-plus.ts": 3505, - "2390-dot-requires/main.cjs": 3502, - "2391-default-builtin-imports/main.ts": 3560, - "2392-block-guard-alias-scope.ts": 2811, - "2393-loop-exit-guard-narrow.ts": 3396, - "2394-loop-narrow-containment.ts": 3368, - "2395-while-cond-guard.ts": 2736, - "2396-born-narrowed-decl.ts": 3324, - "2397-branch-kill-merge.ts": 2593, - "2398-switch-arm-kill.ts": 3348, - "2399-reassign-kill-polarity.ts": 3637, - "240-stdout-write.ts": 3882, - "2400-kill-return-edge.ts": 3195, - "2401-kill-break-staging.ts": 3449, - "2402-labeled-break-kill.ts": 2813, - "2403-kill-continue-backedge.ts": 3428, - "2404-kill-throw-catch.ts": 2824, - "2405-sibling-arm-narrow.ts": 2442, - "2406-switch-clause-sibling-narrow.ts": 2665, - "2407-infinite-loop-seal.ts": 3312, - "2408-loop-terminality-reopen.ts": 3281, - "2409-loop-body-return-not-terminal.ts": 3145, - "2410-stacked-cases-terminality.ts": 3627, - "2411-exhaustive-switch-terminality.ts": 3158, - "2412-dowhile-guard-trailing-test.ts": 3265, - "2413-dowhile-kill-renarrow.ts": 2701, - "2414-dowhile-continue-kill.ts": 3317, - "2415-dowhile-break-trailing-test.ts": 3362, - "2416-spread-ternary-positions.ts": 3467, - "2417-ternary-local-inference.ts": 3368, - "2418-wrapped-ternary-arms.ts": 3310, - "2419-selector-ternary-union.ts": 3702, - "2420-nullish-null-identity.ts": 2553, - "2421-float-lane-inference.ts": 3344, - "2422-ieee-div-rem-corners.ts": 3186, - "2423-param-null-reassign.ts": 3025, - "2424-ternary-miss-first-narrowing.ts": 3552, - "2425-elseif-head-exit-narrow.ts": 3257, - "2426-default-snapshot-mutable/main.ts": 3423, - "2427-perf-hooks-now.ts": 3049, - "2428-field-redeclare-inherited.ts": 3585, - "2429-destructure-class-instance.ts": 2694, - "2430-empty-literal-unknown-field.js": 3401, - "2431-primitive-ctor-values.ts": 2884, - "2432-generic-member-fields-async.ts": 5845, - "2433-as-const-command-tables.ts": 3180, - "2434-deferred-init-fields.ts": 3249, - "2435-loose-same-kind-equality.ts": 3363, - "2440-console-inspect-args.ts": 5418, - "2441-console-process-argv.ts": 3041, - "2442-union-literal-arm-widening.ts": 2555, - "2443-union-literal-shadow-narrowing.ts": 3302, - "2444-union-literal-reducer-spread.ts": 3618, - "2445-math-minmax-nary.ts": 2645, - "2446-performance-global.ts": 3980, - "2447-island-boundary-slots/main.ts": 6217, - "2448-entries-null-arms-regex-arrays.ts": 3545, - "2450-private-instance-methods.ts": 2931, - "2451-private-fields.ts": 3694, - "2452-private-statics.ts": 2965, - "2453-private-accessors.ts": 3478, - "2454-private-generator-methods.ts": 3697, - "2455-private-brand-checks.ts": 3515, - "2456-private-async-methods.ts": 3535, - "2457-private-members.js": 2780, - "2460-qs-parse-grammar.ts": 4534, - "2461-qs-parse-options.ts": 4115, - "2462-qs-stringify.ts": 3434, - "2463-qs-escape-unescape.ts": 3311, - "2464-qs-require-forms.cjs": 2821, - "2470-mockable-module-shape.js": 2978, - "2471-record-keyed-write-hasown.js": 2970, - "2472-string-regexp-union.ts": 3393, - "2473-option-table-widths.js": 3653, - "2474-island-literal-forms.ts": 3643, - "2475-variadic-wrapper-island.js": 3606, - "2476-map-regex-values.ts": 3711, - "2480-recursive-record-tree.ts": 3376, - "2481-mutual-recursive-records.ts": 3699, - "2482-recursive-union-tree.ts": 3347, - "2483-recursive-record-cycles.ts": 2764, - "2484-json-stringify-circular.ts": 3845, - "2485-inspect-circular-refs.ts": 3694, - "2486-recursive-record-boundaries.ts": 3988, - "2487-recursive-deep-equal.ts": 3416, - "2488-ast-walker.ts": 3100, - "2490-find-miss-null-compare.ts": 3107, - "2491-strict-unit-compare-no-arm.ts": 2820, - "2492-loose-null-compare-unions.ts": 3683, - "2493-switch-unit-cases.ts": 3703, - "2494-no-arm-compare-effects.ts": 3089, - "2500-net-autosel-timeout.ts": 3775, - "2510-dyn-evolving-array-map.ts": 3265, - "2511-dyn-evolving-array-filter-foreach.ts": 2885, - "2512-dyn-evolving-array-mixed-push.ts": 3639, - "2520-private-statics-class-name-calls.ts": 3155, - "2521-private-statics-class-expression.ts": 3520, - "2522-private-statics-decorated.ts": 3673, - "2523-private-statics-aliased-class.ts": 3795, - "2530-object-destructuring-decl.ts": 2869, - "2531-array-tuple-destructuring-decl.ts": 3168, - "2532-param-destructuring-options.ts": 2906, - "2533-forof-destructuring.ts": 2840, - "2534-object-rest-decl.ts": 3199, - "2535-destructuring-assign-basics.ts": 3816, - "2536-destructuring-assign-nested.ts": 3047, - "2537-destructuring-assign-member-targets.ts": 3590, - "2538-destructuring-assign-class-source.ts": 3544, - "2539-class-instance-rest.ts": 3764, - "2540-accessor-destructuring-defaults.ts": 3201, - "2541-destructuring-eval-order.ts": 2670, - "2550-generics-keyof-pick.ts": 3947, - "2551-generics-value-aliases.ts": 3227, - "2552-generics-iface-methods.ts": 3318, - "2553-generics-signature-bindings.ts": 3442, - "2554-generics-frontier-mix.ts": 3344, - "2555-generics-keyof-writes.ts": 3448, - "2556-crypto-introspection.ts": 3351, - "2556-width-hybrid-shapes.ts": 3462, - "2557-tls-ca-store.ts": 4438, - "2557-width-field-lifts.ts": 4453, - "2558-index-signature-func-values.ts": 3590, - "2558-rejection-events.cjs": 3641, - "2559-index-signature-container-values.ts": 4066, - "2560-arraybuffer-dataview-set.ts": 3614, - "2561-object-is.ts": 3391, - "2562-intl-numberformat-en-us.ts": 3241, - "2563-stream-promises-pipeline.ts": 3490, - "2564-stream-promises-finished.ts": 2994, - "2565-stream-promises-js.cjs": 2616, - "2566-promise-reject-dyn-reason.js": 3548, - "2567-rest-spread-forward.js": 3292, - "2568-rest-spread-forward-dynamic.js": 3367, - "2569-upcast-identity.ts": 2553, - "2570-buffer-arg-validation.cjs": 5779, - "2571-searchparams-arg-validation.cjs": 3913, - "2572-readable-emitted-readable-flag.cjs": 3556, - "2573-fs-url-arg-ladders.cjs": 3502, - "2574-emitter-max-listeners-ladders.cjs": 2895, - "2575-string-destructuring-decl.ts": 3433, - "2576-string-destructuring-assign.ts": 2984, - "2577-builtin-global-destructuring.js": 3466, - "2578-jsval-into-unknown-rows.ts": 3398, - "2579-jsval-object-param-crossing.js": 3294, - "2580-jsval-routed-keyed-ops.js": 3298, - "2581-jsval-routed-calls.js": 3542, - "2582-jsval-object-statics.js": 3509, - "2582-jsval-routed-keyed-ops.js": 3136, - "2583-dyn-nullish-coalesce.js": 2976, - "2583-jsval-routed-calls.js": 2950, - "2584-jsval-object-statics.js": 3305, - "2584-union-dyn-collapse.ts": 2970, - "2585-dyn-nullish-coalesce.js": 3632, - "2585-unknown-array.ts": 3809, - "2586-object-assign-spread.js": 4084, - "2587-array-entries-forof.ts": 2633, - "2588-array-entries-chains.ts": 4097, - "2589-object-create-null.cjs": 3112, - "2590-object-create-dynamic.js": 4279, - "2591-ambient-generic-traps.ts": 3216, - "2592-ambient-trap-uncaught.ts": 3198, - "2593-generic-inert-bindings.ts": 3007, - "2594-nullish-generic-bindings.ts": 3321, - "2595-fs-arg-ladders.cjs": 3930, - "2596-net-arg-ladders.cjs": 3528, - "2597-dgram-send-ladders.cjs": 4536, - "2598-tls-arg-ladders.cjs": 4142, - "2599-stream-arg-ladders.cjs": 5465, - "2600-dyn-keyed-write-harness.js": 2800, - "2601-dyn-keyed-write-ops.js": 3269, - "2602-dyn-array-destructure.js": 3207, - "2603-island-keyed-write-dyn.js": 3608, - "2604-cycle-classes-mutual/main.ts": 3410, - "2605-cycle-three-module/main.ts": 2592, - "2606-dynamic-import-cycle/main.ts": 2445, - "2608-regex-named-groups.ts": 3896, - "2609-regex-named-replace.ts": 3215, - "2610-regex-named-matchall.ts": 3887, - "2611-regex-named-groups-js.cjs": 3523, - "2613-for-init-uninitialized-let.ts": 3167, - "2614-trap-binding-later-writes.ts": 3345, - "2615-nullish-field-record-binding.ts": 2720, - "2616-js-collect-probe-defers.js": 3534, - "2617-enum-static-field-import/main.ts": 3068, - "2618-ee-emit-override.ts": 3915, - "2619-ee-override-chain.ts": 2567, - "2620-ee-override-once-order.ts": 3439, - "2621-ee-override-error-throw.ts": 3265, - "2622-ee-override-filter.ts": 3339, - "2623-ee-job-queue.ts": 3586, - "2624-ee-override-js.cjs": 2637, - "2625-bytes-views.ts": 2847, - "2626-stream-event-names.ts": 3436, - "2627-stream-ticks-are-nextticks.ts": 4048, - "2628-stream-push-encodings.cjs": 3219, - "2629-stream-consumers.ts": 4523, - "2630-stream-consumers-errors.ts": 3353, - "2631-create-require/main.ts": 2869, - "2632-dyn-jsval-iterate.js": 3938, - "2633-island-promise-crossing.js": 3898, - "2634-stream-pipeline-arg-ladders.cjs": 2829, - "2635-trap-binding-unmappable-written.ts": 3493, - "2636-trap-binding-ambient-rooted-rewrite.ts": 3155, - "2637-create-require-bare/main.ts": 3093, - "2638-http-dyn-res-compat.cjs": 7897, - "2639-http-dyn-req-pause.cjs": 4028, - "2640-net-dyn-socket-compat.cjs": 3877, - "2641-http-agent-surface.cjs": 6286, - "2642-http-agent-maxsockets.cjs": 4681, - "2643-or-default-retag.ts": 3292, - "2644-http-client-url-argument.ts": 3256, - "2645-https-client-url-argument.ts": 24258, - "2646-top-level-await.ts": 3392, - "2647-top-level-await-modules/main.ts": 3047, - "2648-top-level-await-rejection.ts": 3150, - "2649-top-level-await-pending.ts": 3160, - "2650-top-level-await-self-import.ts": 2440, - "2651-top-level-await-pending-unhandled.ts": 2762, - "2652-top-level-await-dynamic/main.ts": 3760, - "2653-top-level-await-rejection-stops-loop.ts": 2631, - "2654-top-level-await-unrelated-rejection.ts": 2643, - "2655-top-level-await-cycle/main.ts": 3098, - "2656-top-level-await-cycle-order/main.ts": 3167, - "2657-top-level-await-cycle-dynamic/main.ts": 2957, - "2658-top-level-await-sync-completion/main.ts": 3318, - "2659-top-level-await-dynamic-cycle/main.ts": 2585, - "2660-top-level-await-cycle-rejection/main.ts": 3210, - "2661-top-level-await-dynamic-runtime-root/main.ts": 3366, - "2662-top-level-await-cycle-external-wait/main.ts": 3005, - "2663-top-level-await-dependency-errors/main.ts": 2847, - "2664-top-level-await-same-checkpoint-rejection.ts": 3116, - "2665-top-level-await-unhandled-listener-liveness.ts": 2875, - "2666-array-to-sorted.ts": 7633, - "2668-stored-number-array-iterator.ts": 3253, - "2669-array-copying-methods.ts": 3549, - "2670-uint8array-copy-iterate.ts": 3853, - "2671-array-copying-js.cjs": 3682, - "2672-http-request-response-callback.ts": 4143, - "2673-top-level-await-implicit-module.ts": 3247, - "2674-top-level-for-await-implicit-module.ts": 3134, - "2675-create-require-nested-esm.js": 2364, - "2675-process-self-reexec.ts": 2727, - "2676-indexed-read-strict-equality.ts": 2731, - "2676-record-clone-overrides.ts": 2957, - "2676-top-level-await-ambiguous/main.ts": 2732, - "2677-runtime-optional-closure.ts": 4013, - "2677-top-level-await-module-scope/main.ts": 3413, - "2678-date-instances.ts": 2682, - "2678-large-string-sparse-index.ts": 3695, - "2678-util-parseargs.ts": 6509, - "2679-util-parseargs-cjs.cjs": 4674, - "2680-util-parseargs-default.ts": 2968, - "2681-util-parseargs-dynamic.js": 4805, - "2682-fs-rename.ts": 3870, - "2683-filter-truthy-predicate.ts": 3057, - "2683-fs-rename-js.cjs": 3194, - "2684-filter-no-predicate-dyn.cjs": 2886, - "2684-fs-rename-abort.ts": 4187, - "2685-array-unshift-reverse.ts": 3336, - "2685-fs-write-sync.ts": 3018, - "2686-fs-file-handle.ts": 4533, - "2687-fsp-write-file-options.ts": 3468, - "2687-process-write-args.ts": 4056, - "2688-fs-stats-disk-fields.ts": 3885, - "2689-http-server-timeout-properties.ts": 3928, - "2690-https-server-timeout-option.ts": 21635, - "2691-retained-lowering-record-order.ts": 4394, - "2692-inline-record-assert-index.ts": 4260, - "2692-string-accumulation.ts": 2769, - "2693-math-constants.ts": 2825, - "2700-array-sort-complexity.ts": 3067, - "2700-http-static-trailers.ts": 3428, - "2700-wasi-core.ts": 3839, - "2701-array-sort-snapshot.ts": 3995, - "2701-http-static-trailer-wire.ts": 3237, - "2701-import-meta/main.mjs": 2794, - "2702-http-static-trailer-end.ts": 3525, - "2702-type-import-link-static/main.ts": 3217, - "2702-uint8array-to-sorted.ts": 3838, - "2703-array-sparse-sort.ts": 7138, - "2703-type-import-link-static-reexport/main.ts": 2989, - "2704-array-sparse-to-sorted.ts": 7251, - "2704-type-import-link-static-success/main.ts": 3249, - "2705-array-sparse-sort-append.ts": 6240, - "2705-type-import-link-dynamic/main.ts": 2760, - "2706-array-search-missing-needle.ts": 3091, - "2706-type-import-link-dynamic-success/main.ts": 3330, - "2707-array-search-huge-sparse.ts": 45179, - "2707-type-import-link-static-default-reexport/main.ts": 2758, - "2708-type-import-link-dynamic/main.ts": 4132, - "2720-array-read-parity.ts": 3456, - "2721-array-nested-missing-receiver.ts": 3322, - "2750-array-sparse-foundation.ts": 3816, - "2751-buffer-concat-sparse-list.ts": 3043, - "2752-array-optional-stores.ts": 3548, - "2753-array-optional-method-values.ts": 3422, - "2754-array-property-undefined.ts": 3456, - "2755-array-optional-literal-forwarding.ts": 3507, - "2780-array-parity-composition.ts": 9748, - "2781-array-missing-value-escape.ts": 2984, - "2782-array-sparse-callbacks.ts": 3368, - "2783-array-defaults-rest.ts": 3426, - "2784-array-reduce-missing-result.ts": 2920, - "2785-array-missing-destructuring.ts": 4220, - "2786-array-sparse-serialization.ts": 3688, - "2787-array-missing-string-arithmetic.ts": 2565, - "2788-array-missing-builtin-conversions.ts": 2767, - "2789-array-missing-optional-tostring.ts": 3009, - "2790-dynamic-import-self-name/main.ts": 3621, - "2791-record-optional-keys.ts": 3660, - "2792-record-optional-spread-entries.ts": 3741, - "2793-union-conversion-identity-capture.ts": 3519, - "2794-array-generic-callback-values.ts": 2842, - "2795-array-optional-typedarray-source.ts": 29642, - "2796-array-sparse-class-value-instanceof.ts": 4014, - "2800-array-expression-consumers.ts": 2964, - "2801-array-switch-consumers.ts": 3634, - "2820-array-missing-method-receivers.ts": 3219, - "2821-array-optional-numeric-comparisons.ts": 3648, - "2830-cjs-require-self-name/main.cjs": 2817, - "2840-finally-completions.ts": 2484, - "2841-using-sync.ts": 3654, - "2842-await-using.ts": 3139, - "2843-using-suppressed-error.ts": 3369, - "2844-node-disposable-resources.ts": 3909, - "2845-for-using-of.ts": 3562, - "2846-generator-using.ts": 3676, - "2850-async-generators-protocol.ts": 4224, - "2851-async-generators-values.ts": 3418, - "2852-timers-promises-interval.ts": 3999, - "2854-leading-bom-literals.ts": 3644, - "2855-searchparams-sort-complexity.ts": 2896, - "2856-dynamic-any-local-operators.ts": 3122, - "2857-branded-primitives.ts": 2535, - "2858-import-meta-resolve/main.mjs": 2803, - "2859-import-meta-resolve-dynamic/main.mjs": 2791, - "2860-require-resolve/main.cjs": 3416, - "2861-readable-iterator-close.ts": 3965, - "2862-web-readable-async-iteration.ts": 48807, - "2863-class-async-iterator.ts": 3227, - "2864-array-class-method-receivers.ts": 2404, - "2865-cjs-process-alias.cjs": 3403, - "2866-dyn-switch.ts": 2311, - "2867-array-shift-length.js": 3507, - "2868-empty-record-promise-presence.js": 2925, - "2869-nullish-mixed-lazy.ts": 2958, - "2870-and-dropped-truthy-arm.ts": 2834, - "2871-optional-promise-to-unknown.ts": 3267, - "2872-unobserved-dynamic-event.ts": 3355, - "2873-optional-receiver-loop-lifetime.js": 3047, - "2874-nullable-callback-field-cycle.js": 3534, - "2875-evolving-let-read-before-write.js": 2810, - "2876-class-unknown-roundtrip.ts": 3764, - "2877-child-unknown-roundtrip.ts": 2785, - "2878-class-private-unknown.cjs": 3352, - "2880-cjs-module-graph/main.cjs": 3782, - "2890-crypto-static-utility.ts": 2826, - "2891-json-record-key-escapes.ts": 3816, - "2892-windows-console-unicode.ts": 3563, - "2893-child-stdin-duplex.ts": 3578, - "2894-child-stdin-backpressure.ts": 3536, - "2895-child-stdin-write-after-end.ts": 3038, - "2896-child-stdin-write-after-finish.ts": 3391, - "2897-child-stdin-destroy.ts": 3563, - "2898-child-stdin-spawn-failure.ts": 3036, - "2899-nested-mutual-recursion.ts": 3350, - "2900-float64array-static.ts": 3865, - "2900-void-conditional-arrow.ts": 2828, - "2901-bigint-core.ts": 3440, - "2902-bigint-bytes.ts": 2684, - "2903-bigint-storage.ts": 3029, - "2904-bigint-errors.ts": 3660, - "2905-bigint-edges.ts": 3424, - "2906-bigint-wasi-width.ts": 3017, - "2910-overloaded-callable-alias.ts": 3175, - "2911-execfile-callback.ts": 3152, - "2912-execfile-callback-options.ts": 3514, - "2912-promisify-fs-readfile.ts": 3307, - "2913-builtin-callable-alias.ts": 4333, - "2914-fixed-tuple-call-spread.ts": 3657, - "2915-path-function-values.ts": 2684, - "2916-path-function-values-cjs.ts": 3544, - "2917-builtin-callable-widths.ts": 3312, - "2918-builtin-callable-widths-cjs.ts": 4040, - "2919-fs-function-values.ts": 4214, - "2920-fs-promises-function-values.ts": 2447, - "2921-zlib-callbacks.ts": 4192, - "2922-dyn-bitwise-not.cjs": 2704, - "2923-cjs-factory-export/main.cjs": 3106, - "2930-union-receiver-calls.ts": 3700, - "2931-union-dynamic-field-call.js": 3466, - "2932-create-require-program/main.ts": 3686, - "2933-static-dynamic-import/main.ts": 3405, - "2934-static-import-stored.ts": 2381, - "2935-module-namespace-values/main.ts": 3289, - "2936-static-loose-equality.ts": 3642, - "2937-bitwise-hot-loop.ts": 3298, - "2938-fs-sync-overloads.cjs": 2598, - "2939-child-shell-text.ts": 2919, - "2940-date-parse.ts": 3171, - "2940-fsp-realpath.ts": 3497, - "2941-fsp-lstat-identity.ts": 3608, - "2941-process-exit-code.ts": 3007, - "2942-fsp-readdir-dirent.ts": 3744, - "2942-process-exit-code-override.ts": 2479, - "2943-process-exit-code-invalid.ts": 3225, - "2944-process-exit-code-wrap.ts": 3249, - "2945-url-origin-username.ts": 2371, - "2946-child-fork-ipc/main.ts": 4191, - "2946-url-port-hash.ts": 2720, - "2947-set-readonly-seeds.ts": 3363, - "2948-child-fork-eof-callback/main.ts": 3691, - "2948-stdio-callback-record.ts": 3021, - "2949-child-fork-default/main.mjs": 3752, - "2949-url-password.ts": 3268, - "2950-fs-descriptor-publication.ts": 3039, - "2951-math-static-analytic.ts": 2897, - "2952-math-static-remaining.ts": 3708, - "2953-http-header-validation.ts": 2926, - "2954-http-outgoing-headers.ts": 3568, - "2955-http-static-state.ts": 3392, - "2956-http-static-informational.ts": 3156, - "2957-http-static-response-controls.ts": 3011, - "2961-emitter-computed-names.cjs": 3061, - "2962-emitter-computed-optional.ts": 3117, - "2963-child-fork-dispatch/main.ts": 3069, - "2964-indexed-compound.ts": 4283, - "2966-numeric-array-read-fusion.ts": 2881, - "2967-numeric-array-read-lifetime.ts": 3327, - "2968-numeric-array-borrow.ts": 3624, - "2969-scalar-record-results.ts": 3705, - "2970-constant-numeric-tables.ts": 3396, - "2971-constant-table-modules/main.ts": 2786, - "2972-http-static-distinct-snapshots.ts": 3464, - "2972-math-receiver-borrow.ts": 4257, - "2973-http-static-agent.ts": 3844, - "2973-integer-bitwise-arithmetic.ts": 3703, - "2974-array-search-from-index.ts": 120829, - "2974-http-static-module-values.ts": 5733, - "2974-numeric-remainder.ts": 3749, - "2975-bigint-default-radix.ts": 2671, - "2975-http-static-client-controls.ts": 3229, - "2976-http-static-incoming-state.ts": 3560, - "2976-json-stringify-no-arguments.js": 3221, - "2977-http-static-incoming-timeout.ts": 3554, - "2977-nested-array-binding-defaults.js": 3145, - "2978-http-static-client-timeout.ts": 3607, - "2978-regexp-optional-subject.js": 3504, - "2979-array-search-mixed-needles.js": 2692, - "2979-http-static-server-timeout.ts": 3769, - "2980-http-static-server-timeout-default.ts": 3050, - "2980-string-position-arguments.js": 3269, - "2981-http-static-events.ts": 2644, - "2981-string-optional-positions.ts": 2494, - "2982-http-static-close-all.ts": 2737, - "2982-string-position-coercion-order.js": 3410, - "2983-http-static-close-idle.ts": 3031, - "2984-http-static-close-upgrade.ts": 3101, - "2985-http-static-message-destroy.ts": 3632, - "2986-http-static-client-socket-finish.ts": 2911, - "2987-http-static-timeout-errors.ts": 3301, - "2988-http-static-client-abort.ts": 2940, - "2989-http-static-response-timeout-handled.ts": 3640, - "2990-http-static-request-timeout-handled.ts": 3597, - "2991-array-indexed-equality.ts": 3696, - "2992-stream-rows.ts": 3357, - "2993-fiber-stack-lifetimes.ts": 3545, - "2994-fromcharcode-scalar.ts": 3381, - "2995-math-hyperbolic.ts": 3225, - "2996-math-near-one.ts": 2714, - "2997-math-integer-float.ts": 3635, - "300-if-else.ts": 2510, - "3001-caught-typeof-object.js": 3444, - "3002-promise-then-two.ts": 3645, - "301-while.ts": 3200, - "302-for.ts": 2865, - "3020-string-last-index-position.ts": 3627, - "3021-buffer-union-narrow-callback.ts": 3829, - "3022-string-affix-positions.ts": 3463, - "3023-string-affix-position-coercion.js": 3644, - "3024-string-number-narrow-for-in.ts": 3394, - "3025-string-search-position-coercion.js": 3367, - "3026-array-last-index-of.js": 2868, - "3027-array-last-index-of-records.ts": 3472, - "3028-string-search-dynamic-needle.js": 2934, - "3029-string-search-union-needle.js": 3701, - "303-break-continue.ts": 2701, - "3030-array-search-no-arg.js": 3806, - "3031-array-relative-index-coercion.js": 3498, - "3031-string-last-index-search-value.js": 2610, - "3032-string-search-value.js": 3067, - "3033-string-search-needle-coercion.js": 3292, - "3034-arguments-with-parameters.js": 2687, - "3035-string-positioned-search-value.js": 3575, - "3036-string-object-search-value.js": 2688, - "3037-number-nullish-conversion.js": 3018, - "3038-number-scalar-unions.ts": 2381, - "3039-string-repeat-count.js": 2336, - "304-compound-incdec.ts": 3307, - "3040-string-prototype-call.js": 3584, - "3041-string-prototype-object-call.js": 3163, - "3042-string-padding-coercion.js": 3486, - "3043-string-split-arguments.js": 3038, - "3044-array-slice-splice-positions.js": 3582, - "3045-array-indexed-mutation.js": 4003, - "3046-array-indexed-ref-identity.ts": 2594, - "3047-object-prototype-tag.js": 5012, - "3048-object-own-prototype.ts": 4080, - "3049-array-flat-depth.ts": 3414, - "305-truthiness.ts": 2664, - "3050-array-splice-insert.ts": 2966, - "3051-array-join-default.ts": 3468, - "3052-array-construction.ts": 4201, - "3053-array-construction-js.js": 2937, - "3054-dynamic-abort-record.ts": 25141, - "3055-default-builtin-nodenext/main.ts": 2702, - "3056-default-builtin-bundler/main.ts": 3487, - "3057-default-builtin-nodenext-dynamic/main.ts": 2447, - "3058-optional-array-chain-join.ts": 3991, - "3059-arguments-property-names.ts": 2550, - "3061-concurrent-fiber-stacks.ts": 3788, - "3062-runtime-optional-record-guards.ts": 3181, - "3063-runtime-optional-class-guards.ts": 3568, - "3064-installed-entry-imports/main.ts": 2606, - "3065-installed-entry-js/main.js": 3045, - "3066-source-debugging/main.ts": 3383, - "3067-cjs-function-export-require/main.cjs": 2939, - "3068-debug-variables/main.ts": 2618, - "3068-url-checked-identity.ts": 3006, - "3069-set-checked-seed.js": 3140, - "3069-tuple-spread.ts": 3376, - "3070-checked-object-accessors.js": 3573, - "3070-collection-views.ts": 3175, - "3071-checked-specialization-narrowing.js": 3321, - "3071-map-contextual-record-seeds.ts": 4329, - "3072-optional-union-receivers.ts": 3610, - "3072-weak-process-streams.js": 2918, - "3073-optional-callable-module.js": 3300, - "3073-union-keyed-reads.ts": 3869, - "3074-discriminated-intersections.ts": 3384, - "3075-recursive-contextual-literals.ts": 4502, - "3076-nullish-record-defaults.ts": 3009, - "3077-optional-union-array-reads.ts": 3992, - "3078-forward-mutable-captures.ts": 3466, - "3079-forward-mutable-tdz.ts": 3489, - "3080-exhaustive-never-bindings.ts": 3664, - "3081-recursive-array-destinations.ts": 3893, - "3082-forward-write-unwind.ts": 3471, - "3083-set-string-seed.ts": 3139, - "3084-record-own-membership.ts": 2971, - "3085-conditional-record-construction.ts": 3822, - "3086-error-constructor-options.ts": 3660, - "3087-error-options-lifetime.ts": 2905, - "3088-array-wide-callbacks.ts": 3195, - "3089-array-find-narrowing.ts": 4220, - "3090-json-discriminated-records.ts": 3463, - "3091-json-recursive-discriminants.ts": 3555, - "3092-number-union-predicates.ts": 2884, - "3093-error-option-data.ts": 2574, - "3094-json-replacer-traversal.ts": 3823, - "3095-json-reviver-traversal.ts": 3825, - "3096-json-callback-nonfinite.ts": 3620, - "3097-json-callback-reentrancy.ts": 2760, - "3098-json-callback-space.ts": 3696, - "3099-json-callback-functions.ts": 4108, - "3100-json-callback-holder.js": 3675, - "3101-json-callback-bytes.ts": 3250, - "3102-json-unknown-fields.ts": 2925, - "3103-scalar-record-nested-control-flow.ts": 3592, - "3104-native-analysis-tables-loops.ts": 3494, - "3105-nullable-collections.ts": 3244, - "3106-mixed-insertion-spreads.ts": 4146, - "3107-nullable-collection-lifetimes.ts": 3486, - "3108-for-await-sync-arrays.js": 4312, - "3108-identity-map-keys.ts": 3894, - "3109-destructuring-unknown-defaults.js": 3234, - "3109-identity-union-collections.ts": 3977, - "3110-builtin-error-families.ts": 3250, - "3110-identity-collection-mutation.ts": 3825, - "3111-identity-collection-cycles.ts": 3640, - "3112-union-switch-control-flow.ts": 2681, - "3113-union-array-removal.ts": 3778, - "3114-union-record-field-write.ts": 3884, - "3115-zlib-static-compression-levels.ts": 4085, - "3116-sequence-expression-lifetimes.ts": 3245, - "3117-unknown-switch-control-flow.ts": 3706, - "3118-recursive-union-spread.ts": 3476, - "3119-runtime-optional-spread.ts": 4508, - "3120-dynamic-property-descriptors.js": 3228, - "3120-generator-method-loop-bindings.ts": 3222, - "3120-ir-nonfinite-numbers.ts": 3251, - "3121-compound-assignment-values.js": 3525, - "3121-dynamic-accessor-descriptors.js": 4470, - "3122-dynamic-delete-descriptors.cjs": 3353, - "3122-dynamic-delete-descriptors.js": 3300, - "3122-js-async-class-methods.js": 3524, - "3123-destructured-global-tdz.js": 3896, - "3124-array-prototype-borrow.js": 4000, - "3125-regex-global-match.ts": 2889, - "3126-js-number-radix/main.ts": 3491, - "3127-spawn-runtime-options.ts": 3338, - "3128-regex-last-index.ts": 3768, - "3129-js-token-union/main.ts": 3461, - "3130-child-generic-streams.ts": 3435, - "3131-child-rest-listeners.js": 3280, - "3132-child-generic-stream-completion.ts": 6821, - "3133-text-decoder-streaming.ts": 32031, - "3134-fs-vectors.ts": 3621, - "3135-fs-file-handle-controls.ts": 3152, - "3136-fs-file-handle-options.ts": 4992, - "3137-fs-vector-callbacks.cjs": 3636, - "3138-array-large-storage.ts": 5104, - "3139-regex-native-deep-alternatives.ts": 38096, - "3140-array-dense-access.ts": 4712, - "3141-map-string-key-hash.ts": 3358, - "3150-integer-remainder.ts": 3568, - "3151-array-push-writes.ts": 3892, - "3170-number-conversion-fast-paths.ts": 2663, - "3171-method-census-data-writes.ts": 4253, - "400-fib.ts": 3919, - "401-mutual-recursion.ts": 2844, - "402-string-functions.ts": 3081, - "403-void-and-params.ts": 3112, - "4030-runtime-object-truthiness.ts": 3275, - "4031-event-emitter-long-tuples.ts": 3646, - "4032-inline-rc-fast-paths.ts": 4866, - "404-rc-stress.ts": 2781, - "4040-adapted-function-identity.ts": 3610, - "4041-adapted-function-properties.ts": 3413, - "4042-object-is-union-subclass.ts": 2746, - "4043-nonnull-missing-element.ts": 3815, - "4044-adapted-callback-modules/main.ts": 2918, - "4045-optional-element-projections.ts": 4182, - "4046-captured-parameter-values.ts": 4191, - "4047-captured-parameter-rebinding.ts": 2867, - "405-params-optional.ts": 2408, - "406-params-defaults.ts": 2614, - "4060-cycle-shared-instance/main.ts": 2758, - "4060-stack-union-reads.ts": 4386, - "4061-cycle-evaluation-order/main.ts": 3229, - "4061-nullable-ref-fields.ts": 6151, - "4062-cycle-tdz-read/main.ts": 3056, - "4063-cycle-hoisted-calls/main.ts": 3238, - "4064-cycle-classes-after-init/main.ts": 2548, - "4065-cycle-init-throws/main.ts": 2955, - "4066-cycle-top-level-tdz/main.ts": 3040, - "4067-dynamic-import-cycle-tdz/main.ts": 3004, - "407-params-rest.ts": 3335, - "408-params-ctors-inheritance.ts": 3021, - "4080-optional-read-presence-tests.ts": 3095, - "4080-string-index-bounds.ts": 3083, - "4081-hoisted-function-tdz.ts": 3193, - "4081-string-index-unproven.ts": 3273, - "4082-hoisted-function-tdz-uncaught.ts": 2845, - "4083-dynamic-import-failure/main.ts": 3748, - "4084-record-optional-field-copies.ts": 4118, - "4085-generator-loop-close.ts": 3638, - "4086-optional-capture-defaults.ts": 3227, - "4088-class-static-tdz.ts": 3234, - "4089-class-wrapper-tdz.js": 3393, - "409-params-async-generics.ts": 2742, - "4090-computed-key-tdz.js": 2796, - "4091-class-evaluation-deferred.ts": 3464, - "410-params-rc-stress.ts": 3461, - "4140-array-callback-split-visit.ts": 7289, - "4141-array-callback-ambient-receiver/main.ts": 3100, - "4142-array-callback-factories.ts": 4541, - "4143-union-refinement-intersection-arms.ts": 3822, - "420-dead-strip-modules/main.ts": 3118, - "4290-acyclic-immutable-trees.ts": 3580, - "4291-acyclic-constructor-escapes.ts": 3039, - "4292-acyclic-readonly-bypass.ts": 4316, - "4293-acyclic-dynamic-writes.ts": 3268, - "4294-console-line-sizes.ts": 6986, - "4295-console-template-parts.ts": 3358, - "4296-console-glued-long-parts.ts": 3290, - "4410-inline-object-allocation.ts": 3305, - "4411-nullable-ref-values.ts": 5301, - "4412-nullable-record-values.ts": 5088, - "4413-cycle-old-late-death.ts": 4012, - "4413-nullable-null-and-undefined.ts": 4328, - "4414-cycle-old-weak-keys.ts": 4005, - "4414-nullable-string-values.ts": 5044, - "4415-identity-borrowed-operands.ts": 3101, - "4415-nullable-container-values.ts": 4932, - "4431-exception-pending-contexts.ts": 3487, - "4432-checked-downcast-failures.ts": 3971, - "4451-int32-field-storage.ts": 3668, - "4452-int32-field-dynamic-writes.ts": 4531, - "4453-int32-closed-locals.ts": 2786, - "4471-unassigned-field-reads.ts": 3896, - "4476-string-ascii-header-fact.ts": 3522, - "4477-buffer-write-ascii-runs.ts": 3321, - "4478-string-large-index-reads.ts": 4146, - "4481-array-optional-push.ts": 3259, - "4482-instanceof-static-class-optional.ts": 3786, - "4483-array-splice-statement.ts": 4036, - "4484-array-length-reset.ts": 2849, - "4485-array-splice-optional-item.ts": 3817, - "4486-array-field-element-borrows.ts": 2903, - "4487-array-literal-optional-values.ts": 3145, - "4520-optional-guard-narrowing.ts": 2774, - "4521-array-callback-element-presence.ts": 5601, - "4522-captured-parameter-lifetimes.ts": 3907, - "4523-array-pop-removal.ts": 3769, - "4524-array-callback-supertype-params.ts": 4594, - "4541-nullable-wrap-borrows.ts": 3939, - "4542-preserving-call-borrows.ts": 3361, - "4543-walk-borrowed-locals.ts": 3633, - "4544-checked-cast-aliases.ts": 3723, - "4545-borrowed-returns.ts": 4116, - "4546-rebound-borrowed-params.ts": 2930, - "4560-field-store-borrowed-receivers.ts": 4438, - "4561-virtual-borrowed-parameters.ts": 3634, - "4562-string-self-concat-move.ts": 2703, - "4563-array-read-projection-receivers.ts": 3601, - "4564-literal-choice-strings.ts": 3137, - "4568-for-of-hole-elements.ts": 3387, - "4569-shorthand-missing-elements.ts": 3958, - "4570-map-lookup-default-record.ts": 3112, - "4591-weak-keys-union-records.ts": 3556, - "4592-cycle-const-from-import/main.ts": 3467, - "4593-weak-keys-empty-objects.ts": 2938, - "4594-union-class-field-mixed-types.ts": 4040, - "4595-union-class-field-optional-receiver.ts": 3379, - "4596-error-subclass-int-fields.ts": 3559, - "4596-tdz-nullable-forward-capture.ts": 4676, - "4597-callback-field-method-name.ts": 4014, - "4598-live-array-ref-element-access.ts": 8384, - "4598-map-set-clear-reuse.ts": 4224, - "4598-os-available-parallelism.ts": 3815, - "4598-publish-constructor-stores.ts": 3618, - "4599-construction-only-field-borrows.ts": 3619, - "4600-construction-only-fields-dynamic-writes.ts": 3184, - "4601-cycle-holders.ts": 3348, - "4602-constructor-escape-order.ts": 3674, - "4610-array-ext-dyn-refresh.ts": 4598, - "4620-optional-chain-borrowed-receivers.ts": 3411, - "4621-edge-preserving-callees/main.ts": 3288, - "4630-contract-int32.ts": 2810, - "4630-reference-write-call-arguments.ts": 3333, - "4631-contract-nothrow.ts": 3196, - "4631-reference-write-aliases.ts": 4264, - "4632-contract-immutable.ts": 3449, - "4632-reference-write-loops-and-walks.ts": 3791, - "4633-contract-program-lifetime.ts": 4644, - "4633-reference-write-callbacks-returns.ts": 4024, - "4634-contract-program-lifetime-publish.ts": 42618, - "4634-optional-element-borrowed-returns.ts": 3411, - "4640-bitwise-identity-ranges.ts": 3713, - "4641-nothrow-try-catch.ts": 3056, - "4642-acyclic-contract.ts": 4040, - "4650-stale-property-narrowing.ts": 3665, - "4651-map-string-get-entry.ts": 3369, - "4652-stale-closure-binding-narrowing.ts": 3504, - "4660-typed-rest-spread-forwarding.ts": 3148, - "4671-scoped-array-read-borrows.ts": 3020, - "4690-cycle-bypass-long-lived.ts": 5374, - "4691-publish-constructor-self-alias.ts": 38620, - "4692-borrowed-result-mutating-callees.ts": 3592, - "4720-cold-throw-paths.ts": 4339, - "4721-integer-induction-numbers.ts": 3854, - "4730-touint32-large-magnitudes.ts": 3431, - "4731-string-mixed-ascii-slices.ts": 4436, - "4732-buffer-write-utf16le-runs.ts": 4084, - "4733-typed-array-read-compares.ts": 3240, - "4750-map-string-absent-filter.ts": 3584, - "4751-string-search-multibyte-needles.ts": 3227, - "4795-published-untyped-member-reads.ts": 3450, - "4806-uint32-loop-accumulators.ts": 3543, - "4810-union-identity-retags.ts": 34911, - "4811-union-retag-checked-cast.ts": 3044, - "4812-int32-wrapping-sums.ts": 3457, - "4813-typed-array-read-equality-bindings.ts": 4853, - "4820-sort-comparator-lent-arguments.ts": 3579, - "4821-callback-lent-arguments.ts": 4210, - "4822-stable-capture-reads.ts": 3094, - "4823-array-store-receivers.ts": 3774, - "4830-typed-teardown-chains.ts": 3908, - "4831-cycle-bypass-probe-windows.ts": 6157, - "4840-array-hole-free-prefix.ts": 3932, - "4860-int32-local-storage.ts": 5136, - "4870-array-pipeline-fusion.ts": 6645, - "4871-array-pipeline-analytics.ts": 4575, - "4872-array-pipeline-temporaries.ts": 10635, - "4875-stream-consumers-array-buffer.ts": 4120, - "4876-array-buffer-inspect.ts": 2819, - "4880-await-call-turn-order.ts": 3872, - "4881-await-call-exceptions.ts": 3027, - "4882-await-call-request-chain.ts": 2730, - "4883-await-values-and-hops.ts": 3412, - "4884-await-call-unhandled-sibling.ts": 3410, - "4885-await-call-checkpoints.ts": 2703, - "4890-regex-literal-sites.ts": 3712, - "4891-regex-plain-text-patterns.ts": 3018, - "4892-regex-exec-read-captures.ts": 4130, - "4900-bigint-division-cross-check.ts": 3763, - "4900-console-instances.ts": 4286, - "4901-bigint-radix-text.ts": 3099, - "4901-console-instance-errors.ts": 3171, - "4902-bigint-compound-assign.ts": 3431, - "4903-bigint-fixed-width.ts": 3707, - "4904-bigint-large-products.ts": 3972, - "4905-bigint-fixed-width-fusion.ts": 3443, - "4906-bigint-small-value-trees.ts": 4875, - "4907-bigint-random-trees.ts": 5277, - "4910-hole-free-prefix-upkeep.ts": 4073, - "4920-string-literal-switch.ts": 3607, - "4930-typed-record-reflection.ts": 4869, - "4931-typed-data-generic-walks.ts": 5228, - "4932-typed-json-unknown.ts": 3250, - "4940-async-return-adoption.ts": 4405, - "4941-async-return-adoption-try.ts": 3533, - "4942-async-return-adoption-values.ts": 4824, - "4943-async-return-adoption-interleaved.ts": 3851, - "4950-regex-compiled-captures.ts": 5146, - "4951-regex-compiled-last-index.ts": 4316, - "4952-regex-compiled-anchors-classes.ts": 3149, - "4953-regex-compiled-backtracking.ts": 3822, - "4954-regex-log-report.ts": 4449, - "4955-regex-compiled-differential.ts": 20102, - "4970-int32-call-abi.ts": 3029, - "4980-generator-early-exit-finally.ts": 3262, - "4981-generator-delegation-iterables.ts": 5306, - "4982-generator-sent-values.ts": 3649, - "4983-generator-reuse-iterables.ts": 4023, - "4984-generator-exceptions.ts": 4220, - "4985-generator-lazy-pipeline.ts": 3164, - "4986-generator-default-channels.ts": 3434, - "4987-generator-closures-methods.ts": 3505, - "4988-generator-async-interplay.ts": 2790, - "4989-generator-step-drives.ts": 3509, - "4990-lone-surrogates.ts": 3213, - "4991-lone-surrogate-halves.ts": 4020, - "4992-lone-surrogate-search.ts": 3375, - "4993-lone-surrogate-json.ts": 3473, - "4994-lone-surrogate-uri.ts": 3848, - "4995-lone-surrogate-regex.ts": 4302, - "4996-lone-surrogate-stdio.ts": 2592, - "4997-lone-surrogate-stdout-patch.js": 3072, - "4998-lone-surrogate-buffers.ts": 3134, - "4999-lone-surrogate-io.ts": 3225, - "500-array-basics.ts": 2886, - "501-array-push-pop.ts": 2682, - "5010-lifetime-region-generations.ts": 4147, - "5011-lifetime-region-outside-references.ts": 3407, - "5012-lifetime-region-shapes.ts": 4861, - "5013-lifetime-region-async.ts": 3124, - "5014-lifetime-region-nesting.ts": 3259, - "5015-lifetime-region-publish.ts": 27669, - "5016-lifetime-region-weak-keys.ts": 2554, - "5017-lifetime-region-cycles.ts": 3105, - "5018-lifetime-region-hierarchies.ts": 4007, - "5019-lifetime-region-values.ts": 2888, - "502-array-for-of.ts": 3621, - "5020-lifetime-region-large.ts": 4812, - "5021-lifetime-region-opaque-holders.ts": 3957, - "5022-lifetime-region-workers.ts": 38841, - "503-array-functions.ts": 2982, - "504-array-rc-stress.ts": 3289, - "5040-promise-all-race-turns.ts": 4439, - "5041-promise-all-turns.js": 3708, - "5042-async-generator-return-promise.ts": 3292, - "5043-async-generator-return-forms.ts": 3922, - "5045-generator-delegation-typed-next.ts": 4740, - "5046-generator-delegation-return-throw.ts": 3192, - "5047-generator-delegation-iterables-typed.ts": 4558, - "5048-generator-delegation-async.ts": 3457, - "5049-generator-delegation-edges.ts": 3057, - "5050-inherited-in-membership.ts": 4297, - "5051-typed-record-prototypes.ts": 3534, - "5052-class-for-in-unknown.ts": 3663, - "5053-json-replacer-arrays.ts": 4093, - "5054-required-field-delete.ts": 3619, - "5055-object-create-record-literal.ts": 3237, - "5056-generator-in-unknown.ts": 3060, - "5060-child-fork-exit-after-messages/main.ts": 3584, - "5061-child-fork-local-disconnect/main.ts": 4277, - "5062-child-fork-message-before-eof/main.ts": 3570, - "5065-global-increment-initializers.ts": 2946, - "5066-global-compound-updates.ts": 3425, - "5067-global-updates-in-functions.ts": 3465, - "5068-global-var-let-const-updates.ts": 3395, - "5069-global-update-modules/main.ts": 3167, - "5070-optional-read-bindings.ts": 3316, - "5071-optional-chain-scalars.ts": 3214, - "5072-optional-nullish-ternary.ts": 2900, - "5073-optional-results.ts": 3751, - "5074-optional-pop-shift.ts": 3099, - "5075-optional-reads-unchecked/main.ts": 3754, - "5076-optional-escapes.ts": 3593, - "5080-boolean-array-storage.ts": 7564, - "5081-boolean-array-dynamic-views.ts": 3915, - "5085-promise-allsettled-turns.ts": 4557, - "5086-promise-any-turns.ts": 3994, - "5087-promise-allsettled-any-dyn.js": 5205, - "5088-promise-combinator-thenables.js": 5007, - "5089-promise-settled-records.ts": 4859, - "5090-generator-finished-result-value.ts": 3648, - "5091-generator-delegation-arrays-strings.ts": 3362, - "5092-generator-delegation-sets-maps.ts": 4496, - "5095-console-count-group.ts": 3356, - "5096-console-assert-dir.ts": 3645, - "5097-console-table.ts": 3255, - "5098-console-time-warnings.ts": 7324, - "5099-console-methods-dynamic.cjs": 3314, - "510-array-map-filter-foreach.ts": 3232, - "511-array-indexof-includes.ts": 3286, - "5110-var-hoisting-early-reads.ts": 4048, - "5111-var-hoisting-closures-classes.ts": 2474, - "5112-var-hoisting-function-scope.ts": 3383, - "5113-tdz-let-const-class.ts": 3628, - "5114-var-hoisting-js.js": 3550, - "5115-regex-replace-compiled.ts": 3344, - "5116-regex-capture-reads.ts": 3874, - "5117-regex-log-report-spans.ts": 3719, - "5118-regex-replace-char-chains.ts": 3632, - "512-array-join-chains.ts": 3268, - "5120-frame-records.ts": 3221, - "5121-frame-objects.ts": 3861, - "5122-frame-result-slots.ts": 3008, - "5123-frame-reassigned.ts": 3589, - "5124-frame-objects-control.ts": 3184, - "5125-frame-mutating-methods.ts": 3607, - "5126-frame-returned-params.ts": 3362, - "5127-frame-loop-bindings.ts": 4392, - "513-array-methods-rc-stress.ts": 3208, - "5130-event-target-dispatch.js": 4958, - "5131-event-target-listener-errors.js": 4558, - "5132-event-target-typed.ts": 5171, - "5133-abort-signal-event-target.ts": 22917, - "5134-events-error-monitor.ts": 3499, - "5135-event-target-warnings.js": 9058, - "5136-events-error-monitor-string-name.ts": 3057, - "5137-events-error-monitor-computed-name.js": 4052, - "5138-events-error-monitor-shared-listener.ts": 2466, - "5139-event-target-listener-throw.ts": 2925, - "514-array-find-some-every.ts": 3925, - "5140-os-host-facts.ts": 3438, - "5141-os-constants.ts": 2815, - "5142-path-parse-format.ts": 3808, - "5145-path-matches-glob-basics.ts": 3287, - "5146-path-matches-glob-braces.ts": 4987, - "5147-path-matches-glob-extglob.ts": 3938, - "5148-path-matches-glob-classes.ts": 3973, - "5149-path-matches-glob-win32.ts": 3835, - "515-array-flatmap.ts": 3688, - "5150-small-array-inline-slots.ts": 4419, - "5155-cycle-header-types.ts": 38708, - "516-array-reduce.ts": 4017, - "5160-field-callback-receiver.ts": 3678, - "5161-field-callback-receiver-escape.ts": 2857, - "5162-field-method-reference-receiver.ts": 2944, - "5163-field-callback-receiver.cjs": 3655, - "5164-worker-field-callback-receiver.ts": 30046, - "5165-interface-method-dispatch.ts": 2969, - "5166-interface-method-values.ts": 4129, - "5167-interface-method-order.ts": 3988, - "5168-interface-method-hierarchy.ts": 4483, - "5169-interface-method-chains.ts": 3336, - "517-array-hof-index-args.ts": 3024, - "5170-string-scan-eviction.ts": 3285, - "5171-lone-surrogate-replace-seams.ts": 3558, - "5175-forin-typed-as-unknown.ts": 4230, - "5176-object-keys-typed-as-unknown.ts": 3721, - "5177-forin-dynamic-objects.ts": 2893, - "5178-forin-keys-js.js": 2555, - "5179-forin-typed-shapes.ts": 4446, - "518-array-sort.ts": 3134, - "518-promise-void-union-callbacks.ts": 2401, - "5180-interface-arrays.ts": 3230, - "5181-interface-array-methods.ts": 11973, - "5182-interface-array-boundaries.ts": 3847, - "5183-interface-property-reads.ts": 3799, - "5184-interface-property-objects.ts": 3828, - "5185-util-inherits.cjs": 5041, - "5186-util-inherits.ts": 4542, - "5187-util-deprecate.cjs": 5818, - "5188-util-deprecate-flags.cjs": 4078, - "5189-util-deprecate.ts": 3798, - "519-array-from-length.ts": 2988, - "519-promise-union-await-values.ts": 3664, - "5190-util-callbackify.cjs": 5115, - "5191-util-callbackify.ts": 4367, - "5192-util-debuglog.cjs": 5096, - "5193-util-debuglog.ts": 4056, - "5194-process-emit-warning-tick.cjs": 2761, - "5195-object-entries-typed-as-unknown.ts": 3177, - "5196-object-values-typed-as-unknown.ts": 4077, - "5197-object-entries-dynamic-objects.ts": 4742, - "5198-object-entries-values-js.js": 3089, - "5199-object-entries-identity.ts": 3679, - "520-map-basics.ts": 3767, - "5200-array-sort-keyed-numbers.ts": 4618, - "5201-array-sort-keyed-records.ts": 5422, - "5202-array-sort-keyed-lookalikes.ts": 4034, - "5203-typed-array-sort-default.ts": 7941, - "5204-typed-array-sort-comparators.ts": 4085, - "521-map-number-keys.ts": 3317, - "5210-process-memory-usage.ts": 3262, - "5211-process-identity.ts": 3448, - "5212-perf-marks-measures.ts": 4026, - "5213-perf-timing-errors.ts": 4151, - "5214-perf-entry-inspect.ts": 4315, - "5215-perf-timing-validation.js": 2982, - "5216-perf-spread-arguments.js": 3745, - "5217-perf-spread-typed.ts": 4057, - "522-map-foreach.ts": 2964, - "5220-url-parse-warnings.ts": 4859, - "5221-url-parse-shapes.ts": 3814, - "5222-url-parse-hosts.ts": 3398, - "5223-url-parse-query.ts": 2653, - "5224-url-format-objects.ts": 5550, - "5225-url-format-whatwg.ts": 5213, - "5226-url-resolve.ts": 2600, - "5227-url-legacy-dependency/main.ts": 5803, - "5228-url-domain-conversion.ts": 4876, - "5229-url-legacy-errors.cjs": 5195, - "523-map-ref-values.ts": 4321, - "5230-inline-union-fields.ts": 3644, - "5231-inline-union-field-kinds.ts": 4871, - "5232-inline-union-fields-dynamic.ts": 3887, - "5233-inline-union-fields-shapes.ts": 4145, - "5234-inline-union-class-fields.ts": 3244, - "5235-inline-union-fields-publish.ts": 3360, - "5236-inline-union-unchecked-reads.ts": 3108, - "5237-inline-union-frame-objects.ts": 2533, - "524-map-cycles.ts": 3943, - "5240-event-target-subclass.ts": 5571, - "5241-event-subclass.ts": 4311, - "5242-event-target-subclass-hierarchy.ts": 4079, - "5243-event-target-subclass-dynamic.ts": 3528, - "5244-event-target-subclass.js": 4645, - "5245-event-target-subclass-signals.ts": 9410, - "5246-event-target-subclass-listener-throw.ts": 3995, - "5247-event-target-subclass-lifetimes.ts": 5991, - "5248-event-target-subclass-warnings.ts": 4513, - "5249-event-target-subclass-unconstructed.ts": 2679, - "525-map-rc-stress.ts": 2764, - "526-set-basics.ts": 2480, - "5260-record-unknown-identity.ts": 3505, - "5261-optional-field-identity.ts": 3914, - "5262-record-unknown-many.ts": 3839, - "527-set-foreach.ts": 3683, - "5270-url-parse-no-deprecation.cjs": 4076, - "5271-url-parse-throw-deprecation.cjs": 3487, - "5275-http-end-callback-order.ts": 3028, - "5276-style-text-hex-colors.cjs": 4502, - "5277-fs-read-file-buffer-option.cjs": 2635, - "5278-host-null-bytes.cjs": 16385, - "5279-search-params-null-init.cjs": 2915, - "528-set-seeded.ts": 3643, - "5285-blob-construct.ts": 3124, - "5286-blob-readers.ts": 3309, - "5287-blob-inspect.ts": 2504, - "5288-blob-validation.js": 3775, - "5289-blob-read-order.ts": 3614, - "529-map-seeded.ts": 3331, - "5290-blob-dynamic.js": 2674, - "5295-readline-promises-question.ts": 2401, - "5296-readline-lines.ts": 3088, - "5297-readline-callback-events.cjs": 2975, - "5298-readline-abort.cjs": 6980, - "5299-readline-stdin.ts": 3836, - "530-record-arrays.ts": 3125, - "5300-stream-add-abort-signal.ts": 7154, - "5301-stream-add-abort-signal-errors.cjs": 7763, - "5302-stream-promises-options.ts": 8927, - "5303-stream-finished-callback-opts.cjs": 7119, - "5305-json-stringify-typed-arrays.ts": 4254, - "531-record-array-hofs.ts": 3609, - "5315-map-iterate-after-front-deletes.ts": 2759, - "5316-map-lru-eviction.ts": 3688, - "5317-map-iterate-while-mutating.ts": 3035, - "5318-set-iterate-after-deletes.ts": 2543, - "5319-map-iteration-values.ts": 4062, - "532-record-arrays-rc-stress.ts": 2708, - "5320-map-iterate-across-compaction.ts": 2736, - "5325-record-boundary-returns.ts": 3046, - "5326-record-boundary-params.ts": 2989, - "5327-record-boundary-identity.ts": 3529, - "5328-record-boundary-open.ts": 3718, - "5329-record-boundary-recursion.ts": 3361, - "533-array-element-cycles.ts": 3118, - "5330-record-boundary-fields.ts": 3048, - "5331-record-boundary-methods.ts": 2560, - "5333-record-boundary-nullable-argument.ts": 3100, - "5334-fetch-mentions-without-calls.ts": 4032, - "5335-top-level-await-pending-exit-code.ts": 2383, - "5336-top-level-await-pending-exit-listener.ts": 2814, - "5337-dc-subscriber-throw-next-tick.cjs": 3273, - "5338-js-tdz-function-element.js": 3733, - "5339-array-buffer-constructor.js": 2884, - "534-record-width-subtyping.ts": 3530, - "5345-object-values-for-of-unknown.ts": 4013, - "5346-object-values-length-dynamic.ts": 3930, - "5347-object-values-loop-control.ts": 3598, - "5348-object-values-for-of-js.js": 2760, - "5349-object-entries-values-optional.ts": 3370, - "535-object-statics.ts": 2862, - "5350-object-values-wide-record.ts": 3272, - "5351-object-values-methods-index.ts": 3637, - "536-map-seed-array.ts": 3237, - "5360-array-sort-comparator-calls.ts": 4265, - "5361-array-sort-inconsistent-comparators.ts": 4181, - "5362-array-sort-comparator-throws.ts": 2826, - "5363-array-sort-comparator-writes.ts": 10362, - "5364-array-sort-union-and-boolean-elements.ts": 14300, - "5365-array-sort-dynamic-values.js": 2919, - "537-map-iter-drains.ts": 3050, - "538-map-set-for-of.ts": 3029, - "5390-interface-loop-element-lifetimes.ts": 3566, - "5391-interface-dispatch-hierarchies.ts": 3731, - "5392-interface-receiver-bindings.ts": 3061, - "5393-interface-array-holes.ts": 2702, - "5394-interface-implementers.ts": 3603, - "5395-locale-compare-ascii.ts": 3587, - "5396-locale-compare-latin.ts": 4291, - "5397-locale-compare-sorting.ts": 3576, - "540-tuples-basics.ts": 3420, - "5400-json-parse-typed-keys.ts": 3141, - "5405-buffer-arraybuffer-window.ts": 3036, - "5406-util-types-keys.ts": 2954, - "5407-http-header-field-limit.ts": 3052, - "5408-http-unread-request-end.ts": 3992, - "5409-http-held-request-body.ts": 3771, - "541-ref-array-json.ts": 3761, - "5410-inspect-class-values.ts": 3124, - "5411-inspect-class-hierarchies.ts": 2423, - "5412-inspect-dynamic-collections.ts": 3042, - "5413-inspect-class-values.cjs": 3217, - "542-union-element-arrays.ts": 2812, - "5430-dyn-number-string-boxes.ts": 3930, - "5435-crypto-hash-algorithms.ts": 3451, - "5436-crypto-hash-names.js": 3185, - "5437-crypto-hmac-algorithms.ts": 3269, - "5438-crypto-kdf-digests.ts": 3099, - "5439-crypto-kdf-callbacks.js": 4398, - "5440-crypto-hash-encodings.js": 4908, - "5441-crypto-hash-output-length.ts": 3959, - "5442-crypto-random-values.ts": 4791, - "5443-crypto-random-arguments.js": 3724, - "5444-crypto-timing-safe-equal.js": 4074, - "5445-crypto-secret-key-objects.ts": 4784, - "5445-stream-buffer-chunks.ts": 5661, - "5446-crypto-secret-key-errors.js": 3275, - "5446-stream-buffer-chunks-dynamic.js": 5780, - "5447-fs-readdir-order.ts": 3355, - "5448-fs-glob-patterns.ts": 3298, - "5449-fs-glob-options.ts": 3827, - "5450-fs-glob-validation.js": 4321, - "5451-fs-promises-glob.ts": 3074, - "5452-fs-glob-callback.ts": 3887, - "5455-power-of-two-remainder.ts": 4228, - "5456-remainder-large-integer-dividends.ts": 3551, - "5457-lcg-modulus.ts": 2909, - "5458-fractional-remainder.ts": 2650, - "5460-locale-compare-contractions.ts": 3201, - "5461-locale-compare-equivalents.ts": 3410, - "5462-locale-compare-probe-sweep.ts": 4164, - "5463-locale-compare-combining-letters.ts": 3755, - "5464-locale-compare-fractions.ts": 3312, - "5470-strip-vt-osc.cjs": 2708, - "5471-strip-vt-csi.cjs": 3038, - "5472-strip-vt-random.cjs": 2850, - "5473-strip-vt-unterminated.cjs": 4462, - "5474-strip-vt-surrogates.ts": 3554, - "5540-fs-callback-forms.cjs": 3079, - "5541-fs-stats-fields.cjs": 4039, - "5542-fs-promises-parity.cjs": 3312, - "5543-fs-promises-typed.ts": 2944, - "5544-fs-opendir.cjs": 3622, - "5545-fs-options-encoding.cjs": 3497, - "5548-fs-callback-arguments.cjs": 3905, - "5549-fs-callback-option-checks.cjs": 3471, - "5550-locale-compare-ascii-words.ts": 2824, - "5551-array-search-references.ts": 3964, - "5552-string-appends.ts": 3653, - "5553-string-append-char-code.ts": 3292, - "5565-fs-dirent-untyped.mjs": 2898, - "5566-fs-dirent-dyn-boundaries/main.mjs": 3333, - "5585-record-results-inlined.ts": 3681, - "5595-net-ref-unref.ts": 3036, + "001-hello.ts": 47467, + "002-log-args.ts": 4723, + "100-number-format.ts": 49913, + "1000-json-stringify-basics.ts": 49071, + "1001-json-escapes-unicode.ts": 5167, + "1002-json-parse-cast.ts": 48226, + "1003-json-parse-unions.ts": 5247, + "1004-json-parse-errors.ts": 4196, + "1005-json-nested.ts": 8262, + "1006-json-fs-config.ts": 36095, + "1007-json-rc-stress.ts": 30487, + "1008-json-null-arms.ts": 48758, + "1009-json-optional-fields.ts": 3469, + "101-arithmetic.ts": 49638, + "1010-json-stringify-space.ts": 48585, + "1011-json-unknown-typeof.ts": 52058, + "102-comparisons.ts": 47851, + "1020-async-basics.ts": 4722, + "1021-async-ordering.ts": 4973, + "1022-async-exceptions.ts": 49732, + "1023-async-rc-stress.ts": 6131, + "1024-async-pending-exit.ts": 48202, + "1025-async-promise-capture.ts": 3959, + "1026-throw-promise.ts": 4948, + "1027-async-return-promise.ts": 4908, + "1028-async-return-record-literals.ts": 4271, + "1029-async-eager-chains.ts": 3619, + "103-ternary.ts": 5182, + "104-ternary-empty-arrays.ts": 7669, + "1050-comptime-tables.ts": 4897, + "1051-comptime-strings.ts": 47107, + "1052-comptime-records.ts": 39735, + "1053-comptime-json.ts": 5104, + "1054-comptime-modules/main.ts": 48253, + "110-number-radix.ts": 3792, + "111-record-entries.ts": 7069, + "1110-math-members.ts": 5365, + "1111-math-random.ts": 4260, + "1113-string-methods.ts": 54370, + "1114-string-unicode-island.ts": 52372, + "1115-parse-globals.ts": 3948, + "1116-island-static-mix.ts": 42223, + "1117-typeof-static-union.ts": 4732, + "1118-object-spread-conditional.ts": 39126, + "1119-switch-union.ts": 28754, + "112-class-descriptor-key.js": 39424, + "1121-infinity-number-tostring.ts": 4725, + "1122-any-captures.ts": 7404, + "1124-union-narrowed-retag.ts": 6000, + "113-promise-checked-exits.ts": 3453, + "114-live-record-delete.ts": 4924, + "115-array-compound.js": 5191, + "116-text-decoder-runtime.js": 46050, + "117-weak-cache-cycle.js": 5083, + "118-fs-stored-callbacks.cjs": 56960, + "119-native-patterns.js": 8396, + "1200-regex-test-basics.ts": 52932, + "1201-regex-replace.ts": 57037, + "1202-regex-substitutions.ts": 57467, + "1203-regex-split.ts": 3335, + "1204-regex-empty-unicode.ts": 42721, + "1205-regex-rc-stress.ts": 4531, + "1300-errors-basics.ts": 4518, + "1301-errors-subclass.ts": 4955, + "1302-errors-typed-catch.ts": 4560, + "1303-errors-rc-stress.ts": 3938, + "1304-errors-uncaught.ts": 4101, + "1305-errors-async-rejections.ts": 3614, + "1306-errors-runtime-instances.ts": 4054, + "1350-path-normalize-join.ts": 3568, + "1351-path-parts.ts": 4963, + "1352-path-resolve-relative.ts": 4503, + "1353-os-basics.ts": 4704, + "1354-builtin-bare-specifiers.ts": 4189, + "1355-url-parse.ts": 3863, + "1356-url-file-bridge.ts": 4207, + "1357-fsp-roundtrip.ts": 4886, + "1358-crypto-random.ts": 4050, + "1359-json-module/main.ts": 3853, + "1360-spawn-sync.ts": 4896, + "1361-spawn-events.ts": 3844, + "1362-spawn-timers.ts": 9749, + "1363-spawn-unhandled-error.ts": 5302, + "1364-union-truthiness.ts": 4307, + "1365-union-logical.ts": 4482, + "1366-union-equality.ts": 4253, + "1367-destructuring.ts": 5033, + "1368-constructor-functions.ts": 4831, + "1369-promise-union.ts": 3513, + "1370-spread.ts": 3969, + "1371-union-template-tostring.ts": 4126, + "1372-loose-null-tests.ts": 4513, + "1373-union-array-arms.ts": 3764, + "140-bitwise-operators.ts": 5173, + "1400-typedarray-basics.ts": 5411, + "1401-typedarray-slice-set.ts": 6335, + "1402-buffer-encodings.ts": 3500, + "1403-buffer-fs.ts": 7777, + "1404-zlib-crypto-bytes.ts": 6742, + "1405-bytes-unions-arrays.ts": 3762, + "1406-dataview-mp4.ts": 4549, + "1407-dataview-bounds.ts": 3820, + "1408-string-indexing.ts": 4530, + "1409-typedarray-integer-loops.ts": 4694, + "1420-number-statics.ts": 2928, + "1421-number-parse-strings.ts": 4454, + "1422-date-iso.ts": 3607, + "1423-text-codec.ts": 45738, + "1424-fs-options.ts": 3565, + "1425-stdin-tty.ts": 3853, + "1426-stdin-read.ts": 4250, + "1427-fromcharcode-lastindexof.ts": 3449, + "1428-settled-await-order.ts": 3904, + "1429-promise-catch-finally.ts": 6712, + "1430-promise-race.ts": 5576, + "1431-caught-tostring.ts": 4594, + "1432-destructured-params.ts": 5133, + "1433-filter-narrow.ts": 5015, + "1434-async-never.ts": 4402, + "1435-math-spread.ts": 4605, + "1436-default-undef-param.ts": 3807, + "1437-pad-default.ts": 3436, + "1438-promise-all.ts": 7568, + "1440-interval-basics.ts": 4290, + "1441-interval-clear-cross.ts": 7227, + "1442-interval-throw.ts": 4291, + "1443-signal-handlers.ts": 9442, + "1444-exit-listeners.ts": 5858, + "1445-exit-process-exit.ts": 5492, + "1446-exit-uncaught.ts": 4521, + "1447-stdin-closed-events.ts": 5005, + "1448-stream-columns.ts": 4280, + "1450-incdec-expression.ts": 3444, + "1451-instanceof-uint8array-unknown.ts": 4098, + "1452-return-through-finally.ts": 4660, + "1453-pmap-settled.ts": 7068, + "1454-nonnull-narrow-and-fcc-bytes.ts": 4716, + "1455-lambda-union-return-adoption.ts": 4826, + "1460-console-error-warn.ts": 4457, + "1461-process-pid-getuid-kill.ts": 4447, + "1462-exec-sync.ts": 4723, + "1463-timeout-unref.ts": 3720, + "1464-env-writes.ts": 4414, + "1465-env-value.ts": 4722, + "1466-child-containers.ts": 3465, + "1467-string-match.ts": 3798, + "1468-exec-path.ts": 4492, + "1469-remove-listener.ts": 6954, + "1470-child-lifecycle.ts": 4162, + "1471-child-unref.ts": 8772, + "1472-errno-code.ts": 5205, + "1473-promisify-execfile.ts": 5324, + "1474-string-decoder.ts": 4470, + "1475-readline-closed-stdin.ts": 55374, + "1476-assign-expression.ts": 4697, + "1477-in-expressions.ts": 3393, + "1478-promise-reject.ts": 4340, + "1479-destructuring-assign.ts": 4907, + "1480-os-network-interfaces.ts": 5202, + "1481-string-case-static.ts": 5232, + "1482-spawnsync-error.ts": 4518, + "1483-array-slice.ts": 47847, + "1520-fs-wider-surface.ts": 4261, + "1520-string-split-static.ts": 3932, + "1521-fs-lstat-lock.ts": 4472, + "1521-string-trim-pad-static.ts": 3262, + "1522-parseint-static.ts": 4734, + "1522-spawnsync-options.ts": 5888, + "1523-isnan-floor-static.ts": 4375, + "1523-spawn-options.ts": 4320, + "1524-atomics-sleep-static.ts": 4175, + "1524-catch-narrowing.ts": 4322, + "1525-child-exit-signal.ts": 4107, + "1525-unknown-typeof-validation.ts": 4804, + "1526-set-spread.ts": 5272, + "1527-logical-mixed-operands.ts": 3380, + "1528-delete-records-env.ts": 26816, + "1529-class-with-statics.ts": 3554, + "1530-array-push-variadic.ts": 4410, + "1530-spread-override-completion.ts": 4642, + "1531-delete-optional-fields.ts": 4468, + "1531-process-arch-versions.ts": 4294, + "1532-array-splice-shift.ts": 4135, + "1532-union-shared-field-read.ts": 3539, + "1533-bool-equality.ts": 3797, + "1533-path-platform-namespaces.ts": 4105, + "1534-crypto-hash-chain.ts": 4243, + "1534-union-as-arm-cast.ts": 3852, + "1535-spawn-fd-stdio.ts": 3827, + "1535-union-param-defaults.ts": 3756, + "1536-destructuring-defaults.ts": 4441, + "1536-string-array-sweep.ts": 4773, + "1537-chalk-hybrid/main.ts": 4555, + "1537-os-release-spawnsync-stdio.ts": 3030, + "1538-await-promiselike-return.ts": 4081, + "1538-math-static-scalar.ts": 2688, + "1539-readonly-set-map.ts": 4386, + "1539-unknown-truthiness.ts": 4573, + "1540-os-userinfo.ts": 4277, + "1540-void-statement.ts": 3770, + "1541-fs-readdir-dirent.ts": 5970, + "1541-union-keyed-reads.ts": 5137, + "1542-map-promise-values.ts": 3680, + "1542-record-literal-into-union.ts": 4161, + "1543-rest-destructuring.ts": 5386, + "1543-set-server-handles.ts": 8749, + "1544-dyn-json-reads.ts": 5370, + "1544-string-matchall.ts": 4375, + "1545-spread-order-and-optional.ts": 4546, + "1546-union-element-reads.ts": 50679, + "1547-computed-key-fold.ts": 5436, + "1548-boolean-condition-forms.ts": 3960, + "1549-array-isarray-unions.ts": 3329, + "1550-param-defaults-func-set.ts": 3161, + "1551-dyn-receiver-methods.ts": 6009, + "1552-exec-options-record.ts": 3255, + "1553-truthy-hof-predicates.ts": 4287, + "1554-caught-into-unknown.ts": 3533, + "1555-index-spread-into-declared.ts": 4772, + "1556-union-retag-width-arms.ts": 4319, + "1557-url-host.ts": 4070, + "1558-any-joins-and-dyn-validation.ts": 54305, + "1559-conditional-spread-index-merge.ts": 2926, + "1560-forof-homogeneous-tuples.ts": 32566, + "1561-forof-strings.ts": 3862, + "1561-promise-then.ts": 4850, + "1562-optional-chain-tails.ts": 4960, + "1562-spawn-conditional-spread.ts": 3616, + "1563-forof-iterator-projections.ts": 4225, + "1563-string-raw-fold.ts": 4244, + "1564-fs-watch.ts": 5142, + "1564-string-raw.ts": 4078, + "1565-spawn-pipe-streams.ts": 4189, + "1565-union-element-join.ts": 3622, + "1566-child-duck-interface.ts": 4142, + "1567-server-close-override.ts": 8728, + "1568-x509-fingerprint.ts": 3542, + "1569-fsp-mkdir-unlink-chmod.ts": 4083, + "1570-child-unref-kill-reffed.ts": 9583, + "1571-optional-call-tostring-tail.ts": 28217, + "1571-stdin-set-raw-mode-non-tty.ts": 3839, + "1572-promise-reject-all-tuple.ts": 4539, + "1572-x509-validity-date-gettime.ts": 4354, + "1573-promisify-execfile-env-spread.ts": 5359, + "1573-tdz-scalar-forward-capture.ts": 4394, + "1574-dyn-optional-method-number-keys.ts": 4461, + "1574-promise-all-tuple-literal.ts": 5082, + "1575-unknown-assert-into-record.ts": 4680, + "1576-width-coercions.ts": 4595, + "1577-url-hostname.ts": 3199, + "1578-exec-input-optional.ts": 3688, + "1579-matchall-index.ts": 4163, + "1580-exec-env-conditional-spread.ts": 3992, + "1581-declare-const-read.ts": 3904, + "1582-timer-sleep-resolve.ts": 5122, + "1583-loops-and-stream-captures.ts": 2955, + "1584-union-field-unassigned.ts": 4202, + "1585-union-field-conditional-ctor.ts": 4837, + "1586-derived-field-before-super-init.ts": 3740, + "1590-js-unannotated.js": 5105, + "1591-js-closures.js": 4745, + "1592-js-classes.js": 5879, + "1593-js-jsdoc-records.js": 4650, + "1594-js-async.js": 4426, + "1595-js-island-gap/main.js": 26477, + "1596-cjs-modules/main.js": 3160, + "1597-mjs-graph/main.mjs": 4960, + "1598-cjs-builtin-require/main.js": 3030, + "1599-js-uncaught-throw.js": 4259, + "1600-assert-passing.ts": 4325, + "1601-assert-fail-exit.ts": 4804, + "1602-assert-caught-error.ts": 5361, + "1603-assert-scalar-messages.ts": 4806, + "1604-assert-deep-structures.ts": 6023, + "1605-assert-import-forms.ts": 5339, + "1606-assert-strict-module.ts": 4600, + "1607-assert-throws-match.ts": 4414, + "1608-cjs-assert/main.js": 5188, + "1609-assert-async.ts": 4729, + "1610-path-win32-full.ts": 2755, + "1611-url-file-bridge-neutral.ts": 3733, + "1612-cjs-module-globals.cjs": 4516, + "1613-cjs-esm-proxy-named/main.mjs": 4105, + "1614-js-fence-dodges.cjs": 5207, + "1615-cjs-export-shapes/main.cjs": 5553, + "1616-cjs-esm-lexer-invisible/main.mjs": 3099, + "1617-cjs-esm-lexer-visible/main.mjs": 4087, + "1618-cjs-esm-poisoned-tail/main.mjs": 2476, + "1619-cjs-esm-reexport-invisible/main.mjs": 3415, + "1620-cjs-require-effects-order/main.js": 2713, + "1621-cjs-require-cache-hit/main.js": 3783, + "1622-cjs-require-conditional/main.js": 3828, + "1623-cjs-require-diamond/main.js": 3626, + "1624-cjs-require-dir-mid-file/main.js": 2336, + "1625-cjs-require-lazy-fn/main.js": 3015, + "1626-cjs-require-mjs/main.js": 2250, + "1627-mjs-import-cjs-requires/main.mjs": 2873, + "1628-checked-dynamic-builtin-args.cjs": 3077, + "1629-require-main-filename.cjs": 3479, + "1630-inspect-scalars.ts": 3977, + "1630-rmsync-retry-options.cjs": 3932, + "1631-inspect-arrays.ts": 5457, + "1632-inspect-records.ts": 4882, + "1633-inspect-map-set.ts": 4086, + "1634-inspect-classes.ts": 5725, + "1635-inspect-buffer.ts": 5155, + "1636-util-format.ts": 5015, + "1637-inspect-dyn.ts": 4071, + "1638-inspect-cjs.cjs": 3892, + "1639-versions-openssl-probe.ts": 4020, + "1640-fd-read-decode.ts": 4014, + "1641-string-search.ts": 21121, + "1642-object-fromentries-rows.ts": 4097, + "1643-metadata-dyn-return.cjs": 56433, + "1644-ee-basics.ts": 3623, + "1645-ee-extends.ts": 5009, + "1646-ee-once-remove.ts": 3768, + "1647-ee-meta-events.ts": 3840, + "1648-ee-error-event.ts": 2892, + "1649-ee-names-counts.ts": 4454, + "1650-ee-prepend.ts": 2707, + "1651-ee-max-listeners.ts": 4174, + "1652-ee-snapshot.ts": 5505, + "1653-ee-cjs.cjs": 4390, + "1654-ee-namespace.ts": 4636, + "1655-spawnsync-neutral.ts": 6342, + "1656-execsync-neutral.ts": 4702, + "1657-spawn-async-neutral.ts": 4011, + "1660-buffer-read-write-num.ts": 4936, + "1661-buffer-encodings-full.ts": 4916, + "1662-string-decoder-encodings.ts": 4639, + "1663-buffer-compare-search-fill.ts": 4818, + "1664-dyn-fn-boundary.cjs": 3636, + "1665-dyn-fn-mustcall/main.cjs": 4145, + "1666-dyn-fn-identity.ts": 3840, + "1667-dyn-fn-not-callable.cjs": 2882, + "1668-dyn-fn-throws.cjs": 3462, + "1669-symbol-identity.ts": 4719, + "1670-symbol-registry.ts": 4117, + "1671-symbol-typeof.ts": 5887, + "1672-symbol-containers.ts": 4625, + "1673-symbol-cjs.cjs": 6028, + "1674-symbol-inspect.ts": 4649, + "1676-func-array-surface.ts": 3616, + "1677-emitter-listeners.ts": 5664, + "1678-emitter-dyn-listeners.cjs": 6093, + "1679-console-dyn.js": 4398, + "1680-assert-bytes.ts": 3589, + "1681-assert-funcs.ts": 4450, + "1685-stream-readable-basics.ts": 8176, + "1686-stream-readable-paused.ts": 8142, + "1687-stream-readable-flow-control.ts": 6069, + "1688-stream-writable-basics.ts": 9377, + "1689-stream-writable-async-drain.ts": 7873, + "1690-stream-duplex.ts": 8422, + "1691-stream-transform.ts": 6383, + "1692-stream-pipe.ts": 5114, + "1693-stream-pipe-backpressure.ts": 3801, + "1694-stream-destroy.ts": 3612, + "1695-stream-props.ts": 8560, + "1696-stream-read-inside-read.ts": 4132, + "1697-stream-tick-vs-timer.ts": 7129, + "1698-stream-uncaught-error.ts": 4025, + "1699-stream-callback-shapes.ts": 4137, + "1700-mustcall-common/main.cjs": 4739, + "1701-mustcall-exit-report/main.cjs": 4788, + "1702-dyn-proto-dispatch.cjs": 4406, + "1703-arguments-rest-props.cjs": 3234, + "1710-cjs-export-class/main.js": 4152, + "1711-cjs-export-single-values/main.js": 3547, + "1712-field-incdec.ts": 3906, + "1713-js-dyn-fields.js": 5278, + "1720-assert-throws-shape.ts": 4205, + "1721-assert-throws-regex-class.ts": 3161, + "1722-assert-rejects.ts": 4021, + "1723-assert-does-not-reject.ts": 4049, + "1724-assert-iferror.ts": 3854, + "1725-assert-symbols.ts": 3165, + "1726-promise-with-resolvers.ts": 2792, + "1727-assert-throws-shape-exit.ts": 4670, + "1730-countdown-symbol-keys/main.js": 3893, + "1731-symbol-field-shapes.cjs": 4357, + "1732-symbol-field-cross-module/main.js": 4117, + "1740-stream-extends-readable.ts": 5412, + "1741-stream-extends-writable.ts": 7703, + "1742-stream-extends-duplex-transform.ts": 8664, + "1743-stream-extends-vt-dispatch.ts": 7746, + "1744-stream-set-encoding.ts": 3694, + "1745-stream-encoding-js.cjs": 3919, + "1746-stream-for-await.ts": 6732, + "1747-stream-for-await-js.cjs": 11913, + "1750-http-agent-options.ts": 7010, + "1751-options-record-stance.ts": 4331, + "1760-surplus-args-drop.cjs": 3419, + "1761-emitter-special-event-names.cjs": 3326, + "1770-assert-dyn-strict.ts": 4129, + "1771-assert-dyn-deep.ts": 4621, + "1772-assert-dyn-js.cjs": 3690, + "1773-assert-dyn-exit.ts": 3870, + "1780-http-res-surface.ts": 7391, + "1781-http-server-shapes.cjs": 11204, + "1790-computed-key-folds.ts": 3769, + "1791-searchparams-core.ts": 2566, + "1792-searchparams-encoding.ts": 3926, + "1793-searchparams-iteration.ts": 3839, + "1794-searchparams-url-live.ts": 3667, + "1795-dyn-handle-request.cjs": 7469, + "1796-dyn-handle-body.cjs": 4708, + "1797-dyn-handle-socket.cjs": 6317, + "1798-dyn-handle-typed-box.ts": 12433, + "1800-immediate-basics.ts": 3461, + "1801-immediate-handle.ts": 2828, + "1802-immediate-unref-exit.ts": 3773, + "1803-timeout-refresh.ts": 2890, + "1804-timers-module.ts": 4324, + "1805-timer-callback-args.ts": 4084, + "1806-timer-delay-trunc.ts": 3166, + "1810-stream-options-const-record.ts": 3962, + "1811-stream-option-value-callbacks.cjs": 3964, + "1812-stream-super-options-forwarding.cjs": 8384, + "1813-stream-finished.ts": 5772, + "1814-stream-pipeline.cjs": 8091, + "1815-stream-state-reads.cjs": 7977, + "1820-static-block-basics.ts": 3028, + "1821-static-block-order.ts": 2726, + "1822-static-block-js.js": 4178, + "1823-static-instance-method-names.ts": 2438, + "1824-for-of-destructuring-defaults.ts": 3053, + "1825-exhaustive-typeof-switch.ts": 3216, + "1826-settimeout-arguments-callback.js": 2649, + "1830-enum-numeric-basics.ts": 3631, + "1831-enum-string-const-reverse.ts": 3353, + "1832-enum-modules/main.ts": 3697, + "1835-var-basics.ts": 3553, + "1836-var-loop-capture.ts": 3991, + "1837-var-undefined-hoisting.ts": 3692, + "1838-var-modules/main.ts": 2987, + "1839-var-js/main.cjs": 3074, + "1840-jsdoc-import-type-only/main.js": 3723, + "1850-overload-basics.ts": 3730, + "1851-overload-return-narrowing.ts": 3097, + "1852-overload-class-members.ts": 4001, + "1853-overload-modules/main.ts": 4277, + "1854-ambient-declare-fn.ts": 2860, + "1855-ambient-declare-fn-uncaught.ts": 4252, + "1870-unit-type-values.ts": 3913, + "1871-empty-array-never.ts": 2656, + "1872-template-tostring-composite.ts": 3669, + "1880-json-declared-field-order.ts": 5166, + "1881-default-anon/main.ts": 3155, + "1882-default-cjs-interop/main.ts": 4152, + "1883-default-exports/main.ts": 4005, + "1890-ns-imports/main.ts": 4423, + "1891-ns-reexport/main.ts": 2975, + "1940-class-values-basics.ts": 2991, + "1941-class-values-registry.ts": 4395, + "1942-class-expressions.ts": 4086, + "1943-class-statics-expanded.ts": 3500, + "1944-class-values-modules/main.ts": 3932, + "1950-generic-fn-values.ts": 4360, + "1951-generic-classes-basics.ts": 4948, + "1952-generic-class-statics-values.ts": 4310, + "1953-generic-class-hierarchy.ts": 3171, + "1954-generic-modules/main.ts": 3610, + "1960-namespace-basics.ts": 3656, + "1961-namespace-nested.ts": 4076, + "1962-namespace-classes.ts": 3740, + "1963-namespace-aliases.ts": 3282, + "1964-namespace-type-only.ts": 3064, + "1965-namespace-ambient.ts": 3659, + "1966-namespace-modules/main.ts": 4077, + "1967-namespace-alias-typeonly.ts": 2697, + "1968-namespace-import-eq-snapshot.ts": 2527, + "1970-decorators-basics.ts": 4151, + "1971-decorators-rebinding.ts": 2897, + "1972-decorators-throwing.ts": 2556, + "1973-decorators-ambient.ts": 3932, + "1980-primitive-proto-statics.ts": 4096, + "1981-date-utc.ts": 3463, + "1982-freeze-resolve-passthrough.ts": 4042, + "1983-array-tuple-surfaces.ts": 4356, + "1990-labels-basics.ts": 3887, + "1991-for-in-loops.ts": 5008, + "1992-small-syntax.ts": 3829, + "200-strings.ts": 3521, + "2000-generic-methods-basic.ts": 4027, + "2001-generic-methods-generic-class.ts": 3431, + "2002-generic-methods-inheritance.ts": 3737, + "2003-generic-methods-object-literal.ts": 4544, + "2004-generic-methods-statics.ts": 3642, + "201-templates.ts": 2558, + "2010-generators-basics.ts": 3652, + "2011-generators-forof.ts": 3852, + "2012-generators-return-throw.ts": 3950, + "2013-generators-sent-values.ts": 4017, + "2014-generators-values.ts": 4246, + "2015-generators-yieldstar.ts": 3908, + "2016-generators-rc-stress.ts": 4275, + "2017-generators-async.ts": 2845, + "2018-generators-uncaught.ts": 3328, + "2019-generators-loops.ts": 3191, + "2020-generic-value-bindings.ts": 5274, + "2021-generic-value-binding-modules/main.ts": 3546, + "2022-width-index-capture.ts": 4336, + "2023-width-readonly.ts": 3104, + "2024-width-array-elems.ts": 3482, + "2025-width-union-compose.ts": 4076, + "2026-width-spread.ts": 3943, + "2030-width-nested.ts": 4567, + "2031-width-tuples.ts": 2753, + "2032-cjs-export-assigned-class-expression/main.cjs": 4056, + "2033-property-assigned-class-extends.cjs": 3174, + "2035-ternary-array-retag.cjs": 4091, + "2036-evolving-array-decl.cjs": 3778, + "2037-fn-decl-hoisting.cjs": 2776, + "2038-evolving-array-js.cjs": 4351, + "2040-any-bindings.ts": 3377, + "2040-mixin-heritage.ts": 3511, + "2041-any-params-returns.ts": 3626, + "2041-mixin-values.ts": 4380, + "2042-any-flow-loops.ts": 3135, + "2042-mixin-modules/main.ts": 4398, + "2043-any-dom-values.ts": 3973, + "2043-mixin-rc-stress.ts": 3648, + "2044-vtable-sibling-slots.ts": 3788, + "2045-objlit-accessors-basic.ts": 3867, + "2045-parameter-properties.ts": 4798, + "2046-abstract-classes.ts": 5738, + "2046-objlit-accessors-effects.ts": 3922, + "2047-objlit-accessors-shapes.ts": 3974, + "2047-optional-class-fields.ts": 5957, + "2050-dynamic-import-own-module/main.ts": 4276, + "2051-dynamic-import-then/main.ts": 3569, + "2052-dynamic-import-self.ts": 2505, + "2053-typeof-static-fold.ts": 3591, + "2054-destructuring-island-source.ts": 4039, + "2060-empty-tuple.ts": 3547, + "2070-computed-key-folds.ts": 5392, + "2071-integer-key-enumeration-order.ts": 4114, + "2072-expando-function-members.ts": 3911, + "2073-destructuring-assignment.ts": 3331, + "2074-island-destructuring.ts": 2722, + "2075-index-signature-runtime-keys.ts": 2808, + "2080-destructuring-defaults.ts": 4723, + "2081-destructuring-rest.ts": 3815, + "2082-destructuring-assignment.ts": 4463, + "2085-destructuring-heads-rest-params.ts": 3370, + "2087-destructuring-for-heads.ts": 3817, + "2090-index-signature-number-keys.ts": 3307, + "2091-index-signature-string-intersection.ts": 4503, + "2092-package-imports/main.ts": 3209, + "2093-timers-promises.ts": 4576, + "2094-diagnostics-channel.ts": 5184, + "2095-js-catch-unknown.js": 3505, + "2096-os-type.ts": 3468, + "2097-js-evolving-globals.js": 3426, + "210-string-methods.ts": 3239, + "2100-stream-default-hwm.ts": 4068, + "2101-dyn-param-defaults.ts": 4169, + "2102-empty-pattern-decls.ts": 3916, + "2105-computed-key-static-folds.ts": 3626, + "2106-comma-expressions.ts": 4728, + "211-string-unicode.ts": 3897, + "2110-top-object-types.ts": 3438, + "2111-json-stringify-unknown.ts": 3888, + "2112-array-at-findlast.ts": 3424, + "2113-string-index-methods.js": 3570, + "212-string-aliasing-append.ts": 3570, + "2120-package-self-import/main.ts": 3971, + "2121-esm-cycle-inert-backedge/main.ts": 2650, + "2123-ambient-import-crash/main.ts": 3746, + "2124-imports-field-wildcard/main.ts": 2731, + "2140-uri-component-codecs.ts": 3381, + "2160-dc-tracing-channel.cjs": 4690, + "2161-js-object-literal-identity.cjs": 4257, + "2162-js-dyn-destructure.cjs": 3551, + "2163-js-selfref-const.cjs": 4654, + "2164-js-then-dyn-handler.cjs": 5156, + "2165-js-throw-dyn.cjs": 3523, + "2166-cjs-getter-this/main.cjs": 3882, + "2170-island-array-exits.ts": 3858, + "2171-island-json-stringify.ts": 3712, + "2172-island-regexp-boundary.ts": 3327, + "2190-new-object-and-string-wrappers.ts": 2850, + "2191-uri-encoders.ts": 2942, + "2192-object-default-tostring.ts": 3177, + "2193-discarded-stdlib-reads.ts": 3355, + "2194-ambient-undef-chains.ts": 3563, + "2195-require-missing-package/main.mjs": 4117, + "2196-island-computed-key-chain.ts": 3932, + "2210-dyn-promise-crossing.cjs": 5102, + "2211-dc-trace-promise.cjs": 4621, + "2212-unhandled-rejection-listener.cjs": 4270, + "2213-async-local-storage.cjs": 4068, + "2214-dc-bind-store.cjs": 5707, + "2215-process-emit-warning-exit.cjs": 4386, + "2240-width-class-into-record.ts": 3665, + "2241-width-record-into-class.ts": 3361, + "2242-width-statics-into-record.ts": 3708, + "2243-width-assert-satisfies-shapes.ts": 3967, + "2250-tagged-templates.ts": 3434, + "2252-class-iterators.ts": 4459, + "2253-union-coercions.ts": 2359, + "2260-http2-constants.cjs": 3538, + "2280-builtin-namespace-destructure.cjs": 3057, + "2281-domexception-atob-btoa.cjs": 3389, + "2282-queue-microtask.cjs": 5820, + "2283-structured-clone.cjs": 4600, + "2284-regexp-constructor.cjs": 3741, + "2285-iferror-dyn.cjs": 2861, + "2286-dyn-object-walks.cjs": 3243, + "2300-dyn-record-spread-and-keyed-access.cjs": 2809, + "2301-cjs-export-table-dom-attach.cjs": 2887, + "2310-process-next-tick.ts": 4130, + "2311-next-tick-js-callbacks.js": 4068, + "2312-stream-underscore-assign.ts": 6594, + "2313-stream-underscore-assign-js.cjs": 4269, + "2314-process-introspection.ts": 3297, + "2320-await-unit.ts": 3657, + "2321-emitter-static-setmax.cjs": 4316, + "2322-dyn-array-sort.cjs": 3658, + "2323-timer-callback-returns.ts": 4288, + "2330-tls-server-runtime-options.cjs": 57265, + "2331-tls-server-options-typed.ts": 24831, + "2350-nan-global.ts": 3780, + "2351-async-methods.ts": 4037, + "2352-void-coercions.ts": 4230, + "2353-decorators-member-ambient.ts": 3783, + "2354-decorators-expression-ambient.ts": 3425, + "2360-tuple-to-array.ts": 4066, + "2361-assign-index-record.ts": 3954, + "2362-execsync-inherit.ts": 3811, + "2363-nullish-retag.ts": 4019, + "2364-in-runtime-key.ts": 3905, + "2365-dyn-into-island.ts": 4006, + "2366-string-well-formed.ts": 2861, + "2367-regexp-escape.ts": 3081, + "2368-set-methods.ts": 3869, + "2369-promise-try.ts": 4228, + "2370-group-by.ts": 4759, + "2371-iterator-helpers.ts": 4028, + "2380-buffer-module-named-import.ts": 3715, + "2381-builtin-default-imports.js": 3602, + "2382-cycle-two-decl/main.ts": 2942, + "2383-cycle-assertdoc/main.js": 2814, + "2384-cycle-mixed-bindings/main.ts": 2985, + "2385-builtin-reexport-facade/main.ts": 2368, + "2386-string-to-chars.ts": 3688, + "2387-tonumber-argv.ts": 4524, + "2388-tonumber-grammar-zoo.ts": 3447, + "2389-tonumber-unary-plus.ts": 3631, + "2390-dot-requires/main.cjs": 3823, + "2391-default-builtin-imports/main.ts": 4261, + "2392-block-guard-alias-scope.ts": 3432, + "2393-loop-exit-guard-narrow.ts": 4204, + "2394-loop-narrow-containment.ts": 3545, + "2395-while-cond-guard.ts": 3342, + "2396-born-narrowed-decl.ts": 3204, + "2397-branch-kill-merge.ts": 2872, + "2398-switch-arm-kill.ts": 2478, + "2399-reassign-kill-polarity.ts": 3975, + "240-stdout-write.ts": 3714, + "2400-kill-return-edge.ts": 2788, + "2401-kill-break-staging.ts": 3266, + "2402-labeled-break-kill.ts": 3546, + "2403-kill-continue-backedge.ts": 3341, + "2404-kill-throw-catch.ts": 3390, + "2405-sibling-arm-narrow.ts": 3636, + "2406-switch-clause-sibling-narrow.ts": 3321, + "2407-infinite-loop-seal.ts": 3706, + "2408-loop-terminality-reopen.ts": 3556, + "2409-loop-body-return-not-terminal.ts": 2952, + "2410-stacked-cases-terminality.ts": 2785, + "2411-exhaustive-switch-terminality.ts": 2898, + "2412-dowhile-guard-trailing-test.ts": 3018, + "2413-dowhile-kill-renarrow.ts": 3619, + "2414-dowhile-continue-kill.ts": 3030, + "2415-dowhile-break-trailing-test.ts": 3541, + "2416-spread-ternary-positions.ts": 3398, + "2417-ternary-local-inference.ts": 2779, + "2418-wrapped-ternary-arms.ts": 3414, + "2419-selector-ternary-union.ts": 2916, + "2420-nullish-null-identity.ts": 2738, + "2421-float-lane-inference.ts": 3483, + "2422-ieee-div-rem-corners.ts": 3493, + "2423-param-null-reassign.ts": 2469, + "2424-ternary-miss-first-narrowing.ts": 2704, + "2425-elseif-head-exit-narrow.ts": 3239, + "2426-default-snapshot-mutable/main.ts": 3047, + "2427-perf-hooks-now.ts": 3594, + "2428-field-redeclare-inherited.ts": 3306, + "2429-destructure-class-instance.ts": 3925, + "2430-empty-literal-unknown-field.js": 3247, + "2431-primitive-ctor-values.ts": 4135, + "2432-generic-member-fields-async.ts": 4525, + "2433-as-const-command-tables.ts": 4328, + "2434-deferred-init-fields.ts": 3024, + "2435-loose-same-kind-equality.ts": 3478, + "2440-console-inspect-args.ts": 5890, + "2441-console-process-argv.ts": 3753, + "2442-union-literal-arm-widening.ts": 3136, + "2443-union-literal-shadow-narrowing.ts": 3135, + "2444-union-literal-reducer-spread.ts": 2966, + "2445-math-minmax-nary.ts": 3844, + "2446-performance-global.ts": 3708, + "2447-island-boundary-slots/main.ts": 4610, + "2448-entries-null-arms-regex-arrays.ts": 4797, + "2450-private-instance-methods.ts": 4126, + "2451-private-fields.ts": 3682, + "2452-private-statics.ts": 3833, + "2453-private-accessors.ts": 3714, + "2454-private-generator-methods.ts": 4326, + "2455-private-brand-checks.ts": 2955, + "2456-private-async-methods.ts": 4273, + "2457-private-members.js": 3893, + "2460-qs-parse-grammar.ts": 5096, + "2461-qs-parse-options.ts": 3628, + "2462-qs-stringify.ts": 4992, + "2463-qs-escape-unescape.ts": 3734, + "2464-qs-require-forms.cjs": 4220, + "2470-mockable-module-shape.js": 2876, + "2471-record-keyed-write-hasown.js": 4081, + "2472-string-regexp-union.ts": 2606, + "2473-option-table-widths.js": 4586, + "2474-island-literal-forms.ts": 4522, + "2475-variadic-wrapper-island.js": 3845, + "2476-map-regex-values.ts": 3182, + "2480-recursive-record-tree.ts": 3879, + "2481-mutual-recursive-records.ts": 3675, + "2482-recursive-union-tree.ts": 3577, + "2483-recursive-record-cycles.ts": 3205, + "2484-json-stringify-circular.ts": 3643, + "2485-inspect-circular-refs.ts": 3845, + "2486-recursive-record-boundaries.ts": 2991, + "2487-recursive-deep-equal.ts": 4100, + "2488-ast-walker.ts": 4477, + "2490-find-miss-null-compare.ts": 3671, + "2491-strict-unit-compare-no-arm.ts": 3227, + "2492-loose-null-compare-unions.ts": 3901, + "2493-switch-unit-cases.ts": 3674, + "2494-no-arm-compare-effects.ts": 3403, + "2500-net-autosel-timeout.ts": 3482, + "2510-dyn-evolving-array-map.ts": 3667, + "2511-dyn-evolving-array-filter-foreach.ts": 4096, + "2512-dyn-evolving-array-mixed-push.ts": 4423, + "2520-private-statics-class-name-calls.ts": 3265, + "2521-private-statics-class-expression.ts": 3750, + "2522-private-statics-decorated.ts": 3195, + "2523-private-statics-aliased-class.ts": 3584, + "2530-object-destructuring-decl.ts": 3283, + "2531-array-tuple-destructuring-decl.ts": 4032, + "2532-param-destructuring-options.ts": 4645, + "2533-forof-destructuring.ts": 4187, + "2534-object-rest-decl.ts": 4358, + "2535-destructuring-assign-basics.ts": 3621, + "2536-destructuring-assign-nested.ts": 3573, + "2537-destructuring-assign-member-targets.ts": 3272, + "2538-destructuring-assign-class-source.ts": 3962, + "2539-class-instance-rest.ts": 4142, + "2540-accessor-destructuring-defaults.ts": 3446, + "2541-destructuring-eval-order.ts": 3928, + "2550-generics-keyof-pick.ts": 3409, + "2551-generics-value-aliases.ts": 3346, + "2552-generics-iface-methods.ts": 3488, + "2553-generics-signature-bindings.ts": 3749, + "2554-generics-frontier-mix.ts": 3794, + "2555-generics-keyof-writes.ts": 3364, + "2556-crypto-introspection.ts": 3435, + "2556-width-hybrid-shapes.ts": 4079, + "2557-tls-ca-store.ts": 3530, + "2557-width-field-lifts.ts": 4176, + "2558-index-signature-func-values.ts": 4225, + "2558-rejection-events.cjs": 3844, + "2559-index-signature-container-values.ts": 4449, + "2560-arraybuffer-dataview-set.ts": 3087, + "2561-object-is.ts": 4355, + "2562-intl-numberformat-en-us.ts": 3901, + "2563-stream-promises-pipeline.ts": 3564, + "2564-stream-promises-finished.ts": 6034, + "2565-stream-promises-js.cjs": 4473, + "2566-promise-reject-dyn-reason.js": 3377, + "2567-rest-spread-forward.js": 3534, + "2568-rest-spread-forward-dynamic.js": 4104, + "2569-upcast-identity.ts": 3496, + "2570-buffer-arg-validation.cjs": 5910, + "2571-searchparams-arg-validation.cjs": 4428, + "2572-readable-emitted-readable-flag.cjs": 3512, + "2573-fs-url-arg-ladders.cjs": 3763, + "2574-emitter-max-listeners-ladders.cjs": 3689, + "2575-string-destructuring-decl.ts": 4712, + "2576-string-destructuring-assign.ts": 3735, + "2577-builtin-global-destructuring.js": 4445, + "2578-jsval-into-unknown-rows.ts": 3828, + "2579-jsval-object-param-crossing.js": 3036, + "2580-jsval-routed-keyed-ops.js": 3956, + "2581-jsval-routed-calls.js": 3809, + "2582-jsval-object-statics.js": 3967, + "2582-jsval-routed-keyed-ops.js": 2714, + "2583-dyn-nullish-coalesce.js": 3955, + "2583-jsval-routed-calls.js": 4033, + "2584-jsval-object-statics.js": 3852, + "2584-union-dyn-collapse.ts": 3199, + "2585-dyn-nullish-coalesce.js": 4086, + "2585-unknown-array.ts": 3037, + "2586-object-assign-spread.js": 4129, + "2587-array-entries-forof.ts": 3963, + "2588-array-entries-chains.ts": 4778, + "2589-object-create-null.cjs": 3994, + "2590-object-create-dynamic.js": 3840, + "2591-ambient-generic-traps.ts": 3572, + "2592-ambient-trap-uncaught.ts": 3517, + "2593-generic-inert-bindings.ts": 3984, + "2594-nullish-generic-bindings.ts": 3028, + "2595-fs-arg-ladders.cjs": 6103, + "2596-net-arg-ladders.cjs": 3811, + "2597-dgram-send-ladders.cjs": 4888, + "2598-tls-arg-ladders.cjs": 26930, + "2599-stream-arg-ladders.cjs": 6141, + "2600-dyn-keyed-write-harness.js": 2931, + "2601-dyn-keyed-write-ops.js": 2148, + "2602-dyn-array-destructure.js": 2954, + "2603-island-keyed-write-dyn.js": 2848, + "2604-cycle-classes-mutual/main.ts": 3417, + "2605-cycle-three-module/main.ts": 3678, + "2606-dynamic-import-cycle/main.ts": 3530, + "2608-regex-named-groups.ts": 4497, + "2609-regex-named-replace.ts": 3665, + "2610-regex-named-matchall.ts": 3003, + "2611-regex-named-groups-js.cjs": 4787, + "2613-for-init-uninitialized-let.ts": 3768, + "2614-trap-binding-later-writes.ts": 2989, + "2615-nullish-field-record-binding.ts": 3529, + "2616-js-collect-probe-defers.js": 3466, + "2617-enum-static-field-import/main.ts": 3293, + "2618-ee-emit-override.ts": 3565, + "2619-ee-override-chain.ts": 3727, + "2620-ee-override-once-order.ts": 4249, + "2621-ee-override-error-throw.ts": 3855, + "2622-ee-override-filter.ts": 3910, + "2623-ee-job-queue.ts": 3743, + "2624-ee-override-js.cjs": 3084, + "2625-bytes-views.ts": 3970, + "2626-stream-event-names.ts": 4359, + "2627-stream-ticks-are-nextticks.ts": 7617, + "2628-stream-push-encodings.cjs": 3343, + "2629-stream-consumers.ts": 4441, + "2630-stream-consumers-errors.ts": 5041, + "2631-create-require/main.ts": 3703, + "2632-dyn-jsval-iterate.js": 3831, + "2633-island-promise-crossing.js": 5160, + "2634-stream-pipeline-arg-ladders.cjs": 3923, + "2635-trap-binding-unmappable-written.ts": 3043, + "2636-trap-binding-ambient-rooted-rewrite.ts": 3569, + "2637-create-require-bare/main.ts": 2767, + "2638-http-dyn-res-compat.cjs": 8125, + "2639-http-dyn-req-pause.cjs": 8808, + "2640-net-dyn-socket-compat.cjs": 4119, + "2641-http-agent-surface.cjs": 8974, + "2642-http-agent-maxsockets.cjs": 7586, + "2643-or-default-retag.ts": 3938, + "2644-http-client-url-argument.ts": 8788, + "2645-https-client-url-argument.ts": 5188, + "2646-top-level-await.ts": 3543, + "2647-top-level-await-modules/main.ts": 3228, + "2648-top-level-await-rejection.ts": 3718, + "2649-top-level-await-pending.ts": 3680, + "2650-top-level-await-self-import.ts": 3580, + "2651-top-level-await-pending-unhandled.ts": 3616, + "2652-top-level-await-dynamic/main.ts": 3624, + "2653-top-level-await-rejection-stops-loop.ts": 3405, + "2654-top-level-await-unrelated-rejection.ts": 3746, + "2655-top-level-await-cycle/main.ts": 3633, + "2656-top-level-await-cycle-order/main.ts": 3581, + "2657-top-level-await-cycle-dynamic/main.ts": 3334, + "2658-top-level-await-sync-completion/main.ts": 3454, + "2659-top-level-await-dynamic-cycle/main.ts": 2695, + "2660-top-level-await-cycle-rejection/main.ts": 3883, + "2661-top-level-await-dynamic-runtime-root/main.ts": 3717, + "2662-top-level-await-cycle-external-wait/main.ts": 3322, + "2663-top-level-await-dependency-errors/main.ts": 4049, + "2664-top-level-await-same-checkpoint-rejection.ts": 4075, + "2665-top-level-await-unhandled-listener-liveness.ts": 3625, + "2666-array-to-sorted.ts": 8369, + "2668-stored-number-array-iterator.ts": 3915, + "2669-array-copying-methods.ts": 4422, + "2670-uint8array-copy-iterate.ts": 4692, + "2671-array-copying-js.cjs": 3615, + "2672-http-request-response-callback.ts": 3326, + "2673-top-level-await-implicit-module.ts": 2622, + "2674-top-level-for-await-implicit-module.ts": 3487, + "2675-create-require-nested-esm.js": 3107, + "2675-process-self-reexec.ts": 3537, + "2676-indexed-read-strict-equality.ts": 3497, + "2676-record-clone-overrides.ts": 3652, + "2676-top-level-await-ambiguous/main.ts": 3641, + "2677-runtime-optional-closure.ts": 4530, + "2677-top-level-await-module-scope/main.ts": 3142, + "2678-date-instances.ts": 4477, + "2678-large-string-sparse-index.ts": 3931, + "2678-util-parseargs.ts": 7627, + "2679-util-parseargs-cjs.cjs": 4984, + "2680-util-parseargs-default.ts": 2670, + "2681-util-parseargs-dynamic.js": 3233, + "2682-fs-rename.ts": 4087, + "2683-filter-truthy-predicate.ts": 4348, + "2683-fs-rename-js.cjs": 2621, + "2684-filter-no-predicate-dyn.cjs": 3942, + "2684-fs-rename-abort.ts": 3403, + "2685-array-unshift-reverse.ts": 3942, + "2685-fs-write-sync.ts": 4263, + "2686-fs-file-handle.ts": 6233, + "2687-fsp-write-file-options.ts": 3951, + "2687-process-write-args.ts": 2844, + "2688-fs-stats-disk-fields.ts": 4789, + "2689-http-server-timeout-properties.ts": 3279, + "2690-https-server-timeout-option.ts": 56311, + "2691-retained-lowering-record-order.ts": 5946, + "2692-inline-record-assert-index.ts": 3857, + "2692-string-accumulation.ts": 3602, + "2693-math-constants.ts": 3816, + "2700-array-sort-complexity.ts": 3912, + "2700-http-static-trailers.ts": 6657, + "2700-wasi-core.ts": 3863, + "2701-array-sort-snapshot.ts": 3906, + "2701-http-static-trailer-wire.ts": 3412, + "2701-import-meta/main.mjs": 4097, + "2702-http-static-trailer-end.ts": 8433, + "2702-type-import-link-static/main.ts": 2947, + "2702-uint8array-to-sorted.ts": 3549, + "2703-array-sparse-sort.ts": 8716, + "2703-type-import-link-static-reexport/main.ts": 3510, + "2704-array-sparse-to-sorted.ts": 8447, + "2704-type-import-link-static-success/main.ts": 3172, + "2705-array-sparse-sort-append.ts": 7740, + "2705-type-import-link-dynamic/main.ts": 3687, + "2706-array-search-missing-needle.ts": 3192, + "2706-type-import-link-dynamic-success/main.ts": 4191, + "2707-array-search-huge-sparse.ts": 48438, + "2707-type-import-link-static-default-reexport/main.ts": 3502, + "2708-type-import-link-dynamic/main.ts": 3358, + "2720-array-read-parity.ts": 3686, + "2721-array-nested-missing-receiver.ts": 2904, + "2750-array-sparse-foundation.ts": 3895, + "2751-buffer-concat-sparse-list.ts": 3589, + "2752-array-optional-stores.ts": 3503, + "2753-array-optional-method-values.ts": 2814, + "2754-array-property-undefined.ts": 2681, + "2755-array-optional-literal-forwarding.ts": 3614, + "2780-array-parity-composition.ts": 12116, + "2781-array-missing-value-escape.ts": 3458, + "2782-array-sparse-callbacks.ts": 3870, + "2783-array-defaults-rest.ts": 3473, + "2784-array-reduce-missing-result.ts": 3973, + "2785-array-missing-destructuring.ts": 4123, + "2786-array-sparse-serialization.ts": 4457, + "2787-array-missing-string-arithmetic.ts": 3381, + "2788-array-missing-builtin-conversions.ts": 3415, + "2789-array-missing-optional-tostring.ts": 2621, + "2790-dynamic-import-self-name/main.ts": 3399, + "2791-record-optional-keys.ts": 3271, + "2792-record-optional-spread-entries.ts": 4055, + "2793-union-conversion-identity-capture.ts": 4295, + "2794-array-generic-callback-values.ts": 3662, + "2795-array-optional-typedarray-source.ts": 38684, + "2796-array-sparse-class-value-instanceof.ts": 3585, + "2800-array-expression-consumers.ts": 3265, + "2801-array-switch-consumers.ts": 4057, + "2820-array-missing-method-receivers.ts": 3301, + "2821-array-optional-numeric-comparisons.ts": 2316, + "2830-cjs-require-self-name/main.cjs": 3030, + "2840-finally-completions.ts": 3523, + "2841-using-sync.ts": 3234, + "2842-await-using.ts": 3418, + "2843-using-suppressed-error.ts": 3352, + "2844-node-disposable-resources.ts": 5430, + "2845-for-using-of.ts": 3355, + "2846-generator-using.ts": 3702, + "2850-async-generators-protocol.ts": 4747, + "2851-async-generators-values.ts": 4111, + "2852-timers-promises-interval.ts": 3376, + "2854-leading-bom-literals.ts": 2675, + "2855-searchparams-sort-complexity.ts": 2462, + "2856-dynamic-any-local-operators.ts": 3959, + "2857-branded-primitives.ts": 3738, + "2858-import-meta-resolve/main.mjs": 2597, + "2859-import-meta-resolve-dynamic/main.mjs": 2565, + "2860-require-resolve/main.cjs": 3076, + "2861-readable-iterator-close.ts": 3422, + "2862-web-readable-async-iteration.ts": 55094, + "2863-class-async-iterator.ts": 3586, + "2864-array-class-method-receivers.ts": 4152, + "2865-cjs-process-alias.cjs": 3499, + "2866-dyn-switch.ts": 3318, + "2867-array-shift-length.js": 3797, + "2868-empty-record-promise-presence.js": 3592, + "2869-nullish-mixed-lazy.ts": 3886, + "2870-and-dropped-truthy-arm.ts": 3748, + "2871-optional-promise-to-unknown.ts": 3966, + "2872-unobserved-dynamic-event.ts": 3095, + "2873-optional-receiver-loop-lifetime.js": 3310, + "2874-nullable-callback-field-cycle.js": 4239, + "2875-evolving-let-read-before-write.js": 2007, + "2876-class-unknown-roundtrip.ts": 3485, + "2877-child-unknown-roundtrip.ts": 3462, + "2878-class-private-unknown.cjs": 3481, + "2880-cjs-module-graph/main.cjs": 4418, + "2890-crypto-static-utility.ts": 3693, + "2891-json-record-key-escapes.ts": 3227, + "2892-windows-console-unicode.ts": 3154, + "2893-child-stdin-duplex.ts": 3517, + "2894-child-stdin-backpressure.ts": 4232, + "2895-child-stdin-write-after-end.ts": 3755, + "2896-child-stdin-write-after-finish.ts": 4128, + "2897-child-stdin-destroy.ts": 2592, + "2898-child-stdin-spawn-failure.ts": 3984, + "2899-nested-mutual-recursion.ts": 3524, + "2900-float64array-static.ts": 2647, + "2900-void-conditional-arrow.ts": 3544, + "2901-bigint-core.ts": 3085, + "2902-bigint-bytes.ts": 3574, + "2903-bigint-storage.ts": 4190, + "2904-bigint-errors.ts": 3820, + "2905-bigint-edges.ts": 3695, + "2906-bigint-wasi-width.ts": 3566, + "2910-overloaded-callable-alias.ts": 2729, + "2911-execfile-callback.ts": 3798, + "2912-execfile-callback-options.ts": 3803, + "2912-promisify-fs-readfile.ts": 3648, + "2913-builtin-callable-alias.ts": 5737, + "2914-fixed-tuple-call-spread.ts": 3851, + "2915-path-function-values.ts": 4013, + "2916-path-function-values-cjs.ts": 3957, + "2917-builtin-callable-widths.ts": 3640, + "2918-builtin-callable-widths-cjs.ts": 3701, + "2919-fs-function-values.ts": 3810, + "2920-fs-promises-function-values.ts": 3724, + "2921-zlib-callbacks.ts": 5492, + "2922-dyn-bitwise-not.cjs": 3645, + "2923-cjs-factory-export/main.cjs": 3645, + "2930-union-receiver-calls.ts": 4841, + "2931-union-dynamic-field-call.js": 3975, + "2932-create-require-program/main.ts": 4060, + "2933-static-dynamic-import/main.ts": 3736, + "2934-static-import-stored.ts": 3490, + "2935-module-namespace-values/main.ts": 3371, + "2936-static-loose-equality.ts": 4954, + "2937-bitwise-hot-loop.ts": 3448, + "2938-fs-sync-overloads.cjs": 3181, + "2939-child-shell-text.ts": 4371, + "2940-date-parse.ts": 3212, + "2940-fsp-realpath.ts": 3484, + "2941-fsp-lstat-identity.ts": 3903, + "2941-process-exit-code.ts": 3406, + "2942-fsp-readdir-dirent.ts": 4202, + "2942-process-exit-code-override.ts": 3082, + "2943-process-exit-code-invalid.ts": 3479, + "2944-process-exit-code-wrap.ts": 3266, + "2945-url-origin-username.ts": 2899, + "2946-child-fork-ipc/main.ts": 4761, + "2946-url-port-hash.ts": 2865, + "2947-set-readonly-seeds.ts": 3446, + "2948-child-fork-eof-callback/main.ts": 3476, + "2948-stdio-callback-record.ts": 3365, + "2949-child-fork-default/main.mjs": 3332, + "2949-url-password.ts": 3628, + "2950-fs-descriptor-publication.ts": 3569, + "2951-math-static-analytic.ts": 3919, + "2952-math-static-remaining.ts": 3652, + "2953-http-header-validation.ts": 7274, + "2954-http-outgoing-headers.ts": 9450, + "2955-http-static-state.ts": 6516, + "2956-http-static-informational.ts": 6092, + "2957-http-static-response-controls.ts": 6929, + "2961-emitter-computed-names.cjs": 4004, + "2962-emitter-computed-optional.ts": 2860, + "2963-child-fork-dispatch/main.ts": 3483, + "2964-indexed-compound.ts": 4204, + "2966-numeric-array-read-fusion.ts": 4381, + "2967-numeric-array-read-lifetime.ts": 3892, + "2968-numeric-array-borrow.ts": 3610, + "2969-scalar-record-results.ts": 4035, + "2970-constant-numeric-tables.ts": 2720, + "2971-constant-table-modules/main.ts": 3311, + "2972-http-static-distinct-snapshots.ts": 4474, + "2972-math-receiver-borrow.ts": 4401, + "2973-http-static-agent.ts": 3997, + "2973-integer-bitwise-arithmetic.ts": 3629, + "2974-array-search-from-index.ts": 116997, + "2974-http-static-module-values.ts": 7598, + "2974-numeric-remainder.ts": 3511, + "2975-bigint-default-radix.ts": 3179, + "2975-http-static-client-controls.ts": 3852, + "2976-http-static-incoming-state.ts": 8478, + "2976-json-stringify-no-arguments.js": 3354, + "2977-http-static-incoming-timeout.ts": 3463, + "2977-nested-array-binding-defaults.js": 2952, + "2978-http-static-client-timeout.ts": 4066, + "2978-regexp-optional-subject.js": 2771, + "2979-array-search-mixed-needles.js": 3599, + "2979-http-static-server-timeout.ts": 3821, + "2980-http-static-server-timeout-default.ts": 3238, + "2980-string-position-arguments.js": 3754, + "2981-http-static-events.ts": 3579, + "2981-string-optional-positions.ts": 3623, + "2982-http-static-close-all.ts": 2800, + "2982-string-position-coercion-order.js": 4005, + "2983-http-static-close-idle.ts": 3208, + "2984-http-static-close-upgrade.ts": 3773, + "2985-http-static-message-destroy.ts": 3787, + "2986-http-static-client-socket-finish.ts": 3574, + "2987-http-static-timeout-errors.ts": 3533, + "2988-http-static-client-abort.ts": 4341, + "2989-http-static-response-timeout-handled.ts": 3444, + "2990-http-static-request-timeout-handled.ts": 3719, + "2991-array-indexed-equality.ts": 3650, + "2992-stream-rows.ts": 3551, + "2993-fiber-stack-lifetimes.ts": 3792, + "2994-fromcharcode-scalar.ts": 4459, + "2995-math-hyperbolic.ts": 3860, + "2996-math-near-one.ts": 3086, + "2997-math-integer-float.ts": 3955, + "300-if-else.ts": 3194, + "3001-caught-typeof-object.js": 4263, + "3002-promise-then-two.ts": 4357, + "301-while.ts": 3525, + "302-for.ts": 3433, + "3020-string-last-index-position.ts": 3282, + "3021-buffer-union-narrow-callback.ts": 3951, + "3022-string-affix-positions.ts": 2990, + "3023-string-affix-position-coercion.js": 3327, + "3024-string-number-narrow-for-in.ts": 3695, + "3025-string-search-position-coercion.js": 3055, + "3026-array-last-index-of.js": 3971, + "3027-array-last-index-of-records.ts": 3174, + "3028-string-search-dynamic-needle.js": 3488, + "3029-string-search-union-needle.js": 2317, + "303-break-continue.ts": 3497, + "3030-array-search-no-arg.js": 3148, + "3031-array-relative-index-coercion.js": 4248, + "3031-string-last-index-search-value.js": 2998, + "3032-string-search-value.js": 3484, + "3033-string-search-needle-coercion.js": 3256, + "3034-arguments-with-parameters.js": 3316, + "3035-string-positioned-search-value.js": 3436, + "3036-string-object-search-value.js": 3562, + "3037-number-nullish-conversion.js": 3657, + "3038-number-scalar-unions.ts": 2371, + "3039-string-repeat-count.js": 3353, + "304-compound-incdec.ts": 3802, + "3040-string-prototype-call.js": 4850, + "3041-string-prototype-object-call.js": 3234, + "3042-string-padding-coercion.js": 3916, + "3043-string-split-arguments.js": 3976, + "3044-array-slice-splice-positions.js": 4465, + "3045-array-indexed-mutation.js": 3477, + "3046-array-indexed-ref-identity.ts": 3717, + "3047-object-prototype-tag.js": 7241, + "3048-object-own-prototype.ts": 2902, + "3049-array-flat-depth.ts": 4100, + "305-truthiness.ts": 3370, + "3050-array-splice-insert.ts": 4056, + "3051-array-join-default.ts": 3538, + "3052-array-construction.ts": 4542, + "3053-array-construction-js.js": 3392, + "3054-dynamic-abort-record.ts": 30732, + "3055-default-builtin-nodenext/main.ts": 3399, + "3056-default-builtin-bundler/main.ts": 3748, + "3057-default-builtin-nodenext-dynamic/main.ts": 3727, + "3058-optional-array-chain-join.ts": 3025, + "3059-arguments-property-names.ts": 3619, + "3061-concurrent-fiber-stacks.ts": 4083, + "3062-runtime-optional-record-guards.ts": 4619, + "3063-runtime-optional-class-guards.ts": 4458, + "3064-installed-entry-imports/main.ts": 2755, + "3065-installed-entry-js/main.js": 2496, + "3066-source-debugging/main.ts": 3345, + "3067-cjs-function-export-require/main.cjs": 3584, + "3068-debug-variables/main.ts": 2803, + "3068-url-checked-identity.ts": 3525, + "3069-set-checked-seed.js": 3730, + "3069-tuple-spread.ts": 3638, + "3070-checked-object-accessors.js": 3937, + "3070-collection-views.ts": 3112, + "3071-checked-specialization-narrowing.js": 4666, + "3071-map-contextual-record-seeds.ts": 3637, + "3072-optional-union-receivers.ts": 4348, + "3072-weak-process-streams.js": 3937, + "3073-optional-callable-module.js": 3783, + "3073-union-keyed-reads.ts": 3349, + "3074-discriminated-intersections.ts": 3833, + "3075-recursive-contextual-literals.ts": 4956, + "3076-nullish-record-defaults.ts": 3537, + "3077-optional-union-array-reads.ts": 4192, + "3078-forward-mutable-captures.ts": 4709, + "3079-forward-mutable-tdz.ts": 4069, + "3080-exhaustive-never-bindings.ts": 3678, + "3081-recursive-array-destinations.ts": 3824, + "3082-forward-write-unwind.ts": 3698, + "3083-set-string-seed.ts": 3916, + "3084-record-own-membership.ts": 4502, + "3085-conditional-record-construction.ts": 4272, + "3086-error-constructor-options.ts": 2549, + "3087-error-options-lifetime.ts": 3996, + "3088-array-wide-callbacks.ts": 4379, + "3089-array-find-narrowing.ts": 4095, + "3090-json-discriminated-records.ts": 4621, + "3091-json-recursive-discriminants.ts": 4799, + "3092-number-union-predicates.ts": 3661, + "3093-error-option-data.ts": 3834, + "3094-json-replacer-traversal.ts": 3366, + "3095-json-reviver-traversal.ts": 3492, + "3096-json-callback-nonfinite.ts": 3652, + "3097-json-callback-reentrancy.ts": 4051, + "3098-json-callback-space.ts": 4000, + "3099-json-callback-functions.ts": 4355, + "3100-json-callback-holder.js": 4131, + "3101-json-callback-bytes.ts": 4053, + "3102-json-unknown-fields.ts": 3096, + "3103-scalar-record-nested-control-flow.ts": 3773, + "3104-native-analysis-tables-loops.ts": 3270, + "3105-nullable-collections.ts": 3945, + "3106-mixed-insertion-spreads.ts": 4363, + "3107-nullable-collection-lifetimes.ts": 4026, + "3108-for-await-sync-arrays.js": 5613, + "3108-identity-map-keys.ts": 3552, + "3109-destructuring-unknown-defaults.js": 3464, + "3109-identity-union-collections.ts": 4940, + "3110-builtin-error-families.ts": 3056, + "3110-identity-collection-mutation.ts": 4022, + "3111-identity-collection-cycles.ts": 4287, + "3112-union-switch-control-flow.ts": 3956, + "3113-union-array-removal.ts": 4360, + "3114-union-record-field-write.ts": 3442, + "3115-zlib-static-compression-levels.ts": 5168, + "3116-sequence-expression-lifetimes.ts": 4189, + "3117-unknown-switch-control-flow.ts": 4180, + "3118-recursive-union-spread.ts": 3041, + "3119-runtime-optional-spread.ts": 3381, + "3120-dynamic-property-descriptors.js": 2965, + "3120-generator-method-loop-bindings.ts": 4201, + "3120-ir-nonfinite-numbers.ts": 4055, + "3121-compound-assignment-values.js": 3508, + "3121-dynamic-accessor-descriptors.js": 5206, + "3122-dynamic-delete-descriptors.cjs": 3618, + "3122-dynamic-delete-descriptors.js": 3463, + "3122-js-async-class-methods.js": 3826, + "3123-destructured-global-tdz.js": 3445, + "3124-array-prototype-borrow.js": 4427, + "3125-regex-global-match.ts": 2948, + "3126-js-number-radix/main.ts": 3569, + "3127-spawn-runtime-options.ts": 3489, + "3128-regex-last-index.ts": 4225, + "3129-js-token-union/main.ts": 4007, + "3130-child-generic-streams.ts": 4070, + "3131-child-rest-listeners.js": 3532, + "3132-child-generic-stream-completion.ts": 11386, + "3133-text-decoder-streaming.ts": 19582, + "3134-fs-vectors.ts": 4100, + "3135-fs-file-handle-controls.ts": 5084, + "3136-fs-file-handle-options.ts": 5319, + "3137-fs-vector-callbacks.cjs": 4121, + "3138-array-large-storage.ts": 5662, + "3139-regex-native-deep-alternatives.ts": 37923, + "3140-array-dense-access.ts": 5683, + "3141-map-string-key-hash.ts": 3292, + "3150-integer-remainder.ts": 4041, + "3151-array-push-writes.ts": 4409, + "3170-number-conversion-fast-paths.ts": 3918, + "3171-method-census-data-writes.ts": 4678, + "400-fib.ts": 3649, + "401-mutual-recursion.ts": 2468, + "402-string-functions.ts": 3526, + "403-void-and-params.ts": 3277, + "4030-runtime-object-truthiness.ts": 4681, + "4031-event-emitter-long-tuples.ts": 3970, + "4032-inline-rc-fast-paths.ts": 6135, + "404-rc-stress.ts": 3734, + "4040-adapted-function-identity.ts": 4226, + "4041-adapted-function-properties.ts": 3785, + "4042-object-is-union-subclass.ts": 3204, + "4043-nonnull-missing-element.ts": 4658, + "4044-adapted-callback-modules/main.ts": 3502, + "4045-optional-element-projections.ts": 4551, + "4046-captured-parameter-values.ts": 4678, + "4047-captured-parameter-rebinding.ts": 3804, + "405-params-optional.ts": 3480, + "406-params-defaults.ts": 3673, + "4060-cycle-shared-instance/main.ts": 2973, + "4060-stack-union-reads.ts": 3684, + "4061-cycle-evaluation-order/main.ts": 3762, + "4061-nullable-ref-fields.ts": 5610, + "4062-cycle-tdz-read/main.ts": 3351, + "4063-cycle-hoisted-calls/main.ts": 3608, + "4064-cycle-classes-after-init/main.ts": 3570, + "4065-cycle-init-throws/main.ts": 3220, + "4066-cycle-top-level-tdz/main.ts": 2340, + "4067-dynamic-import-cycle-tdz/main.ts": 3378, + "407-params-rest.ts": 3809, + "408-params-ctors-inheritance.ts": 4026, + "4080-optional-read-presence-tests.ts": 3072, + "4080-string-index-bounds.ts": 2694, + "4081-hoisted-function-tdz.ts": 4427, + "4081-string-index-unproven.ts": 3902, + "4082-hoisted-function-tdz-uncaught.ts": 2748, + "4083-dynamic-import-failure/main.ts": 3742, + "4084-record-optional-field-copies.ts": 4621, + "4085-generator-loop-close.ts": 4491, + "4086-optional-capture-defaults.ts": 2947, + "4088-class-static-tdz.ts": 3366, + "4089-class-wrapper-tdz.js": 2781, + "409-params-async-generics.ts": 4252, + "4090-computed-key-tdz.js": 3408, + "4091-class-evaluation-deferred.ts": 2828, + "410-params-rc-stress.ts": 2917, + "4140-array-callback-split-visit.ts": 6798, + "4141-array-callback-ambient-receiver/main.ts": 3870, + "4142-array-callback-factories.ts": 4472, + "4143-union-refinement-intersection-arms.ts": 4107, + "420-dead-strip-modules/main.ts": 2681, + "4290-acyclic-immutable-trees.ts": 3286, + "4291-acyclic-constructor-escapes.ts": 3619, + "4292-acyclic-readonly-bypass.ts": 4006, + "4293-acyclic-dynamic-writes.ts": 3787, + "4294-console-line-sizes.ts": 5430, + "4295-console-template-parts.ts": 3102, + "4296-console-glued-long-parts.ts": 4254, + "4410-inline-object-allocation.ts": 4263, + "4411-nullable-ref-values.ts": 5324, + "4412-nullable-record-values.ts": 4337, + "4413-cycle-old-late-death.ts": 3017, + "4413-nullable-null-and-undefined.ts": 4035, + "4414-cycle-old-weak-keys.ts": 3820, + "4414-nullable-string-values.ts": 5821, + "4415-identity-borrowed-operands.ts": 4327, + "4415-nullable-container-values.ts": 5953, + "4431-exception-pending-contexts.ts": 5399, + "4432-checked-downcast-failures.ts": 4507, + "4451-int32-field-storage.ts": 5079, + "4452-int32-field-dynamic-writes.ts": 4478, + "4453-int32-closed-locals.ts": 3221, + "4454-int32-field-reflection-reads.ts": 4583, + "4455-live-view-reads-without-stores.ts": 4961, + "4471-unassigned-field-reads.ts": 4391, + "4476-string-ascii-header-fact.ts": 4538, + "4477-buffer-write-ascii-runs.ts": 4115, + "4478-string-large-index-reads.ts": 4211, + "4481-array-optional-push.ts": 3640, + "4482-instanceof-static-class-optional.ts": 2991, + "4483-array-splice-statement.ts": 5079, + "4484-array-length-reset.ts": 3655, + "4485-array-splice-optional-item.ts": 4264, + "4486-array-field-element-borrows.ts": 3950, + "4487-array-literal-optional-values.ts": 5139, + "4520-optional-guard-narrowing.ts": 4441, + "4521-array-callback-element-presence.ts": 6451, + "4522-captured-parameter-lifetimes.ts": 3198, + "4523-array-pop-removal.ts": 4334, + "4524-array-callback-supertype-params.ts": 5586, + "4541-nullable-wrap-borrows.ts": 4310, + "4542-preserving-call-borrows.ts": 4231, + "4543-walk-borrowed-locals.ts": 3976, + "4544-checked-cast-aliases.ts": 4280, + "4545-borrowed-returns.ts": 4524, + "4546-rebound-borrowed-params.ts": 4010, + "4560-field-store-borrowed-receivers.ts": 3877, + "4561-virtual-borrowed-parameters.ts": 4633, + "4562-string-self-concat-move.ts": 3881, + "4563-array-read-projection-receivers.ts": 4188, + "4564-literal-choice-strings.ts": 4026, + "4568-for-of-hole-elements.ts": 4432, + "4569-shorthand-missing-elements.ts": 4672, + "4570-map-lookup-default-record.ts": 3777, + "4591-weak-keys-union-records.ts": 3889, + "4592-cycle-const-from-import/main.ts": 2581, + "4593-weak-keys-empty-objects.ts": 3813, + "4594-union-class-field-mixed-types.ts": 7147, + "4595-union-class-field-optional-receiver.ts": 3827, + "4596-error-subclass-int-fields.ts": 3477, + "4596-tdz-nullable-forward-capture.ts": 3990, + "4597-callback-field-method-name.ts": 4176, + "4598-live-array-ref-element-access.ts": 9941, + "4598-map-set-clear-reuse.ts": 5807, + "4598-os-available-parallelism.ts": 3624, + "4598-publish-constructor-stores.ts": 3208, + "4599-construction-only-field-borrows.ts": 5064, + "4600-construction-only-fields-dynamic-writes.ts": 3234, + "4601-cycle-holders.ts": 3389, + "4602-constructor-escape-order.ts": 3798, + "4610-array-ext-dyn-refresh.ts": 4533, + "4620-optional-chain-borrowed-receivers.ts": 4161, + "4621-edge-preserving-callees/main.ts": 4709, + "4630-contract-int32.ts": 4369, + "4630-reference-write-call-arguments.ts": 4010, + "4631-contract-nothrow.ts": 4027, + "4631-reference-write-aliases.ts": 4138, + "4632-contract-immutable.ts": 3925, + "4632-reference-write-loops-and-walks.ts": 4126, + "4633-contract-program-lifetime.ts": 5198, + "4633-reference-write-callbacks-returns.ts": 4361, + "4634-contract-program-lifetime-publish.ts": 51728, + "4634-optional-element-borrowed-returns.ts": 3758, + "4640-bitwise-identity-ranges.ts": 4521, + "4641-nothrow-try-catch.ts": 3856, + "4642-acyclic-contract.ts": 4836, + "4650-stale-property-narrowing.ts": 5065, + "4651-map-string-get-entry.ts": 3204, + "4652-stale-closure-binding-narrowing.ts": 4161, + "4660-typed-rest-spread-forwarding.ts": 2965, + "4671-scoped-array-read-borrows.ts": 4639, + "4690-cycle-bypass-long-lived.ts": 6384, + "4691-publish-constructor-self-alias.ts": 43679, + "4692-borrowed-result-mutating-callees.ts": 4134, + "4720-cold-throw-paths.ts": 3925, + "4721-integer-induction-numbers.ts": 3986, + "4730-touint32-large-magnitudes.ts": 3378, + "4731-string-mixed-ascii-slices.ts": 3992, + "4732-buffer-write-utf16le-runs.ts": 4419, + "4733-typed-array-read-compares.ts": 3723, + "4750-map-string-absent-filter.ts": 4339, + "4751-string-search-multibyte-needles.ts": 2934, + "4795-published-untyped-member-reads.ts": 4864, + "4806-uint32-loop-accumulators.ts": 4131, + "4810-union-identity-retags.ts": 45852, + "4811-union-retag-checked-cast.ts": 3777, + "4812-int32-wrapping-sums.ts": 4491, + "4813-typed-array-read-equality-bindings.ts": 5104, + "4820-sort-comparator-lent-arguments.ts": 4547, + "4821-callback-lent-arguments.ts": 4044, + "4822-stable-capture-reads.ts": 3520, + "4823-array-store-receivers.ts": 3708, + "4830-typed-teardown-chains.ts": 5155, + "4831-cycle-bypass-probe-windows.ts": 6539, + "4840-array-hole-free-prefix.ts": 5312, + "4860-int32-local-storage.ts": 5193, + "4870-array-pipeline-fusion.ts": 9277, + "4871-array-pipeline-analytics.ts": 4466, + "4872-array-pipeline-temporaries.ts": 8037, + "4875-stream-consumers-array-buffer.ts": 4195, + "4876-array-buffer-inspect.ts": 3460, + "4880-await-call-turn-order.ts": 3196, + "4881-await-call-exceptions.ts": 3913, + "4882-await-call-request-chain.ts": 3966, + "4883-await-values-and-hops.ts": 3305, + "4884-await-call-unhandled-sibling.ts": 3775, + "4885-await-call-checkpoints.ts": 3389, + "4890-regex-literal-sites.ts": 4481, + "4891-regex-plain-text-patterns.ts": 4954, + "4892-regex-exec-read-captures.ts": 5836, + "4900-bigint-division-cross-check.ts": 4132, + "4900-console-instances.ts": 3398, + "4901-bigint-radix-text.ts": 4240, + "4901-console-instance-errors.ts": 4118, + "4902-bigint-compound-assign.ts": 3348, + "4903-bigint-fixed-width.ts": 4053, + "4904-bigint-large-products.ts": 4084, + "4905-bigint-fixed-width-fusion.ts": 4866, + "4906-bigint-small-value-trees.ts": 4495, + "4907-bigint-random-trees.ts": 6985, + "4910-hole-free-prefix-upkeep.ts": 3869, + "4920-string-literal-switch.ts": 3948, + "4930-typed-record-reflection.ts": 6446, + "4931-typed-data-generic-walks.ts": 6005, + "4932-typed-json-unknown.ts": 4690, + "4940-async-return-adoption.ts": 4747, + "4941-async-return-adoption-try.ts": 4808, + "4942-async-return-adoption-values.ts": 4525, + "4943-async-return-adoption-interleaved.ts": 4076, + "4950-regex-compiled-captures.ts": 5853, + "4951-regex-compiled-last-index.ts": 4237, + "4952-regex-compiled-anchors-classes.ts": 2970, + "4953-regex-compiled-backtracking.ts": 4881, + "4954-regex-log-report.ts": 4017, + "4955-regex-compiled-differential.ts": 17656, + "4970-int32-call-abi.ts": 4034, + "4980-generator-early-exit-finally.ts": 4293, + "4981-generator-delegation-iterables.ts": 4701, + "4982-generator-sent-values.ts": 3850, + "4983-generator-reuse-iterables.ts": 4013, + "4984-generator-exceptions.ts": 3941, + "4985-generator-lazy-pipeline.ts": 5191, + "4986-generator-default-channels.ts": 4218, + "4987-generator-closures-methods.ts": 3564, + "4988-generator-async-interplay.ts": 4129, + "4989-generator-step-drives.ts": 3945, + "4990-lone-surrogates.ts": 4283, + "4991-lone-surrogate-halves.ts": 3965, + "4992-lone-surrogate-search.ts": 4450, + "4993-lone-surrogate-json.ts": 4533, + "4994-lone-surrogate-uri.ts": 3275, + "4995-lone-surrogate-regex.ts": 4305, + "4996-lone-surrogate-stdio.ts": 3980, + "4997-lone-surrogate-stdout-patch.js": 3708, + "4998-lone-surrogate-buffers.ts": 3397, + "4999-lone-surrogate-io.ts": 4183, + "500-array-basics.ts": 3681, + "501-array-push-pop.ts": 3744, + "5010-lifetime-region-generations.ts": 4361, + "5011-lifetime-region-outside-references.ts": 3723, + "5012-lifetime-region-shapes.ts": 5352, + "5013-lifetime-region-async.ts": 4836, + "5014-lifetime-region-nesting.ts": 4098, + "5015-lifetime-region-publish.ts": 44284, + "5016-lifetime-region-weak-keys.ts": 4090, + "5017-lifetime-region-cycles.ts": 2993, + "5018-lifetime-region-hierarchies.ts": 4448, + "5019-lifetime-region-values.ts": 4593, + "502-array-for-of.ts": 3697, + "5020-lifetime-region-large.ts": 6810, + "5021-lifetime-region-opaque-holders.ts": 3221, + "5022-lifetime-region-workers.ts": 43902, + "503-array-functions.ts": 3221, + "504-array-rc-stress.ts": 3902, + "5040-promise-all-race-turns.ts": 3963, + "5041-promise-all-turns.js": 3961, + "5042-async-generator-return-promise.ts": 4464, + "5043-async-generator-return-forms.ts": 3956, + "5045-generator-delegation-typed-next.ts": 4940, + "5046-generator-delegation-return-throw.ts": 4744, + "5047-generator-delegation-iterables-typed.ts": 5495, + "5048-generator-delegation-async.ts": 4004, + "5049-generator-delegation-edges.ts": 3818, + "5050-inherited-in-membership.ts": 2952, + "5051-typed-record-prototypes.ts": 4128, + "5052-class-for-in-unknown.ts": 4437, + "5053-json-replacer-arrays.ts": 4585, + "5054-required-field-delete.ts": 3565, + "5055-object-create-record-literal.ts": 3433, + "5056-generator-in-unknown.ts": 3552, + "5060-child-fork-exit-after-messages/main.ts": 4059, + "5061-child-fork-local-disconnect/main.ts": 3921, + "5062-child-fork-message-before-eof/main.ts": 5311, + "5065-global-increment-initializers.ts": 3409, + "5066-global-compound-updates.ts": 3878, + "5067-global-updates-in-functions.ts": 3060, + "5068-global-var-let-const-updates.ts": 3099, + "5069-global-update-modules/main.ts": 3105, + "5070-optional-read-bindings.ts": 3986, + "5071-optional-chain-scalars.ts": 4053, + "5072-optional-nullish-ternary.ts": 3786, + "5073-optional-results.ts": 3653, + "5074-optional-pop-shift.ts": 3809, + "5075-optional-reads-unchecked/main.ts": 4486, + "5076-optional-escapes.ts": 3781, + "5080-boolean-array-storage.ts": 9389, + "5081-boolean-array-dynamic-views.ts": 5005, + "5085-promise-allsettled-turns.ts": 5227, + "5086-promise-any-turns.ts": 4926, + "5087-promise-allsettled-any-dyn.js": 5648, + "5088-promise-combinator-thenables.js": 6097, + "5089-promise-settled-records.ts": 4902, + "5090-generator-finished-result-value.ts": 3980, + "5091-generator-delegation-arrays-strings.ts": 4920, + "5092-generator-delegation-sets-maps.ts": 5655, + "5095-console-count-group.ts": 4543, + "5096-console-assert-dir.ts": 3659, + "5097-console-table.ts": 4019, + "5098-console-time-warnings.ts": 7779, + "5099-console-methods-dynamic.cjs": 4211, + "510-array-map-filter-foreach.ts": 3693, + "511-array-indexof-includes.ts": 2587, + "5110-var-hoisting-early-reads.ts": 3722, + "5111-var-hoisting-closures-classes.ts": 3558, + "5112-var-hoisting-function-scope.ts": 3736, + "5113-tdz-let-const-class.ts": 3427, + "5114-var-hoisting-js.js": 2426, + "5115-regex-replace-compiled.ts": 4045, + "5116-regex-capture-reads.ts": 3563, + "5117-regex-log-report-spans.ts": 3810, + "5118-regex-replace-char-chains.ts": 3242, + "512-array-join-chains.ts": 3887, + "5120-frame-records.ts": 4007, + "5121-frame-objects.ts": 3950, + "5122-frame-result-slots.ts": 3225, + "5123-frame-reassigned.ts": 3642, + "5124-frame-objects-control.ts": 2980, + "5125-frame-mutating-methods.ts": 3316, + "5126-frame-returned-params.ts": 3759, + "5127-frame-loop-bindings.ts": 4535, + "513-array-methods-rc-stress.ts": 3991, + "5130-event-target-dispatch.js": 5194, + "5131-event-target-listener-errors.js": 5170, + "5132-event-target-typed.ts": 5485, + "5133-abort-signal-event-target.ts": 30480, + "5134-events-error-monitor.ts": 3910, + "5135-event-target-warnings.js": 38892, + "5136-events-error-monitor-string-name.ts": 3923, + "5137-events-error-monitor-computed-name.js": 4432, + "5138-events-error-monitor-shared-listener.ts": 3642, + "5139-event-target-listener-throw.ts": 4714, + "514-array-find-some-every.ts": 3747, + "5140-os-host-facts.ts": 4713, + "5141-os-constants.ts": 3991, + "5142-path-parse-format.ts": 3463, + "5145-path-matches-glob-basics.ts": 4364, + "5146-path-matches-glob-braces.ts": 5382, + "5147-path-matches-glob-extglob.ts": 3804, + "5148-path-matches-glob-classes.ts": 3686, + "5149-path-matches-glob-win32.ts": 4358, + "515-array-flatmap.ts": 4323, + "5150-small-array-inline-slots.ts": 4485, + "5155-cycle-header-types.ts": 32161, + "516-array-reduce.ts": 4410, + "5160-field-callback-receiver.ts": 4515, + "5161-field-callback-receiver-escape.ts": 3931, + "5162-field-method-reference-receiver.ts": 3961, + "5163-field-callback-receiver.cjs": 4008, + "5164-worker-field-callback-receiver.ts": 43587, + "5165-interface-method-dispatch.ts": 4146, + "5166-interface-method-values.ts": 5178, + "5167-interface-method-order.ts": 4344, + "5168-interface-method-hierarchy.ts": 5405, + "5169-interface-method-chains.ts": 5047, + "517-array-hof-index-args.ts": 3899, + "5170-string-scan-eviction.ts": 2657, + "5171-lone-surrogate-replace-seams.ts": 3047, + "5175-forin-typed-as-unknown.ts": 3918, + "5176-object-keys-typed-as-unknown.ts": 2645, + "5177-forin-dynamic-objects.ts": 3654, + "5178-forin-keys-js.js": 2761, + "5179-forin-typed-shapes.ts": 3622, + "518-array-sort.ts": 4004, + "518-promise-void-union-callbacks.ts": 3964, + "5180-interface-arrays.ts": 4400, + "5181-interface-array-methods.ts": 13672, + "5182-interface-array-boundaries.ts": 3272, + "5183-interface-property-reads.ts": 4146, + "5184-interface-property-objects.ts": 3495, + "5185-util-inherits.cjs": 6043, + "5186-util-inherits.ts": 6829, + "5187-util-deprecate.cjs": 6304, + "5188-util-deprecate-flags.cjs": 4852, + "5189-util-deprecate.ts": 5176, + "519-array-from-length.ts": 4670, + "519-promise-union-await-values.ts": 3522, + "5190-util-callbackify.cjs": 4881, + "5191-util-callbackify.ts": 5163, + "5192-util-debuglog.cjs": 5490, + "5193-util-debuglog.ts": 3737, + "5194-process-emit-warning-tick.cjs": 4043, + "5195-object-entries-typed-as-unknown.ts": 3294, + "5196-object-values-typed-as-unknown.ts": 4153, + "5197-object-entries-dynamic-objects.ts": 4163, + "5198-object-entries-values-js.js": 3223, + "5199-object-entries-identity.ts": 4287, + "520-map-basics.ts": 3177, + "5200-array-sort-keyed-numbers.ts": 5498, + "5201-array-sort-keyed-records.ts": 6386, + "5202-array-sort-keyed-lookalikes.ts": 3643, + "5203-typed-array-sort-default.ts": 7538, + "5204-typed-array-sort-comparators.ts": 5252, + "521-map-number-keys.ts": 3394, + "5210-process-memory-usage.ts": 2806, + "5211-process-identity.ts": 3698, + "5212-perf-marks-measures.ts": 4803, + "5213-perf-timing-errors.ts": 4464, + "5214-perf-entry-inspect.ts": 4525, + "5215-perf-timing-validation.js": 4263, + "5216-perf-spread-arguments.js": 4935, + "5217-perf-spread-typed.ts": 3571, + "522-map-foreach.ts": 2998, + "5220-url-parse-warnings.ts": 5276, + "5221-url-parse-shapes.ts": 5152, + "5222-url-parse-hosts.ts": 5614, + "5223-url-parse-query.ts": 5852, + "5224-url-format-objects.ts": 5092, + "5225-url-format-whatwg.ts": 5939, + "5226-url-resolve.ts": 4968, + "5227-url-legacy-dependency/main.ts": 5444, + "5228-url-domain-conversion.ts": 2782, + "5229-url-legacy-errors.cjs": 6339, + "523-map-ref-values.ts": 3549, + "5230-inline-union-fields.ts": 4686, + "5231-inline-union-field-kinds.ts": 4192, + "5232-inline-union-fields-dynamic.ts": 4074, + "5233-inline-union-fields-shapes.ts": 4531, + "5234-inline-union-class-fields.ts": 4699, + "5235-inline-union-fields-publish.ts": 3783, + "5236-inline-union-unchecked-reads.ts": 3109, + "5237-inline-union-frame-objects.ts": 2338, + "524-map-cycles.ts": 3268, + "5240-event-target-subclass.ts": 5177, + "5241-event-subclass.ts": 5478, + "5242-event-target-subclass-hierarchy.ts": 4631, + "5243-event-target-subclass-dynamic.ts": 4520, + "5244-event-target-subclass.js": 5329, + "5245-event-target-subclass-signals.ts": 33048, + "5246-event-target-subclass-listener-throw.ts": 3829, + "5247-event-target-subclass-lifetimes.ts": 6504, + "5248-event-target-subclass-warnings.ts": 4300, + "5249-event-target-subclass-unconstructed.ts": 4427, + "525-map-rc-stress.ts": 3704, + "5250-cipher-aes-gcm.ts": 7929, + "5251-cipher-aes-cbc.ts": 15678, + "5252-cipher-aes-ctr.ts": 26018, + "5253-cipher-chacha20-poly1305.ts": 7999, + "5254-cipher-errors.js": 26643, + "5255-cipher-encodings.cjs": 20470, + "5256-cipher-deprecation.cjs": 48818, + "5257-cipher-vectors.ts": 18839, + "5258-cipher-handles.js": 21996, + "5259-cipher-chunked.ts": 21780, + "526-set-basics.ts": 3497, + "5260-record-unknown-identity.ts": 3759, + "5261-optional-field-identity.ts": 3633, + "5262-record-unknown-many.ts": 4065, + "527-set-foreach.ts": 3282, + "5270-url-parse-no-deprecation.cjs": 4123, + "5271-url-parse-throw-deprecation.cjs": 5457, + "5275-http-end-callback-order.ts": 4317, + "5276-style-text-hex-colors.cjs": 4489, + "5277-fs-read-file-buffer-option.cjs": 3576, + "5278-host-null-bytes.cjs": 8285, + "5279-search-params-null-init.cjs": 3511, + "528-set-seeded.ts": 3372, + "5285-blob-construct.ts": 4331, + "5286-blob-readers.ts": 3684, + "5287-blob-inspect.ts": 4285, + "5288-blob-validation.js": 4292, + "5289-blob-read-order.ts": 3682, + "529-map-seeded.ts": 3677, + "5290-blob-dynamic.js": 4399, + "5295-readline-promises-question.ts": 3697, + "5296-readline-lines.ts": 3534, + "5297-readline-callback-events.cjs": 3926, + "5298-readline-abort.cjs": 12732, + "5299-readline-stdin.ts": 4774, + "530-record-arrays.ts": 3665, + "5300-stream-add-abort-signal.ts": 34654, + "5301-stream-add-abort-signal-errors.cjs": 12589, + "5302-stream-promises-options.ts": 13246, + "5303-stream-finished-callback-opts.cjs": 9506, + "5305-json-stringify-typed-arrays.ts": 5926, + "531-record-array-hofs.ts": 3761, + "5315-map-iterate-after-front-deletes.ts": 3399, + "5316-map-lru-eviction.ts": 4060, + "5317-map-iterate-while-mutating.ts": 3994, + "5318-set-iterate-after-deletes.ts": 3956, + "5319-map-iteration-values.ts": 4002, + "532-record-arrays-rc-stress.ts": 3024, + "5320-map-iterate-across-compaction.ts": 4445, + "5321-integer-closed-arithmetic-loops.ts": 3363, + "5321-json-parse-cycles.ts": 3162, + "5322-integer-variable-step-loops.ts": 3747, + "5322-json-stringify-parsed-trees.ts": 4167, + "5323-dyn-numeric-index-reads.ts": 3375, + "5323-int32-nonnegative-slot-facts.ts": 3657, + "5324-int32-initializer-locals.ts": 2946, + "5324-structured-clone-documents.ts": 4653, + "5325-record-boundary-returns.ts": 3627, + "5326-record-boundary-params.ts": 3878, + "5327-record-boundary-identity.ts": 2625, + "5328-record-boundary-open.ts": 3032, + "5329-record-boundary-recursion.ts": 3600, + "533-array-element-cycles.ts": 3019, + "5330-record-boundary-fields.ts": 3682, + "5331-record-boundary-methods.ts": 3949, + "5332-int32-narrowed-slot-facts.ts": 3391, + "5333-integer-guarded-while-counters.ts": 3537, + "5333-record-boundary-nullable-argument.ts": 4003, + "5334-fetch-mentions-without-calls.ts": 3134, + "5335-stream-operators-values.ts": 5552, + "5335-top-level-await-pending-exit-code.ts": 3309, + "5336-stream-operators-promise-timing.ts": 3761, + "5336-top-level-await-pending-exit-listener.ts": 4072, + "5337-dc-subscriber-throw-next-tick.cjs": 4314, + "5337-stream-operators-concurrency.ts": 9296, + "5338-js-tdz-function-element.js": 2718, + "5338-stream-operators-checks.cjs": 4825, + "5339-array-buffer-constructor.js": 3399, + "5339-stream-for-await-hops.ts": 5761, + "534-record-width-subtyping.ts": 3917, + "5340-readable-from-options.ts": 4100, + "5341-compound-any-operand.ts": 4139, + "5341-generator-callback-params.ts": 4032, + "5341-integer-recursion-boundaries.ts": 3324, + "5341-readable-from-dynamic.cjs": 5054, + "5342-compound-any-operand.cjs": 3210, + "5342-generator-scalar-channels.ts": 3572, + "5342-integer-recursion-stack-and-mutual.ts": 4091, + "5342-stream-compose.ts": 8635, + "5343-any-flow-compound.ts": 3298, + "5343-integer-recursion-array-index.ts": 4086, + "5343-iterator-result-records.ts": 3462, + "5343-stream-compose-edges.ts": 8761, + "5344-json-parse-undeclared-keys.ts": 4683, + "5344-stream-pipeline-timing.ts": 3627, + "5345-object-values-for-of-unknown.ts": 3893, + "5346-object-values-length-dynamic.ts": 4302, + "5347-object-values-loop-control.ts": 3777, + "5348-object-values-for-of-js.js": 3584, + "5349-object-entries-values-optional.ts": 3677, + "535-object-statics.ts": 4668, + "5350-object-values-wide-record.ts": 4386, + "5351-object-values-methods-index.ts": 3615, + "5352-final-field-loop-reads.ts": 3880, + "5353-captured-const-values.ts": 4470, + "5354-captured-const-tdz.ts": 3331, + "5355-captured-function-declarations.ts": 3574, + "5356-captured-tdz-ordering.ts": 3626, + "5357-init-only-module-bindings.ts": 3698, + "536-map-seed-array.ts": 3057, + "5360-array-sort-comparator-calls.ts": 4503, + "5361-array-sort-inconsistent-comparators.ts": 4396, + "5362-array-sort-comparator-throws.ts": 3173, + "5363-array-sort-comparator-writes.ts": 12179, + "5364-array-sort-union-and-boolean-elements.ts": 14770, + "5365-array-sort-dynamic-values.js": 4175, + "537-map-iter-drains.ts": 3108, + "5370-zlib-stream-roundtrip.ts": 6069, + "5371-zlib-stream-chunking.cjs": 3999, + "5372-zlib-stream-errors.cjs": 4377, + "5373-zlib-stream-options.cjs": 4901, + "5374-zlib-stream-flush-params.ts": 4306, + "5375-zlib-stream-promises.ts": 5322, + "5376-zlib-constants.cjs": 3332, + "5377-zlib-stream-backpressure.cjs": 5428, + "5378-zlib-sync-options.cjs": 5415, + "5379-zlib-callback-options.ts": 5768, + "538-map-set-for-of.ts": 3575, + "5390-interface-loop-element-lifetimes.ts": 4065, + "5391-interface-dispatch-hierarchies.ts": 4925, + "5392-interface-receiver-bindings.ts": 3293, + "5393-interface-array-holes.ts": 3549, + "5394-interface-implementers.ts": 4320, + "5395-locale-compare-ascii.ts": 4299, + "5396-locale-compare-latin.ts": 3694, + "5397-locale-compare-sorting.ts": 4218, + "540-tuples-basics.ts": 3768, + "5400-json-parse-typed-keys.ts": 4494, + "5405-buffer-arraybuffer-window.ts": 3875, + "5406-util-types-keys.ts": 4065, + "5407-http-header-field-limit.ts": 2684, + "5408-http-unread-request-end.ts": 4832, + "5409-http-held-request-body.ts": 4395, + "541-ref-array-json.ts": 4658, + "5410-inspect-class-values.ts": 4013, + "5411-inspect-class-hierarchies.ts": 3695, + "5412-inspect-dynamic-collections.ts": 2565, + "5413-inspect-class-values.cjs": 4189, + "5415-zlib-dynamic-inputs.cjs": 3913, + "542-union-element-arrays.ts": 4031, + "5420-readable-from-generators.ts": 5476, + "5421-readable-from-generators.cjs": 3700, + "5422-stream-async-push-wakeup.ts": 4528, + "5423-stream-end-and-eos-timing.ts": 3712, + "5424-stream-write-buffer-encoding.ts": 3446, + "5425-pipeline-generator-stage.ts": 3465, + "5426-pipeline-generator-errors.ts": 4156, + "5427-pipeline-generator-backpressure.ts": 3689, + "5428-pipeline-generator-stages.cjs": 5519, + "5429-pipeline-generator-buffers.ts": 4449, + "5430-dyn-number-string-boxes.ts": 3851, + "5435-crypto-hash-algorithms.ts": 4090, + "5436-crypto-hash-names.js": 3513, + "5437-crypto-hmac-algorithms.ts": 3873, + "5438-crypto-kdf-digests.ts": 4076, + "5439-crypto-kdf-callbacks.js": 3741, + "5440-crypto-hash-encodings.js": 5108, + "5441-crypto-hash-output-length.ts": 5257, + "5442-crypto-random-values.ts": 4596, + "5443-crypto-random-arguments.js": 4093, + "5444-crypto-timing-safe-equal.js": 3904, + "5445-crypto-secret-key-objects.ts": 3885, + "5445-stream-buffer-chunks.ts": 4371, + "5446-crypto-secret-key-errors.js": 3542, + "5446-stream-buffer-chunks-dynamic.js": 5530, + "5447-fs-readdir-order.ts": 3865, + "5448-fs-glob-patterns.ts": 3617, + "5449-fs-glob-options.ts": 4047, + "5450-fs-glob-validation.js": 4514, + "5451-fs-promises-glob.ts": 4041, + "5452-fs-glob-callback.ts": 3311, + "5455-power-of-two-remainder.ts": 3496, + "5456-remainder-large-integer-dividends.ts": 3106, + "5457-lcg-modulus.ts": 3217, + "5458-fractional-remainder.ts": 3231, + "5460-locale-compare-contractions.ts": 4279, + "5461-locale-compare-equivalents.ts": 4168, + "5462-locale-compare-probe-sweep.ts": 5118, + "5463-locale-compare-combining-letters.ts": 4089, + "5464-locale-compare-fractions.ts": 3465, + "5465-dyn-index-read-arrays.ts": 2910, + "5466-dyn-index-read-special.ts": 3472, + "5470-strip-vt-osc.cjs": 2950, + "5471-strip-vt-csi.cjs": 3252, + "5472-strip-vt-random.cjs": 3939, + "5473-strip-vt-unterminated.cjs": 4153, + "5474-strip-vt-surrogates.ts": 3689, + "5510-assert-error-properties.js": 3848, + "5511-assert-error-class.ts": 3354, + "5512-assert-error-options.js": 3961, + "5513-assert-deep-equal-loose.js": 4575, + "5514-assert-deep-equal-typed.ts": 4346, + "5515-assert-deep-strict-typed-messages.ts": 3857, + "5516-assert-deep-equal-edges.js": 4060, + "5517-assert-partial-deep-equal.js": 4428, + "5518-assert-partial-deep-typed.ts": 4540, + "5519-assert-partial-deep-typed-edges.ts": 4298, + "5520-assert-record-literal-failures.ts": 4043, + "5520-dyn-property-read-receivers.ts": 3946, + "5521-assert-empty-message.js": 4460, + "5521-dyn-property-read-keys.ts": 3510, + "5522-assert-throws-failure-properties.ts": 3814, + "5523-assert-class-options.js": 4920, + "5524-assert-class-skip-prototype.ts": 3993, + "5530-buffer-pool.ts": 4954, + "5531-buffer-pool-first-slab.ts": 4419, + "5532-buffer-pool-first-slab-untyped.mjs": 156958, + "5540-fs-callback-forms.cjs": 5033, + "5541-fs-stats-fields.cjs": 5031, + "5542-fs-promises-parity.cjs": 3782, + "5543-fs-promises-typed.ts": 4425, + "5544-fs-opendir.cjs": 4598, + "5545-fs-options-encoding.cjs": 3812, + "5546-fs-read-stream.cjs": 4053, + "5547-fs-write-stream.cjs": 5026, + "5548-fs-callback-arguments.cjs": 3447, + "5549-fs-callback-option-checks.cjs": 4220, + "5550-locale-compare-ascii-words.ts": 3391, + "5551-array-search-references.ts": 4559, + "5552-string-appends.ts": 3836, + "5553-string-append-char-code.ts": 3220, + "5554-fs-streams-typed.ts": 4826, + "5555-fs-callback-turns.cjs": 4160, + "5555-http-server-close-keep-alive.ts": 16562, + "5556-http-client-agent-connection.ts": 7869, + "5557-http-outgoing-header-values.ts": 4486, + "5558-http-incoming-duplicate-headers.ts": 3277, + "5559-http-expect-header.ts": 13540, + "5560-http-response-framing.ts": 11999, + "5561-http-max-header-size.ts": 4546, + "5562-https-verify-errors.ts": 5339, + "5563-http-keep-alive-timeout.ts": 18223, + "5564-http-request-signal.ts": 6038, + "5565-fs-dirent-untyped.mjs": 4190, + "5566-fs-dirent-dyn-boundaries/main.mjs": 4370, + "5567-fs-cpsync.ts": 4231, + "5568-fs-cp-errors.js": 4710, + "5569-fs-cp-symlinks.ts": 3975, + "5570-fs-cp-async.ts": 4871, + "5571-fs-cp-deep.ts": 4651, + "5585-record-results-inlined.ts": 3799, + "5595-net-ref-unref.ts": 2930, + "5600-dyn-cycle-self.ts": 2377, + "5601-dyn-cycle-mutual.ts": 3087, + "5602-dyn-cycle-arrays.ts": 3074, + "5603-dyn-cycle-identity.ts": 3151, + "5604-dyn-cycle-checks.ts": 4016, + "5605-dyn-cycle-containers.ts": 4827, + "5606-dyn-cycle-capsules.ts": 3409, + "5610-readable-from-sets-and-views.ts": 6055, + "5611-readable-from-class-iterables.ts": 4787, + "5612-readable-from-iterables.cjs": 4888, + "5613-readable-from-iterable-timing.cjs": 4572, + "5614-readable-from-iterable-errors.cjs": 4862, + "5615-next-tick-callback-phases.ts": 4035, + "5616-next-tick-callback-phases.cjs": 3650, + "5617-pipeline-function-ends.ts": 55330, + "5618-pipeline-function-ends-errors.ts": 9347, + "5619-pipeline-function-ends.cjs": 5502, + "5620-timers-promises-values.ts": 3441, + "5621-util-format-float.ts": 4023, + "5622-events-once.mjs": 2752, + "5623-events-once.ts": 3430, + "5624-timers-promises-unawaited.ts": 3337, + "5625-promisify-exec.ts": 7797, + "5626-promisify-forms.ts": 2892, "5627-exec-callback.ts": 2500, + "5628-promisify-timers.ts": 4069, + "5629-promisify-stream.ts": 4133, + "5630-promisify-zlib.ts": 3777, "5631-promisify-crypto.ts": 2600, "5632-promisify-dns.ts": 2000, - "5644-net-socket-addresses.ts": 2393, - "5645-net-socket-callbacks.ts": 2060, - "5646-net-server-connections.ts": 2755, - "5647-net-is-ip.ts": 2560, - "5648-dns-lookup-forms.ts": 3416, - "5649-dns-service-servers.ts": 4916, - "5650-dns-lookup-errors-untyped.cjs": 3889, - "5681-array-pop-and-length.ts": 3216, - "5800-broadcast-channel.ts": 28374, - "5801-broadcast-channel.cjs": 27251, - "5802-broadcast-channel-workers.ts": 27251, - "5803-worker-environment-data.ts": 29298, - "5804-worker-environment-data.cjs": 26404, - "5805-worker-receive-message-parent-port.ts": 30268, - "5806-worker-resource-limits.ts": 29711, - "5807-worker-error-values.ts": 35248, - "5808-worker-unhandled-rejections.ts": 33209, - "5809-process-exit-and-rejections.cjs": 30261, - "5810-mock-method-records.ts": 6363, - "5811-mock-tracker-restore.ts": 4503, - "5812-dyn-box-async-fields.ts": 5278, - "5813-mock-timers-module.ts": 4227, - "5814-mock-timers-date.ts": 17708, - "5831-util-types-brands.ts": 4380, - "5832-util-types-brands-dynamic.js": 3658, - "5833-url-search-params-iterators.ts": 5339, - "5834-url-search-params-iterators-dynamic.mjs": 3797, - "5835-util-format-integer-specifiers.ts": 2768, - "5836-url-search-params-tuple-pairs.ts": 3193, - "5837-util-format-json-circular.ts": 3408, - "5838-qs-stringify-bigint.ts": 3519, - "5841-json-typed-dyn-members.ts": 3238, - "5842-qs-parse-null-prototype.ts": 7077, - "5843-qs-parse-null-prototype-js.mjs": 5395, - "5844-date-unknown-values.ts": 4543, + "5644-net-socket-addresses.ts": 3299, + "5645-net-socket-callbacks.ts": 4363, + "5646-net-server-connections.ts": 4089, + "5647-net-is-ip.ts": 3406, + "5648-dns-lookup-forms.ts": 4891, + "5649-dns-service-servers.ts": 4574, + "5650-dns-lookup-errors-untyped.cjs": 4634, + "5651-tls-socket-protocol.ts": 4232, + "5652-http-client-trailer-overflow.ts": 3846, + "5653-net-socket-read-ahead.ts": 5725, + "5654-https-empty-servername.ts": 5753, + "5655-dgram-socket-options.ts": 5148, + "5656-dgram-option-states.ts": 4307, + "5657-net-reset-and-address.ts": 3700, + "5658-net-reset-dynamic.cjs": 3925, + "5659-net-blocklist-socketaddress.ts": 4339, + "5664-tls-client-identity.ts": 5675, + "5674-union-instanceof-array-arms.ts": 4342, + "5680-array-growth-after-copy.ts": 5326, + "5681-array-pop-and-length.ts": 4603, + "5682-publish-wide-objects.ts": 2847, + "5700-cycle-release-retained.ts": 2881, + "5701-cycle-release-old-edges.ts": 2910, + "5702-publish-candidate-buffers.ts": 3240, + "5703-lifetime-region-debug.ts": 2720, + "5704-publish-refused-restores-counts.ts": 3978, + "5710-map-number-keys-hashed.ts": 4622, + "5711-map-number-write-after-read.ts": 4051, + "5712-map-number-overwrite-at-growth.ts": 3797, + "5714-cycle-large-candidate-buffers.ts": 5014, + "5715-json-parse-fitted-tables.ts": 4538, + "5717-set-prototype-of-primitives.ts": 3446, + "5719-int32-fields-dynamic-operators.ts": 3704, + "5720-intern-table-basics.ts": 4156, + "5721-intern-table-values.ts": 4709, + "5722-intern-table-workers.ts": 39327, + "5723-intern-table-shared-types.ts": 5477, + "5724-intern-table-array-keys.ts": 5614, + "5725-intern-table-callbacks.ts": 3793, + "5726-intern-table-key-limits.ts": 4034, + "5740-atomics-operation-semantics.ts": 3727, + "5741-atomics-contended-counters.ts": 24517, + "5742-atomics-lock-ordering.ts": 5553, + "5743-atomics-wait-notify.ts": 29359, + "5744-atomics-ring-buffer.ts": 32353, + "5745-atomics-semaphore-stress.ts": 39374, + "5746-shared-bulk-operations.ts": 4179, + "5747-fs-stat-throw-if-no-entry.ts": 3952, + "5748-fs-stat-throw-if-no-entry-js.cjs": 4210, + "5752-string-number-concat.ts": 2959, + "5760-crypto-hash-stream.ts": 3973, + "5761-crypto-hash-stream-states.ts": 3637, + "5762-crypto-hash-stream.cjs": 3895, + "5763-crypto-sha-blocks.ts": 3916, + "5764-class-structural-view-writes.ts": 4447, + "5764-crypto-hmac-edges.cjs": 3134, + "5765-class-structural-view-identity.ts": 3804, + "5766-class-structural-view-callbacks.ts": 3899, + "5767-class-opaque-accessor-view.ts": 3629, + "5776-power-of-two-remainder-integer-path.ts": 4355, + "5780-readline-history-options.ts": 2574, + "5781-readline-history-options.cjs": 2685, + "5782-readline-terminal-editing.ts": 7458, + "5783-readline-terminal-completion.cjs": 9987, + "5784-readline-terminal-promises.ts": 7899, + "5785-readline-terminal-keys.ts": 8463, + "5786-readline-terminal-history.cjs": 4186, + "5787-readline-cursor-helpers.cjs": 4616, + "5788-readline-promises-readline.ts": 4151, + "5789-readline-cursor-pos.cjs": 8106, + "5790-readline-keypress-events.ts": 4768, + "5791-dyn-constant-key-read-sites.ts": 3912, + "5791-readline-keypress-interfaces.cjs": 4765, + "5792-json-parse-repeated-layouts.ts": 4527, + "5792-readline-keypress-listeners.ts": 5406, + "5793-worker-message-channel.ts": 5212, + "5794-worker-message-port-close-order.ts": 4655, + "5795-worker-message-port-batches.ts": 3502, + "5796-worker-message-channel.cjs": 4995, + "5797-worker-message-port-transfer.ts": 23371, + "5800-broadcast-channel.ts": 4829, + "5801-broadcast-channel.cjs": 36650, + "5802-broadcast-channel-workers.ts": 3203, + "5803-worker-environment-data.ts": 6261, + "5804-worker-environment-data.cjs": 3356, + "5805-worker-receive-message-parent-port.ts": 3933, + "5806-worker-resource-limits.ts": 22085, + "5807-worker-error-values.ts": 5689, + "5808-worker-unhandled-rejections.ts": 6775, + "5809-process-exit-and-rejections.cjs": 38724, + "5810-mock-method-records.ts": 6060, + "5811-mock-tracker-restore.ts": 5297, + "5812-dyn-box-async-fields.ts": 4153, + "5813-mock-timers-module.ts": 3845, + "5814-mock-timers-date.ts": 10489, + "5830-timers-promises-signal.ts": 5868, + "5831-util-types-brands.ts": 3846, + "5832-util-types-brands-dynamic.js": 3912, + "5833-url-search-params-iterators.ts": 3034, + "5834-url-search-params-iterators-dynamic.mjs": 3877, + "5835-util-format-integer-specifiers.ts": 2899, + "5836-url-search-params-tuple-pairs.ts": 2897, + "5837-util-format-json-circular.ts": 2745, + "5838-qs-stringify-bigint.ts": 2868, + "5839-timers-promises-scheduler.ts": 3136, + "5840-promise-with-resolvers-js.js": 2701, + "5841-json-typed-dyn-members.ts": 4508, + "5842-qs-parse-null-prototype.ts": 3749, + "5843-qs-parse-null-prototype-js.mjs": 3308, + "5844-date-unknown-values.ts": 3966, + "5845-groupby-null-prototype.ts": 3946, "5846-events-esm-default-max.ts": 3102, "5847-events-cjs-default-max.cjs": 3039, - "5857-regexp-unicode-sets.ts": 3900, - "5858-disposable-stack.ts": 3750, - "5859-disposable-stack-js.js": 3600, - "5870-worker-thread-names.ts": 31697, - "5871-worker-untransferable.cjs": 27481, - "5874-worker-stdio-streams.ts": 27801, - "5875-worker-stdout-pipe.cjs": 31391, - "5879-worker-stdin.ts": 33232, - "5881-inspect-weak-collections.ts": 2915, - "5882-string-decoder-runtime-encoding.ts": 3854, - "5883-os-set-priority.ts": 3417, - "5884-inspect-layout-options.ts": 3596, - "5886-inspect-dates.ts": 2736, - "5887-inspect-typed-arrays.ts": 2997, - "5888-inspect-sorted.ts": 2861, - "5900-float16-array.ts": 3750, - "5901-float16-array-js.js": 3700, - "5904-async-generator-completion.ts": 3800, - "5905-array-from-async-generator.ts": 3500, - "5906-array-from-async-generator-js.js": 3750, + "5849-class-view-observations.ts": 3234, + "5850-using-disposable-values.ts": 3491, + "5851-using-suppressed-error-values.ts": 4335, + "5852-using-disposable-values-js.js": 3438, + "5853-set-methods-map-arguments.ts": 3861, + "5854-array-from-async.ts": 4644, + "5855-array-from-async-js.js": 3880, + "5856-error-is-error.ts": 3947, + "5857-regexp-unicode-sets.ts": 3156, + "5858-disposable-stack.ts": 4000, + "5859-disposable-stack-js.js": 4197, + "5860-url-ipv4-hosts.ts": 3379, + "5870-worker-thread-names.ts": 5388, + "5871-worker-untransferable.cjs": 38904, + "5872-readline-positional-create-interface.mjs": 4683, + "5873-readline-promises-namespace.cjs": 3786, + "5874-worker-stdio-streams.ts": 8408, + "5875-worker-stdout-pipe.cjs": 36125, + "5879-worker-stdin.ts": 56815, + "5880-emitter-leak-warning-delivery.ts": 3928, + "5881-inspect-weak-collections.ts": 3161, + "5882-string-decoder-runtime-encoding.ts": 3686, + "5883-os-set-priority.ts": 2593, + "5884-inspect-layout-options.ts": 3958, + "5885-events-max-listener-helpers.ts": 3524, + "5886-inspect-dates.ts": 3606, + "5887-inspect-typed-arrays.ts": 3660, + "5888-inspect-sorted.ts": 2960, + "5889-timers-scheduler-signal.ts": 3671, + "5890-while-string-length-counters.ts": 3347, + "5892-buffer-write-utf16le-runs.ts": 3722, + "5900-float16-array.ts": 3748, + "5901-float16-array-js.js": 3979, + "5904-async-generator-completion.ts": 6741, + "5905-array-from-async-generator.ts": 4080, + "5906-array-from-async-generator-js.js": 3999, "5907-regex-groups-match-rows.ts": 3750, - "5910-set-prototype-of-primitive-object-kinds.ts": 5033, - "5911-dyn-class-to-primitive.ts": 4732, - "5912-dyn-class-conversion-methods.ts": 4424, - "5913-prototype-type-error-messages.ts": 4068, - "5914-dyn-in-class-prototype-members.ts": 4327, - "5915-dyn-error-string-conversions.ts": 4247, - "5922-matchall-groups-callbacks.ts": 5960, - "5923-matchall-groups-js.js": 6650, + "5910-set-prototype-of-primitive-object-kinds.ts": 4285, + "5911-dyn-class-to-primitive.ts": 6260, + "5912-dyn-class-conversion-methods.ts": 4623, + "5913-prototype-type-error-messages.ts": 3542, + "5914-dyn-in-class-prototype-members.ts": 2963, + "5915-dyn-error-string-conversions.ts": 2860, + "5920-promise-try-args.ts": 2731, + "5921-promise-try-args-js.js": 2533, + "5922-matchall-groups-callbacks.ts": 4812, + "5923-matchall-groups-js.js": 4191, + "5924-js-literal-identity.js": 2661, + "5925-class-view-identity-observers.ts": 2640, + "5926-class-view-switch-js.js": 2843, + "5927-switch-object-identity.ts": 3333, + "5928-groupby-iterables.ts": 4581, + "5929-groupby-js.js": 3288, + "5930-contract-int32-arrays.ts": 4209, + "5930-method-census-asserted-number-keys.ts": 3405, + "5931-asserted-reads-keep-number-parameters.ts": 3441, + "5932-generic-class-observed-methods.ts": 4594, + "5933-class-fields-unknown-object.ts": 4036, + "5934-js-class-fields-property-order.js": 4840, + "5935-js-subclass-fields-and-element-calls.js": 4505, + "5936-checked-js-class-types.js": 3902, + "5937-override-narrowed-union-returns.ts": 3617, "5938-object-literal-computed-keys-keep-methods.ts": 7194, - "5939-js-let-object-reassigned-wider.js": 4436, + "5939-js-let-object-reassigned-wider.js": 3070, + "5940-callback-helper-specialization.ts": 5355, + "5941-callback-specialization-recursion.ts": 4385, + "5942-callback-specialization-throws.ts": 3535, "5943-fields-read-before-assignment.ts": 72293, "5944-js-fields-read-before-assignment.js": 40310, "5945-local-class-observed-methods.ts": 6212, "5946-nested-record-field-optional-writes.ts": 68117, - "5950-tuple-predicate-methods.ts": 7790, - "5951-result-never-widening.ts": 6120, + "5950-tuple-predicate-methods.ts": 5999, + "5951-result-never-widening.ts": 3370, "5952-record-missing-keys.ts": 20400, "5953-nan-coded-method-returns.ts": 15600, - "5955-any-promise-methods.js": 5120, - "5956-erased-generic-members.ts": 8750, - "5958-asserted-union-receiver.ts": 3160, - "5959-date-to-json.ts": 4330, - "5960-generic-mapped-types.ts": 3300, - "5970-net-connect-host-name.ts": 2800, - "5971-buffer-chunks-to-string.ts": 3100, - "5972-net-set-encoding-listeners.ts": 3000, - "5974-typeof-module-exports.cjs": 2500, + "5955-any-promise-methods.js": 3616, + "5956-erased-generic-members.ts": 6191, + "5958-asserted-union-receiver.ts": 2929, + "5959-date-to-json.ts": 2856, + "5960-generic-mapped-types.ts": 3526, + "5970-net-connect-host-name.ts": 2998, + "5971-buffer-chunks-to-string.ts": 3483, + "5972-net-set-encoding-listeners.ts": 7935, + "5974-typeof-module-exports.cjs": 2121, "5975-zlib-class-values.ts": 4200, - "5990-worker-uncloneable.mjs": 22432, - "5991-worker-async-dispose.mjs": 25768, - "5992-worker-thread-name-lifetime.mjs": 28932, - "600-closures-basic.ts": 2534, - "601-closures-loops.ts": 2297, - "602-closures-identity-recursion.ts": 2427, - "6020-class-extends-function-constructor.js": 7500, + "5990-worker-uncloneable.mjs": 37308, + "5991-worker-async-dispose.mjs": 7506, + "5992-worker-thread-name-lifetime.mjs": 44550, + "600-closures-basic.ts": 3477, + "601-closures-loops.ts": 2866, + "602-closures-identity-recursion.ts": 3704, + "6020-class-extends-function-constructor.js": 3671, "6021-asserted-literal-union-arm.ts": 7200, - "603-closures-rc-stress.ts": 2589, - "604-closures-for-of.ts": 3514, - "605-closures-forward-capture-tdz.ts": 4638, - "700-classes-basic.ts": 2674, - "701-classes-composition.ts": 2606, - "702-classes-this-capture.ts": 2403, - "703-classes-rc-stress.ts": 3477, - "710-inheritance-basics.ts": 2972, - "711-inheritance-dispatch.ts": 2507, - "712-inheritance-instanceof.ts": 2847, - "713-inheritance-rc-stress.ts": 3484, - "720-accessors-basics.ts": 3144, - "721-accessors-eval-order.ts": 3241, - "722-accessors-inheritance.ts": 3694, - "723-accessors-rc-stress.ts": 2838, - "750-cycle-closure-box.ts": 3262, - "751-cycle-records-mutual.ts": 3163, - "752-cycle-classes.ts": 2239, - "753-cycle-owned-arrays.ts": 2204, - "754-cycle-external-ref.ts": 2593, - "755-cycle-async-promise.ts": 3154, - "756-cycle-inheritance.ts": 2213, - "757-cycle-cross-generation.ts": 3118, - "762-any-boundary.ts": 3063, - "764-any-async.ts": 3129, - "765-any-optional-chain.ts": 3899, - "766-any-union-boundary.ts": 3346, - "767-string-literal-keys.ts": 2340, - "768-any-uninitialized.ts": 2983, - "800-switch-basics.ts": 3128, - "801-switch-lazy-tests.ts": 2842, - "802-switch-loops.ts": 3486, - "803-switch-rc-stress.ts": 2321, - "804-switch-braced-blocks.ts": 3234, - "810-do-while.ts": 3326, - "820-multi-decl.ts": 2338, - "830-let-uninitialized.ts": 2579, - "900-records-basics.ts": 3473, - "901-records-eval-order.ts": 2890, - "902-records-functions-closures.ts": 3085, - "903-records-rc-stress.ts": 3146, - "904-records-optional-fields.ts": 2930, - "905-records-optional-rc-stress.ts": 2986, - "906-records-utility-types.ts": 2822, - "907-records-utility-generics.ts": 3048, - "908-records-index-signatures.ts": 2695, - "909-records-index-json.ts": 3037, - "910-records-index-rc-stress.ts": 2958, - "911-records-index-dot-access.ts": 4686, - "912-unknown-slots.ts": 3359, - "913-records-index-iteration.ts": 3265, - "914-records-from-entries.ts": 3414, - "915-unknown-tostring-eq.ts": 3349, - "916-unknown-bytes.ts": 3729, - "917-record-array-index-dot.ts": 3331, - "950-modules-basic/main.ts": 2717, - "951-modules-diamond/main.ts": 2315, - "952-modules-cross/main.ts": 2751, - "953-modules-default/main.ts": 3300, - "954-modules-reexport/main.ts": 2770, - "957-builtins-namespace.ts": 2759, - "960-generics-basics.ts": 3631, - "961-generics-recursion.ts": 3262, - "962-generics-closures.ts": 2245, - "963-generics-modules/main.ts": 2769, - "964-generics-rc-stress.ts": 3123, - "965-generics-async.ts": 3925, - "965-unions-retag.ts": 3882, - "966-unions-retag-rc-stress.ts": 3167, - "967-record-field-widening.ts": 2827, - "969-unions-arm-matrix.ts": 3297, - "970-unions-basics.ts": 3439, - "971-unions-switch.ts": 3593, - "972-unions-nested.ts": 2812, - "973-unions-rc-stress.ts": 2567, - "974-unions-modules/main.ts": 2485, - "975-unions-undefined.ts": 2505, - "976-unions-null.ts": 3528, - "977-unions-unit-rc-stress.ts": 2503, - "978-unions-nullish.ts": 2591, - "979-unions-optional-chaining.ts": 2499, - "980-exceptions-basics.ts": 2297, - "981-exceptions-values.ts": 3503, - "982-exceptions-rc-stress.ts": 3146, - "983-exceptions-control-flow.ts": 2518, - "984-exceptions-finally.ts": 2504, - "985-exceptions-call-chains.ts": 3540, - "986-exceptions-uncaught.ts": 3473, - "987-exceptions-result-unions.ts": 3527, - "990-process-basics.ts": 3510, - "991-process-exit.ts": 2297, - "992-fs-roundtrip.ts": 2694, - "993-fs-readdir.ts": 3781, - "994-fs-errors.ts": 2370, - "995-fs-uncaught.ts": 2239, - "996-fs-rc-stress.ts": 2822, - "997-fs-modules/main.ts": 2578, - "998-process-env.ts": 2181, - "abstract-property-dispatch.ts": 2739, - "arguments-arrow-capture.mjs": 3039, - "arguments-reexport/main.ts": 2635, - "array-argument-lifetimes-exits.ts": 3136, - "array-argument-lifetimes-mutation.ts": 3333, - "array-argument-lifetimes-strings.ts": 3015, - "array-argument-lifetimes-values.ts": 3223, - "array-buffer-conversions.js": 2594, - "array-buffer-storage.ts": 3699, - "array-checked-callback-results.mjs": 3402, - "array-checked-constructor.js": 3477, - "array-concat-widening.ts": 3858, - "array-element-compound-updates.ts": 3591, - "array-fill-unit-values.ts": 2572, - "array-from-checked.js": 3097, - "array-from-value.mjs": 3428, - "array-isarray-value/main.js": 3143, - "array-numeric-own-keys.ts": 3632, - "array-optional-number-write-index.ts": 3380, - "array-primitive-ordering.ts": 3925, - "array-read-helper-effects.ts": 3425, - "array-refined-storage.ts": 3909, - "array-sort-dense-effects.ts": 2917, - "array-sort-dense-values.ts": 5261, - "array-sort-holes-published.ts": 13040, - "array-sort-runs.ts": 10059, - "array-sort-runtime-comparator.ts": 5498, - "array-sort-unknown-comparator.ts": 2858, - "array-storage-transitions.ts": 2799, - "array-truncate-reuse.ts": 2407, - "async-backend-factory.mjs": 3609, - "async-local-typed-results.ts": 2487, - "atomics-integer-operations.ts": 3832, - "bigint-checked-casts.ts": 3603, - "bigint-checked-storage.js": 3992, - "bigint-union-conversion.ts": 3125, - "boxed-error-rethrows.mjs": 2646, - "buffer-codec-boundaries.ts": 3139, - "buffer-primitive-predicate.ts": 3495, - "builtin-prototype-method-values.mjs": 4297, - "byte-loop-bounds.ts": 3001, - "byte-number-pipeline.ts": 3966, - "byte-record-windows.ts": 3749, - "call-lifetimes-argument-order.ts": 2794, - "call-lifetimes-control-flow.ts": 3894, - "call-lifetimes-owned-boundaries.ts": 3881, - "call-lifetimes-projections.ts": 3082, - "call-lifetimes-union-values.ts": 3090, + "603-closures-rc-stress.ts": 3096, + "604-closures-for-of.ts": 3045, + "605-closures-forward-capture-tdz.ts": 3323, + "700-classes-basic.ts": 2577, + "701-classes-composition.ts": 3154, + "702-classes-this-capture.ts": 2733, + "703-classes-rc-stress.ts": 3485, + "710-inheritance-basics.ts": 3238, + "711-inheritance-dispatch.ts": 3078, + "712-inheritance-instanceof.ts": 3534, + "713-inheritance-rc-stress.ts": 3301, + "720-accessors-basics.ts": 3158, + "721-accessors-eval-order.ts": 2971, + "722-accessors-inheritance.ts": 3316, + "723-accessors-rc-stress.ts": 3170, + "750-cycle-closure-box.ts": 2126, + "751-cycle-records-mutual.ts": 2363, + "752-cycle-classes.ts": 1960, + "753-cycle-owned-arrays.ts": 2692, + "754-cycle-external-ref.ts": 2903, + "755-cycle-async-promise.ts": 3043, + "756-cycle-inheritance.ts": 2972, + "757-cycle-cross-generation.ts": 2984, + "762-any-boundary.ts": 2786, + "764-any-async.ts": 3084, + "765-any-optional-chain.ts": 3008, + "766-any-union-boundary.ts": 3499, + "767-string-literal-keys.ts": 3514, + "768-any-uninitialized.ts": 3560, + "800-switch-basics.ts": 2767, + "801-switch-lazy-tests.ts": 2686, + "802-switch-loops.ts": 3125, + "803-switch-rc-stress.ts": 3547, + "804-switch-braced-blocks.ts": 2839, + "810-do-while.ts": 2218, + "820-multi-decl.ts": 3261, + "830-let-uninitialized.ts": 3097, + "900-records-basics.ts": 3422, + "901-records-eval-order.ts": 2695, + "902-records-functions-closures.ts": 3207, + "903-records-rc-stress.ts": 2631, + "904-records-optional-fields.ts": 2009, + "905-records-optional-rc-stress.ts": 2569, + "906-records-utility-types.ts": 3252, + "907-records-utility-generics.ts": 3311, + "908-records-index-signatures.ts": 3591, + "909-records-index-json.ts": 3947, + "910-records-index-rc-stress.ts": 3536, + "911-records-index-dot-access.ts": 3503, + "912-unknown-slots.ts": 3313, + "913-records-index-iteration.ts": 4350, + "914-records-from-entries.ts": 3768, + "915-unknown-tostring-eq.ts": 2630, + "916-unknown-bytes.ts": 3440, + "917-record-array-index-dot.ts": 3157, + "950-modules-basic/main.ts": 2848, + "951-modules-diamond/main.ts": 3198, + "952-modules-cross/main.ts": 3183, + "953-modules-default/main.ts": 3167, + "954-modules-reexport/main.ts": 2018, + "957-builtins-namespace.ts": 3430, + "960-generics-basics.ts": 3705, + "961-generics-recursion.ts": 2537, + "962-generics-closures.ts": 3548, + "963-generics-modules/main.ts": 2784, + "964-generics-rc-stress.ts": 3384, + "965-generics-async.ts": 2822, + "965-unions-retag.ts": 3386, + "966-unions-retag-rc-stress.ts": 2717, + "967-record-field-widening.ts": 2715, + "969-unions-arm-matrix.ts": 3012, + "970-unions-basics.ts": 2986, + "971-unions-switch.ts": 3685, + "972-unions-nested.ts": 3090, + "973-unions-rc-stress.ts": 3424, + "974-unions-modules/main.ts": 3121, + "975-unions-undefined.ts": 2840, + "976-unions-null.ts": 2783, + "977-unions-unit-rc-stress.ts": 3216, + "978-unions-nullish.ts": 3540, + "979-unions-optional-chaining.ts": 3197, + "980-exceptions-basics.ts": 3555, + "981-exceptions-values.ts": 3193, + "982-exceptions-rc-stress.ts": 2933, + "983-exceptions-control-flow.ts": 3085, + "984-exceptions-finally.ts": 3513, + "985-exceptions-call-chains.ts": 2381, + "986-exceptions-uncaught.ts": 2898, + "987-exceptions-result-unions.ts": 2879, + "990-process-basics.ts": 3199, + "991-process-exit.ts": 3081, + "992-fs-roundtrip.ts": 2369, + "993-fs-readdir.ts": 3082, + "994-fs-errors.ts": 3422, + "995-fs-uncaught.ts": 3294, + "996-fs-rc-stress.ts": 3471, + "997-fs-modules/main.ts": 2673, + "998-process-env.ts": 3051, + "abstract-property-dispatch.ts": 3176, + "arguments-arrow-capture.mjs": 3073, + "arguments-reexport/main.ts": 2672, + "array-argument-lifetimes-exits.ts": 3589, + "array-argument-lifetimes-mutation.ts": 3438, + "array-argument-lifetimes-strings.ts": 3059, + "array-argument-lifetimes-values.ts": 3883, + "array-buffer-conversions.js": 2989, + "array-buffer-storage.ts": 3822, + "array-checked-callback-results.mjs": 3408, + "array-checked-constructor.js": 3489, + "array-concat-widening.ts": 3866, + "array-deque-unshift.ts": 2667, + "array-element-compound-updates.ts": 5084, + "array-fill-unit-values.ts": 3524, + "array-from-checked.js": 4344, + "array-from-value.mjs": 3171, + "array-isarray-value/main.js": 2914, + "array-numeric-own-keys.ts": 3622, + "array-optional-number-write-index.ts": 2652, + "array-primitive-ordering.ts": 4006, + "array-queue-head-room.ts": 3597, + "array-read-helper-effects.ts": 3562, + "array-refined-storage.ts": 4149, + "array-sort-dense-effects.ts": 4479, + "array-sort-dense-values.ts": 4819, + "array-sort-holes-published.ts": 7708, + "array-sort-runs.ts": 7566, + "array-sort-runtime-comparator.ts": 6150, + "array-sort-unknown-comparator.ts": 2544, + "array-storage-transitions.ts": 3926, + "array-truncate-reuse.ts": 3660, + "async-backend-factory.mjs": 3134, + "async-local-typed-results.ts": 3527, + "atomics-integer-operations.ts": 4356, + "bigint-checked-casts.ts": 2554, + "bigint-checked-storage.js": 3784, + "bigint-union-conversion.ts": 3322, + "boxed-error-rethrows.mjs": 2897, + "buffer-codec-boundaries.ts": 3387, + "buffer-primitive-predicate.ts": 3237, + "builtin-prototype-method-values.mjs": 3628, + "byte-loop-bounds.ts": 3700, + "byte-number-pipeline.ts": 3420, + "byte-record-windows.ts": 3513, + "call-lifetimes-argument-order.ts": 3157, + "call-lifetimes-control-flow.ts": 3596, + "call-lifetimes-owned-boundaries.ts": 3515, + "call-lifetimes-projections.ts": 2258, + "call-lifetimes-union-values.ts": 3157, "call-lifetimes-virtual-optionals.ts": 3774, - "callable-module-members.mjs": 2996, - "callable-properties.mjs": 3737, - "callable-property-cycles.js": 2394, - "callable-reexport/main.ts": 2995, - "captured-class-refinement.ts": 3815, - "catch-capture.ts": 2295, - "caught-class-identity.ts": 3893, - "caught-standalone-class.ts": 3591, - "caught-system-error-fields.ts": 3373, - "checked-addition.js": 3059, - "checked-any-addition.ts": 2638, - "checked-array-assignment.ts": 2861, - "checked-array-flat/main.ts": 2441, - "checked-bitwise/main.js": 3177, - "checked-builder-cycles.js": 3284, - "checked-byte-storage/main.ts": 3985, - "checked-callback-options.ts": 3034, - "checked-class-descriptors.mjs": 2786, - "checked-class-factory.mjs": 2348, - "checked-collection-iterators.ts": 3731, - "checked-collection-symbol-methods.ts": 3019, - "checked-dispatch-input-lifetimes.js": 3481, - "checked-increment/main.js": 2884, - "checked-inherited-fields.ts": 2756, - "checked-iterator-consumption.js": 4074, - "checked-numeric-arithmetic.js": 2874, - "checked-object-module-alias.js": 3204, - "checked-optional-calls.mjs": 2897, - "checked-promise-recovery.ts": 2819, - "checked-proxy-callback/main.ts": 3009, - "checked-record-constructor.ts": 3034, - "checked-renderer-defaults.js": 2935, - "checked-rest-function-adapters.js": 2965, - "checked-storage-transitions.js": 2510, - "checked-symbol-array.ts": 2504, - "checked-value-input-lifetimes.ts": 3033, - "class-accessor-returned-function.js": 2287, - "class-array-optional-return.ts": 3498, - "class-bracket-method-calls.js": 3071, - "class-brand-overload.js": 3526, - "class-callback-replacement.js": 3460, - "class-callback-storage.ts": 4585, - "class-checked-composites.ts": 3187, - "class-checked-upcast.ts": 3072, - "class-collection-insertion.ts": 4235, - "class-computed-presence.ts": 2974, - "class-computed-symbols.js": 3740, - "class-covariant-returns.ts": 3957, - "class-curried-factory.mjs": 4128, - "class-data-descriptors.js": 3270, - "class-factory-inherited-statics.mjs": 2538, - "class-factory-parameter-base.mjs": 2587, - "class-factory-record-base.mjs": 5836, - "class-factory-recursive-statics.mjs": 3651, - "class-factory-static-members.mjs": 3672, - "class-function-base/main.js": 2657, - "class-instance-constructor.js": 2942, - "class-interface-protocols.ts": 3713, - "class-interface-refinements.ts": 4567, - "class-json-checked.ts": 2571, - "class-local-function-base.mjs": 3643, - "class-method-spreads.ts": 3220, - "class-narrowed-views.ts": 3766, - "class-property-call-values.mjs": 3125, - "class-prototype-data.js": 4251, - "class-prototype-descriptor-copy.mjs": 3998, - "class-specialized-computed-base.mjs": 3397, - "class-static-data.js": 2157, - "class-subclass-assertions.ts": 3733, - "class-super-surplus-spread.mjs": 2301, - "class-symbol-accessors.ts": 2479, - "class-symbol-cache.mjs": 3721, - "class-value-constructor-exceptions.ts": 3210, - "closure-nullable-union-return.ts": 2727, - "closure-union-locals.ts": 2878, - "collection-array-cycles.ts": 3240, - "collection-array-maps.ts": 4497, - "collection-array-missing.ts": 3865, - "collection-array-sets.ts": 3087, - "collection-copy-identities.ts": 2655, - "collection-data-unions.ts": 2993, - "collection-ingestion-mappers.ts": 3305, - "collection-ingestion-protocol/main.ts": 5059, - "collection-ingestion-references.ts": 4238, - "collection-ingestion.ts": 3626, - "collection-storage-copies.ts": 4163, - "collection-value-keys.ts": 4167, - "compound-field-receivers.ts": 2877, - "compound-presence-guards.ts": 3145, - "conditional-tuple-destructuring.ts": 3213, - "console-imports.cjs": 2893, - "console-native-value.js": 2516, - "const-enum-module-cycle/main.ts": 3456, - "constant-callback-dispatch.ts": 2916, - "constant-module-globals/main.ts": 2911, - "constant-number-remainders.ts": 2372, - "constructed-class-dispatch.ts": 3382, - "contextual-array-union-write.ts": 6417, - "contextual-return-layouts.ts": 3746, - "counted-loop-numbers.ts": 2724, - "counted-loop-storage.ts": 2302, - "crypto-hash-optional-input.ts": 3311, - "cycle-generations-long-lived.ts": 3514, - "cycle-growth-yield.ts": 3352, - "date-checked-native.js": 2676, - "declared-index-spread.ts": 2941, - "deep-reference-teardown.ts": 4427, - "default-undefined-parameters.ts": 3232, - "deferred-field-updates.ts": 3345, - "deferred-registry-many.ts": 3072, - "derived-numeric-updates.ts": 2702, - "destructure-call-assignment.js": 2978, - "destructure-inferred-row-defaults.js": 3175, - "destructure-union-arrays.ts": 3248, - "dynamic-function-descriptors.js": 2750, - "error-cause-writes.js": 3104, - "error-inherited-message.mjs": 3024, - "error-inherited-name.mjs": 2500, - "error-property-writes.mjs": 3373, - "error-prototype-tostring.js": 3874, - "error-stack-frames.ts": 2418, - "error-stack-limit.ts": 2675, - "error-tostring-overrides.ts": 3246, - "error-values-inspect.ts": 3043, - "exact-index-round-trip.ts": 3701, - "expression-runtime-values.ts": 2154, - "fiber-switch-stress.ts": 5012, - "fiberless-async-ordering.ts": 3413, - "fiberless-async-unhandled.ts": 2739, - "field-assignment-values.ts": 2662, - "file-handle-values.ts": 3133, - "file-read-storage.ts": 3685, - "file-url-percent-decoding.ts": 2659, - "final-field-borrows.ts": 3350, - "for-multiple-bindings.ts": 3223, - "for-multiple-lexical-bindings.ts": 3021, - "for-of-checked-iterator.js": 3541, - "for-of-subclass-elements.ts": 3037, - "forward-generic-signatures.ts": 2999, - "fresh-array-union-layout.js": 2679, - "frozen-checked-dictionaries.mjs": 3220, - "fs-native-realpath.ts": 2477, - "fs-read-encodings.ts": 3111, - "fs-remove-readonly.ts": 2708, - "fs-write-string-bytes-union.ts": 2772, - "function-apply-value.mjs": 2976, - "function-constructor-global.mjs": 2229, - "function-constructor-kinds/main.js": 3064, - "function-custom-prototype.js": 3165, - "function-custom-to-string.mjs": 3379, - "function-object-assign.js": 3235, - "function-own-prototype/main.js": 2539, - "generator-checked-protocol.ts": 3197, - "generator-checked-return.js": 3544, - "generator-custom-delegation/main.ts": 3611, - "generator-default-return-pattern.ts": 3352, - "generator-delegation-values.ts": 3047, - "generator-inferred-date.js": 3314, - "generator-mixed-checked-channels.ts": 3576, - "generator-untyped-consumer/main.ts": 3225, - "generic-base-specializations.ts": 2247, - "generic-binding-ownership.ts": 3517, - "generic-class-js-functions/main.ts": 2300, - "generic-class-recovery.ts": 2961, - "generic-namespace-factories/main.ts": 3104, - "generic-nullable-collections.ts": 2983, - "generic-pattern-bindings.ts": 3518, - "generic-record-index.ts": 3239, - "generic-visitor-void.ts": 3402, - "global-error-subclasses.ts": 2754, - "global-runtime-probes.js": 2804, - "global-stored-probes.js": 3113, - "global-string-cache/main.js": 2090, - "global-symbol-cache/main.js": 3628, - "guarded-native-iterables.ts": 3327, - "heap-input-aliases.ts": 3457, - "heap-input-collections.ts": 3653, - "in-array-runtime-index.ts": 3275, - "indexed-assignment-values.js": 3011, - "indexed-assignment-values.ts": 2182, - "indexed-element-field-reads.ts": 3247, - "inferred-array-assignment-values.mjs": 2906, - "inferred-class-default.mjs": 2977, - "inferred-compound-values.mjs": 2759, - "inferred-conditional-class.mjs": 3292, - "inferred-error-fields.js": 3405, - "inferred-map-patterns.mjs": 2764, - "inferred-method-override.js": 2696, - "inferred-partial-destructuring.mjs": 2539, - "inferred-primitive-properties.mjs": 2255, - "inferred-record-return.mjs": 2589, - "inferred-recursive-record.mjs": 2186, - "inferred-undefined-field.mjs": 2551, - "input-lifetime-intervals.ts": 3191, - "input-lifetimes-modules/main.ts": 3221, - "instanceof-class-record-union.ts": 3279, - "integer-flow-arithmetic.ts": 3347, - "integer-loop-forms.ts": 2940, - "integer-view-control.ts": 2093, - "integer-view-numbers.ts": 2680, - "integer-view-storage.ts": 3947, - "intl-grapheme-conformance/main.ts": 5064, - "intl-grapheme.ts": 2412, - "iterator-typed-returns.ts": 3466, - "js-abort-portable.js": 4587, - "js-array-constructor.js": 3296, - "js-array-default-buffer.js": 3604, - "js-array-iterators.js": 3215, - "js-arrow-bind.cjs": 3596, - "js-buffer-callback-brand.cjs": 3526, - "js-callable-proxy.js": 3865, - "js-chained-native-results.mjs": 3076, - "js-checked-array-iterator.js": 2790, - "js-checked-array-reference.js": 2884, - "js-checked-number-negation.mjs": 2418, - "js-checked-sort-result.js": 2906, - "js-child-error-listener.cjs": 2538, - "js-cjs-callable-snapshots/main.cjs": 2461, - "js-class-added-parameters.js": 2522, - "js-class-checked-overrides.js": 2542, - "js-class-computed-fields.js": 2281, - "js-class-enumeration.js": 3084, - "js-class-field-accessor-override.js": 3865, - "js-class-fluent-overrides.js": 3368, - "js-class-late-method-values.js": 2526, - "js-class-member-dispatch.js": 3846, - "js-class-return-shapes.js": 2639, - "js-class-shadowed-methods.js": 2891, - "js-class-stored-method-receiver.js": 2685, - "js-class-subclass-properties.js": 3775, - "js-class-symbol-spread.cjs": 3550, - "js-computed-prototype-additions.js": 3462, - "js-constructor-returned-callable.js": 3346, + "callable-module-members.mjs": 3196, + "callable-properties.mjs": 3885, + "callable-property-cycles.js": 3532, + "callable-reexport/main.ts": 3427, + "captured-class-refinement.ts": 3597, + "catch-capture.ts": 2987, + "caught-class-identity.ts": 4072, + "caught-standalone-class.ts": 2672, + "caught-system-error-fields.ts": 3700, + "checked-addition.js": 3105, + "checked-any-addition.ts": 2239, + "checked-array-assignment.ts": 3049, + "checked-array-flat/main.ts": 3431, + "checked-bitwise/main.js": 3320, + "checked-builder-cycles.js": 2792, + "checked-byte-storage/main.ts": 3747, + "checked-callback-options.ts": 2687, + "checked-class-descriptors.mjs": 3712, + "checked-class-factory.mjs": 2771, + "checked-collection-iterators.ts": 3380, + "checked-collection-symbol-methods.ts": 2530, + "checked-dispatch-input-lifetimes.js": 3328, + "checked-increment/main.js": 3104, + "checked-inherited-fields.ts": 2621, + "checked-iterator-consumption.js": 4294, + "checked-numeric-arithmetic.js": 3111, + "checked-object-module-alias.js": 3420, + "checked-optional-calls.mjs": 3475, + "checked-promise-recovery.ts": 3214, + "checked-proxy-callback/main.ts": 2353, + "checked-record-constructor.ts": 3432, + "checked-renderer-defaults.js": 3283, + "checked-rest-function-adapters.js": 3083, + "checked-storage-transitions.js": 3622, + "checked-symbol-array.ts": 3310, + "checked-value-input-lifetimes.ts": 3545, + "class-accessor-returned-function.js": 3128, + "class-array-optional-return.ts": 2098, + "class-bracket-method-calls.js": 3772, + "class-brand-overload.js": 2492, + "class-callback-replacement.js": 4751, + "class-callback-storage.ts": 4435, + "class-checked-composites.ts": 2988, + "class-checked-upcast.ts": 3528, + "class-collection-insertion.ts": 3819, + "class-computed-presence.ts": 3069, + "class-computed-symbols.js": 4319, + "class-covariant-returns.ts": 2381, + "class-curried-factory.mjs": 4502, + "class-data-descriptors.js": 3422, + "class-factory-inherited-statics.mjs": 3137, + "class-factory-parameter-base.mjs": 3744, + "class-factory-record-base.mjs": 4712, + "class-factory-recursive-statics.mjs": 3419, + "class-factory-static-members.mjs": 3588, + "class-function-base/main.js": 3762, + "class-instance-constructor.js": 3074, + "class-interface-protocols.ts": 5102, + "class-interface-refinements.ts": 3720, + "class-json-checked.ts": 2934, + "class-local-function-base.mjs": 3255, + "class-method-spreads.ts": 4902, + "class-narrowed-views.ts": 3371, + "class-property-call-values.mjs": 4011, + "class-prototype-data.js": 3004, + "class-prototype-descriptor-copy.mjs": 3813, + "class-specialized-computed-base.mjs": 4267, + "class-static-data.js": 3151, + "class-subclass-assertions.ts": 3297, + "class-super-surplus-spread.mjs": 3182, + "class-symbol-accessors.ts": 3548, + "class-symbol-cache.mjs": 4032, + "class-value-constructor-exceptions.ts": 2673, + "closed-virtual-dispatch-modules/main.ts": 2555, + "closed-virtual-dispatch.ts": 3659, + "closure-nullable-union-return.ts": 3544, + "closure-union-locals.ts": 3476, + "collection-array-cycles.ts": 3864, + "collection-array-maps.ts": 4225, + "collection-array-missing.ts": 4159, + "collection-array-sets.ts": 4385, + "collection-copy-identities.ts": 2778, + "collection-data-unions.ts": 3634, + "collection-ingestion-mappers.ts": 3206, + "collection-ingestion-protocol/main.ts": 3833, + "collection-ingestion-references.ts": 3449, + "collection-ingestion.ts": 3258, + "collection-storage-copies.ts": 3108, + "collection-value-keys.ts": 4397, + "compound-field-receivers.ts": 3249, + "compound-presence-guards.ts": 2877, + "conditional-tuple-destructuring.ts": 2382, + "console-imports.cjs": 3167, + "console-native-value.js": 3394, + "const-enum-module-cycle/main.ts": 2006, + "constant-callback-dispatch.ts": 2991, + "constant-module-globals/main.ts": 2958, + "constant-number-remainders.ts": 3341, + "constructed-class-dispatch.ts": 2784, + "contextual-array-union-write.ts": 7276, + "contextual-return-layouts.ts": 3888, + "counted-loop-numbers.ts": 3637, + "counted-loop-storage.ts": 2691, + "crypto-hash-optional-input.ts": 3463, + "cycle-generations-long-lived.ts": 3441, + "cycle-growth-yield.ts": 3944, + "date-checked-native.js": 2845, + "declared-index-spread.ts": 4567, + "deep-reference-teardown.ts": 3926, + "default-undefined-parameters.ts": 3319, + "deferred-field-updates.ts": 3102, + "deferred-registry-many.ts": 3953, + "derived-numeric-updates.ts": 3389, + "destructure-call-assignment.js": 2983, + "destructure-inferred-row-defaults.js": 3512, + "destructure-union-arrays.ts": 2816, + "dynamic-function-descriptors.js": 3146, + "error-cause-writes.js": 3354, + "error-inherited-message.mjs": 3845, + "error-inherited-name.mjs": 2619, + "error-property-writes.mjs": 3158, + "error-prototype-tostring.js": 3672, + "error-stack-frames.ts": 3288, + "error-stack-limit.ts": 2624, + "error-tostring-overrides.ts": 3434, + "error-values-inspect.ts": 2196, + "exact-index-round-trip.ts": 3473, + "expression-runtime-values.ts": 3088, + "fiber-switch-stress.ts": 4040, + "fiberless-async-ordering.ts": 3692, + "fiberless-async-unhandled.ts": 2796, + "field-assignment-values.ts": 3175, + "file-handle-values.ts": 4245, + "file-read-storage.ts": 3850, + "file-url-percent-decoding.ts": 3346, + "final-field-borrows.ts": 4200, + "for-multiple-bindings.ts": 3350, + "for-multiple-lexical-bindings.ts": 2400, + "for-of-checked-iterator.js": 2766, + "for-of-subclass-elements.ts": 3269, + "forward-generic-signatures.ts": 3369, + "fresh-array-union-layout.js": 2566, + "frozen-checked-dictionaries.mjs": 3872, + "fs-native-realpath.ts": 3355, + "fs-null-byte-paths-js.cjs": 2643, + "fs-null-byte-paths.ts": 5975, + "fs-read-encodings.ts": 3730, + "fs-read-utf8-edges.ts": 4190, + "fs-read-utf8-handle-forms.ts": 3943, + "fs-remove-readonly.ts": 3417, + "fs-write-string-bytes-union.ts": 3274, + "function-apply-value.mjs": 3476, + "function-constructor-global.mjs": 3249, + "function-constructor-kinds/main.js": 3769, + "function-custom-prototype.js": 3876, + "function-custom-to-string.mjs": 3155, + "function-object-assign.js": 3527, + "function-own-prototype/main.js": 3460, + "generator-checked-protocol.ts": 2621, + "generator-checked-return.js": 3221, + "generator-custom-delegation/main.ts": 5126, + "generator-default-return-pattern.ts": 3182, + "generator-delegation-values.ts": 3197, + "generator-inferred-date.js": 3585, + "generator-mixed-checked-channels.ts": 3199, + "generator-untyped-consumer/main.ts": 3049, + "generic-base-specializations.ts": 3459, + "generic-binding-ownership.ts": 3288, + "generic-class-js-functions/main.ts": 2834, + "generic-class-recovery.ts": 3640, + "generic-namespace-factories/main.ts": 2618, + "generic-nullable-collections.ts": 3599, + "generic-pattern-bindings.ts": 3103, + "generic-record-index.ts": 3516, + "generic-visitor-void.ts": 3557, + "global-accumulator-loops.ts": 3302, + "global-error-subclasses.ts": 2292, + "global-runtime-probes.js": 3435, + "global-stored-probes.js": 2946, + "global-string-cache/main.js": 2368, + "global-symbol-cache/main.js": 2737, + "guarded-native-iterables.ts": 3541, + "heap-input-aliases.ts": 3756, + "heap-input-collections.ts": 4265, + "in-array-runtime-index.ts": 3804, + "indexed-assignment-values.js": 3469, + "indexed-assignment-values.ts": 2742, + "indexed-element-field-reads.ts": 3016, + "inferred-array-assignment-values.mjs": 2506, + "inferred-class-default.mjs": 2376, + "inferred-compound-values.mjs": 2280, + "inferred-conditional-class.mjs": 3032, + "inferred-error-fields.js": 3161, + "inferred-map-patterns.mjs": 3075, + "inferred-method-override.js": 3123, + "inferred-partial-destructuring.mjs": 3133, + "inferred-primitive-properties.mjs": 2211, + "inferred-record-return.mjs": 3298, + "inferred-recursive-record.mjs": 3328, + "inferred-undefined-field.mjs": 2721, + "input-lifetime-intervals.ts": 3442, + "input-lifetimes-modules/main.ts": 3449, + "instanceof-class-record-union.ts": 3488, + "integer-flow-arithmetic.ts": 3827, + "integer-loop-forms.ts": 3201, + "integer-view-control.ts": 3231, + "integer-view-numbers.ts": 3409, + "integer-view-storage.ts": 3994, + "intl-grapheme-conformance/main.ts": 3445, + "intl-grapheme.ts": 2906, + "iterator-typed-returns.ts": 4729, + "js-abort-portable.js": 27919, + "js-array-constructor.js": 3813, + "js-array-default-buffer.js": 2697, + "js-array-iterators.js": 3607, + "js-arrow-bind.cjs": 4009, + "js-buffer-callback-brand.cjs": 3617, + "js-callable-proxy.js": 4304, + "js-chained-native-results.mjs": 2822, + "js-checked-array-iterator.js": 3340, + "js-checked-array-reference.js": 3923, + "js-checked-number-negation.mjs": 2222, + "js-checked-sort-result.js": 3358, + "js-child-error-listener.cjs": 3277, + "js-cjs-callable-snapshots/main.cjs": 2133, + "js-class-added-parameters.js": 4197, + "js-class-checked-overrides.js": 3307, + "js-class-computed-fields.js": 2995, + "js-class-enumeration.js": 4227, + "js-class-field-accessor-override.js": 3739, + "js-class-fluent-overrides.js": 3694, + "js-class-late-method-values.js": 3823, + "js-class-member-dispatch.js": 2888, + "js-class-return-shapes.js": 4179, + "js-class-shadowed-methods.js": 3019, + "js-class-stored-method-receiver.js": 3182, + "js-class-subclass-properties.js": 4548, + "js-class-symbol-spread.cjs": 3271, + "js-computed-prototype-additions.js": 3652, + "js-constructor-returned-callable.js": 3080, "js-constructor-spread.js": 3311, - "js-dataview-dispatch.js": 2423, - "js-declared-fields.cjs": 3098, - "js-default-listener-arguments.cjs": 2941, - "js-default-options/main.ts": 3442, - "js-deferred-field-initializers.js": 2409, - "js-deferred-registry-effects.js": 2980, - "js-derived-constructor-hoisting.js": 2695, - "js-dormant-array-write.js": 2014, - "js-dormant-overrides.js": 3783, - "js-expando-records.js": 2526, - "js-implicit-call-results.js": 2892, - "js-inferred-callback-exports/main.js": 3776, - "js-inferred-class-array-return.js": 3477, - "js-inferred-object-values.js": 3358, - "js-inherited-field-storage.js": 3527, - "js-inherited-parameter-abi.js": 3324, - "js-iterable-spread.js": 3504, - "js-loose-dynamic-primitives.js": 2079, - "js-map-object-seeds.js": 3322, - "js-member-increment.js": 4257, - "js-module-function-values.js": 3135, - "js-mutable-null-members.js": 2750, - "js-nested-native-descriptors.js": 2725, - "js-normalize-dispatch.js": 3264, - "js-nullish-inherited-fields.mjs": 3080, - "js-object-receiver-storage.js": 3515, - "js-object-returning-constructors.mjs": 3015, - "js-object-shared-arrays.js": 2539, - "js-omitted-typed-arguments.js": 2295, - "js-open-binding-writes.js": 1944, - "js-optional-class-fields.js": 3252, - "js-optional-member-call.js": 3095, - "js-primitive-union-addition.js": 2779, - "js-promise-all-values.js": 3443, - "js-promise-catch-handler.js": 2034, - "js-promise-finally-order.js": 2084, - "js-promise-pending-reactions.js": 3602, - "js-prototype-host-boundary.js": 4779, - "js-reflect-receivers.js": 3486, - "js-regex-record-captures.js": 2214, - "js-scalar-iterables.js": 3719, - "js-shared-method-dispatch.js": 2114, - "js-specialized-field-method.js": 3011, - "js-static-accessors.js": 3435, - "js-static-method-values.js": 3174, - "js-static-registries.cjs": 3047, - "js-super-accessor-initialization.js": 2998, - "js-uninitialized-native-fields.js": 2354, - "json-guarded-map-values.ts": 2502, - "json-output-bulk.ts": 3214, - "json-runtime-options.mjs": 2794, - "json-stringify-value.js": 2833, - "json-typed-parse-direct.ts": 3580, - "literal-switch-dispatch.ts": 2951, - "live-reference-shared-converters.ts": 19276, - "llvm-read-receiver-lifetime.ts": 3803, - "local-class-call-spreads.js": 3495, - "local-class-declaration.ts": 2661, - "local-class-evaluation.ts": 3104, - "local-class-inheritance.ts": 2552, - "local-class-lifetimes.ts": 3344, - "local-class-namespace/main.js": 3630, - "local-class-prototype-data.js": 3990, - "local-class-specialization.js": 2812, - "local-class-unknown.ts": 3002, - "local-class-values.ts": 2009, - "local-union-storage.ts": 3026, - "locale-compare-root-order.ts": 3444, - "logical-assignment-dynamic.js": 3230, - "logical-assignment-values.ts": 3566, - "logical-runtime-optional-record.ts": 3322, - "loop-reference-lifetimes.ts": 3339, - "map-checked-boundary/main.ts": 2843, - "map-checked-seed.js": 2966, - "map-number-keys-dense.ts": 2773, - "map-read-lifetimes-exits.ts": 2761, - "map-read-lifetimes.ts": 3024, - "map-seeds-and-spreads.ts": 3502, - "map-typed-array-values.ts": 3300, - "math-function-values.js": 2815, - "missing-read-lambda-results.ts": 3370, - "missing-read-narrowed-storage.ts": 2854, - "missing-read-number-conversions.ts": 2326, - "module-byte-loops.ts": 2961, - "module-fallback-functions/main.js": 2737, - "narrowed-nullish-values.ts": 3160, - "native-any-timer-callback.ts": 2388, - "native-array-borrowed-find-last.js": 2571, - "native-array-borrowed-slice.js": 3010, - "native-array-copying-methods.js": 3608, - "native-array-fill-copywithin.js": 2996, - "native-array-frozen-noops.js": 3132, - "native-array-index-boundaries.js": 2225, - "native-array-integrity.js": 3091, - "native-array-length.js": 2365, - "native-array-named-properties.js": 2772, - "native-array-prototype/main.js": 3257, - "native-array-read-lifetimes.ts": 3805, - "native-array-reduce-find-last.js": 2524, - "native-array-search-from-index.js": 2027, - "native-array-splice-coercion.js": 2902, - "native-array-splice-flat.js": 2702, - "native-buffer-coercion.js": 2533, - "native-callback-dispatch.ts": 3850, - "native-class-array-boundaries.ts": 3272, - "native-class-cache.js": 3290, - "native-class-properties.cjs": 4583, - "native-class-property-cycles.cjs": 2888, - "native-class-property-order.cjs": 2105, - "native-class-type-predicates.ts": 2960, - "native-factory-records.js": 3080, - "native-method-values.js": 3222, - "native-method-values.ts": 2808, - "native-npm-imports/main.ts": 2750, - "native-object-descriptors.js": 2979, - "native-object-for-in-minimal.js": 2411, - "native-object-property-attributes.js": 3057, - "native-object-prototype.js": 3409, - "native-property-names.ts": 2077, - "native-proxy-env.js": 4372, - "native-worker-arena-reuse.ts": 33854, - "native-worker-bounded-errors.ts": 2556, - "native-worker-buffer-consumers.ts": 38253, - "native-worker-cancel-hot.ts": 28908, - "native-worker-class-fields.ts": 3286, - "native-worker-clone-errors.ts": 3629, - "native-worker-commonjs.cjs": 3085, - "native-worker-delayed-messages.ts": 28752, - "native-worker-discarded-heaps.ts": 39440, - "native-worker-environment.ts": 27133, - "native-worker-error.ts": 2958, - "native-worker-exception-state.ts": 3945, - "native-worker-exit-listeners.ts": 4052, - "native-worker-io.ts": 3361, - "native-worker-loop-cancellation.ts": 2798, - "native-worker-message-graphs.ts": 2738, - "native-worker-messages.ts": 3079, - "native-worker-poll-exceptions.ts": 2575, - "native-worker-port-lifetime.ts": 3213, - "native-worker-process-exit.ts": 4104, - "native-worker-publish-classes.ts": 24713, - "native-worker-publish-refusals.ts": 2820, - "native-worker-published-graphs.ts": 3534, - "native-worker-references.ts": 3358, - "native-worker-roots/main.ts": 2808, - "native-worker-shared-views.ts": 3012, - "native-worker-stack-overflow.ts": 2597, - "native-worker-terminate-exception-state.ts": 3340, - "native-worker-terminate-loop.ts": 2222, - "native-worker-terminate-recursion.ts": 2829, - "native-worker-terminate-suspended.ts": 4348, - "native-worker-terminate-tested-loops.ts": 3576, - "native-worker-terminate-wait.ts": 3222, - "native-worker-typed-arrays.ts": 2653, - "nested-map-cycles.ts": 3041, - "nested-map-values.ts": 2382, - "never-returning-calls.ts": 2642, - "next-tick-commonjs-entry.cjs": 2624, - "node24-buffer-encoding-errors.ts": 2695, - "node24-buffer-encoding.ts": 3038, - "node24-crypto-kdf-errors.ts": 2745, - "node24-crypto-kdf-options.ts": 2029, - "node24-crypto-kdf.ts": 3632, - "node24-crypto-sha2.ts": 2849, - "node24-deep-equality-properties.js": 3355, - "node24-deep-equality.cjs": 2682, - "node24-deep-equality.ts": 4058, - "node24-env-files-errors.ts": 3202, - "node24-env-files.ts": 3044, - "node24-env-imports.cjs": 2529, - "node24-env-parse-errors.ts": 2062, - "node24-env-parse.ts": 3684, - "node24-esm-metadata/main.mjs": 2492, - "node24-file-url-buffer.ts": 2158, - "node24-file-url-errors.js": 3331, - "node24-file-url-options.ts": 2772, - "node24-fs-links-callbacks.cjs": 3549, - "node24-fs-links-errors.cjs": 2633, - "node24-fs-links-options.cjs": 3571, - "node24-fs-links-promise-errors.cjs": 2445, - "node24-fs-links-promises.ts": 2105, - "node24-fs-links.ts": 2967, - "node24-fs-statfs-callbacks.cjs": 3035, - "node24-fs-statfs-errors.cjs": 2969, - "node24-fs-statfs-options.cjs": 3557, - "node24-fs-statfs.ts": 3067, - "node24-fs-timestamps-callbacks.cjs": 3095, - "node24-fs-timestamps-errors.cjs": 3110, - "node24-fs-timestamps-promises.ts": 3573, - "node24-fs-timestamps-symlinks.ts": 3390, - "node24-fs-timestamps.ts": 3032, - "node24-no-error-assertions-coercion.js": 2850, - "node24-no-error-assertions.cjs": 2814, - "node24-no-error-assertions.ts": 4358, - "node24-parseargs.js": 5971, - "node24-string-decoder.ts": 3185, - "node24-style-text-environment.js": 4225, - "node24-style-text-validation.js": 3673, - "node24-style-text.cjs": 3476, - "node24-style-text.ts": 3037, - "node24-system-error-validation.js": 3005, - "node24-system-errors.cjs": 3631, - "node24-system-errors.ts": 2849, - "node24-text-codec-properties.ts": 30185, - "node24-text-encode-into.ts": 3601, - "node24-text-utilities-coercion.js": 3094, - "node24-text-utilities-validation.js": 2330, - "node24-text-utilities.cjs": 2768, - "node24-text-utilities.ts": 3312, - "node24-url-authority-coercion.js": 3307, - "node24-url-authority.ts": 2639, - "node24-url-factories.ts": 3240, - "node24-url-factory-errors.ts": 2819, - "node24-url-mutation-coercion.js": 2399, - "node24-url-mutation.ts": 3257, - "node24-util-types.cjs": 3263, - "node24-util-types.js": 2199, - "node24-util-types.ts": 3506, - "non-null-class-iteration.ts": 3295, - "nonnull-element-arguments.ts": 2857, - "nonnull-forwarded-class-values.ts": 3303, - "nullable-object-extension.mjs": 2652, - "nullish-asserted-class-arms.ts": 2669, - "nullish-assignment-values.ts": 2125, - "nullish-long-chain.ts": 2641, - "number-parse-statics.ts": 2471, - "number-predicates-unknown.ts": 2568, - "numeric-call-specialization.ts": 2498, - "object-enumeration-array-reads.ts": 2246, - "object-from-checked-entries.js": 3478, - "object-inherited-to-string.js": 2987, - "object-key-indexes.js": 3206, - "object-prototype-identity.mjs": 3083, - "object-reexport/main.js": 2466, - "object-spread-computed.ts": 2806, - "opentui-byte-queue.js": 3532, - "optional-callback-arity.ts": 2417, - "optional-class-flows.ts": 2497, - "optional-element-defaults.ts": 2632, - "optional-flag-comparisons.ts": 2536, - "optional-native-callables.js": 2751, - "optional-node-list-iteration.ts": 2564, - "optional-string-index/main.ts": 3419, - "path-to-file-url-options.ts": 2301, - "performance-presence.ts": 2913, - "primitive-and-function-descriptors.js": 3070, - "primitive-union-string.ts": 3434, - "process-builtin-values.js": 2781, - "process-constrained-memory.ts": 2857, - "process-env-computed-keys.js": 3185, - "process-hrtime.js": 2662, - "process-named-signals.cjs": 3171, - "process-uncaught-handler-throws.cjs": 2344, - "process-uncaught-loop.cjs": 3141, - "process-uncaught-module.mjs": 2646, - "process-uncaught-monitor.cjs": 2837, - "process-uncaught-rejection.cjs": 2664, - "process-uncaught-sync.cjs": 2858, - "process-version-pin.ts": 3005, - "process-versions-storage.ts": 2055, - "projected-collection-lifetimes.ts": 3232, - "promise-checked-rejections.ts": 2914, - "promise-resolve-void.ts": 2846, - "prototype-method-overrides.mjs": 4119, - "prototype-named-data-records.ts": 3179, - "record-field-presence.ts": 3698, - "record-key-order.ts": 2706, - "record-optional-json-presence.ts": 3216, - "record-presence-copies.ts": 3381, - "record-presence-delete-json.ts": 3160, - "record-unchecked-read-presence.ts": 2953, - "record-unknown-values.ts": 4095, - "reflect-own-keys.mjs": 2705, - "reflect-record-union-keys.mjs": 2815, - "reflect-typed-record-keys.ts": 2683, - "regex-callback-replacements.ts": 2631, - "regex-callback-values.js": 3741, - "regex-checked-casts.ts": 2405, - "regex-checked-storage.js": 3560, - "regex-exec-long-subject.ts": 5584, - "regex-input-lifetimes.ts": 3241, - "regex-native-matcher.ts": 3652, - "regex-optional-captures.ts": 2740, - "regex-optional-templates.ts": 2802, - "regex-split-captures.ts": 3590, - "regex-text-paths.ts": 2840, - "regexp-constructor-repeat.ts": 2602, - "regexp-optional-constructor.ts": 2950, - "regexp-string-coercion.js": 2621, - "renderer-export-dictionaries.js": 3415, - "renderer-null-state.js": 2259, - "renderer-specializations.js": 2837, - "repeat-and-typed-read-errors.ts": 3220, - "rest-optional-array-arguments.ts": 2860, - "rest-optional-elements.ts": 2445, - "return-void-through-finally.ts": 2861, - "runtime-optional-string-flows.ts": 2977, - "scalar-string-slices.ts": 2840, - "set-checked-methods.js": 3072, - "set-checked-storage.ts": 2667, - "set-iterator-seed-references.ts": 3159, - "set-iterator-seeds.ts": 3269, - "set-optional-seeds.ts": 2164, - "small-collection-transitions.ts": 3586, - "stack-depth-async-bodies.ts": 2727, - "stack-overflow-async.ts": 2942, - "stack-overflow-caught.ts": 3056, - "stack-overflow-finally.ts": 3694, - "stack-overflow-shapes.ts": 3565, - "stack-overflow-uncaught.ts": 2532, - "static-field-updates/main.ts": 2914, - "static-method-receivers.ts": 2350, - "stdio-values.mjs": 2761, - "stdio-write-errors.mjs": 2672, - "stdio-write-overrides.mjs": 3205, - "stored-native-builtins.js": 3341, - "stored-object-helpers.js": 2959, - "string-char-code-integer-loops.ts": 2575, - "string-code-points.ts": 2460, - "string-concat-number-parts.ts": 2155, - "string-construction-order.ts": 3307, - "string-lifetimes-boundaries.ts": 3304, - "string-lifetimes-evaluation.ts": 2835, - "string-lifetimes-iteration.ts": 2037, - "string-lifetimes-operations.ts": 2789, - "string-normalize.ts": 2348, - "string-pattern-replacement.ts": 3823, - "string-scan-fast-paths.ts": 3224, - "string-split-checked-separator.mjs": 2349, - "string-split-traversal.ts": 3258, - "structural-class-properties.ts": 2627, - "structured-text-boundaries.js": 3452, - "structured-text-storage.ts": 3201, - "switch-integer-dispatch.ts": 2387, - "symbol-checked-boundary/main.ts": 2796, - "symbol-class-fields.ts": 2814, - "symbol-class-fields/main.cjs": 2659, - "symbol-class-methods/main.ts": 1948, - "symbol-fields-deferred-factory.ts": 2721, - "symbol-fields-inferred.js": 2792, - "symbol-object-properties/main.js": 3376, - "synchronous-callback-lifetimes.ts": 2872, - "terminal-stream-properties.ts": 2946, - "text-codec-values/main.ts": 18964, - "text-codec-var.ts": 3480, - "text-encode-into-boundaries.ts": 2224, - "timers-clear-many.ts": 3073, - "tuple-and-string-search.ts": 2595, - "tuple-array-union.ts": 3305, - "tuple-callback-visitation.ts": 3801, - "tuple-forof-visitation.ts": 3276, - "typed-array-bulk-conversion.mjs": 5346, - "typed-array-byte-io.js": 41314, - "typed-array-checked-index.js": 2607, - "typed-array-constructor-alias.ts": 2778, - "typed-array-constructor-identity.js": 2769, - "typed-array-constructor-union.ts": 2366, - "typed-array-constructor-values.mjs": 3448, - "typed-array-dynamic-methods.js": 3373, - "typed-array-integer-widths.ts": 3014, - "typed-array-nan-coded-reads.ts": 4239, - "typed-array-numeric-import.ts": 3499, - "typed-array-present-reads.ts": 3561, - "typed-array-reversed-storage.ts": 2954, - "typed-array-unknown.ts": 3453, - "typed-collection-iterator-references.ts": 3531, - "typed-collection-iterators.ts": 3385, - "typed-collection-views/main.ts": 2577, - "typed-index-arguments.ts": 3036, - "typed-prototype-methods.ts": 2475, - "typed-rest-callables.ts": 2463, - "typed-rest-filtered-return.ts": 2800, - "typedarray-native-inputs.js": 3164, - "typeof-checked-comparison.js": 2913, - "uint8array-sort-domains.ts": 2505, - "unicode-case-paths.ts": 2924, - "unicode-process-argv.ts": 2793, - "union-discriminant-width.ts": 3726, - "union-literal-scalar-discriminants.ts": 3704, - "union-literal-slot-conversion.ts": 2972, - "union-nested-layout-discriminant.ts": 2841, - "union-optional-semantic-identity.ts": 3100, - "union-record-clone.ts": 3480, - "union-record-structural-copy.ts": 3563, - "union-reference-comparison.ts": 3338, - "unknown-array-holes.ts": 2088, - "unknown-collections.ts": 3765, - "unknown-object-enumeration.ts": 4219, - "unknown-record-views.ts": 3040, - "url-runtime-base.ts": 2778, - "utf8-span-decoding.ts": 2655, - "util-parseargs-wrapped/main.ts": 2482, - "virtual-runtime-optional-returns.ts": 3876, - "weak-map-array-buffer.ts": 2826, - "weak-map-fresh-array.js": 2495, - "weak-map-native.js": 3627, - "weak-native-class-identity.ts": 2943, - "weak-set-native.js": 3056, - "worker-class-instance-clone.ts": 35222 + "js-dataview-dispatch.js": 2584, + "js-declared-fields.cjs": 4858, + "js-default-listener-arguments.cjs": 2246, + "js-default-options/main.ts": 2763, + "js-deferred-field-initializers.js": 3209, + "js-deferred-registry-effects.js": 3112, + "js-derived-constructor-hoisting.js": 2435, + "js-dormant-array-write.js": 2504, + "js-dormant-overrides.js": 2426, + "js-expando-records.js": 2649, + "js-implicit-call-results.js": 2821, + "js-inferred-callback-exports/main.js": 4081, + "js-inferred-class-array-return.js": 3706, + "js-inferred-object-values.js": 2559, + "js-inherited-field-storage.js": 3955, + "js-inherited-parameter-abi.js": 2394, + "js-iterable-spread.js": 3349, + "js-loose-dynamic-primitives.js": 3110, + "js-map-object-seeds.js": 3942, + "js-member-increment.js": 4274, + "js-module-function-values.js": 3403, + "js-mutable-null-members.js": 2899, + "js-nested-native-descriptors.js": 3202, + "js-normalize-dispatch.js": 3282, + "js-nullish-inherited-fields.mjs": 2655, + "js-object-receiver-storage.js": 3904, + "js-object-returning-constructors.mjs": 2279, + "js-object-shared-arrays.js": 3613, + "js-omitted-typed-arguments.js": 2937, + "js-open-binding-writes.js": 2903, + "js-optional-class-fields.js": 3536, + "js-optional-member-call.js": 2325, + "js-primitive-union-addition.js": 3324, + "js-promise-all-values.js": 3699, + "js-promise-catch-handler.js": 3309, + "js-promise-finally-order.js": 3229, + "js-promise-pending-reactions.js": 3312, + "js-prototype-host-boundary.js": 3876, + "js-reflect-receivers.js": 2676, + "js-regex-record-captures.js": 3109, + "js-scalar-iterables.js": 3335, + "js-shared-method-dispatch.js": 3207, + "js-specialized-field-method.js": 3320, + "js-static-accessors.js": 3426, + "js-static-method-values.js": 3661, + "js-static-registries.cjs": 3718, + "js-super-accessor-initialization.js": 2555, + "js-uninitialized-native-fields.js": 3260, + "json-guarded-map-values.ts": 2760, + "json-output-bulk.ts": 3183, + "json-runtime-options.mjs": 3276, + "json-stringify-value.js": 3464, + "json-typed-parse-direct.ts": 4317, + "json-typed-parse-index-signatures.ts": 4012, + "json-typed-parse-optional-members.ts": 4377, + "json-typed-parse-union-members.ts": 4357, + "literal-switch-dispatch.ts": 2642, + "live-reference-shared-converters.ts": 5581, + "llvm-read-receiver-lifetime.ts": 3426, + "local-class-call-spreads.js": 3773, + "local-class-declaration.ts": 3293, + "local-class-evaluation.ts": 2921, + "local-class-inheritance.ts": 3273, + "local-class-lifetimes.ts": 3403, + "local-class-namespace/main.js": 4002, + "local-class-prototype-data.js": 3135, + "local-class-specialization.js": 3358, + "local-class-unknown.ts": 3386, + "local-class-values.ts": 3003, + "local-union-storage.ts": 3264, + "locale-compare-root-order.ts": 2579, + "logical-assignment-dynamic.js": 3596, + "logical-assignment-values.ts": 2685, + "logical-runtime-optional-record.ts": 3575, + "loop-reference-lifetimes.ts": 2726, + "map-checked-boundary/main.ts": 3371, + "map-checked-seed.js": 2974, + "map-get-set-fusion.ts": 3516, + "map-number-keys-dense.ts": 3426, + "map-read-lifetimes-exits.ts": 2870, + "map-read-lifetimes.ts": 2755, + "map-seeds-and-spreads.ts": 3696, + "map-typed-array-values.ts": 3121, + "math-function-values.js": 3080, + "missing-read-lambda-results.ts": 2590, + "missing-read-narrowed-storage.ts": 3503, + "missing-read-number-conversions.ts": 3648, + "module-byte-loops.ts": 3462, + "module-fallback-functions/main.js": 3043, + "narrowed-nullish-values.ts": 2912, + "native-any-timer-callback.ts": 1952, + "native-array-borrowed-find-last.js": 2795, + "native-array-borrowed-slice.js": 3711, + "native-array-copying-methods.js": 3069, + "native-array-fill-copywithin.js": 3430, + "native-array-frozen-noops.js": 3638, + "native-array-index-boundaries.js": 2630, + "native-array-integrity.js": 3935, + "native-array-length.js": 3375, + "native-array-named-properties.js": 3404, + "native-array-prototype/main.js": 3369, + "native-array-read-lifetimes.ts": 3688, + "native-array-reduce-find-last.js": 3264, + "native-array-search-from-index.js": 3220, + "native-array-splice-coercion.js": 3281, + "native-array-splice-flat.js": 3336, + "native-buffer-coercion.js": 2766, + "native-callback-dispatch.ts": 3779, + "native-class-array-boundaries.ts": 3630, + "native-class-cache.js": 3925, + "native-class-properties.cjs": 3940, + "native-class-property-cycles.cjs": 2802, + "native-class-property-order.cjs": 3298, + "native-class-type-predicates.ts": 3174, + "native-factory-records.js": 3338, + "native-method-values.js": 4444, + "native-method-values.ts": 3470, + "native-npm-imports/main.ts": 4028, + "native-object-descriptors.js": 2892, + "native-object-for-in-minimal.js": 2799, + "native-object-property-attributes.js": 3744, + "native-object-prototype.js": 2121, + "native-property-names.ts": 2951, + "native-proxy-env.js": 4417, + "native-worker-arena-reuse.ts": 38589, + "native-worker-bounded-errors.ts": 3955, + "native-worker-buffer-consumers.ts": 3076, + "native-worker-cancel-hot.ts": 3811, + "native-worker-class-fields.ts": 3737, + "native-worker-clone-errors.ts": 3557, + "native-worker-commonjs.cjs": 3258, + "native-worker-delayed-messages.ts": 3234, + "native-worker-discarded-heaps.ts": 8633, + "native-worker-environment.ts": 2690, + "native-worker-error.ts": 2115, + "native-worker-exception-state.ts": 37223, + "native-worker-exit-listeners.ts": 4215, + "native-worker-io.ts": 4024, + "native-worker-loop-cancellation.ts": 3683, + "native-worker-message-graphs.ts": 4038, + "native-worker-messages.ts": 2850, + "native-worker-poll-exceptions.ts": 3386, + "native-worker-port-lifetime.ts": 3672, + "native-worker-process-exit.ts": 4483, + "native-worker-publish-classes.ts": 43586, + "native-worker-publish-refusals.ts": 3568, + "native-worker-published-graphs.ts": 4341, + "native-worker-references.ts": 3658, + "native-worker-roots/main.ts": 3661, + "native-worker-shared-views.ts": 3873, + "native-worker-stack-overflow.ts": 3498, + "native-worker-terminate-exception-state.ts": 4768, + "native-worker-terminate-loop.ts": 3671, + "native-worker-terminate-recursion.ts": 2944, + "native-worker-terminate-suspended.ts": 4867, + "native-worker-terminate-tested-loops.ts": 3737, + "native-worker-terminate-wait.ts": 3200, + "native-worker-typed-arrays.ts": 2972, + "nested-map-cycles.ts": 3092, + "nested-map-values.ts": 3902, + "never-returning-calls.ts": 3512, + "next-tick-commonjs-entry.cjs": 3497, + "node24-buffer-encoding-errors.ts": 2874, + "node24-buffer-encoding.ts": 2697, + "node24-crypto-kdf-errors.ts": 3771, + "node24-crypto-kdf-options.ts": 2897, + "node24-crypto-kdf.ts": 3236, + "node24-crypto-sha2.ts": 3082, + "node24-deep-equality-properties.js": 3692, + "node24-deep-equality.cjs": 4490, + "node24-deep-equality.ts": 2856, + "node24-env-files-errors.ts": 2870, + "node24-env-files.ts": 3392, + "node24-env-imports.cjs": 2365, + "node24-env-parse-errors.ts": 3439, + "node24-env-parse.ts": 3033, + "node24-esm-metadata/main.mjs": 3209, + "node24-file-url-buffer.ts": 3465, + "node24-file-url-errors.js": 3937, + "node24-file-url-options.ts": 3735, + "node24-fs-links-callbacks.cjs": 3621, + "node24-fs-links-errors.cjs": 3404, + "node24-fs-links-options.cjs": 6459, + "node24-fs-links-promise-errors.cjs": 3319, + "node24-fs-links-promises.ts": 2636, + "node24-fs-links.ts": 3567, + "node24-fs-statfs-callbacks.cjs": 2515, + "node24-fs-statfs-errors.cjs": 2787, + "node24-fs-statfs-options.cjs": 3945, + "node24-fs-statfs.ts": 3105, + "node24-fs-timestamps-callbacks.cjs": 3550, + "node24-fs-timestamps-errors.cjs": 2070, + "node24-fs-timestamps-promises.ts": 3342, + "node24-fs-timestamps-symlinks.ts": 3375, + "node24-fs-timestamps.ts": 3308, + "node24-no-error-assertions-coercion.js": 3613, + "node24-no-error-assertions.cjs": 2851, + "node24-no-error-assertions.ts": 4400, + "node24-parseargs.js": 5202, + "node24-string-decoder.ts": 3402, + "node24-style-text-environment.js": 3896, + "node24-style-text-validation.js": 3092, + "node24-style-text.cjs": 3244, + "node24-style-text.ts": 2726, + "node24-system-error-validation.js": 3065, + "node24-system-errors.cjs": 2955, + "node24-system-errors.ts": 3258, + "node24-text-codec-properties.ts": 31240, + "node24-text-encode-into.ts": 2827, + "node24-text-utilities-coercion.js": 3019, + "node24-text-utilities-validation.js": 3576, + "node24-text-utilities.cjs": 3204, + "node24-text-utilities.ts": 2533, + "node24-url-authority-coercion.js": 3364, + "node24-url-authority.ts": 3386, + "node24-url-factories.ts": 3341, + "node24-url-factory-errors.ts": 3442, + "node24-url-mutation-coercion.js": 3344, + "node24-url-mutation.ts": 3264, + "node24-util-types.cjs": 3872, + "node24-util-types.js": 3533, + "node24-util-types.ts": 2848, + "non-null-class-iteration.ts": 2837, + "nonnull-element-arguments.ts": 3131, + "nonnull-forwarded-class-values.ts": 2449, + "nullable-object-extension.mjs": 3515, + "nullish-asserted-class-arms.ts": 3564, + "nullish-assignment-values.ts": 3337, + "nullish-long-chain.ts": 4149, + "number-parse-statics.ts": 2899, + "number-predicates-unknown.ts": 2922, + "numeric-call-specialization.ts": 2677, + "object-enumeration-array-reads.ts": 3480, + "object-from-checked-entries.js": 4289, + "object-inherited-to-string.js": 3243, + "object-key-indexes.js": 3558, + "object-prototype-identity.mjs": 3385, + "object-reexport/main.js": 2771, + "object-spread-computed.ts": 3307, + "opentui-byte-queue.js": 3572, + "optional-callback-arity.ts": 3027, + "optional-class-flows.ts": 3557, + "optional-element-defaults.ts": 3575, + "optional-flag-comparisons.ts": 3414, + "optional-native-callables.js": 3002, + "optional-node-list-iteration.ts": 2230, + "optional-string-index/main.ts": 3788, + "path-to-file-url-options.ts": 2444, + "performance-presence.ts": 2497, + "primitive-and-function-descriptors.js": 3169, + "primitive-union-string.ts": 2622, + "process-builtin-values.js": 3706, + "process-constrained-memory.ts": 2749, + "process-env-computed-keys.js": 3550, + "process-hrtime.js": 2677, + "process-named-signals.cjs": 3293, + "process-uncaught-handler-throws.cjs": 2718, + "process-uncaught-loop.cjs": 2801, + "process-uncaught-module.mjs": 3158, + "process-uncaught-monitor.cjs": 3031, + "process-uncaught-rejection.cjs": 3327, + "process-uncaught-sync.cjs": 2443, + "process-version-pin.ts": 2957, + "process-versions-storage.ts": 3651, + "projected-collection-lifetimes.ts": 3241, + "promise-checked-rejections.ts": 3404, + "promise-resolve-void.ts": 3343, + "prototype-method-overrides.mjs": 4289, + "prototype-named-data-records.ts": 3466, + "rc-last-use-moves.ts": 4113, + "rc-private-array-writes.ts": 4261, + "record-field-presence.ts": 4642, + "record-key-order.ts": 3034, + "record-optional-json-presence.ts": 3355, + "record-presence-copies.ts": 2764, + "record-presence-delete-json.ts": 2807, + "record-unchecked-read-presence.ts": 3073, + "record-unknown-values.ts": 4519, + "reflect-own-keys.mjs": 3709, + "reflect-record-union-keys.mjs": 2498, + "reflect-typed-record-keys.ts": 2697, + "regex-callback-replacements.ts": 3004, + "regex-callback-values.js": 2710, + "regex-checked-casts.ts": 3352, + "regex-checked-storage.js": 3330, + "regex-exec-long-subject.ts": 6176, + "regex-exec-result-arrays.ts": 3812, + "regex-fs-text-surfaces.ts": 4280, + "regex-input-lifetimes.ts": 3127, + "regex-native-matcher.ts": 5535, + "regex-optional-captures.ts": 3580, + "regex-optional-templates.ts": 3221, + "regex-split-captures.ts": 2939, + "regex-text-paths.ts": 3596, + "regexp-constructor-repeat.ts": 3069, + "regexp-optional-constructor.ts": 2996, + "regexp-string-coercion.js": 3263, + "renderer-export-dictionaries.js": 3616, + "renderer-null-state.js": 3037, + "renderer-specializations.js": 3634, + "repeat-and-typed-read-errors.ts": 2617, + "rest-optional-array-arguments.ts": 3777, + "rest-optional-elements.ts": 3195, + "return-void-through-finally.ts": 2410, + "runtime-optional-string-flows.ts": 3467, + "scalar-string-slices.ts": 3659, + "set-checked-methods.js": 2038, + "set-checked-storage.ts": 3153, + "set-iterator-seed-references.ts": 3637, + "set-iterator-seeds.ts": 3641, + "set-optional-seeds.ts": 3312, + "small-collection-transitions.ts": 3749, + "speculative-integer-globals.ts": 3132, + "speculative-integer-loops.ts": 3533, + "speculative-integer-reads.ts": 3953, + "stack-depth-async-bodies.ts": 3272, + "stack-overflow-async.ts": 2638, + "stack-overflow-caught.ts": 2219, + "stack-overflow-finally.ts": 3033, + "stack-overflow-shapes.ts": 4491, + "stack-overflow-uncaught.ts": 2225, + "stackless-async-concurrency.ts": 4361, + "stackless-async-context.ts": 2699, + "stackless-async-exceptions.ts": 3282, + "stackless-async-ordering.ts": 3335, + "stackless-async-unhandled.ts": 2784, + "static-field-updates/main.ts": 2292, + "static-method-receivers.ts": 3195, + "stdio-values.mjs": 3475, + "stdio-write-errors.mjs": 3473, + "stdio-write-overrides.mjs": 2782, + "stored-native-builtins.js": 3709, + "stored-object-helpers.js": 3602, + "stream-dynamic-entry-kinds.cjs": 4557, + "stream-dynamic-entry-kinds.ts": 4257, + "stream-encoded-from-entries.cjs": 4266, + "stream-encoded-from-entries.ts": 5622, + "string-char-code-integer-loops.ts": 2285, + "string-code-points.ts": 3745, + "string-concat-number-parts.ts": 3405, + "string-construction-order.ts": 3532, + "string-field-append.ts": 3568, + "string-lifetimes-boundaries.ts": 2538, + "string-lifetimes-evaluation.ts": 3059, + "string-lifetimes-iteration.ts": 2631, + "string-lifetimes-operations.ts": 3387, + "string-normalize.ts": 2789, + "string-pattern-replacement.ts": 3618, + "string-scan-fast-paths.ts": 3272, + "string-split-checked-separator.mjs": 3453, + "string-split-traversal.ts": 4337, + "structural-class-properties.ts": 3247, + "structured-text-boundaries.js": 3686, + "structured-text-storage.ts": 3429, + "switch-integer-dispatch.ts": 3032, + "symbol-checked-boundary/main.ts": 3536, + "symbol-class-fields.ts": 2762, + "symbol-class-fields/main.cjs": 3297, + "symbol-class-methods/main.ts": 3256, + "symbol-fields-deferred-factory.ts": 2417, + "symbol-fields-inferred.js": 3396, + "symbol-object-properties/main.js": 3134, + "synchronous-callback-lifetimes.ts": 3731, + "terminal-stream-properties.ts": 3204, + "text-codec-values/main.ts": 34352, + "text-codec-var.ts": 32460, + "text-encode-into-boundaries.ts": 3355, + "timers-clear-many.ts": 3559, + "tuple-and-string-search.ts": 3678, + "tuple-array-union.ts": 3569, + "tuple-callback-visitation.ts": 4765, + "tuple-forof-visitation.ts": 3560, + "typed-array-bulk-conversion.mjs": 5651, + "typed-array-byte-io.js": 4933, + "typed-array-checked-index.js": 3214, + "typed-array-constructor-alias.ts": 3116, + "typed-array-constructor-identity.js": 2735, + "typed-array-constructor-union.ts": 2841, + "typed-array-constructor-values.mjs": 3638, + "typed-array-dynamic-methods.js": 3255, + "typed-array-integer-widths.ts": 3434, + "typed-array-nan-coded-reads.ts": 3804, + "typed-array-numeric-import.ts": 2396, + "typed-array-present-reads.ts": 4348, + "typed-array-reversed-storage.ts": 3192, + "typed-array-unknown.ts": 2874, + "typed-collection-iterator-references.ts": 4029, + "typed-collection-iterators.ts": 4109, + "typed-collection-views/main.ts": 3005, + "typed-index-arguments.ts": 2798, + "typed-prototype-methods.ts": 3814, + "typed-rest-callables.ts": 2881, + "typed-rest-filtered-return.ts": 3723, + "typedarray-native-inputs.js": 2740, + "typeof-checked-comparison.js": 2277, + "uint8array-sort-domains.ts": 3386, + "unicode-case-paths.ts": 3002, + "unicode-process-argv.ts": 3272, + "union-discriminant-width.ts": 3302, + "union-literal-scalar-discriminants.ts": 2833, + "union-literal-slot-conversion.ts": 4058, + "union-nested-layout-discriminant.ts": 3205, + "union-optional-semantic-identity.ts": 3833, + "union-record-clone.ts": 3862, + "union-record-structural-copy.ts": 3756, + "union-reference-comparison.ts": 2883, + "unknown-array-holes.ts": 2863, + "unknown-collections.ts": 4132, + "unknown-object-enumeration.ts": 4976, + "unknown-record-views.ts": 4014, + "url-runtime-base.ts": 3421, + "utf8-span-decoding.ts": 3446, + "util-parseargs-wrapped/main.ts": 3987, + "virtual-runtime-optional-returns.ts": 4683, + "weak-map-array-buffer.ts": 3291, + "weak-map-fresh-array.js": 2703, + "weak-map-native.js": 3899, + "weak-native-class-identity.ts": 2332, + "weak-set-native.js": 2464, + "worker-class-instance-clone.ts": 46305 } } From 4bba6c1e0b1f370c64c34ba8ea6528cd521f8010 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 11:30:08 -0500 Subject: [PATCH 5/7] Keep this PR's refreshed corpus costs after the main merge --- tests/harness/corpus-costs.json | 10772 +++++++++++++++--------------- 1 file changed, 5386 insertions(+), 5386 deletions(-) diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index 797986e20..622b64700 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -1,1697 +1,1697 @@ { "note": "Milliseconds per corpus program on a GitHub-hosted ubuntu-24.04 runner: its differential plus llvm-differential case, per flavor (medians of green main runs). scripts/ci-corpus-costs.mjs refreshes it from CI logs.", "plain": { - "001-hello.ts": 3069, - "002-log-args.ts": 2728, - "100-number-format.ts": 3733, - "1000-json-stringify-basics.ts": 4746, - "1001-json-escapes-unicode.ts": 3114, - "1002-json-parse-cast.ts": 4816, - "1003-json-parse-unions.ts": 3373, - "1004-json-parse-errors.ts": 2257, - "1005-json-nested.ts": 3430, - "1006-json-fs-config.ts": 3508, - "1007-json-rc-stress.ts": 4738, - "1008-json-null-arms.ts": 3237, - "1009-json-optional-fields.ts": 3598, - "101-arithmetic.ts": 2904, - "1010-json-stringify-space.ts": 4663, - "1011-json-unknown-typeof.ts": 2914, - "102-comparisons.ts": 2408, - "1020-async-basics.ts": 2514, - "1021-async-ordering.ts": 2150, - "1022-async-exceptions.ts": 2155, - "1023-async-rc-stress.ts": 3249, - "1024-async-pending-exit.ts": 3248, - "1025-async-promise-capture.ts": 4134, - "1026-throw-promise.ts": 2862, - "1027-async-return-promise.ts": 3195, - "1028-async-return-record-literals.ts": 2979, - "1029-async-eager-chains.ts": 3200, - "103-ternary.ts": 2586, - "104-ternary-empty-arrays.ts": 3925, - "1050-comptime-tables.ts": 3449, - "1051-comptime-strings.ts": 4033, - "1052-comptime-records.ts": 4539, - "1053-comptime-json.ts": 2953, - "1054-comptime-modules/main.ts": 2477, - "110-number-radix.ts": 2253, - "111-record-entries.ts": 4124, - "1110-math-members.ts": 3859, - "1111-math-random.ts": 2956, - "1113-string-methods.ts": 3292, - "1114-string-unicode-island.ts": 2830, - "1115-parse-globals.ts": 2990, + "001-hello.ts": 3065, + "002-log-args.ts": 4101, + "100-number-format.ts": 4051, + "1000-json-stringify-basics.ts": 5187, + "1001-json-escapes-unicode.ts": 4569, + "1002-json-parse-cast.ts": 3516, + "1003-json-parse-unions.ts": 3382, + "1004-json-parse-errors.ts": 4383, + "1005-json-nested.ts": 5206, + "1006-json-fs-config.ts": 3979, + "1007-json-rc-stress.ts": 3920, + "1008-json-null-arms.ts": 3823, + "1009-json-optional-fields.ts": 4367, + "101-arithmetic.ts": 3258, + "1010-json-stringify-space.ts": 3979, + "1011-json-unknown-typeof.ts": 4108, + "102-comparisons.ts": 4061, + "1020-async-basics.ts": 3165, + "1021-async-ordering.ts": 3062, + "1022-async-exceptions.ts": 3356, + "1023-async-rc-stress.ts": 3530, + "1024-async-pending-exit.ts": 2901, + "1025-async-promise-capture.ts": 3471, + "1026-throw-promise.ts": 3173, + "1027-async-return-promise.ts": 2405, + "1028-async-return-record-literals.ts": 3561, + "1029-async-eager-chains.ts": 3698, + "103-ternary.ts": 3292, + "104-ternary-empty-arrays.ts": 4072, + "1050-comptime-tables.ts": 3518, + "1051-comptime-strings.ts": 2082, + "1052-comptime-records.ts": 3252, + "1053-comptime-json.ts": 3388, + "1054-comptime-modules/main.ts": 3286, + "110-number-radix.ts": 3749, + "111-record-entries.ts": 4017, + "1110-math-members.ts": 2615, + "1111-math-random.ts": 2691, + "1113-string-methods.ts": 3490, + "1114-string-unicode-island.ts": 2532, + "1115-parse-globals.ts": 2850, "1116-island-static-mix.ts": 3032, - "1117-typeof-static-union.ts": 2965, - "1118-object-spread-conditional.ts": 2667, - "1119-switch-union.ts": 3067, - "112-class-descriptor-key.js": 2522, - "1121-infinity-number-tostring.ts": 3370, - "1122-any-captures.ts": 3176, - "1124-union-narrowed-retag.ts": 2492, - "113-promise-checked-exits.ts": 2859, - "114-live-record-delete.ts": 2500, - "115-array-compound.js": 3135, - "116-text-decoder-runtime.js": 2862, - "117-weak-cache-cycle.js": 2266, - "118-fs-stored-callbacks.cjs": 3485, - "119-native-patterns.js": 3500, - "1200-regex-test-basics.ts": 3223, - "1201-regex-replace.ts": 3086, - "1202-regex-substitutions.ts": 3684, - "1203-regex-split.ts": 3320, - "1204-regex-empty-unicode.ts": 2968, - "1205-regex-rc-stress.ts": 2448, - "1300-errors-basics.ts": 2709, - "1301-errors-subclass.ts": 3447, - "1302-errors-typed-catch.ts": 3128, - "1303-errors-rc-stress.ts": 2776, - "1304-errors-uncaught.ts": 2907, - "1305-errors-async-rejections.ts": 2863, - "1306-errors-runtime-instances.ts": 2803, - "1350-path-normalize-join.ts": 2394, - "1351-path-parts.ts": 2228, - "1352-path-resolve-relative.ts": 3019, - "1353-os-basics.ts": 2682, - "1354-builtin-bare-specifiers.ts": 2284, - "1355-url-parse.ts": 2467, - "1356-url-file-bridge.ts": 3063, - "1357-fsp-roundtrip.ts": 3440, - "1358-crypto-random.ts": 2124, - "1359-json-module/main.ts": 2889, - "1360-spawn-sync.ts": 3158, - "1361-spawn-events.ts": 3000, - "1362-spawn-timers.ts": 8505, - "1363-spawn-unhandled-error.ts": 2724, - "1364-union-truthiness.ts": 2131, - "1365-union-logical.ts": 2948, - "1366-union-equality.ts": 2233, - "1367-destructuring.ts": 3492, - "1368-constructor-functions.ts": 2941, - "1369-promise-union.ts": 2048, - "1370-spread.ts": 2658, - "1371-union-template-tostring.ts": 2681, - "1372-loose-null-tests.ts": 2819, - "1373-union-array-arms.ts": 2414, - "140-bitwise-operators.ts": 3378, - "1400-typedarray-basics.ts": 3056, - "1401-typedarray-slice-set.ts": 2697, - "1402-buffer-encodings.ts": 3146, - "1403-buffer-fs.ts": 3327, - "1404-zlib-crypto-bytes.ts": 3318, - "1405-bytes-unions-arrays.ts": 2463, - "1406-dataview-mp4.ts": 2536, - "1407-dataview-bounds.ts": 3301, - "1408-string-indexing.ts": 2027, - "1409-typedarray-integer-loops.ts": 2940, - "1420-number-statics.ts": 2894, - "1421-number-parse-strings.ts": 2645, - "1422-date-iso.ts": 2686, - "1423-text-codec.ts": 4188, - "1424-fs-options.ts": 2662, - "1425-stdin-tty.ts": 2638, - "1426-stdin-read.ts": 2379, - "1427-fromcharcode-lastindexof.ts": 2109, - "1428-settled-await-order.ts": 2663, - "1429-promise-catch-finally.ts": 3486, - "1430-promise-race.ts": 4032, - "1431-caught-tostring.ts": 2082, - "1432-destructured-params.ts": 3251, - "1433-filter-narrow.ts": 3353, - "1434-async-never.ts": 2711, - "1435-math-spread.ts": 2665, - "1436-default-undef-param.ts": 2896, - "1437-pad-default.ts": 3003, - "1438-promise-all.ts": 6347, - "1440-interval-basics.ts": 3004, - "1441-interval-clear-cross.ts": 5524, - "1442-interval-throw.ts": 3148, - "1443-signal-handlers.ts": 5739, - "1444-exit-listeners.ts": 3270, - "1445-exit-process-exit.ts": 2515, - "1446-exit-uncaught.ts": 2709, - "1447-stdin-closed-events.ts": 2034, - "1448-stream-columns.ts": 2668, - "1450-incdec-expression.ts": 3189, - "1451-instanceof-uint8array-unknown.ts": 3003, - "1452-return-through-finally.ts": 2097, - "1453-pmap-settled.ts": 3863, - "1454-nonnull-narrow-and-fcc-bytes.ts": 2192, - "1455-lambda-union-return-adoption.ts": 3144, - "1460-console-error-warn.ts": 2229, - "1461-process-pid-getuid-kill.ts": 2853, - "1462-exec-sync.ts": 3145, - "1463-timeout-unref.ts": 2935, - "1464-env-writes.ts": 2594, - "1465-env-value.ts": 3233, - "1466-child-containers.ts": 2674, - "1467-string-match.ts": 2677, - "1468-exec-path.ts": 2974, - "1469-remove-listener.ts": 4038, - "1470-child-lifecycle.ts": 1948, - "1471-child-unref.ts": 6913, - "1472-errno-code.ts": 2768, - "1473-promisify-execfile.ts": 3155, - "1474-string-decoder.ts": 3057, - "1475-readline-closed-stdin.ts": 2826, - "1476-assign-expression.ts": 2557, - "1477-in-expressions.ts": 2740, - "1478-promise-reject.ts": 3143, - "1479-destructuring-assign.ts": 2933, - "1480-os-network-interfaces.ts": 3749, - "1481-string-case-static.ts": 1949, - "1482-spawnsync-error.ts": 2332, - "1483-array-slice.ts": 3329, - "1520-fs-wider-surface.ts": 3206, - "1520-string-split-static.ts": 2787, - "1521-fs-lstat-lock.ts": 2868, - "1521-string-trim-pad-static.ts": 2727, - "1522-parseint-static.ts": 2059, - "1522-spawnsync-options.ts": 3990, - "1523-isnan-floor-static.ts": 2552, - "1523-spawn-options.ts": 2955, - "1524-atomics-sleep-static.ts": 3221, - "1524-catch-narrowing.ts": 2221, - "1525-child-exit-signal.ts": 2022, - "1525-unknown-typeof-validation.ts": 2311, - "1526-set-spread.ts": 3277, - "1527-logical-mixed-operands.ts": 2920, - "1528-delete-records-env.ts": 3318, - "1529-class-with-statics.ts": 2626, - "1530-array-push-variadic.ts": 2272, - "1530-spread-override-completion.ts": 2333, - "1531-delete-optional-fields.ts": 2822, - "1531-process-arch-versions.ts": 2409, - "1532-array-splice-shift.ts": 2440, - "1532-union-shared-field-read.ts": 2449, - "1533-bool-equality.ts": 3130, - "1533-path-platform-namespaces.ts": 2472, - "1534-crypto-hash-chain.ts": 3303, - "1534-union-as-arm-cast.ts": 2773, - "1535-spawn-fd-stdio.ts": 3617, - "1535-union-param-defaults.ts": 2848, - "1536-destructuring-defaults.ts": 2783, - "1536-string-array-sweep.ts": 2930, - "1537-chalk-hybrid/main.ts": 3161, - "1537-os-release-spawnsync-stdio.ts": 2411, - "1538-await-promiselike-return.ts": 2433, - "1538-math-static-scalar.ts": 2674, - "1539-readonly-set-map.ts": 2573, - "1539-unknown-truthiness.ts": 2629, - "1540-os-userinfo.ts": 2636, - "1540-void-statement.ts": 2658, - "1541-fs-readdir-dirent.ts": 3093, - "1541-union-keyed-reads.ts": 4144, - "1542-map-promise-values.ts": 2657, - "1542-record-literal-into-union.ts": 3004, - "1543-rest-destructuring.ts": 2897, - "1543-set-server-handles.ts": 2927, - "1544-dyn-json-reads.ts": 3602, - "1544-string-matchall.ts": 2940, - "1545-spread-order-and-optional.ts": 2963, - "1546-union-element-reads.ts": 2716, - "1547-computed-key-fold.ts": 4334, - "1548-boolean-condition-forms.ts": 4675, - "1549-array-isarray-unions.ts": 3420, - "1550-param-defaults-func-set.ts": 3314, - "1551-dyn-receiver-methods.ts": 4271, - "1552-exec-options-record.ts": 3353, - "1553-truthy-hof-predicates.ts": 2475, - "1554-caught-into-unknown.ts": 2996, - "1555-index-spread-into-declared.ts": 3100, - "1556-union-retag-width-arms.ts": 2198, - "1557-url-host.ts": 2745, - "1558-any-joins-and-dyn-validation.ts": 2600, - "1559-conditional-spread-index-merge.ts": 3037, - "1560-forof-homogeneous-tuples.ts": 2478, - "1561-forof-strings.ts": 2503, - "1561-promise-then.ts": 3156, - "1562-optional-chain-tails.ts": 3390, - "1562-spawn-conditional-spread.ts": 3006, - "1563-forof-iterator-projections.ts": 3054, - "1563-string-raw-fold.ts": 2666, - "1564-fs-watch.ts": 3415, - "1564-string-raw.ts": 2651, - "1565-spawn-pipe-streams.ts": 3154, - "1565-union-element-join.ts": 2733, - "1566-child-duck-interface.ts": 2463, - "1567-server-close-override.ts": 2863, - "1568-x509-fingerprint.ts": 2419, - "1569-fsp-mkdir-unlink-chmod.ts": 2704, - "1570-child-unref-kill-reffed.ts": 8818, - "1571-optional-call-tostring-tail.ts": 4280, - "1571-stdin-set-raw-mode-non-tty.ts": 2435, - "1572-promise-reject-all-tuple.ts": 3046, - "1572-x509-validity-date-gettime.ts": 2933, - "1573-promisify-execfile-env-spread.ts": 3140, - "1573-tdz-scalar-forward-capture.ts": 2068, - "1574-dyn-optional-method-number-keys.ts": 3318, - "1574-promise-all-tuple-literal.ts": 3025, - "1575-unknown-assert-into-record.ts": 3248, - "1576-width-coercions.ts": 2888, - "1577-url-hostname.ts": 2352, - "1578-exec-input-optional.ts": 3178, - "1579-matchall-index.ts": 3025, - "1580-exec-env-conditional-spread.ts": 3275, - "1581-declare-const-read.ts": 2341, - "1582-timer-sleep-resolve.ts": 2315, - "1583-loops-and-stream-captures.ts": 3154, - "1584-union-field-unassigned.ts": 2858, - "1585-union-field-conditional-ctor.ts": 2073, - "1586-derived-field-before-super-init.ts": 2823, - "1590-js-unannotated.js": 2965, - "1591-js-closures.js": 2113, - "1592-js-classes.js": 4260, - "1593-js-jsdoc-records.js": 3366, - "1594-js-async.js": 2772, - "1595-js-island-gap/main.js": 2168, - "1596-cjs-modules/main.js": 2751, - "1597-mjs-graph/main.mjs": 2858, - "1598-cjs-builtin-require/main.js": 2109, - "1599-js-uncaught-throw.js": 1870, - "1600-assert-passing.ts": 3321, - "1601-assert-fail-exit.ts": 2842, - "1602-assert-caught-error.ts": 2041, - "1603-assert-scalar-messages.ts": 2650, - "1604-assert-deep-structures.ts": 3035, - "1605-assert-import-forms.ts": 3128, - "1606-assert-strict-module.ts": 2927, - "1607-assert-throws-match.ts": 2731, - "1608-cjs-assert/main.js": 3193, - "1609-assert-async.ts": 1990, - "1610-path-win32-full.ts": 1939, - "1611-url-file-bridge-neutral.ts": 2575, - "1612-cjs-module-globals.cjs": 2846, - "1613-cjs-esm-proxy-named/main.mjs": 2282, - "1614-js-fence-dodges.cjs": 2910, - "1615-cjs-export-shapes/main.cjs": 3349, - "1616-cjs-esm-lexer-invisible/main.mjs": 2499, - "1617-cjs-esm-lexer-visible/main.mjs": 2355, - "1618-cjs-esm-poisoned-tail/main.mjs": 2404, - "1619-cjs-esm-reexport-invisible/main.mjs": 2675, - "1620-cjs-require-effects-order/main.js": 2586, - "1621-cjs-require-cache-hit/main.js": 2101, - "1622-cjs-require-conditional/main.js": 2194, - "1623-cjs-require-diamond/main.js": 2241, - "1624-cjs-require-dir-mid-file/main.js": 2559, - "1625-cjs-require-lazy-fn/main.js": 2333, - "1626-cjs-require-mjs/main.js": 2430, - "1627-mjs-import-cjs-requires/main.mjs": 2803, - "1628-checked-dynamic-builtin-args.cjs": 2085, - "1629-require-main-filename.cjs": 2419, - "1630-inspect-scalars.ts": 2701, - "1630-rmsync-retry-options.cjs": 2427, - "1631-inspect-arrays.ts": 3949, - "1632-inspect-records.ts": 3013, - "1633-inspect-map-set.ts": 2316, - "1634-inspect-classes.ts": 3062, - "1635-inspect-buffer.ts": 2271, - "1636-util-format.ts": 2132, - "1637-inspect-dyn.ts": 3164, - "1638-inspect-cjs.cjs": 2023, - "1639-versions-openssl-probe.ts": 2845, - "1640-fd-read-decode.ts": 3219, - "1641-string-search.ts": 3172, - "1642-object-fromentries-rows.ts": 2713, - "1643-metadata-dyn-return.cjs": 3460, - "1644-ee-basics.ts": 2495, - "1645-ee-extends.ts": 2603, - "1646-ee-once-remove.ts": 2849, - "1647-ee-meta-events.ts": 2040, - "1648-ee-error-event.ts": 2703, - "1649-ee-names-counts.ts": 2487, - "1650-ee-prepend.ts": 2672, - "1651-ee-max-listeners.ts": 2331, - "1652-ee-snapshot.ts": 2031, - "1653-ee-cjs.cjs": 2472, - "1654-ee-namespace.ts": 2390, - "1655-spawnsync-neutral.ts": 4056, - "1656-execsync-neutral.ts": 2824, - "1657-spawn-async-neutral.ts": 3268, - "1660-buffer-read-write-num.ts": 3727, - "1661-buffer-encodings-full.ts": 2670, - "1662-string-decoder-encodings.ts": 2362, - "1663-buffer-compare-search-fill.ts": 3956, - "1664-dyn-fn-boundary.cjs": 2792, - "1665-dyn-fn-mustcall/main.cjs": 2827, - "1666-dyn-fn-identity.ts": 2623, - "1667-dyn-fn-not-callable.cjs": 2618, - "1668-dyn-fn-throws.cjs": 2216, - "1669-symbol-identity.ts": 2335, - "1670-symbol-registry.ts": 1852, - "1671-symbol-typeof.ts": 2343, - "1672-symbol-containers.ts": 2800, - "1673-symbol-cjs.cjs": 2407, - "1674-symbol-inspect.ts": 1818, - "1676-func-array-surface.ts": 2784, - "1677-emitter-listeners.ts": 2400, - "1678-emitter-dyn-listeners.cjs": 2358, - "1679-console-dyn.js": 2880, - "1680-assert-bytes.ts": 3465, - "1681-assert-funcs.ts": 2454, - "1685-stream-readable-basics.ts": 2506, - "1686-stream-readable-paused.ts": 2711, - "1687-stream-readable-flow-control.ts": 2359, - "1688-stream-writable-basics.ts": 2613, - "1689-stream-writable-async-drain.ts": 2671, - "1690-stream-duplex.ts": 2112, - "1691-stream-transform.ts": 1780, - "1692-stream-pipe.ts": 3345, - "1693-stream-pipe-backpressure.ts": 2344, - "1694-stream-destroy.ts": 1870, - "1695-stream-props.ts": 2766, - "1696-stream-read-inside-read.ts": 3023, - "1697-stream-tick-vs-timer.ts": 2275, - "1698-stream-uncaught-error.ts": 2523, - "1699-stream-callback-shapes.ts": 1972, - "1700-mustcall-common/main.cjs": 3401, - "1701-mustcall-exit-report/main.cjs": 3316, - "1702-dyn-proto-dispatch.cjs": 2744, - "1703-arguments-rest-props.cjs": 2431, - "1710-cjs-export-class/main.js": 2997, - "1711-cjs-export-single-values/main.js": 2866, - "1712-field-incdec.ts": 1828, - "1713-js-dyn-fields.js": 2492, - "1720-assert-throws-shape.ts": 2372, - "1721-assert-throws-regex-class.ts": 2125, - "1722-assert-rejects.ts": 2761, - "1723-assert-does-not-reject.ts": 2536, - "1724-assert-iferror.ts": 2883, - "1725-assert-symbols.ts": 2626, - "1726-promise-with-resolvers.ts": 2320, - "1727-assert-throws-shape-exit.ts": 2580, - "1730-countdown-symbol-keys/main.js": 2657, - "1731-symbol-field-shapes.cjs": 3005, - "1732-symbol-field-cross-module/main.js": 2509, - "1740-stream-extends-readable.ts": 2167, - "1741-stream-extends-writable.ts": 2479, - "1742-stream-extends-duplex-transform.ts": 2640, - "1743-stream-extends-vt-dispatch.ts": 2388, - "1744-stream-set-encoding.ts": 2886, - "1745-stream-encoding-js.cjs": 2861, - "1746-stream-for-await.ts": 2864, - "1747-stream-for-await-js.cjs": 2685, - "1750-http-agent-options.ts": 2435, - "1751-options-record-stance.ts": 3010, - "1760-surplus-args-drop.cjs": 2845, - "1761-emitter-special-event-names.cjs": 2672, - "1770-assert-dyn-strict.ts": 2841, - "1771-assert-dyn-deep.ts": 2098, - "1772-assert-dyn-js.cjs": 2493, - "1773-assert-dyn-exit.ts": 2809, - "1780-http-res-surface.ts": 3019, - "1781-http-server-shapes.cjs": 2697, - "1790-computed-key-folds.ts": 2567, - "1791-searchparams-core.ts": 2632, - "1792-searchparams-encoding.ts": 2548, - "1793-searchparams-iteration.ts": 2977, - "1794-searchparams-url-live.ts": 2027, - "1795-dyn-handle-request.cjs": 2079, - "1796-dyn-handle-body.cjs": 3120, - "1797-dyn-handle-socket.cjs": 2724, - "1798-dyn-handle-typed-box.ts": 2104, - "1800-immediate-basics.ts": 2313, - "1801-immediate-handle.ts": 2272, - "1802-immediate-unref-exit.ts": 2368, - "1803-timeout-refresh.ts": 2346, - "1804-timers-module.ts": 2379, - "1805-timer-callback-args.ts": 2475, - "1806-timer-delay-trunc.ts": 2847, - "1810-stream-options-const-record.ts": 2576, - "1811-stream-option-value-callbacks.cjs": 2945, - "1812-stream-super-options-forwarding.cjs": 3075, - "1813-stream-finished.ts": 2644, - "1814-stream-pipeline.cjs": 2915, - "1815-stream-state-reads.cjs": 2499, - "1820-static-block-basics.ts": 2475, - "1821-static-block-order.ts": 2605, - "1822-static-block-js.js": 1831, - "1823-static-instance-method-names.ts": 2522, - "1824-for-of-destructuring-defaults.ts": 2238, - "1825-exhaustive-typeof-switch.ts": 1814, - "1826-settimeout-arguments-callback.js": 2356, - "1830-enum-numeric-basics.ts": 2431, - "1831-enum-string-const-reverse.ts": 2780, - "1832-enum-modules/main.ts": 2343, - "1835-var-basics.ts": 2924, - "1836-var-loop-capture.ts": 2857, - "1837-var-undefined-hoisting.ts": 2785, - "1838-var-modules/main.ts": 2572, - "1839-var-js/main.cjs": 2766, - "1840-jsdoc-import-type-only/main.js": 2328, - "1850-overload-basics.ts": 2354, - "1851-overload-return-narrowing.ts": 2268, - "1852-overload-class-members.ts": 2874, - "1853-overload-modules/main.ts": 2339, - "1854-ambient-declare-fn.ts": 2384, - "1855-ambient-declare-fn-uncaught.ts": 2441, - "1870-unit-type-values.ts": 2730, - "1871-empty-array-never.ts": 2177, - "1872-template-tostring-composite.ts": 2526, - "1880-json-declared-field-order.ts": 2276, - "1881-default-anon/main.ts": 2233, - "1882-default-cjs-interop/main.ts": 2407, - "1883-default-exports/main.ts": 2358, - "1890-ns-imports/main.ts": 2428, - "1891-ns-reexport/main.ts": 2422, - "1940-class-values-basics.ts": 2483, - "1941-class-values-registry.ts": 2632, - "1942-class-expressions.ts": 2765, - "1943-class-statics-expanded.ts": 2459, - "1944-class-values-modules/main.ts": 2440, - "1950-generic-fn-values.ts": 2561, - "1951-generic-classes-basics.ts": 2197, - "1952-generic-class-statics-values.ts": 2662, - "1953-generic-class-hierarchy.ts": 3001, - "1954-generic-modules/main.ts": 2756, - "1960-namespace-basics.ts": 2647, - "1961-namespace-nested.ts": 2257, - "1962-namespace-classes.ts": 2660, - "1963-namespace-aliases.ts": 2070, - "1964-namespace-type-only.ts": 2445, - "1965-namespace-ambient.ts": 2332, - "1966-namespace-modules/main.ts": 2434, - "1967-namespace-alias-typeonly.ts": 2455, - "1968-namespace-import-eq-snapshot.ts": 2251, - "1970-decorators-basics.ts": 2885, - "1971-decorators-rebinding.ts": 2022, - "1972-decorators-throwing.ts": 2312, - "1973-decorators-ambient.ts": 2390, - "1980-primitive-proto-statics.ts": 3122, - "1981-date-utc.ts": 3440, - "1982-freeze-resolve-passthrough.ts": 2302, - "1983-array-tuple-surfaces.ts": 3057, - "1990-labels-basics.ts": 2548, - "1991-for-in-loops.ts": 2966, - "1992-small-syntax.ts": 1927, - "200-strings.ts": 2314, - "2000-generic-methods-basic.ts": 2743, - "2001-generic-methods-generic-class.ts": 2632, - "2002-generic-methods-inheritance.ts": 3264, - "2003-generic-methods-object-literal.ts": 2644, - "2004-generic-methods-statics.ts": 2578, - "201-templates.ts": 2516, - "2010-generators-basics.ts": 1908, - "2011-generators-forof.ts": 2574, - "2012-generators-return-throw.ts": 2779, - "2013-generators-sent-values.ts": 2065, - "2014-generators-values.ts": 2940, - "2015-generators-yieldstar.ts": 1953, - "2016-generators-rc-stress.ts": 2595, - "2017-generators-async.ts": 2715, - "2018-generators-uncaught.ts": 2356, - "2019-generators-loops.ts": 2496, - "2020-generic-value-bindings.ts": 2351, - "2021-generic-value-binding-modules/main.ts": 2687, - "2022-width-index-capture.ts": 2751, - "2023-width-readonly.ts": 2800, - "2024-width-array-elems.ts": 2726, - "2025-width-union-compose.ts": 2851, - "2026-width-spread.ts": 2485, - "2030-width-nested.ts": 2774, - "2031-width-tuples.ts": 2693, - "2032-cjs-export-assigned-class-expression/main.cjs": 2477, - "2033-property-assigned-class-extends.cjs": 2618, - "2035-ternary-array-retag.cjs": 2404, - "2036-evolving-array-decl.cjs": 2542, - "2037-fn-decl-hoisting.cjs": 2645, - "2038-evolving-array-js.cjs": 3054, - "2040-any-bindings.ts": 2984, - "2040-mixin-heritage.ts": 2131, - "2041-any-params-returns.ts": 2687, - "2041-mixin-values.ts": 2744, - "2042-any-flow-loops.ts": 2769, - "2042-mixin-modules/main.ts": 1924, - "2043-any-dom-values.ts": 2778, - "2043-mixin-rc-stress.ts": 2775, - "2044-vtable-sibling-slots.ts": 2571, - "2045-objlit-accessors-basic.ts": 2640, - "2045-parameter-properties.ts": 2113, - "2046-abstract-classes.ts": 3000, - "2046-objlit-accessors-effects.ts": 2795, - "2047-objlit-accessors-shapes.ts": 2983, - "2047-optional-class-fields.ts": 2949, - "2050-dynamic-import-own-module/main.ts": 2608, - "2051-dynamic-import-then/main.ts": 2467, - "2052-dynamic-import-self.ts": 2449, - "2053-typeof-static-fold.ts": 2181, - "2054-destructuring-island-source.ts": 2707, - "2060-empty-tuple.ts": 2373, - "2070-computed-key-folds.ts": 2645, - "2071-integer-key-enumeration-order.ts": 3006, - "2072-expando-function-members.ts": 2512, - "2073-destructuring-assignment.ts": 2535, - "2074-island-destructuring.ts": 2609, - "2075-index-signature-runtime-keys.ts": 1981, - "2080-destructuring-defaults.ts": 2417, - "2081-destructuring-rest.ts": 2774, - "2082-destructuring-assignment.ts": 2489, - "2085-destructuring-heads-rest-params.ts": 2668, - "2087-destructuring-for-heads.ts": 2521, - "2090-index-signature-number-keys.ts": 1958, - "2091-index-signature-string-intersection.ts": 2567, - "2092-package-imports/main.ts": 2340, - "2093-timers-promises.ts": 2743, - "2094-diagnostics-channel.ts": 1983, - "2095-js-catch-unknown.js": 2499, - "2096-os-type.ts": 2709, - "2097-js-evolving-globals.js": 2560, - "210-string-methods.ts": 2593, - "2100-stream-default-hwm.ts": 2961, - "2101-dyn-param-defaults.ts": 2737, - "2102-empty-pattern-decls.ts": 2787, - "2105-computed-key-static-folds.ts": 2507, - "2106-comma-expressions.ts": 2500, - "211-string-unicode.ts": 1823, - "2110-top-object-types.ts": 1971, - "2111-json-stringify-unknown.ts": 2830, - "2112-array-at-findlast.ts": 2001, - "2113-string-index-methods.js": 2989, - "212-string-aliasing-append.ts": 1909, - "2120-package-self-import/main.ts": 1825, - "2121-esm-cycle-inert-backedge/main.ts": 1748, - "2123-ambient-import-crash/main.ts": 1870, - "2124-imports-field-wildcard/main.ts": 2082, - "2140-uri-component-codecs.ts": 1955, - "2160-dc-tracing-channel.cjs": 2212, - "2161-js-object-literal-identity.cjs": 2587, - "2162-js-dyn-destructure.cjs": 2628, - "2163-js-selfref-const.cjs": 2533, - "2164-js-then-dyn-handler.cjs": 2503, - "2165-js-throw-dyn.cjs": 2509, - "2166-cjs-getter-this/main.cjs": 2420, - "2170-island-array-exits.ts": 3096, - "2171-island-json-stringify.ts": 2652, - "2172-island-regexp-boundary.ts": 2763, - "2190-new-object-and-string-wrappers.ts": 1860, - "2191-uri-encoders.ts": 2586, - "2192-object-default-tostring.ts": 2607, - "2193-discarded-stdlib-reads.ts": 2445, - "2194-ambient-undef-chains.ts": 2022, - "2195-require-missing-package/main.mjs": 2412, - "2196-island-computed-key-chain.ts": 2831, - "2210-dyn-promise-crossing.cjs": 1918, - "2211-dc-trace-promise.cjs": 2793, - "2212-unhandled-rejection-listener.cjs": 2511, - "2213-async-local-storage.cjs": 2825, - "2214-dc-bind-store.cjs": 2651, - "2215-process-emit-warning-exit.cjs": 2666, - "2240-width-class-into-record.ts": 2573, - "2241-width-record-into-class.ts": 2686, - "2242-width-statics-into-record.ts": 2654, - "2243-width-assert-satisfies-shapes.ts": 2411, - "2250-tagged-templates.ts": 2617, - "2252-class-iterators.ts": 3448, - "2253-union-coercions.ts": 2899, - "2260-http2-constants.cjs": 2471, - "2280-builtin-namespace-destructure.cjs": 2645, - "2281-domexception-atob-btoa.cjs": 2853, - "2282-queue-microtask.cjs": 2526, - "2283-structured-clone.cjs": 3050, - "2284-regexp-constructor.cjs": 1945, - "2285-iferror-dyn.cjs": 2665, - "2286-dyn-object-walks.cjs": 2662, - "2300-dyn-record-spread-and-keyed-access.cjs": 2261, - "2301-cjs-export-table-dom-attach.cjs": 2384, - "2310-process-next-tick.ts": 2843, - "2311-next-tick-js-callbacks.js": 2254, - "2312-stream-underscore-assign.ts": 2790, - "2313-stream-underscore-assign-js.cjs": 2842, - "2314-process-introspection.ts": 2971, - "2320-await-unit.ts": 2748, - "2321-emitter-static-setmax.cjs": 2272, - "2322-dyn-array-sort.cjs": 1886, - "2323-timer-callback-returns.ts": 2523, - "2330-tls-server-runtime-options.cjs": 2677, - "2331-tls-server-options-typed.ts": 2790, - "2350-nan-global.ts": 2734, - "2351-async-methods.ts": 2622, - "2352-void-coercions.ts": 1788, - "2353-decorators-member-ambient.ts": 2547, - "2354-decorators-expression-ambient.ts": 2465, - "2360-tuple-to-array.ts": 2471, - "2361-assign-index-record.ts": 3021, - "2362-execsync-inherit.ts": 2693, - "2363-nullish-retag.ts": 2801, - "2364-in-runtime-key.ts": 2572, - "2365-dyn-into-island.ts": 1996, - "2366-string-well-formed.ts": 2147, - "2367-regexp-escape.ts": 2470, - "2368-set-methods.ts": 2846, - "2369-promise-try.ts": 2170, - "2370-group-by.ts": 2298, - "2371-iterator-helpers.ts": 2730, - "2380-buffer-module-named-import.ts": 2400, - "2381-builtin-default-imports.js": 2365, - "2382-cycle-two-decl/main.ts": 1682, - "2383-cycle-assertdoc/main.js": 2760, - "2384-cycle-mixed-bindings/main.ts": 1815, - "2385-builtin-reexport-facade/main.ts": 1834, - "2386-string-to-chars.ts": 2748, - "2387-tonumber-argv.ts": 2345, - "2388-tonumber-grammar-zoo.ts": 2619, - "2389-tonumber-unary-plus.ts": 2473, - "2390-dot-requires/main.cjs": 2365, - "2391-default-builtin-imports/main.ts": 3036, - "2392-block-guard-alias-scope.ts": 2477, - "2393-loop-exit-guard-narrow.ts": 2791, - "2394-loop-narrow-containment.ts": 2749, - "2395-while-cond-guard.ts": 2574, - "2396-born-narrowed-decl.ts": 2435, - "2397-branch-kill-merge.ts": 2334, - "2398-switch-arm-kill.ts": 2438, - "2399-reassign-kill-polarity.ts": 2238, - "240-stdout-write.ts": 2820, - "2400-kill-return-edge.ts": 2315, - "2401-kill-break-staging.ts": 2347, - "2402-labeled-break-kill.ts": 2610, - "2403-kill-continue-backedge.ts": 2391, - "2404-kill-throw-catch.ts": 2611, - "2405-sibling-arm-narrow.ts": 2300, - "2406-switch-clause-sibling-narrow.ts": 1885, - "2407-infinite-loop-seal.ts": 2596, - "2408-loop-terminality-reopen.ts": 2452, - "2409-loop-body-return-not-terminal.ts": 1860, - "2410-stacked-cases-terminality.ts": 2588, - "2411-exhaustive-switch-terminality.ts": 2704, - "2412-dowhile-guard-trailing-test.ts": 2401, - "2413-dowhile-kill-renarrow.ts": 2389, - "2414-dowhile-continue-kill.ts": 2546, - "2415-dowhile-break-trailing-test.ts": 2461, - "2416-spread-ternary-positions.ts": 2790, - "2417-ternary-local-inference.ts": 2737, - "2418-wrapped-ternary-arms.ts": 2485, - "2419-selector-ternary-union.ts": 2554, - "2420-nullish-null-identity.ts": 2418, - "2421-float-lane-inference.ts": 2337, - "2422-ieee-div-rem-corners.ts": 2498, - "2423-param-null-reassign.ts": 2447, - "2424-ternary-miss-first-narrowing.ts": 2373, - "2425-elseif-head-exit-narrow.ts": 2194, - "2426-default-snapshot-mutable/main.ts": 2194, - "2427-perf-hooks-now.ts": 2489, - "2428-field-redeclare-inherited.ts": 2204, - "2429-destructure-class-instance.ts": 2362, - "2430-empty-literal-unknown-field.js": 2633, - "2431-primitive-ctor-values.ts": 2702, - "2432-generic-member-fields-async.ts": 2679, - "2433-as-const-command-tables.ts": 2271, - "2434-deferred-init-fields.ts": 2673, - "2435-loose-same-kind-equality.ts": 2441, - "2440-console-inspect-args.ts": 3150, - "2441-console-process-argv.ts": 2027, - "2442-union-literal-arm-widening.ts": 2300, - "2443-union-literal-shadow-narrowing.ts": 2799, - "2444-union-literal-reducer-spread.ts": 2545, - "2445-math-minmax-nary.ts": 2355, - "2446-performance-global.ts": 2453, - "2447-island-boundary-slots/main.ts": 3241, - "2448-entries-null-arms-regex-arrays.ts": 3215, - "2450-private-instance-methods.ts": 2581, - "2451-private-fields.ts": 2918, - "2452-private-statics.ts": 2431, - "2453-private-accessors.ts": 2589, - "2454-private-generator-methods.ts": 2809, - "2455-private-brand-checks.ts": 2369, - "2456-private-async-methods.ts": 2625, - "2457-private-members.js": 2014, - "2460-qs-parse-grammar.ts": 2706, - "2461-qs-parse-options.ts": 2139, - "2462-qs-stringify.ts": 2756, - "2463-qs-escape-unescape.ts": 2677, - "2464-qs-require-forms.cjs": 2768, - "2470-mockable-module-shape.js": 3152, - "2471-record-keyed-write-hasown.js": 2699, - "2472-string-regexp-union.ts": 2532, - "2473-option-table-widths.js": 2095, - "2474-island-literal-forms.ts": 2881, - "2475-variadic-wrapper-island.js": 2240, - "2476-map-regex-values.ts": 2431, - "2480-recursive-record-tree.ts": 2075, - "2481-mutual-recursive-records.ts": 2525, - "2482-recursive-union-tree.ts": 2633, - "2483-recursive-record-cycles.ts": 2479, - "2484-json-stringify-circular.ts": 2869, - "2485-inspect-circular-refs.ts": 2957, - "2486-recursive-record-boundaries.ts": 2857, - "2487-recursive-deep-equal.ts": 2516, - "2488-ast-walker.ts": 2925, - "2490-find-miss-null-compare.ts": 2051, - "2491-strict-unit-compare-no-arm.ts": 2381, - "2492-loose-null-compare-unions.ts": 2451, - "2493-switch-unit-cases.ts": 2503, - "2494-no-arm-compare-effects.ts": 2501, - "2500-net-autosel-timeout.ts": 2202, - "2510-dyn-evolving-array-map.ts": 2611, - "2511-dyn-evolving-array-filter-foreach.ts": 2729, - "2512-dyn-evolving-array-mixed-push.ts": 2656, - "2520-private-statics-class-name-calls.ts": 2568, - "2521-private-statics-class-expression.ts": 2429, - "2522-private-statics-decorated.ts": 2492, - "2523-private-statics-aliased-class.ts": 2618, - "2530-object-destructuring-decl.ts": 2513, - "2531-array-tuple-destructuring-decl.ts": 2504, - "2532-param-destructuring-options.ts": 2714, - "2533-forof-destructuring.ts": 2583, - "2534-object-rest-decl.ts": 2277, - "2535-destructuring-assign-basics.ts": 2758, - "2536-destructuring-assign-nested.ts": 2761, - "2537-destructuring-assign-member-targets.ts": 2552, - "2538-destructuring-assign-class-source.ts": 2658, - "2539-class-instance-rest.ts": 2852, - "2540-accessor-destructuring-defaults.ts": 2732, - "2541-destructuring-eval-order.ts": 2121, - "2550-generics-keyof-pick.ts": 2790, - "2551-generics-value-aliases.ts": 2489, - "2552-generics-iface-methods.ts": 2118, - "2553-generics-signature-bindings.ts": 2838, - "2554-generics-frontier-mix.ts": 2857, - "2555-generics-keyof-writes.ts": 2600, - "2556-crypto-introspection.ts": 2362, - "2556-width-hybrid-shapes.ts": 3063, - "2557-tls-ca-store.ts": 2877, - "2557-width-field-lifts.ts": 2899, - "2558-index-signature-func-values.ts": 2980, - "2558-rejection-events.cjs": 2741, - "2559-index-signature-container-values.ts": 2921, - "2560-arraybuffer-dataview-set.ts": 2985, - "2561-object-is.ts": 3314, - "2562-intl-numberformat-en-us.ts": 1713, - "2563-stream-promises-pipeline.ts": 2673, - "2564-stream-promises-finished.ts": 2596, - "2565-stream-promises-js.cjs": 2121, - "2566-promise-reject-dyn-reason.js": 2527, - "2567-rest-spread-forward.js": 3263, - "2568-rest-spread-forward-dynamic.js": 2990, - "2569-upcast-identity.ts": 1878, - "2570-buffer-arg-validation.cjs": 4190, - "2571-searchparams-arg-validation.cjs": 2897, - "2572-readable-emitted-readable-flag.cjs": 2583, - "2573-fs-url-arg-ladders.cjs": 2789, - "2574-emitter-max-listeners-ladders.cjs": 2728, - "2575-string-destructuring-decl.ts": 2831, - "2576-string-destructuring-assign.ts": 2718, - "2577-builtin-global-destructuring.js": 2482, - "2578-jsval-into-unknown-rows.ts": 2821, - "2579-jsval-object-param-crossing.js": 2723, - "2580-jsval-routed-keyed-ops.js": 2125, - "2581-jsval-routed-calls.js": 3090, - "2582-jsval-object-statics.js": 2972, - "2582-jsval-routed-keyed-ops.js": 2851, - "2583-dyn-nullish-coalesce.js": 2185, - "2583-jsval-routed-calls.js": 2972, - "2584-jsval-object-statics.js": 2832, - "2584-union-dyn-collapse.ts": 2220, - "2585-dyn-nullish-coalesce.js": 2398, - "2585-unknown-array.ts": 2751, - "2586-object-assign-spread.js": 3004, - "2587-array-entries-forof.ts": 2555, - "2588-array-entries-chains.ts": 3001, - "2589-object-create-null.cjs": 2994, - "2590-object-create-dynamic.js": 3188, - "2591-ambient-generic-traps.ts": 2461, - "2592-ambient-trap-uncaught.ts": 2508, - "2593-generic-inert-bindings.ts": 2003, - "2594-nullish-generic-bindings.ts": 2473, - "2595-fs-arg-ladders.cjs": 3590, - "2596-net-arg-ladders.cjs": 2708, - "2597-dgram-send-ladders.cjs": 3185, - "2598-tls-arg-ladders.cjs": 3457, - "2599-stream-arg-ladders.cjs": 2639, - "2600-dyn-keyed-write-harness.js": 2645, - "2601-dyn-keyed-write-ops.js": 2850, - "2602-dyn-array-destructure.js": 3140, - "2603-island-keyed-write-dyn.js": 2307, - "2604-cycle-classes-mutual/main.ts": 2453, - "2605-cycle-three-module/main.ts": 2707, - "2606-dynamic-import-cycle/main.ts": 2783, - "2608-regex-named-groups.ts": 3177, - "2609-regex-named-replace.ts": 2707, - "2610-regex-named-matchall.ts": 2590, - "2611-regex-named-groups-js.cjs": 2302, - "2613-for-init-uninitialized-let.ts": 2413, - "2614-trap-binding-later-writes.ts": 2362, - "2615-nullish-field-record-binding.ts": 2480, - "2616-js-collect-probe-defers.js": 2756, - "2617-enum-static-field-import/main.ts": 2551, - "2618-ee-emit-override.ts": 2613, - "2619-ee-override-chain.ts": 2034, - "2620-ee-override-once-order.ts": 2930, - "2621-ee-override-error-throw.ts": 2533, - "2622-ee-override-filter.ts": 2677, - "2623-ee-job-queue.ts": 2500, - "2624-ee-override-js.cjs": 2183, - "2625-bytes-views.ts": 2152, - "2626-stream-event-names.ts": 2499, - "2627-stream-ticks-are-nextticks.ts": 2708, - "2628-stream-push-encodings.cjs": 2440, - "2629-stream-consumers.ts": 2913, - "2630-stream-consumers-errors.ts": 2991, - "2631-create-require/main.ts": 3044, - "2632-dyn-jsval-iterate.js": 2878, - "2633-island-promise-crossing.js": 3370, - "2634-stream-pipeline-arg-ladders.cjs": 2714, - "2635-trap-binding-unmappable-written.ts": 2160, - "2636-trap-binding-ambient-rooted-rewrite.ts": 2374, - "2637-create-require-bare/main.ts": 2239, - "2638-http-dyn-res-compat.cjs": 3131, - "2639-http-dyn-req-pause.cjs": 2921, - "2640-net-dyn-socket-compat.cjs": 2968, - "2641-http-agent-surface.cjs": 3429, - "2642-http-agent-maxsockets.cjs": 2699, - "2643-or-default-retag.ts": 2845, - "2644-http-client-url-argument.ts": 2453, - "2645-https-client-url-argument.ts": 2836, - "2646-top-level-await.ts": 2403, - "2647-top-level-await-modules/main.ts": 2235, - "2648-top-level-await-rejection.ts": 1959, - "2649-top-level-await-pending.ts": 2384, - "2650-top-level-await-self-import.ts": 1987, - "2651-top-level-await-pending-unhandled.ts": 2002, - "2652-top-level-await-dynamic/main.ts": 2598, - "2653-top-level-await-rejection-stops-loop.ts": 2523, - "2654-top-level-await-unrelated-rejection.ts": 2015, - "2655-top-level-await-cycle/main.ts": 2308, - "2656-top-level-await-cycle-order/main.ts": 4054, - "2657-top-level-await-cycle-dynamic/main.ts": 2392, - "2658-top-level-await-sync-completion/main.ts": 2314, - "2659-top-level-await-dynamic-cycle/main.ts": 2467, - "2660-top-level-await-cycle-rejection/main.ts": 2494, - "2661-top-level-await-dynamic-runtime-root/main.ts": 2327, - "2662-top-level-await-cycle-external-wait/main.ts": 2397, - "2663-top-level-await-dependency-errors/main.ts": 2080, - "2664-top-level-await-same-checkpoint-rejection.ts": 2543, - "2665-top-level-await-unhandled-listener-liveness.ts": 2570, - "2666-array-to-sorted.ts": 6667, - "2668-stored-number-array-iterator.ts": 2876, - "2669-array-copying-methods.ts": 3089, - "2670-uint8array-copy-iterate.ts": 2885, - "2671-array-copying-js.cjs": 2315, - "2672-http-request-response-callback.ts": 2962, - "2673-top-level-await-implicit-module.ts": 2333, - "2674-top-level-for-await-implicit-module.ts": 2353, - "2675-create-require-nested-esm.js": 2188, - "2675-process-self-reexec.ts": 2836, - "2676-indexed-read-strict-equality.ts": 2408, - "2676-record-clone-overrides.ts": 2543, - "2676-top-level-await-ambiguous/main.ts": 2576, - "2677-runtime-optional-closure.ts": 4255, - "2677-top-level-await-module-scope/main.ts": 2463, - "2678-date-instances.ts": 2194, - "2678-large-string-sparse-index.ts": 2586, - "2678-util-parseargs.ts": 4462, - "2679-util-parseargs-cjs.cjs": 4905, - "2680-util-parseargs-default.ts": 1889, - "2681-util-parseargs-dynamic.js": 2618, - "2682-fs-rename.ts": 3414, - "2683-filter-truthy-predicate.ts": 3055, - "2683-fs-rename-js.cjs": 4058, - "2684-filter-no-predicate-dyn.cjs": 2608, - "2684-fs-rename-abort.ts": 2639, - "2685-array-unshift-reverse.ts": 3540, - "2685-fs-write-sync.ts": 2779, - "2686-fs-file-handle.ts": 3096, - "2687-fsp-write-file-options.ts": 2864, - "2687-process-write-args.ts": 2396, - "2688-fs-stats-disk-fields.ts": 3953, - "2689-http-server-timeout-properties.ts": 2717, - "2690-https-server-timeout-option.ts": 2702, - "2691-retained-lowering-record-order.ts": 2988, - "2692-inline-record-assert-index.ts": 2526, - "2692-string-accumulation.ts": 2081, - "2693-math-constants.ts": 1991, - "2700-array-sort-complexity.ts": 2921, - "2700-http-static-trailers.ts": 2864, - "2700-wasi-core.ts": 2423, - "2701-array-sort-snapshot.ts": 2953, - "2701-http-static-trailer-wire.ts": 4541, - "2701-import-meta/main.mjs": 2520, - "2702-http-static-trailer-end.ts": 2827, - "2702-type-import-link-static/main.ts": 2535, - "2702-uint8array-to-sorted.ts": 2284, - "2703-array-sparse-sort.ts": 4504, - "2703-type-import-link-static-reexport/main.ts": 3626, - "2704-array-sparse-to-sorted.ts": 4339, - "2704-type-import-link-static-success/main.ts": 2363, - "2705-array-sparse-sort-append.ts": 4401, - "2705-type-import-link-dynamic/main.ts": 1851, - "2706-array-search-missing-needle.ts": 2603, - "2706-type-import-link-dynamic-success/main.ts": 2413, - "2707-array-search-huge-sparse.ts": 45742, - "2707-type-import-link-static-default-reexport/main.ts": 2437, - "2708-type-import-link-dynamic/main.ts": 2892, - "2720-array-read-parity.ts": 3049, - "2721-array-nested-missing-receiver.ts": 2315, - "2750-array-sparse-foundation.ts": 3742, - "2751-buffer-concat-sparse-list.ts": 4185, - "2752-array-optional-stores.ts": 2347, - "2753-array-optional-method-values.ts": 3965, - "2754-array-property-undefined.ts": 2255, - "2755-array-optional-literal-forwarding.ts": 2583, - "2780-array-parity-composition.ts": 6251, - "2781-array-missing-value-escape.ts": 2554, - "2782-array-sparse-callbacks.ts": 3284, - "2783-array-defaults-rest.ts": 2724, - "2784-array-reduce-missing-result.ts": 2691, - "2785-array-missing-destructuring.ts": 2806, - "2786-array-sparse-serialization.ts": 2888, - "2787-array-missing-string-arithmetic.ts": 1877, - "2788-array-missing-builtin-conversions.ts": 1930, - "2789-array-missing-optional-tostring.ts": 1731, - "2790-dynamic-import-self-name/main.ts": 2308, - "2791-record-optional-keys.ts": 2478, - "2792-record-optional-spread-entries.ts": 2703, - "2793-union-conversion-identity-capture.ts": 1753, - "2794-array-generic-callback-values.ts": 2420, - "2795-array-optional-typedarray-source.ts": 1737, - "2796-array-sparse-class-value-instanceof.ts": 2296, - "2800-array-expression-consumers.ts": 2565, - "2801-array-switch-consumers.ts": 2471, - "2820-array-missing-method-receivers.ts": 2123, - "2821-array-optional-numeric-comparisons.ts": 2408, - "2830-cjs-require-self-name/main.cjs": 2633, - "2840-finally-completions.ts": 2505, - "2841-using-sync.ts": 2632, - "2842-await-using.ts": 1790, - "2843-using-suppressed-error.ts": 2235, - "2844-node-disposable-resources.ts": 2658, - "2845-for-using-of.ts": 4410, - "2846-generator-using.ts": 2392, - "2850-async-generators-protocol.ts": 3002, - "2851-async-generators-values.ts": 4379, - "2852-timers-promises-interval.ts": 2511, - "2854-leading-bom-literals.ts": 2528, - "2855-searchparams-sort-complexity.ts": 2416, - "2856-dynamic-any-local-operators.ts": 1839, - "2857-branded-primitives.ts": 1736, - "2858-import-meta-resolve/main.mjs": 2679, - "2859-import-meta-resolve-dynamic/main.mjs": 2295, - "2860-require-resolve/main.cjs": 2780, - "2861-readable-iterator-close.ts": 3207, - "2862-web-readable-async-iteration.ts": 3375, - "2863-class-async-iterator.ts": 2531, - "2864-array-class-method-receivers.ts": 1837, - "2865-cjs-process-alias.cjs": 2734, - "2866-dyn-switch.ts": 1772, - "2867-array-shift-length.js": 2411, - "2868-empty-record-promise-presence.js": 2531, - "2869-nullish-mixed-lazy.ts": 2433, - "2870-and-dropped-truthy-arm.ts": 2606, - "2871-optional-promise-to-unknown.ts": 2387, - "2872-unobserved-dynamic-event.ts": 2191, - "2873-optional-receiver-loop-lifetime.js": 2453, - "2874-nullable-callback-field-cycle.js": 2707, - "2875-evolving-let-read-before-write.js": 3668, - "2876-class-unknown-roundtrip.ts": 2817, - "2877-child-unknown-roundtrip.ts": 2660, - "2878-class-private-unknown.cjs": 4040, - "2880-cjs-module-graph/main.cjs": 2924, - "2890-crypto-static-utility.ts": 2261, - "2891-json-record-key-escapes.ts": 2705, - "2892-windows-console-unicode.ts": 2266, - "2893-child-stdin-duplex.ts": 3340, - "2894-child-stdin-backpressure.ts": 3131, - "2895-child-stdin-write-after-end.ts": 2384, - "2896-child-stdin-write-after-finish.ts": 2871, - "2897-child-stdin-destroy.ts": 2871, - "2898-child-stdin-spawn-failure.ts": 2549, - "2899-nested-mutual-recursion.ts": 2721, - "2900-float64array-static.ts": 2799, - "2900-void-conditional-arrow.ts": 2537, - "2901-bigint-core.ts": 2424, - "2902-bigint-bytes.ts": 2498, - "2903-bigint-storage.ts": 2708, - "2904-bigint-errors.ts": 2577, - "2905-bigint-edges.ts": 2439, - "2906-bigint-wasi-width.ts": 1786, - "2910-overloaded-callable-alias.ts": 2648, - "2911-execfile-callback.ts": 2191, - "2912-execfile-callback-options.ts": 2127, - "2912-promisify-fs-readfile.ts": 2460, - "2913-builtin-callable-alias.ts": 2481, - "2914-fixed-tuple-call-spread.ts": 2974, - "2915-path-function-values.ts": 2177, - "2916-path-function-values-cjs.ts": 2451, - "2917-builtin-callable-widths.ts": 2149, - "2918-builtin-callable-widths-cjs.ts": 2749, - "2919-fs-function-values.ts": 2635, - "2920-fs-promises-function-values.ts": 1999, - "2921-zlib-callbacks.ts": 2825, - "2922-dyn-bitwise-not.cjs": 2337, - "2923-cjs-factory-export/main.cjs": 2557, - "2930-union-receiver-calls.ts": 3403, - "2931-union-dynamic-field-call.js": 3002, - "2932-create-require-program/main.ts": 2467, - "2933-static-dynamic-import/main.ts": 2896, - "2934-static-import-stored.ts": 2404, - "2935-module-namespace-values/main.ts": 2608, - "2936-static-loose-equality.ts": 3140, - "2937-bitwise-hot-loop.ts": 2268, - "2938-fs-sync-overloads.cjs": 1857, - "2939-child-shell-text.ts": 3041, - "2940-date-parse.ts": 2483, - "2940-fsp-realpath.ts": 2587, - "2941-fsp-lstat-identity.ts": 2657, - "2941-process-exit-code.ts": 1743, - "2942-fsp-readdir-dirent.ts": 2911, - "2942-process-exit-code-override.ts": 1751, - "2943-process-exit-code-invalid.ts": 2583, - "2944-process-exit-code-wrap.ts": 2435, - "2945-url-origin-username.ts": 1863, - "2946-child-fork-ipc/main.ts": 3271, - "2946-url-port-hash.ts": 2587, - "2947-set-readonly-seeds.ts": 2456, - "2948-child-fork-eof-callback/main.ts": 3043, - "2948-stdio-callback-record.ts": 2421, - "2949-child-fork-default/main.mjs": 2736, - "2949-url-password.ts": 2744, - "2950-fs-descriptor-publication.ts": 2681, - "2951-math-static-analytic.ts": 3121, - "2952-math-static-remaining.ts": 2862, - "2953-http-header-validation.ts": 2956, - "2954-http-outgoing-headers.ts": 2822, - "2955-http-static-state.ts": 2955, - "2956-http-static-informational.ts": 3085, - "2957-http-static-response-controls.ts": 2273, - "2961-emitter-computed-names.cjs": 2632, - "2962-emitter-computed-optional.ts": 2051, - "2963-child-fork-dispatch/main.ts": 2809, - "2964-indexed-compound.ts": 2982, - "2966-numeric-array-read-fusion.ts": 2045, - "2967-numeric-array-read-lifetime.ts": 3048, - "2968-numeric-array-borrow.ts": 2914, - "2969-scalar-record-results.ts": 2620, - "2970-constant-numeric-tables.ts": 2078, - "2971-constant-table-modules/main.ts": 2587, - "2972-http-static-distinct-snapshots.ts": 2220, - "2972-math-receiver-borrow.ts": 3503, - "2973-http-static-agent.ts": 3163, - "2973-integer-bitwise-arithmetic.ts": 2756, - "2974-array-search-from-index.ts": 120636, - "2974-http-static-module-values.ts": 2696, - "2974-numeric-remainder.ts": 2784, - "2975-bigint-default-radix.ts": 1741, - "2975-http-static-client-controls.ts": 2204, - "2976-http-static-incoming-state.ts": 2949, - "2976-json-stringify-no-arguments.js": 2583, - "2977-http-static-incoming-timeout.ts": 2724, - "2977-nested-array-binding-defaults.js": 2760, - "2978-http-static-client-timeout.ts": 3060, - "2978-regexp-optional-subject.js": 2540, - "2979-array-search-mixed-needles.js": 2011, - "2979-http-static-server-timeout.ts": 2740, - "2980-http-static-server-timeout-default.ts": 2671, - "2980-string-position-arguments.js": 2246, - "2981-http-static-events.ts": 1817, - "2981-string-optional-positions.ts": 1836, - "2982-http-static-close-all.ts": 2421, - "2982-string-position-coercion-order.js": 3081, - "2983-http-static-close-idle.ts": 2006, - "2984-http-static-close-upgrade.ts": 2129, - "2985-http-static-message-destroy.ts": 2630, - "2986-http-static-client-socket-finish.ts": 1940, - "2987-http-static-timeout-errors.ts": 2737, - "2988-http-static-client-abort.ts": 2025, - "2989-http-static-response-timeout-handled.ts": 2928, - "2990-http-static-request-timeout-handled.ts": 2599, - "2991-array-indexed-equality.ts": 2993, - "2992-stream-rows.ts": 2556, - "2993-fiber-stack-lifetimes.ts": 3202, - "2994-fromcharcode-scalar.ts": 2833, - "2995-math-hyperbolic.ts": 2687, - "2996-math-near-one.ts": 2252, - "2997-math-integer-float.ts": 3190, - "300-if-else.ts": 2219, - "3001-caught-typeof-object.js": 2450, - "3002-promise-then-two.ts": 2484, - "301-while.ts": 2153, - "302-for.ts": 1918, - "3020-string-last-index-position.ts": 2434, - "3021-buffer-union-narrow-callback.ts": 2866, - "3022-string-affix-positions.ts": 2229, - "3023-string-affix-position-coercion.js": 3333, - "3024-string-number-narrow-for-in.ts": 2650, - "3025-string-search-position-coercion.js": 2447, - "3026-array-last-index-of.js": 2579, - "3027-array-last-index-of-records.ts": 2304, - "3028-string-search-dynamic-needle.js": 2564, - "3029-string-search-union-needle.js": 1657, - "303-break-continue.ts": 2442, - "3030-array-search-no-arg.js": 3027, - "3031-array-relative-index-coercion.js": 2940, - "3031-string-last-index-search-value.js": 2407, - "3032-string-search-value.js": 2579, - "3033-string-search-needle-coercion.js": 2232, - "3034-arguments-with-parameters.js": 2126, - "3035-string-positioned-search-value.js": 2449, - "3036-string-object-search-value.js": 1849, - "3037-number-nullish-conversion.js": 2478, - "3038-number-scalar-unions.ts": 1881, - "3039-string-repeat-count.js": 2372, - "304-compound-incdec.ts": 2266, - "3040-string-prototype-call.js": 2389, - "3041-string-prototype-object-call.js": 2679, - "3042-string-padding-coercion.js": 2923, - "3043-string-split-arguments.js": 3247, - "3044-array-slice-splice-positions.js": 2966, - "3045-array-indexed-mutation.js": 2960, - "3046-array-indexed-ref-identity.ts": 2358, - "3047-object-prototype-tag.js": 2265, - "3048-object-own-prototype.ts": 3162, - "3049-array-flat-depth.ts": 2904, - "305-truthiness.ts": 2588, - "3050-array-splice-insert.ts": 2779, - "3051-array-join-default.ts": 2220, - "3052-array-construction.ts": 2520, - "3053-array-construction-js.js": 2821, - "3054-dynamic-abort-record.ts": 2818, - "3055-default-builtin-nodenext/main.ts": 2044, - "3056-default-builtin-bundler/main.ts": 2874, - "3057-default-builtin-nodenext-dynamic/main.ts": 1912, - "3058-optional-array-chain-join.ts": 2986, - "3059-arguments-property-names.ts": 1856, - "3061-concurrent-fiber-stacks.ts": 2766, - "3062-runtime-optional-record-guards.ts": 3210, - "3063-runtime-optional-class-guards.ts": 2677, - "3064-installed-entry-imports/main.ts": 1867, - "3065-installed-entry-js/main.js": 2294, - "3066-source-debugging/main.ts": 2276, - "3067-cjs-function-export-require/main.cjs": 1963, - "3068-debug-variables/main.ts": 2578, - "3068-url-checked-identity.ts": 2207, - "3069-set-checked-seed.js": 2608, - "3069-tuple-spread.ts": 2969, - "3070-checked-object-accessors.js": 2496, - "3070-collection-views.ts": 2799, - "3071-checked-specialization-narrowing.js": 2715, - "3071-map-contextual-record-seeds.ts": 3095, - "3072-optional-union-receivers.ts": 2303, - "3072-weak-process-streams.js": 2885, - "3073-optional-callable-module.js": 2520, - "3073-union-keyed-reads.ts": 2905, - "3074-discriminated-intersections.ts": 2460, - "3075-recursive-contextual-literals.ts": 3335, - "3076-nullish-record-defaults.ts": 2894, - "3077-optional-union-array-reads.ts": 2500, - "3078-forward-mutable-captures.ts": 3097, - "3079-forward-mutable-tdz.ts": 2796, - "3080-exhaustive-never-bindings.ts": 2704, - "3081-recursive-array-destinations.ts": 2667, - "3082-forward-write-unwind.ts": 2538, - "3083-set-string-seed.ts": 2595, - "3084-record-own-membership.ts": 2879, - "3085-conditional-record-construction.ts": 2874, - "3086-error-constructor-options.ts": 2970, - "3087-error-options-lifetime.ts": 2675, - "3088-array-wide-callbacks.ts": 2690, - "3089-array-find-narrowing.ts": 2833, - "3090-json-discriminated-records.ts": 3066, - "3091-json-recursive-discriminants.ts": 2220, - "3092-number-union-predicates.ts": 2324, - "3093-error-option-data.ts": 2104, - "3094-json-replacer-traversal.ts": 2818, - "3095-json-reviver-traversal.ts": 2804, - "3096-json-callback-nonfinite.ts": 2753, - "3097-json-callback-reentrancy.ts": 2198, - "3098-json-callback-space.ts": 2839, - "3099-json-callback-functions.ts": 3102, - "3100-json-callback-holder.js": 2748, - "3101-json-callback-bytes.ts": 2087, - "3102-json-unknown-fields.ts": 2238, - "3103-scalar-record-nested-control-flow.ts": 2806, - "3104-native-analysis-tables-loops.ts": 2680, - "3105-nullable-collections.ts": 2913, - "3106-mixed-insertion-spreads.ts": 3159, - "3107-nullable-collection-lifetimes.ts": 3025, - "3108-for-await-sync-arrays.js": 3537, - "3108-identity-map-keys.ts": 3249, - "3109-destructuring-unknown-defaults.js": 2565, - "3109-identity-union-collections.ts": 3588, - "3110-builtin-error-families.ts": 2812, - "3110-identity-collection-mutation.ts": 2831, - "3111-identity-collection-cycles.ts": 2915, - "3112-union-switch-control-flow.ts": 2075, - "3113-union-array-removal.ts": 3111, - "3114-union-record-field-write.ts": 2886, - "3115-zlib-static-compression-levels.ts": 2667, - "3116-sequence-expression-lifetimes.ts": 2953, - "3117-unknown-switch-control-flow.ts": 2388, - "3118-recursive-union-spread.ts": 3091, - "3119-runtime-optional-spread.ts": 3563, - "3120-dynamic-property-descriptors.js": 2806, - "3120-generator-method-loop-bindings.ts": 2970, - "3120-ir-nonfinite-numbers.ts": 2756, - "3121-compound-assignment-values.js": 2784, - "3121-dynamic-accessor-descriptors.js": 2889, - "3122-dynamic-delete-descriptors.cjs": 2435, - "3122-dynamic-delete-descriptors.js": 2554, - "3122-js-async-class-methods.js": 2294, - "3123-destructured-global-tdz.js": 2755, - "3124-array-prototype-borrow.js": 2322, - "3125-regex-global-match.ts": 2783, - "3126-js-number-radix/main.ts": 2820, - "3127-spawn-runtime-options.ts": 3072, - "3128-regex-last-index.ts": 1823, - "3129-js-token-union/main.ts": 2769, - "3130-child-generic-streams.ts": 2981, - "3131-child-rest-listeners.js": 2627, - "3132-child-generic-stream-completion.ts": 5669, - "3133-text-decoder-streaming.ts": 2916, - "3134-fs-vectors.ts": 2782, - "3135-fs-file-handle-controls.ts": 3077, - "3136-fs-file-handle-options.ts": 3203, - "3137-fs-vector-callbacks.cjs": 3063, - "3138-array-large-storage.ts": 4112, - "3139-regex-native-deep-alternatives.ts": 26910, - "3140-array-dense-access.ts": 3431, - "3141-map-string-key-hash.ts": 3132, - "3150-integer-remainder.ts": 3203, - "3151-array-push-writes.ts": 3025, - "3170-number-conversion-fast-paths.ts": 2101, - "3171-method-census-data-writes.ts": 3216, - "400-fib.ts": 2634, - "401-mutual-recursion.ts": 2541, - "402-string-functions.ts": 2183, - "403-void-and-params.ts": 2239, - "4030-runtime-object-truthiness.ts": 2407, - "4031-event-emitter-long-tuples.ts": 2624, - "4032-inline-rc-fast-paths.ts": 3924, - "404-rc-stress.ts": 2608, - "4040-adapted-function-identity.ts": 3296, - "4041-adapted-function-properties.ts": 2613, - "4042-object-is-union-subclass.ts": 2694, - "4043-nonnull-missing-element.ts": 2672, - "4044-adapted-callback-modules/main.ts": 2828, - "4045-optional-element-projections.ts": 2963, - "4046-captured-parameter-values.ts": 3070, - "4047-captured-parameter-rebinding.ts": 2848, - "405-params-optional.ts": 1924, - "406-params-defaults.ts": 1978, - "4060-cycle-shared-instance/main.ts": 2198, - "4060-stack-union-reads.ts": 3362, - "4061-cycle-evaluation-order/main.ts": 2399, - "4061-nullable-ref-fields.ts": 4246, - "4062-cycle-tdz-read/main.ts": 2254, - "4063-cycle-hoisted-calls/main.ts": 2402, - "4064-cycle-classes-after-init/main.ts": 2048, - "4065-cycle-init-throws/main.ts": 2640, - "4066-cycle-top-level-tdz/main.ts": 2245, - "4067-dynamic-import-cycle-tdz/main.ts": 2515, - "407-params-rest.ts": 2698, - "408-params-ctors-inheritance.ts": 2092, - "4080-optional-read-presence-tests.ts": 2936, - "4080-string-index-bounds.ts": 2863, - "4081-hoisted-function-tdz.ts": 2788, - "4081-string-index-unproven.ts": 2335, - "4082-hoisted-function-tdz-uncaught.ts": 1949, - "4083-dynamic-import-failure/main.ts": 2717, - "4084-record-optional-field-copies.ts": 2527, - "4085-generator-loop-close.ts": 2591, - "4086-optional-capture-defaults.ts": 2395, - "4088-class-static-tdz.ts": 2363, - "4089-class-wrapper-tdz.js": 2402, - "409-params-async-generics.ts": 2098, - "4090-computed-key-tdz.js": 2605, - "4091-class-evaluation-deferred.ts": 2199, - "410-params-rc-stress.ts": 2565, - "4140-array-callback-split-visit.ts": 4386, - "4141-array-callback-ambient-receiver/main.ts": 2299, - "4142-array-callback-factories.ts": 3208, - "4143-union-refinement-intersection-arms.ts": 2685, - "420-dead-strip-modules/main.ts": 2527, - "4290-acyclic-immutable-trees.ts": 3246, - "4291-acyclic-constructor-escapes.ts": 2909, - "4292-acyclic-readonly-bypass.ts": 3024, - "4293-acyclic-dynamic-writes.ts": 2956, - "4294-console-line-sizes.ts": 5873, - "4295-console-template-parts.ts": 2597, - "4296-console-glued-long-parts.ts": 2868, - "4410-inline-object-allocation.ts": 3093, - "4411-nullable-ref-values.ts": 4434, - "4412-nullable-record-values.ts": 3635, - "4413-cycle-old-late-death.ts": 2102, - "4413-nullable-null-and-undefined.ts": 2783, - "4414-cycle-old-weak-keys.ts": 2960, - "4414-nullable-string-values.ts": 3874, - "4415-identity-borrowed-operands.ts": 2087, - "4415-nullable-container-values.ts": 3581, - "4431-exception-pending-contexts.ts": 3035, - "4432-checked-downcast-failures.ts": 3246, - "4451-int32-field-storage.ts": 3457, - "4452-int32-field-dynamic-writes.ts": 3861, - "4453-int32-closed-locals.ts": 2280, + "1117-typeof-static-union.ts": 3626, + "1118-object-spread-conditional.ts": 2554, + "1119-switch-union.ts": 2726, + "112-class-descriptor-key.js": 2549, + "1121-infinity-number-tostring.ts": 3208, + "1122-any-captures.ts": 3054, + "1124-union-narrowed-retag.ts": 3578, + "113-promise-checked-exits.ts": 3586, + "114-live-record-delete.ts": 3626, + "115-array-compound.js": 3341, + "116-text-decoder-runtime.js": 2988, + "117-weak-cache-cycle.js": 2923, + "118-fs-stored-callbacks.cjs": 4172, + "119-native-patterns.js": 3825, + "1200-regex-test-basics.ts": 3353, + "1201-regex-replace.ts": 3417, + "1202-regex-substitutions.ts": 2747, + "1203-regex-split.ts": 3543, + "1204-regex-empty-unicode.ts": 3255, + "1205-regex-rc-stress.ts": 3482, + "1300-errors-basics.ts": 4832, + "1301-errors-subclass.ts": 1974, + "1302-errors-typed-catch.ts": 3160, + "1303-errors-rc-stress.ts": 3496, + "1304-errors-uncaught.ts": 2419, + "1305-errors-async-rejections.ts": 3908, + "1306-errors-runtime-instances.ts": 3226, + "1350-path-normalize-join.ts": 3294, + "1351-path-parts.ts": 3299, + "1352-path-resolve-relative.ts": 3380, + "1353-os-basics.ts": 3216, + "1354-builtin-bare-specifiers.ts": 3413, + "1355-url-parse.ts": 3188, + "1356-url-file-bridge.ts": 3020, + "1357-fsp-roundtrip.ts": 3377, + "1358-crypto-random.ts": 3134, + "1359-json-module/main.ts": 3195, + "1360-spawn-sync.ts": 3446, + "1361-spawn-events.ts": 3606, + "1362-spawn-timers.ts": 9552, + "1363-spawn-unhandled-error.ts": 3308, + "1364-union-truthiness.ts": 2872, + "1365-union-logical.ts": 3452, + "1366-union-equality.ts": 2813, + "1367-destructuring.ts": 3209, + "1368-constructor-functions.ts": 1858, + "1369-promise-union.ts": 2635, + "1370-spread.ts": 2894, + "1371-union-template-tostring.ts": 3244, + "1372-loose-null-tests.ts": 3198, + "1373-union-array-arms.ts": 3455, + "140-bitwise-operators.ts": 3457, + "1400-typedarray-basics.ts": 2651, + "1401-typedarray-slice-set.ts": 4371, + "1402-buffer-encodings.ts": 3496, + "1403-buffer-fs.ts": 3517, + "1404-zlib-crypto-bytes.ts": 3174, + "1405-bytes-unions-arrays.ts": 4083, + "1406-dataview-mp4.ts": 3511, + "1407-dataview-bounds.ts": 2861, + "1408-string-indexing.ts": 3596, + "1409-typedarray-integer-loops.ts": 3161, + "1420-number-statics.ts": 1931, + "1421-number-parse-strings.ts": 2420, + "1422-date-iso.ts": 3107, + "1423-text-codec.ts": 4835, + "1424-fs-options.ts": 3321, + "1425-stdin-tty.ts": 2403, + "1426-stdin-read.ts": 3082, + "1427-fromcharcode-lastindexof.ts": 3173, + "1428-settled-await-order.ts": 1798, + "1429-promise-catch-finally.ts": 3573, + "1430-promise-race.ts": 3479, + "1431-caught-tostring.ts": 3384, + "1432-destructured-params.ts": 2875, + "1433-filter-narrow.ts": 3756, + "1434-async-never.ts": 3046, + "1435-math-spread.ts": 2761, + "1436-default-undef-param.ts": 2349, + "1437-pad-default.ts": 3147, + "1438-promise-all.ts": 6716, + "1440-interval-basics.ts": 2538, + "1441-interval-clear-cross.ts": 6428, + "1442-interval-throw.ts": 3155, + "1443-signal-handlers.ts": 5897, + "1444-exit-listeners.ts": 2050, + "1445-exit-process-exit.ts": 3031, + "1446-exit-uncaught.ts": 3104, + "1447-stdin-closed-events.ts": 2554, + "1448-stream-columns.ts": 2939, + "1450-incdec-expression.ts": 3366, + "1451-instanceof-uint8array-unknown.ts": 3581, + "1452-return-through-finally.ts": 2366, + "1453-pmap-settled.ts": 3689, + "1454-nonnull-narrow-and-fcc-bytes.ts": 3631, + "1455-lambda-union-return-adoption.ts": 3317, + "1460-console-error-warn.ts": 2928, + "1461-process-pid-getuid-kill.ts": 2613, + "1462-exec-sync.ts": 3611, + "1463-timeout-unref.ts": 2351, + "1464-env-writes.ts": 2366, + "1465-env-value.ts": 3573, + "1466-child-containers.ts": 3261, + "1467-string-match.ts": 2763, + "1468-exec-path.ts": 1874, + "1469-remove-listener.ts": 3366, + "1470-child-lifecycle.ts": 3503, + "1471-child-unref.ts": 7428, + "1472-errno-code.ts": 3503, + "1473-promisify-execfile.ts": 3923, + "1474-string-decoder.ts": 3543, + "1475-readline-closed-stdin.ts": 2561, + "1476-assign-expression.ts": 2094, + "1477-in-expressions.ts": 2351, + "1478-promise-reject.ts": 3535, + "1479-destructuring-assign.ts": 3422, + "1480-os-network-interfaces.ts": 3878, + "1481-string-case-static.ts": 1956, + "1482-spawnsync-error.ts": 3384, + "1483-array-slice.ts": 2259, + "1520-fs-wider-surface.ts": 2338, + "1520-string-split-static.ts": 2323, + "1521-fs-lstat-lock.ts": 2828, + "1521-string-trim-pad-static.ts": 3386, + "1522-parseint-static.ts": 3245, + "1522-spawnsync-options.ts": 5207, + "1523-isnan-floor-static.ts": 2460, + "1523-spawn-options.ts": 3155, + "1524-atomics-sleep-static.ts": 3514, + "1524-catch-narrowing.ts": 3000, + "1525-child-exit-signal.ts": 3280, + "1525-unknown-typeof-validation.ts": 3939, + "1526-set-spread.ts": 3125, + "1527-logical-mixed-operands.ts": 3109, + "1528-delete-records-env.ts": 3666, + "1529-class-with-statics.ts": 2773, + "1530-array-push-variadic.ts": 2981, + "1530-spread-override-completion.ts": 2727, + "1531-delete-optional-fields.ts": 3366, + "1531-process-arch-versions.ts": 3284, + "1532-array-splice-shift.ts": 3298, + "1532-union-shared-field-read.ts": 3134, + "1533-bool-equality.ts": 2685, + "1533-path-platform-namespaces.ts": 2976, + "1534-crypto-hash-chain.ts": 3181, + "1534-union-as-arm-cast.ts": 1932, + "1535-spawn-fd-stdio.ts": 2678, + "1535-union-param-defaults.ts": 3163, + "1536-destructuring-defaults.ts": 2281, + "1536-string-array-sweep.ts": 2437, + "1537-chalk-hybrid/main.ts": 2748, + "1537-os-release-spawnsync-stdio.ts": 1762, + "1538-await-promiselike-return.ts": 3032, + "1538-math-static-scalar.ts": 3194, + "1539-readonly-set-map.ts": 2459, + "1539-unknown-truthiness.ts": 3106, + "1540-os-userinfo.ts": 3344, + "1540-void-statement.ts": 2967, + "1541-fs-readdir-dirent.ts": 3638, + "1541-union-keyed-reads.ts": 3287, + "1542-map-promise-values.ts": 2441, + "1542-record-literal-into-union.ts": 3261, + "1543-rest-destructuring.ts": 2933, + "1543-set-server-handles.ts": 1958, + "1544-dyn-json-reads.ts": 2284, + "1544-string-matchall.ts": 2886, + "1545-spread-order-and-optional.ts": 3651, + "1546-union-element-reads.ts": 3172, + "1547-computed-key-fold.ts": 3047, + "1548-boolean-condition-forms.ts": 2170, + "1549-array-isarray-unions.ts": 3931, + "1550-param-defaults-func-set.ts": 2398, + "1551-dyn-receiver-methods.ts": 3835, + "1552-exec-options-record.ts": 3202, + "1553-truthy-hof-predicates.ts": 3421, + "1554-caught-into-unknown.ts": 3543, + "1555-index-spread-into-declared.ts": 3633, + "1556-union-retag-width-arms.ts": 2627, + "1557-url-host.ts": 2357, + "1558-any-joins-and-dyn-validation.ts": 3196, + "1559-conditional-spread-index-merge.ts": 3131, + "1560-forof-homogeneous-tuples.ts": 3159, + "1561-forof-strings.ts": 2864, + "1561-promise-then.ts": 2385, + "1562-optional-chain-tails.ts": 3642, + "1562-spawn-conditional-spread.ts": 3319, + "1563-forof-iterator-projections.ts": 2786, + "1563-string-raw-fold.ts": 2587, + "1564-fs-watch.ts": 3261, + "1564-string-raw.ts": 2451, + "1565-spawn-pipe-streams.ts": 3391, + "1565-union-element-join.ts": 2486, + "1566-child-duck-interface.ts": 2840, + "1567-server-close-override.ts": 3237, + "1568-x509-fingerprint.ts": 3907, + "1569-fsp-mkdir-unlink-chmod.ts": 2903, + "1570-child-unref-kill-reffed.ts": 8636, + "1571-optional-call-tostring-tail.ts": 2889, + "1571-stdin-set-raw-mode-non-tty.ts": 2975, + "1572-promise-reject-all-tuple.ts": 3556, + "1572-x509-validity-date-gettime.ts": 3310, + "1573-promisify-execfile-env-spread.ts": 2814, + "1573-tdz-scalar-forward-capture.ts": 1712, + "1574-dyn-optional-method-number-keys.ts": 3878, + "1574-promise-all-tuple-literal.ts": 2253, + "1575-unknown-assert-into-record.ts": 1861, + "1576-width-coercions.ts": 2898, + "1577-url-hostname.ts": 2901, + "1578-exec-input-optional.ts": 3273, + "1579-matchall-index.ts": 3564, + "1580-exec-env-conditional-spread.ts": 2271, + "1581-declare-const-read.ts": 3037, + "1582-timer-sleep-resolve.ts": 3206, + "1583-loops-and-stream-captures.ts": 3193, + "1584-union-field-unassigned.ts": 3119, + "1585-union-field-conditional-ctor.ts": 3101, + "1586-derived-field-before-super-init.ts": 2618, + "1590-js-unannotated.js": 2053, + "1591-js-closures.js": 2387, + "1592-js-classes.js": 4973, + "1593-js-jsdoc-records.js": 3116, + "1594-js-async.js": 2589, + "1595-js-island-gap/main.js": 3108, + "1596-cjs-modules/main.js": 3096, + "1597-mjs-graph/main.mjs": 2863, + "1598-cjs-builtin-require/main.js": 2598, + "1599-js-uncaught-throw.js": 1785, + "1600-assert-passing.ts": 3203, + "1601-assert-fail-exit.ts": 2955, + "1602-assert-caught-error.ts": 2978, + "1603-assert-scalar-messages.ts": 3055, + "1604-assert-deep-structures.ts": 3591, + "1605-assert-import-forms.ts": 2429, + "1606-assert-strict-module.ts": 3039, + "1607-assert-throws-match.ts": 2826, + "1608-cjs-assert/main.js": 3263, + "1609-assert-async.ts": 3342, + "1610-path-win32-full.ts": 2405, + "1611-url-file-bridge-neutral.ts": 2476, + "1612-cjs-module-globals.cjs": 2856, + "1613-cjs-esm-proxy-named/main.mjs": 2613, + "1614-js-fence-dodges.cjs": 1967, + "1615-cjs-export-shapes/main.cjs": 2975, + "1616-cjs-esm-lexer-invisible/main.mjs": 2660, + "1617-cjs-esm-lexer-visible/main.mjs": 3090, + "1618-cjs-esm-poisoned-tail/main.mjs": 2780, + "1619-cjs-esm-reexport-invisible/main.mjs": 2185, + "1620-cjs-require-effects-order/main.js": 1410, + "1621-cjs-require-cache-hit/main.js": 2836, + "1622-cjs-require-conditional/main.js": 2564, + "1623-cjs-require-diamond/main.js": 2652, + "1624-cjs-require-dir-mid-file/main.js": 2573, + "1625-cjs-require-lazy-fn/main.js": 2246, + "1626-cjs-require-mjs/main.js": 2951, + "1627-mjs-import-cjs-requires/main.mjs": 2683, + "1628-checked-dynamic-builtin-args.cjs": 1896, + "1629-require-main-filename.cjs": 2867, + "1630-inspect-scalars.ts": 2361, + "1630-rmsync-retry-options.cjs": 2984, + "1631-inspect-arrays.ts": 3811, + "1632-inspect-records.ts": 4779, + "1633-inspect-map-set.ts": 3008, + "1634-inspect-classes.ts": 3344, + "1635-inspect-buffer.ts": 2898, + "1636-util-format.ts": 2261, + "1637-inspect-dyn.ts": 2934, + "1638-inspect-cjs.cjs": 3133, + "1639-versions-openssl-probe.ts": 2209, + "1640-fd-read-decode.ts": 3309, + "1641-string-search.ts": 2951, + "1642-object-fromentries-rows.ts": 3231, + "1643-metadata-dyn-return.cjs": 3375, + "1644-ee-basics.ts": 3158, + "1645-ee-extends.ts": 2448, + "1646-ee-once-remove.ts": 2581, + "1647-ee-meta-events.ts": 2563, + "1648-ee-error-event.ts": 2097, + "1649-ee-names-counts.ts": 2941, + "1650-ee-prepend.ts": 3190, + "1651-ee-max-listeners.ts": 2691, + "1652-ee-snapshot.ts": 2882, + "1653-ee-cjs.cjs": 2645, + "1654-ee-namespace.ts": 2314, + "1655-spawnsync-neutral.ts": 4787, + "1656-execsync-neutral.ts": 3015, + "1657-spawn-async-neutral.ts": 3128, + "1660-buffer-read-write-num.ts": 2511, + "1661-buffer-encodings-full.ts": 3466, + "1662-string-decoder-encodings.ts": 3207, + "1663-buffer-compare-search-fill.ts": 3063, + "1664-dyn-fn-boundary.cjs": 2280, + "1665-dyn-fn-mustcall/main.cjs": 2798, + "1666-dyn-fn-identity.ts": 3303, + "1667-dyn-fn-not-callable.cjs": 2431, + "1668-dyn-fn-throws.cjs": 3052, + "1669-symbol-identity.ts": 3194, + "1670-symbol-registry.ts": 2198, + "1671-symbol-typeof.ts": 2786, + "1672-symbol-containers.ts": 2209, + "1673-symbol-cjs.cjs": 2979, + "1674-symbol-inspect.ts": 2795, + "1676-func-array-surface.ts": 2945, + "1677-emitter-listeners.ts": 4548, + "1678-emitter-dyn-listeners.cjs": 3185, + "1679-console-dyn.js": 2910, + "1680-assert-bytes.ts": 3154, + "1681-assert-funcs.ts": 1828, + "1685-stream-readable-basics.ts": 2976, + "1686-stream-readable-paused.ts": 2831, + "1687-stream-readable-flow-control.ts": 2863, + "1688-stream-writable-basics.ts": 2245, + "1689-stream-writable-async-drain.ts": 1562, + "1690-stream-duplex.ts": 3124, + "1691-stream-transform.ts": 2070, + "1692-stream-pipe.ts": 2661, + "1693-stream-pipe-backpressure.ts": 2944, + "1694-stream-destroy.ts": 2243, + "1695-stream-props.ts": 2801, + "1696-stream-read-inside-read.ts": 2398, + "1697-stream-tick-vs-timer.ts": 2703, + "1698-stream-uncaught-error.ts": 2045, + "1699-stream-callback-shapes.ts": 2523, + "1700-mustcall-common/main.cjs": 3695, + "1701-mustcall-exit-report/main.cjs": 4202, + "1702-dyn-proto-dispatch.cjs": 3277, + "1703-arguments-rest-props.cjs": 2983, + "1710-cjs-export-class/main.js": 3030, + "1711-cjs-export-single-values/main.js": 2594, + "1712-field-incdec.ts": 1845, + "1713-js-dyn-fields.js": 2654, + "1720-assert-throws-shape.ts": 2898, + "1721-assert-throws-regex-class.ts": 3751, + "1722-assert-rejects.ts": 2848, + "1723-assert-does-not-reject.ts": 3358, + "1724-assert-iferror.ts": 1705, + "1725-assert-symbols.ts": 2141, + "1726-promise-with-resolvers.ts": 2575, + "1727-assert-throws-shape-exit.ts": 2905, + "1730-countdown-symbol-keys/main.js": 2273, + "1731-symbol-field-shapes.cjs": 2895, + "1732-symbol-field-cross-module/main.js": 2678, + "1740-stream-extends-readable.ts": 2983, + "1741-stream-extends-writable.ts": 2337, + "1742-stream-extends-duplex-transform.ts": 3417, + "1743-stream-extends-vt-dispatch.ts": 2520, + "1744-stream-set-encoding.ts": 3582, + "1745-stream-encoding-js.cjs": 2993, + "1746-stream-for-await.ts": 4666, + "1747-stream-for-await-js.cjs": 3552, + "1750-http-agent-options.ts": 2667, + "1751-options-record-stance.ts": 3044, + "1760-surplus-args-drop.cjs": 2775, + "1761-emitter-special-event-names.cjs": 2427, + "1770-assert-dyn-strict.ts": 3393, + "1771-assert-dyn-deep.ts": 3639, + "1772-assert-dyn-js.cjs": 2854, + "1773-assert-dyn-exit.ts": 2368, + "1780-http-res-surface.ts": 2318, + "1781-http-server-shapes.cjs": 3339, + "1790-computed-key-folds.ts": 2833, + "1791-searchparams-core.ts": 2212, + "1792-searchparams-encoding.ts": 2305, + "1793-searchparams-iteration.ts": 3412, + "1794-searchparams-url-live.ts": 2492, + "1795-dyn-handle-request.cjs": 3337, + "1796-dyn-handle-body.cjs": 3287, + "1797-dyn-handle-socket.cjs": 2497, + "1798-dyn-handle-typed-box.ts": 2870, + "1800-immediate-basics.ts": 2802, + "1801-immediate-handle.ts": 2655, + "1802-immediate-unref-exit.ts": 2450, + "1803-timeout-refresh.ts": 2797, + "1804-timers-module.ts": 2773, + "1805-timer-callback-args.ts": 2736, + "1806-timer-delay-trunc.ts": 2060, + "1810-stream-options-const-record.ts": 2542, + "1811-stream-option-value-callbacks.cjs": 2462, + "1812-stream-super-options-forwarding.cjs": 3383, + "1813-stream-finished.ts": 2720, + "1814-stream-pipeline.cjs": 3409, + "1815-stream-state-reads.cjs": 2880, + "1820-static-block-basics.ts": 1635, + "1821-static-block-order.ts": 2551, + "1822-static-block-js.js": 2387, + "1823-static-instance-method-names.ts": 1936, + "1824-for-of-destructuring-defaults.ts": 2145, + "1825-exhaustive-typeof-switch.ts": 2973, + "1826-settimeout-arguments-callback.js": 2489, + "1830-enum-numeric-basics.ts": 2207, + "1831-enum-string-const-reverse.ts": 1943, + "1832-enum-modules/main.ts": 2350, + "1835-var-basics.ts": 2804, + "1836-var-loop-capture.ts": 3197, + "1837-var-undefined-hoisting.ts": 2836, + "1838-var-modules/main.ts": 2550, + "1839-var-js/main.cjs": 2492, + "1840-jsdoc-import-type-only/main.js": 1919, + "1850-overload-basics.ts": 2640, + "1851-overload-return-narrowing.ts": 1736, + "1852-overload-class-members.ts": 2774, + "1853-overload-modules/main.ts": 2509, + "1854-ambient-declare-fn.ts": 2603, + "1855-ambient-declare-fn-uncaught.ts": 1999, + "1870-unit-type-values.ts": 2905, + "1871-empty-array-never.ts": 2516, + "1872-template-tostring-composite.ts": 1682, + "1880-json-declared-field-order.ts": 3529, + "1881-default-anon/main.ts": 2084, + "1882-default-cjs-interop/main.ts": 2606, + "1883-default-exports/main.ts": 2612, + "1890-ns-imports/main.ts": 2704, + "1891-ns-reexport/main.ts": 2129, + "1940-class-values-basics.ts": 2668, + "1941-class-values-registry.ts": 2870, + "1942-class-expressions.ts": 2682, + "1943-class-statics-expanded.ts": 2734, + "1944-class-values-modules/main.ts": 2146, + "1950-generic-fn-values.ts": 2755, + "1951-generic-classes-basics.ts": 3235, + "1952-generic-class-statics-values.ts": 2233, + "1953-generic-class-hierarchy.ts": 2990, + "1954-generic-modules/main.ts": 2377, + "1960-namespace-basics.ts": 2728, + "1961-namespace-nested.ts": 2156, + "1962-namespace-classes.ts": 2835, + "1963-namespace-aliases.ts": 2550, + "1964-namespace-type-only.ts": 2471, + "1965-namespace-ambient.ts": 2707, + "1966-namespace-modules/main.ts": 2766, + "1967-namespace-alias-typeonly.ts": 2273, + "1968-namespace-import-eq-snapshot.ts": 2594, + "1970-decorators-basics.ts": 2916, + "1971-decorators-rebinding.ts": 2369, + "1972-decorators-throwing.ts": 2667, + "1973-decorators-ambient.ts": 2709, + "1980-primitive-proto-statics.ts": 3013, + "1981-date-utc.ts": 2644, + "1982-freeze-resolve-passthrough.ts": 3023, + "1983-array-tuple-surfaces.ts": 3232, + "1990-labels-basics.ts": 2990, + "1991-for-in-loops.ts": 3611, + "1992-small-syntax.ts": 3054, + "200-strings.ts": 1903, + "2000-generic-methods-basic.ts": 2832, + "2001-generic-methods-generic-class.ts": 2741, + "2002-generic-methods-inheritance.ts": 2972, + "2003-generic-methods-object-literal.ts": 3023, + "2004-generic-methods-statics.ts": 2292, + "201-templates.ts": 2534, + "2010-generators-basics.ts": 1525, + "2011-generators-forof.ts": 2217, + "2012-generators-return-throw.ts": 3262, + "2013-generators-sent-values.ts": 2117, + "2014-generators-values.ts": 2991, + "2015-generators-yieldstar.ts": 2892, + "2016-generators-rc-stress.ts": 2942, + "2017-generators-async.ts": 1965, + "2018-generators-uncaught.ts": 2403, + "2019-generators-loops.ts": 2116, + "2020-generic-value-bindings.ts": 3355, + "2021-generic-value-binding-modules/main.ts": 2720, + "2022-width-index-capture.ts": 2258, + "2023-width-readonly.ts": 2519, + "2024-width-array-elems.ts": 2776, + "2025-width-union-compose.ts": 3243, + "2026-width-spread.ts": 1625, + "2030-width-nested.ts": 3160, + "2031-width-tuples.ts": 2019, + "2032-cjs-export-assigned-class-expression/main.cjs": 2230, + "2033-property-assigned-class-extends.cjs": 2058, + "2035-ternary-array-retag.cjs": 2602, + "2036-evolving-array-decl.cjs": 2125, + "2037-fn-decl-hoisting.cjs": 1595, + "2038-evolving-array-js.cjs": 2965, + "2040-any-bindings.ts": 3143, + "2040-mixin-heritage.ts": 3206, + "2041-any-params-returns.ts": 2996, + "2041-mixin-values.ts": 3090, + "2042-any-flow-loops.ts": 3104, + "2042-mixin-modules/main.ts": 2762, + "2043-any-dom-values.ts": 3345, + "2043-mixin-rc-stress.ts": 2605, + "2044-vtable-sibling-slots.ts": 3123, + "2045-objlit-accessors-basic.ts": 2774, + "2045-parameter-properties.ts": 3393, + "2046-abstract-classes.ts": 2184, + "2046-objlit-accessors-effects.ts": 2948, + "2047-objlit-accessors-shapes.ts": 1767, + "2047-optional-class-fields.ts": 2566, + "2050-dynamic-import-own-module/main.ts": 2384, + "2051-dynamic-import-then/main.ts": 2679, + "2052-dynamic-import-self.ts": 2722, + "2053-typeof-static-fold.ts": 2817, + "2054-destructuring-island-source.ts": 2995, + "2060-empty-tuple.ts": 2635, + "2070-computed-key-folds.ts": 2872, + "2071-integer-key-enumeration-order.ts": 3125, + "2072-expando-function-members.ts": 2341, + "2073-destructuring-assignment.ts": 2794, + "2074-island-destructuring.ts": 2364, + "2075-index-signature-runtime-keys.ts": 2866, + "2080-destructuring-defaults.ts": 1887, + "2081-destructuring-rest.ts": 3136, + "2082-destructuring-assignment.ts": 2594, + "2085-destructuring-heads-rest-params.ts": 2973, + "2087-destructuring-for-heads.ts": 2753, + "2090-index-signature-number-keys.ts": 2175, + "2091-index-signature-string-intersection.ts": 2763, + "2092-package-imports/main.ts": 2350, + "2093-timers-promises.ts": 2872, + "2094-diagnostics-channel.ts": 2689, + "2095-js-catch-unknown.js": 2633, + "2096-os-type.ts": 1968, + "2097-js-evolving-globals.js": 2880, + "210-string-methods.ts": 2798, + "2100-stream-default-hwm.ts": 2089, + "2101-dyn-param-defaults.ts": 2260, + "2102-empty-pattern-decls.ts": 1677, + "2105-computed-key-static-folds.ts": 2815, + "2106-comma-expressions.ts": 2657, + "211-string-unicode.ts": 2741, + "2110-top-object-types.ts": 2919, + "2111-json-stringify-unknown.ts": 2401, + "2112-array-at-findlast.ts": 1741, + "2113-string-index-methods.js": 1867, + "212-string-aliasing-append.ts": 2513, + "2120-package-self-import/main.ts": 2334, + "2121-esm-cycle-inert-backedge/main.ts": 2266, + "2123-ambient-import-crash/main.ts": 2890, + "2124-imports-field-wildcard/main.ts": 2153, + "2140-uri-component-codecs.ts": 2446, + "2160-dc-tracing-channel.cjs": 2881, + "2161-js-object-literal-identity.cjs": 2928, + "2162-js-dyn-destructure.cjs": 2896, + "2163-js-selfref-const.cjs": 2717, + "2164-js-then-dyn-handler.cjs": 2572, + "2165-js-throw-dyn.cjs": 2672, + "2166-cjs-getter-this/main.cjs": 2899, + "2170-island-array-exits.ts": 2722, + "2171-island-json-stringify.ts": 2071, + "2172-island-regexp-boundary.ts": 2828, + "2190-new-object-and-string-wrappers.ts": 2625, + "2191-uri-encoders.ts": 2849, + "2192-object-default-tostring.ts": 2537, + "2193-discarded-stdlib-reads.ts": 2594, + "2194-ambient-undef-chains.ts": 1718, + "2195-require-missing-package/main.mjs": 2757, + "2196-island-computed-key-chain.ts": 2575, + "2210-dyn-promise-crossing.cjs": 2319, + "2211-dc-trace-promise.cjs": 1935, + "2212-unhandled-rejection-listener.cjs": 2879, + "2213-async-local-storage.cjs": 2883, + "2214-dc-bind-store.cjs": 2240, + "2215-process-emit-warning-exit.cjs": 3330, + "2240-width-class-into-record.ts": 2571, + "2241-width-record-into-class.ts": 2500, + "2242-width-statics-into-record.ts": 1787, + "2243-width-assert-satisfies-shapes.ts": 2738, + "2250-tagged-templates.ts": 2408, + "2252-class-iterators.ts": 3611, + "2253-union-coercions.ts": 2810, + "2260-http2-constants.cjs": 2702, + "2280-builtin-namespace-destructure.cjs": 2594, + "2281-domexception-atob-btoa.cjs": 2615, + "2282-queue-microtask.cjs": 2780, + "2283-structured-clone.cjs": 3105, + "2284-regexp-constructor.cjs": 2648, + "2285-iferror-dyn.cjs": 2717, + "2286-dyn-object-walks.cjs": 3110, + "2300-dyn-record-spread-and-keyed-access.cjs": 2464, + "2301-cjs-export-table-dom-attach.cjs": 2425, + "2310-process-next-tick.ts": 2609, + "2311-next-tick-js-callbacks.js": 2450, + "2312-stream-underscore-assign.ts": 2473, + "2313-stream-underscore-assign-js.cjs": 3017, + "2314-process-introspection.ts": 3479, + "2320-await-unit.ts": 2334, + "2321-emitter-static-setmax.cjs": 2697, + "2322-dyn-array-sort.cjs": 3014, + "2323-timer-callback-returns.ts": 3852, + "2330-tls-server-runtime-options.cjs": 2565, + "2331-tls-server-options-typed.ts": 1980, + "2350-nan-global.ts": 3180, + "2351-async-methods.ts": 2138, + "2352-void-coercions.ts": 2843, + "2353-decorators-member-ambient.ts": 3089, + "2354-decorators-expression-ambient.ts": 1841, + "2360-tuple-to-array.ts": 2335, + "2361-assign-index-record.ts": 3492, + "2362-execsync-inherit.ts": 2484, + "2363-nullish-retag.ts": 2875, + "2364-in-runtime-key.ts": 2156, + "2365-dyn-into-island.ts": 2339, + "2366-string-well-formed.ts": 2760, + "2367-regexp-escape.ts": 2791, + "2368-set-methods.ts": 3237, + "2369-promise-try.ts": 2605, + "2370-group-by.ts": 3569, + "2371-iterator-helpers.ts": 3561, + "2380-buffer-module-named-import.ts": 2746, + "2381-builtin-default-imports.js": 2945, + "2382-cycle-two-decl/main.ts": 2560, + "2383-cycle-assertdoc/main.js": 3011, + "2384-cycle-mixed-bindings/main.ts": 2477, + "2385-builtin-reexport-facade/main.ts": 2948, + "2386-string-to-chars.ts": 2475, + "2387-tonumber-argv.ts": 3071, + "2388-tonumber-grammar-zoo.ts": 3157, + "2389-tonumber-unary-plus.ts": 2176, + "2390-dot-requires/main.cjs": 2329, + "2391-default-builtin-imports/main.ts": 2387, + "2392-block-guard-alias-scope.ts": 2363, + "2393-loop-exit-guard-narrow.ts": 2936, + "2394-loop-narrow-containment.ts": 2244, + "2395-while-cond-guard.ts": 2443, + "2396-born-narrowed-decl.ts": 2276, + "2397-branch-kill-merge.ts": 2681, + "2398-switch-arm-kill.ts": 3027, + "2399-reassign-kill-polarity.ts": 2662, + "240-stdout-write.ts": 1918, + "2400-kill-return-edge.ts": 2414, + "2401-kill-break-staging.ts": 2162, + "2402-labeled-break-kill.ts": 2493, + "2403-kill-continue-backedge.ts": 2457, + "2404-kill-throw-catch.ts": 1792, + "2405-sibling-arm-narrow.ts": 1781, + "2406-switch-clause-sibling-narrow.ts": 2641, + "2407-infinite-loop-seal.ts": 2308, + "2408-loop-terminality-reopen.ts": 2756, + "2409-loop-body-return-not-terminal.ts": 2759, + "2410-stacked-cases-terminality.ts": 2830, + "2411-exhaustive-switch-terminality.ts": 2112, + "2412-dowhile-guard-trailing-test.ts": 2230, + "2413-dowhile-kill-renarrow.ts": 2630, + "2414-dowhile-continue-kill.ts": 2624, + "2415-dowhile-break-trailing-test.ts": 2524, + "2416-spread-ternary-positions.ts": 2956, + "2417-ternary-local-inference.ts": 2300, + "2418-wrapped-ternary-arms.ts": 2768, + "2419-selector-ternary-union.ts": 2727, + "2420-nullish-null-identity.ts": 2533, + "2421-float-lane-inference.ts": 2620, + "2422-ieee-div-rem-corners.ts": 2629, + "2423-param-null-reassign.ts": 2622, + "2424-ternary-miss-first-narrowing.ts": 2228, + "2425-elseif-head-exit-narrow.ts": 2186, + "2426-default-snapshot-mutable/main.ts": 2520, + "2427-perf-hooks-now.ts": 2346, + "2428-field-redeclare-inherited.ts": 2882, + "2429-destructure-class-instance.ts": 2852, + "2430-empty-literal-unknown-field.js": 2190, + "2431-primitive-ctor-values.ts": 2149, + "2432-generic-member-fields-async.ts": 3225, + "2433-as-const-command-tables.ts": 3139, + "2434-deferred-init-fields.ts": 2789, + "2435-loose-same-kind-equality.ts": 2652, + "2440-console-inspect-args.ts": 3314, + "2441-console-process-argv.ts": 2095, + "2442-union-literal-arm-widening.ts": 2062, + "2443-union-literal-shadow-narrowing.ts": 2856, + "2444-union-literal-reducer-spread.ts": 2705, + "2445-math-minmax-nary.ts": 2093, + "2446-performance-global.ts": 2484, + "2447-island-boundary-slots/main.ts": 3456, + "2448-entries-null-arms-regex-arrays.ts": 2911, + "2450-private-instance-methods.ts": 2310, + "2451-private-fields.ts": 2058, + "2452-private-statics.ts": 2844, + "2453-private-accessors.ts": 2851, + "2454-private-generator-methods.ts": 2328, + "2455-private-brand-checks.ts": 2840, + "2456-private-async-methods.ts": 2932, + "2457-private-members.js": 2832, + "2460-qs-parse-grammar.ts": 2844, + "2461-qs-parse-options.ts": 2944, + "2462-qs-stringify.ts": 3219, + "2463-qs-escape-unescape.ts": 2133, + "2464-qs-require-forms.cjs": 2362, + "2470-mockable-module-shape.js": 3020, + "2471-record-keyed-write-hasown.js": 2921, + "2472-string-regexp-union.ts": 1528, + "2473-option-table-widths.js": 2792, + "2474-island-literal-forms.ts": 2730, + "2475-variadic-wrapper-island.js": 2962, + "2476-map-regex-values.ts": 1895, + "2480-recursive-record-tree.ts": 2781, + "2481-mutual-recursive-records.ts": 2829, + "2482-recursive-union-tree.ts": 2626, + "2483-recursive-record-cycles.ts": 2385, + "2484-json-stringify-circular.ts": 1936, + "2485-inspect-circular-refs.ts": 3139, + "2486-recursive-record-boundaries.ts": 3118, + "2487-recursive-deep-equal.ts": 2998, + "2488-ast-walker.ts": 3274, + "2490-find-miss-null-compare.ts": 2608, + "2491-strict-unit-compare-no-arm.ts": 2376, + "2492-loose-null-compare-unions.ts": 2805, + "2493-switch-unit-cases.ts": 2280, + "2494-no-arm-compare-effects.ts": 2159, + "2500-net-autosel-timeout.ts": 2195, + "2510-dyn-evolving-array-map.ts": 1961, + "2511-dyn-evolving-array-filter-foreach.ts": 2859, + "2512-dyn-evolving-array-mixed-push.ts": 1607, + "2520-private-statics-class-name-calls.ts": 2420, + "2521-private-statics-class-expression.ts": 1848, + "2522-private-statics-decorated.ts": 3008, + "2523-private-statics-aliased-class.ts": 2743, + "2530-object-destructuring-decl.ts": 2036, + "2531-array-tuple-destructuring-decl.ts": 2908, + "2532-param-destructuring-options.ts": 2917, + "2533-forof-destructuring.ts": 2821, + "2534-object-rest-decl.ts": 2914, + "2535-destructuring-assign-basics.ts": 2888, + "2536-destructuring-assign-nested.ts": 2697, + "2537-destructuring-assign-member-targets.ts": 1747, + "2538-destructuring-assign-class-source.ts": 2594, + "2539-class-instance-rest.ts": 2144, + "2540-accessor-destructuring-defaults.ts": 2790, + "2541-destructuring-eval-order.ts": 2901, + "2550-generics-keyof-pick.ts": 2724, + "2551-generics-value-aliases.ts": 2899, + "2552-generics-iface-methods.ts": 2924, + "2553-generics-signature-bindings.ts": 1690, + "2554-generics-frontier-mix.ts": 2607, + "2555-generics-keyof-writes.ts": 2074, + "2556-crypto-introspection.ts": 2165, + "2556-width-hybrid-shapes.ts": 1904, + "2557-tls-ca-store.ts": 3159, + "2557-width-field-lifts.ts": 3231, + "2558-index-signature-func-values.ts": 2869, + "2558-rejection-events.cjs": 1923, + "2559-index-signature-container-values.ts": 2319, + "2560-arraybuffer-dataview-set.ts": 3376, + "2561-object-is.ts": 3499, + "2562-intl-numberformat-en-us.ts": 2371, + "2563-stream-promises-pipeline.ts": 3059, + "2564-stream-promises-finished.ts": 1663, + "2565-stream-promises-js.cjs": 2464, + "2566-promise-reject-dyn-reason.js": 2041, + "2567-rest-spread-forward.js": 3238, + "2568-rest-spread-forward-dynamic.js": 2074, + "2569-upcast-identity.ts": 2471, + "2570-buffer-arg-validation.cjs": 4288, + "2571-searchparams-arg-validation.cjs": 2294, + "2572-readable-emitted-readable-flag.cjs": 2792, + "2573-fs-url-arg-ladders.cjs": 3144, + "2574-emitter-max-listeners-ladders.cjs": 2768, + "2575-string-destructuring-decl.ts": 3093, + "2576-string-destructuring-assign.ts": 1948, + "2577-builtin-global-destructuring.js": 1471, + "2578-jsval-into-unknown-rows.ts": 2895, + "2579-jsval-object-param-crossing.js": 2920, + "2580-jsval-routed-keyed-ops.js": 2793, + "2581-jsval-routed-calls.js": 2527, + "2582-jsval-object-statics.js": 3114, + "2582-jsval-routed-keyed-ops.js": 3012, + "2583-dyn-nullish-coalesce.js": 2872, + "2583-jsval-routed-calls.js": 3060, + "2584-jsval-object-statics.js": 3017, + "2584-union-dyn-collapse.ts": 3110, + "2585-dyn-nullish-coalesce.js": 3233, + "2585-unknown-array.ts": 3147, + "2586-object-assign-spread.js": 3063, + "2587-array-entries-forof.ts": 2868, + "2588-array-entries-chains.ts": 2948, + "2589-object-create-null.cjs": 2175, + "2590-object-create-dynamic.js": 2548, + "2591-ambient-generic-traps.ts": 2668, + "2592-ambient-trap-uncaught.ts": 2071, + "2593-generic-inert-bindings.ts": 2582, + "2594-nullish-generic-bindings.ts": 2649, + "2595-fs-arg-ladders.cjs": 3450, + "2596-net-arg-ladders.cjs": 3163, + "2597-dgram-send-ladders.cjs": 3471, + "2598-tls-arg-ladders.cjs": 2644, + "2599-stream-arg-ladders.cjs": 2952, + "2600-dyn-keyed-write-harness.js": 3162, + "2601-dyn-keyed-write-ops.js": 2780, + "2602-dyn-array-destructure.js": 2123, + "2603-island-keyed-write-dyn.js": 2776, + "2604-cycle-classes-mutual/main.ts": 2653, + "2605-cycle-three-module/main.ts": 2386, + "2606-dynamic-import-cycle/main.ts": 2580, + "2608-regex-named-groups.ts": 3189, + "2609-regex-named-replace.ts": 2460, + "2610-regex-named-matchall.ts": 1815, + "2611-regex-named-groups-js.cjs": 3151, + "2613-for-init-uninitialized-let.ts": 2759, + "2614-trap-binding-later-writes.ts": 1833, + "2615-nullish-field-record-binding.ts": 2522, + "2616-js-collect-probe-defers.js": 2932, + "2617-enum-static-field-import/main.ts": 2674, + "2618-ee-emit-override.ts": 2416, + "2619-ee-override-chain.ts": 2759, + "2620-ee-override-once-order.ts": 2863, + "2621-ee-override-error-throw.ts": 2669, + "2622-ee-override-filter.ts": 2972, + "2623-ee-job-queue.ts": 2457, + "2624-ee-override-js.cjs": 2851, + "2625-bytes-views.ts": 1866, + "2626-stream-event-names.ts": 3082, + "2627-stream-ticks-are-nextticks.ts": 2115, + "2628-stream-push-encodings.cjs": 2780, + "2629-stream-consumers.ts": 3333, + "2630-stream-consumers-errors.ts": 2597, + "2631-create-require/main.ts": 3215, + "2632-dyn-jsval-iterate.js": 3094, + "2633-island-promise-crossing.js": 2715, + "2634-stream-pipeline-arg-ladders.cjs": 2970, + "2635-trap-binding-unmappable-written.ts": 2644, + "2636-trap-binding-ambient-rooted-rewrite.ts": 2711, + "2637-create-require-bare/main.ts": 2926, + "2638-http-dyn-res-compat.cjs": 3551, + "2639-http-dyn-req-pause.cjs": 2114, + "2640-net-dyn-socket-compat.cjs": 3221, + "2641-http-agent-surface.cjs": 3393, + "2642-http-agent-maxsockets.cjs": 2445, + "2643-or-default-retag.ts": 2951, + "2644-http-client-url-argument.ts": 3003, + "2645-https-client-url-argument.ts": 1965, + "2646-top-level-await.ts": 1994, + "2647-top-level-await-modules/main.ts": 2883, + "2648-top-level-await-rejection.ts": 2548, + "2649-top-level-await-pending.ts": 2420, + "2650-top-level-await-self-import.ts": 2738, + "2651-top-level-await-pending-unhandled.ts": 1959, + "2652-top-level-await-dynamic/main.ts": 1976, + "2653-top-level-await-rejection-stops-loop.ts": 2530, + "2654-top-level-await-unrelated-rejection.ts": 2557, + "2655-top-level-await-cycle/main.ts": 2575, + "2656-top-level-await-cycle-order/main.ts": 2788, + "2657-top-level-await-cycle-dynamic/main.ts": 1945, + "2658-top-level-await-sync-completion/main.ts": 2486, + "2659-top-level-await-dynamic-cycle/main.ts": 2311, + "2660-top-level-await-cycle-rejection/main.ts": 1648, + "2661-top-level-await-dynamic-runtime-root/main.ts": 2615, + "2662-top-level-await-cycle-external-wait/main.ts": 2307, + "2663-top-level-await-dependency-errors/main.ts": 2145, + "2664-top-level-await-same-checkpoint-rejection.ts": 2652, + "2665-top-level-await-unhandled-listener-liveness.ts": 3003, + "2666-array-to-sorted.ts": 5347, + "2668-stored-number-array-iterator.ts": 2840, + "2669-array-copying-methods.ts": 2792, + "2670-uint8array-copy-iterate.ts": 2664, + "2671-array-copying-js.cjs": 2591, + "2672-http-request-response-callback.ts": 2953, + "2673-top-level-await-implicit-module.ts": 1743, + "2674-top-level-for-await-implicit-module.ts": 2697, + "2675-create-require-nested-esm.js": 2199, + "2675-process-self-reexec.ts": 2588, + "2676-indexed-read-strict-equality.ts": 2188, + "2676-record-clone-overrides.ts": 2426, + "2676-top-level-await-ambiguous/main.ts": 2482, + "2677-runtime-optional-closure.ts": 3477, + "2677-top-level-await-module-scope/main.ts": 2623, + "2678-date-instances.ts": 3208, + "2678-large-string-sparse-index.ts": 2981, + "2678-util-parseargs.ts": 5281, + "2679-util-parseargs-cjs.cjs": 3377, + "2680-util-parseargs-default.ts": 2722, + "2681-util-parseargs-dynamic.js": 1944, + "2682-fs-rename.ts": 3375, + "2683-filter-truthy-predicate.ts": 2838, + "2683-fs-rename-js.cjs": 1913, + "2684-filter-no-predicate-dyn.cjs": 2576, + "2684-fs-rename-abort.ts": 2742, + "2685-array-unshift-reverse.ts": 2654, + "2685-fs-write-sync.ts": 2517, + "2686-fs-file-handle.ts": 3648, + "2687-fsp-write-file-options.ts": 2384, + "2687-process-write-args.ts": 2846, + "2688-fs-stats-disk-fields.ts": 2938, + "2689-http-server-timeout-properties.ts": 3060, + "2690-https-server-timeout-option.ts": 2700, + "2691-retained-lowering-record-order.ts": 4234, + "2692-inline-record-assert-index.ts": 2826, + "2692-string-accumulation.ts": 2691, + "2693-math-constants.ts": 2761, + "2700-array-sort-complexity.ts": 2705, + "2700-http-static-trailers.ts": 2446, + "2700-wasi-core.ts": 2208, + "2701-array-sort-snapshot.ts": 2717, + "2701-http-static-trailer-wire.ts": 2689, + "2701-import-meta/main.mjs": 2846, + "2702-http-static-trailer-end.ts": 2522, + "2702-type-import-link-static/main.ts": 1984, + "2702-uint8array-to-sorted.ts": 2225, + "2703-array-sparse-sort.ts": 5044, + "2703-type-import-link-static-reexport/main.ts": 2359, + "2704-array-sparse-to-sorted.ts": 4461, + "2704-type-import-link-static-success/main.ts": 2324, + "2705-array-sparse-sort-append.ts": 5020, + "2705-type-import-link-dynamic/main.ts": 2074, + "2706-array-search-missing-needle.ts": 1941, + "2706-type-import-link-dynamic-success/main.ts": 2411, + "2707-array-search-huge-sparse.ts": 45551, + "2707-type-import-link-static-default-reexport/main.ts": 2522, + "2708-type-import-link-dynamic/main.ts": 2609, + "2720-array-read-parity.ts": 1979, + "2721-array-nested-missing-receiver.ts": 2483, + "2750-array-sparse-foundation.ts": 2217, + "2751-buffer-concat-sparse-list.ts": 2792, + "2752-array-optional-stores.ts": 2339, + "2753-array-optional-method-values.ts": 2060, + "2754-array-property-undefined.ts": 2275, + "2755-array-optional-literal-forwarding.ts": 2382, + "2780-array-parity-composition.ts": 6446, + "2781-array-missing-value-escape.ts": 1639, + "2782-array-sparse-callbacks.ts": 3365, + "2783-array-defaults-rest.ts": 2775, + "2784-array-reduce-missing-result.ts": 2916, + "2785-array-missing-destructuring.ts": 2952, + "2786-array-sparse-serialization.ts": 3296, + "2787-array-missing-string-arithmetic.ts": 2457, + "2788-array-missing-builtin-conversions.ts": 2610, + "2789-array-missing-optional-tostring.ts": 2734, + "2790-dynamic-import-self-name/main.ts": 2631, + "2791-record-optional-keys.ts": 1771, + "2792-record-optional-spread-entries.ts": 2836, + "2793-union-conversion-identity-capture.ts": 1991, + "2794-array-generic-callback-values.ts": 2454, + "2795-array-optional-typedarray-source.ts": 2778, + "2796-array-sparse-class-value-instanceof.ts": 1902, + "2800-array-expression-consumers.ts": 2537, + "2801-array-switch-consumers.ts": 2609, + "2820-array-missing-method-receivers.ts": 1866, + "2821-array-optional-numeric-comparisons.ts": 2322, + "2830-cjs-require-self-name/main.cjs": 1845, + "2840-finally-completions.ts": 2496, + "2841-using-sync.ts": 2927, + "2842-await-using.ts": 2618, + "2843-using-suppressed-error.ts": 2318, + "2844-node-disposable-resources.ts": 2824, + "2845-for-using-of.ts": 2486, + "2846-generator-using.ts": 2761, + "2850-async-generators-protocol.ts": 3258, + "2851-async-generators-values.ts": 2768, + "2852-timers-promises-interval.ts": 2398, + "2854-leading-bom-literals.ts": 1935, + "2855-searchparams-sort-complexity.ts": 2792, + "2856-dynamic-any-local-operators.ts": 2781, + "2857-branded-primitives.ts": 2351, + "2858-import-meta-resolve/main.mjs": 1967, + "2859-import-meta-resolve-dynamic/main.mjs": 1446, + "2860-require-resolve/main.cjs": 2029, + "2861-readable-iterator-close.ts": 3028, + "2862-web-readable-async-iteration.ts": 3505, + "2863-class-async-iterator.ts": 2866, + "2864-array-class-method-receivers.ts": 2760, + "2865-cjs-process-alias.cjs": 2491, + "2866-dyn-switch.ts": 1865, + "2867-array-shift-length.js": 1558, + "2868-empty-record-promise-presence.js": 2022, + "2869-nullish-mixed-lazy.ts": 2676, + "2870-and-dropped-truthy-arm.ts": 2329, + "2871-optional-promise-to-unknown.ts": 2191, + "2872-unobserved-dynamic-event.ts": 2513, + "2873-optional-receiver-loop-lifetime.js": 1923, + "2874-nullable-callback-field-cycle.js": 2614, + "2875-evolving-let-read-before-write.js": 2456, + "2876-class-unknown-roundtrip.ts": 2982, + "2877-child-unknown-roundtrip.ts": 2124, + "2878-class-private-unknown.cjs": 2900, + "2880-cjs-module-graph/main.cjs": 2229, + "2890-crypto-static-utility.ts": 3535, + "2891-json-record-key-escapes.ts": 3128, + "2892-windows-console-unicode.ts": 2483, + "2893-child-stdin-duplex.ts": 3150, + "2894-child-stdin-backpressure.ts": 2319, + "2895-child-stdin-write-after-end.ts": 3184, + "2896-child-stdin-write-after-finish.ts": 2909, + "2897-child-stdin-destroy.ts": 3007, + "2898-child-stdin-spawn-failure.ts": 2417, + "2899-nested-mutual-recursion.ts": 2782, + "2900-float64array-static.ts": 2797, + "2900-void-conditional-arrow.ts": 2455, + "2901-bigint-core.ts": 2012, + "2902-bigint-bytes.ts": 2175, + "2903-bigint-storage.ts": 2677, + "2904-bigint-errors.ts": 2992, + "2905-bigint-edges.ts": 2250, + "2906-bigint-wasi-width.ts": 2455, + "2910-overloaded-callable-alias.ts": 2480, + "2911-execfile-callback.ts": 2820, + "2912-execfile-callback-options.ts": 2673, + "2912-promisify-fs-readfile.ts": 1599, + "2913-builtin-callable-alias.ts": 2823, + "2914-fixed-tuple-call-spread.ts": 2909, + "2915-path-function-values.ts": 2957, + "2916-path-function-values-cjs.ts": 2512, + "2917-builtin-callable-widths.ts": 3024, + "2918-builtin-callable-widths-cjs.ts": 2656, + "2919-fs-function-values.ts": 3021, + "2920-fs-promises-function-values.ts": 2741, + "2921-zlib-callbacks.ts": 3153, + "2922-dyn-bitwise-not.cjs": 2708, + "2923-cjs-factory-export/main.cjs": 2093, + "2930-union-receiver-calls.ts": 2543, + "2931-union-dynamic-field-call.js": 2484, + "2932-create-require-program/main.ts": 2505, + "2933-static-dynamic-import/main.ts": 2593, + "2934-static-import-stored.ts": 2045, + "2935-module-namespace-values/main.ts": 2788, + "2936-static-loose-equality.ts": 3392, + "2937-bitwise-hot-loop.ts": 2487, + "2938-fs-sync-overloads.cjs": 1878, + "2939-child-shell-text.ts": 3433, + "2940-date-parse.ts": 2705, + "2940-fsp-realpath.ts": 2908, + "2941-fsp-lstat-identity.ts": 3091, + "2941-process-exit-code.ts": 2544, + "2942-fsp-readdir-dirent.ts": 3069, + "2942-process-exit-code-override.ts": 2534, + "2943-process-exit-code-invalid.ts": 2277, + "2944-process-exit-code-wrap.ts": 1815, + "2945-url-origin-username.ts": 2639, + "2946-child-fork-ipc/main.ts": 3716, + "2946-url-port-hash.ts": 1906, + "2947-set-readonly-seeds.ts": 2763, + "2948-child-fork-eof-callback/main.ts": 2163, + "2948-stdio-callback-record.ts": 2566, + "2949-child-fork-default/main.mjs": 3027, + "2949-url-password.ts": 1993, + "2950-fs-descriptor-publication.ts": 2687, + "2951-math-static-analytic.ts": 3185, + "2952-math-static-remaining.ts": 2865, + "2953-http-header-validation.ts": 2969, + "2954-http-outgoing-headers.ts": 3565, + "2955-http-static-state.ts": 2954, + "2956-http-static-informational.ts": 2194, + "2957-http-static-response-controls.ts": 3186, + "2961-emitter-computed-names.cjs": 1565, + "2962-emitter-computed-optional.ts": 2714, + "2963-child-fork-dispatch/main.ts": 3146, + "2964-indexed-compound.ts": 3331, + "2966-numeric-array-read-fusion.ts": 3033, + "2967-numeric-array-read-lifetime.ts": 2835, + "2968-numeric-array-borrow.ts": 2871, + "2969-scalar-record-results.ts": 2889, + "2970-constant-numeric-tables.ts": 3083, + "2971-constant-table-modules/main.ts": 2199, + "2972-http-static-distinct-snapshots.ts": 3234, + "2972-math-receiver-borrow.ts": 3625, + "2973-http-static-agent.ts": 2730, + "2973-integer-bitwise-arithmetic.ts": 2687, + "2974-array-search-from-index.ts": 104135, + "2974-http-static-module-values.ts": 2450, + "2974-numeric-remainder.ts": 3031, + "2975-bigint-default-radix.ts": 2379, + "2975-http-static-client-controls.ts": 2663, + "2976-http-static-incoming-state.ts": 2293, + "2976-json-stringify-no-arguments.js": 2688, + "2977-http-static-incoming-timeout.ts": 2143, + "2977-nested-array-binding-defaults.js": 2455, + "2978-http-static-client-timeout.ts": 2987, + "2978-regexp-optional-subject.js": 2083, + "2979-array-search-mixed-needles.js": 2924, + "2979-http-static-server-timeout.ts": 2502, + "2980-http-static-server-timeout-default.ts": 2655, + "2980-string-position-arguments.js": 2015, + "2981-http-static-events.ts": 2563, + "2981-string-optional-positions.ts": 2841, + "2982-http-static-close-all.ts": 1931, + "2982-string-position-coercion-order.js": 2986, + "2983-http-static-close-idle.ts": 2485, + "2984-http-static-close-upgrade.ts": 2815, + "2985-http-static-message-destroy.ts": 2511, + "2986-http-static-client-socket-finish.ts": 2889, + "2987-http-static-timeout-errors.ts": 2695, + "2988-http-static-client-abort.ts": 2770, + "2989-http-static-response-timeout-handled.ts": 2973, + "2990-http-static-request-timeout-handled.ts": 3045, + "2991-array-indexed-equality.ts": 3039, + "2992-stream-rows.ts": 1990, + "2993-fiber-stack-lifetimes.ts": 3353, + "2994-fromcharcode-scalar.ts": 2251, + "2995-math-hyperbolic.ts": 3028, + "2996-math-near-one.ts": 2750, + "2997-math-integer-float.ts": 2792, + "300-if-else.ts": 2615, + "3001-caught-typeof-object.js": 2565, + "3002-promise-then-two.ts": 3076, + "301-while.ts": 2690, + "302-for.ts": 2617, + "3020-string-last-index-position.ts": 2669, + "3021-buffer-union-narrow-callback.ts": 3133, + "3022-string-affix-positions.ts": 2471, + "3023-string-affix-position-coercion.js": 2793, + "3024-string-number-narrow-for-in.ts": 2773, + "3025-string-search-position-coercion.js": 2152, + "3026-array-last-index-of.js": 2967, + "3027-array-last-index-of-records.ts": 1994, + "3028-string-search-dynamic-needle.js": 2238, + "3029-string-search-union-needle.js": 2519, + "303-break-continue.ts": 2536, + "3030-array-search-no-arg.js": 2653, + "3031-array-relative-index-coercion.js": 3093, + "3031-string-last-index-search-value.js": 1619, + "3032-string-search-value.js": 2450, + "3033-string-search-needle-coercion.js": 2494, + "3034-arguments-with-parameters.js": 3025, + "3035-string-positioned-search-value.js": 3075, + "3036-string-object-search-value.js": 2233, + "3037-number-nullish-conversion.js": 2181, + "3038-number-scalar-unions.ts": 2410, + "3039-string-repeat-count.js": 2478, + "304-compound-incdec.ts": 2719, + "3040-string-prototype-call.js": 3243, + "3041-string-prototype-object-call.js": 2455, + "3042-string-padding-coercion.js": 3099, + "3043-string-split-arguments.js": 2355, + "3044-array-slice-splice-positions.js": 2214, + "3045-array-indexed-mutation.js": 3434, + "3046-array-indexed-ref-identity.ts": 2361, + "3047-object-prototype-tag.js": 3196, + "3048-object-own-prototype.ts": 3472, + "3049-array-flat-depth.ts": 1949, + "305-truthiness.ts": 2568, + "3050-array-splice-insert.ts": 3099, + "3051-array-join-default.ts": 1846, + "3052-array-construction.ts": 3399, + "3053-array-construction-js.js": 1676, + "3054-dynamic-abort-record.ts": 1731, + "3055-default-builtin-nodenext/main.ts": 2687, + "3056-default-builtin-bundler/main.ts": 2789, + "3057-default-builtin-nodenext-dynamic/main.ts": 2579, + "3058-optional-array-chain-join.ts": 2967, + "3059-arguments-property-names.ts": 2947, + "3061-concurrent-fiber-stacks.ts": 2717, + "3062-runtime-optional-record-guards.ts": 3531, + "3063-runtime-optional-class-guards.ts": 3234, + "3064-installed-entry-imports/main.ts": 2104, + "3065-installed-entry-js/main.js": 2454, + "3066-source-debugging/main.ts": 2680, + "3067-cjs-function-export-require/main.cjs": 2781, + "3068-debug-variables/main.ts": 2201, + "3068-url-checked-identity.ts": 3005, + "3069-set-checked-seed.js": 3167, + "3069-tuple-spread.ts": 3057, + "3070-checked-object-accessors.js": 3314, + "3070-collection-views.ts": 2586, + "3071-checked-specialization-narrowing.js": 2429, + "3071-map-contextual-record-seeds.ts": 2886, + "3072-optional-union-receivers.ts": 3001, + "3072-weak-process-streams.js": 2971, + "3073-optional-callable-module.js": 2030, + "3073-union-keyed-reads.ts": 3228, + "3074-discriminated-intersections.ts": 3008, + "3075-recursive-contextual-literals.ts": 3333, + "3076-nullish-record-defaults.ts": 3030, + "3077-optional-union-array-reads.ts": 2968, + "3078-forward-mutable-captures.ts": 1926, + "3079-forward-mutable-tdz.ts": 2889, + "3080-exhaustive-never-bindings.ts": 2787, + "3081-recursive-array-destinations.ts": 2576, + "3082-forward-write-unwind.ts": 2875, + "3083-set-string-seed.ts": 2684, + "3084-record-own-membership.ts": 3102, + "3085-conditional-record-construction.ts": 1925, + "3086-error-constructor-options.ts": 3227, + "3087-error-options-lifetime.ts": 2113, + "3088-array-wide-callbacks.ts": 2993, + "3089-array-find-narrowing.ts": 3128, + "3090-json-discriminated-records.ts": 3480, + "3091-json-recursive-discriminants.ts": 2300, + "3092-number-union-predicates.ts": 2639, + "3093-error-option-data.ts": 2191, + "3094-json-replacer-traversal.ts": 2898, + "3095-json-reviver-traversal.ts": 2824, + "3096-json-callback-nonfinite.ts": 1927, + "3097-json-callback-reentrancy.ts": 3321, + "3098-json-callback-space.ts": 2551, + "3099-json-callback-functions.ts": 3507, + "3100-json-callback-holder.js": 3048, + "3101-json-callback-bytes.ts": 2658, + "3102-json-unknown-fields.ts": 2725, + "3103-scalar-record-nested-control-flow.ts": 3195, + "3104-native-analysis-tables-loops.ts": 1557, + "3105-nullable-collections.ts": 1888, + "3106-mixed-insertion-spreads.ts": 3368, + "3107-nullable-collection-lifetimes.ts": 3149, + "3108-for-await-sync-arrays.js": 4447, + "3108-identity-map-keys.ts": 3401, + "3109-destructuring-unknown-defaults.js": 2735, + "3109-identity-union-collections.ts": 3270, + "3110-builtin-error-families.ts": 2441, + "3110-identity-collection-mutation.ts": 2906, + "3111-identity-collection-cycles.ts": 3069, + "3112-union-switch-control-flow.ts": 2641, + "3113-union-array-removal.ts": 3416, + "3114-union-record-field-write.ts": 3033, + "3115-zlib-static-compression-levels.ts": 2443, + "3116-sequence-expression-lifetimes.ts": 3044, + "3117-unknown-switch-control-flow.ts": 2684, + "3118-recursive-union-spread.ts": 2422, + "3119-runtime-optional-spread.ts": 2447, + "3120-dynamic-property-descriptors.js": 3293, + "3120-generator-method-loop-bindings.ts": 3248, + "3120-ir-nonfinite-numbers.ts": 3000, + "3121-compound-assignment-values.js": 2549, + "3121-dynamic-accessor-descriptors.js": 3250, + "3122-dynamic-delete-descriptors.cjs": 2600, + "3122-dynamic-delete-descriptors.js": 2091, + "3122-js-async-class-methods.js": 2297, + "3123-destructured-global-tdz.js": 2836, + "3124-array-prototype-borrow.js": 3537, + "3125-regex-global-match.ts": 2402, + "3126-js-number-radix/main.ts": 3052, + "3127-spawn-runtime-options.ts": 3285, + "3128-regex-last-index.ts": 3076, + "3129-js-token-union/main.ts": 2700, + "3130-child-generic-streams.ts": 3044, + "3131-child-rest-listeners.js": 2943, + "3132-child-generic-stream-completion.ts": 6235, + "3133-text-decoder-streaming.ts": 2265, + "3134-fs-vectors.ts": 2815, + "3135-fs-file-handle-controls.ts": 2278, + "3136-fs-file-handle-options.ts": 3814, + "3137-fs-vector-callbacks.cjs": 3509, + "3138-array-large-storage.ts": 4245, + "3139-regex-native-deep-alternatives.ts": 27587, + "3140-array-dense-access.ts": 3800, + "3141-map-string-key-hash.ts": 2566, + "3150-integer-remainder.ts": 3289, + "3151-array-push-writes.ts": 3227, + "3170-number-conversion-fast-paths.ts": 2553, + "3171-method-census-data-writes.ts": 3442, + "400-fib.ts": 2589, + "401-mutual-recursion.ts": 2527, + "402-string-functions.ts": 2176, + "403-void-and-params.ts": 2350, + "4030-runtime-object-truthiness.ts": 2749, + "4031-event-emitter-long-tuples.ts": 2083, + "4032-inline-rc-fast-paths.ts": 4192, + "404-rc-stress.ts": 2456, + "4040-adapted-function-identity.ts": 2867, + "4041-adapted-function-properties.ts": 2991, + "4042-object-is-union-subclass.ts": 2310, + "4043-nonnull-missing-element.ts": 2433, + "4044-adapted-callback-modules/main.ts": 2886, + "4045-optional-element-projections.ts": 3138, + "4046-captured-parameter-values.ts": 3423, + "4047-captured-parameter-rebinding.ts": 2500, + "405-params-optional.ts": 2755, + "406-params-defaults.ts": 2105, + "4060-cycle-shared-instance/main.ts": 2837, + "4060-stack-union-reads.ts": 3299, + "4061-cycle-evaluation-order/main.ts": 2712, + "4061-nullable-ref-fields.ts": 4653, + "4062-cycle-tdz-read/main.ts": 1857, + "4063-cycle-hoisted-calls/main.ts": 2616, + "4064-cycle-classes-after-init/main.ts": 2926, + "4065-cycle-init-throws/main.ts": 2592, + "4066-cycle-top-level-tdz/main.ts": 1456, + "4067-dynamic-import-cycle-tdz/main.ts": 2785, + "407-params-rest.ts": 2693, + "408-params-ctors-inheritance.ts": 2837, + "4080-optional-read-presence-tests.ts": 2357, + "4080-string-index-bounds.ts": 2174, + "4081-hoisted-function-tdz.ts": 3131, + "4081-string-index-unproven.ts": 2850, + "4082-hoisted-function-tdz-uncaught.ts": 2634, + "4083-dynamic-import-failure/main.ts": 2355, + "4084-record-optional-field-copies.ts": 2952, + "4085-generator-loop-close.ts": 3078, + "4086-optional-capture-defaults.ts": 2684, + "4088-class-static-tdz.ts": 2183, + "4089-class-wrapper-tdz.js": 2911, + "409-params-async-generics.ts": 1894, + "4090-computed-key-tdz.js": 2483, + "4091-class-evaluation-deferred.ts": 3134, + "410-params-rc-stress.ts": 1591, + "4140-array-callback-split-visit.ts": 4467, + "4141-array-callback-ambient-receiver/main.ts": 2178, + "4142-array-callback-factories.ts": 3521, + "4143-union-refinement-intersection-arms.ts": 3254, + "420-dead-strip-modules/main.ts": 2523, + "4290-acyclic-immutable-trees.ts": 3062, + "4291-acyclic-constructor-escapes.ts": 2390, + "4292-acyclic-readonly-bypass.ts": 1956, + "4293-acyclic-dynamic-writes.ts": 3149, + "4294-console-line-sizes.ts": 5491, + "4295-console-template-parts.ts": 3025, + "4296-console-glued-long-parts.ts": 4102, + "4410-inline-object-allocation.ts": 3371, + "4411-nullable-ref-values.ts": 3446, + "4412-nullable-record-values.ts": 3505, + "4413-cycle-old-late-death.ts": 3210, + "4413-nullable-null-and-undefined.ts": 3960, + "4414-cycle-old-weak-keys.ts": 2210, + "4414-nullable-string-values.ts": 3960, + "4415-identity-borrowed-operands.ts": 2923, + "4415-nullable-container-values.ts": 4078, + "4431-exception-pending-contexts.ts": 3547, + "4432-checked-downcast-failures.ts": 3362, + "4451-int32-field-storage.ts": 3587, + "4452-int32-field-dynamic-writes.ts": 2629, + "4453-int32-closed-locals.ts": 2708, "4454-int32-field-reflection-reads.ts": 3626, "4455-live-view-reads-without-stores.ts": 3673, - "4471-unassigned-field-reads.ts": 3309, - "4476-string-ascii-header-fact.ts": 2846, - "4477-buffer-write-ascii-runs.ts": 2125, - "4478-string-large-index-reads.ts": 3334, - "4481-array-optional-push.ts": 3059, - "4482-instanceof-static-class-optional.ts": 2994, - "4483-array-splice-statement.ts": 3331, - "4484-array-length-reset.ts": 2664, - "4485-array-splice-optional-item.ts": 2526, - "4486-array-field-element-borrows.ts": 2341, - "4487-array-literal-optional-values.ts": 2248, - "4520-optional-guard-narrowing.ts": 2281, - "4521-array-callback-element-presence.ts": 4131, - "4522-captured-parameter-lifetimes.ts": 2903, - "4523-array-pop-removal.ts": 2536, - "4524-array-callback-supertype-params.ts": 3251, - "4541-nullable-wrap-borrows.ts": 2882, - "4542-preserving-call-borrows.ts": 3130, - "4543-walk-borrowed-locals.ts": 3034, - "4544-checked-cast-aliases.ts": 2574, - "4545-borrowed-returns.ts": 3551, - "4546-rebound-borrowed-params.ts": 2811, - "4560-field-store-borrowed-receivers.ts": 3116, - "4561-virtual-borrowed-parameters.ts": 3237, - "4562-string-self-concat-move.ts": 2061, - "4563-array-read-projection-receivers.ts": 2512, - "4564-literal-choice-strings.ts": 2795, - "4568-for-of-hole-elements.ts": 2661, - "4569-shorthand-missing-elements.ts": 3064, - "4570-map-lookup-default-record.ts": 2901, - "4591-weak-keys-union-records.ts": 2778, - "4592-cycle-const-from-import/main.ts": 2529, - "4593-weak-keys-empty-objects.ts": 2806, - "4594-union-class-field-mixed-types.ts": 3153, - "4595-union-class-field-optional-receiver.ts": 1997, - "4596-error-subclass-int-fields.ts": 2606, - "4596-tdz-nullable-forward-capture.ts": 3433, - "4597-callback-field-method-name.ts": 2519, - "4598-live-array-ref-element-access.ts": 4363, - "4598-map-set-clear-reuse.ts": 4118, - "4598-os-available-parallelism.ts": 2474, - "4598-publish-constructor-stores.ts": 2635, - "4599-construction-only-field-borrows.ts": 3147, - "4600-construction-only-fields-dynamic-writes.ts": 2319, - "4601-cycle-holders.ts": 2904, - "4602-constructor-escape-order.ts": 2703, - "4610-array-ext-dyn-refresh.ts": 3049, - "4620-optional-chain-borrowed-receivers.ts": 3006, - "4621-edge-preserving-callees/main.ts": 2464, - "4630-contract-int32.ts": 2586, - "4630-reference-write-call-arguments.ts": 2892, - "4631-contract-nothrow.ts": 2842, - "4631-reference-write-aliases.ts": 2922, - "4632-contract-immutable.ts": 2582, - "4632-reference-write-loops-and-walks.ts": 2399, - "4633-contract-program-lifetime.ts": 3449, - "4633-reference-write-callbacks-returns.ts": 2678, - "4634-contract-program-lifetime-publish.ts": 4573, - "4634-optional-element-borrowed-returns.ts": 2111, - "4640-bitwise-identity-ranges.ts": 2671, - "4641-nothrow-try-catch.ts": 2141, - "4642-acyclic-contract.ts": 2859, - "4650-stale-property-narrowing.ts": 2759, - "4651-map-string-get-entry.ts": 3114, - "4652-stale-closure-binding-narrowing.ts": 3092, - "4660-typed-rest-spread-forwarding.ts": 2331, - "4671-scoped-array-read-borrows.ts": 2575, - "4690-cycle-bypass-long-lived.ts": 4228, - "4691-publish-constructor-self-alias.ts": 2964, - "4692-borrowed-result-mutating-callees.ts": 2766, - "4720-cold-throw-paths.ts": 3228, - "4721-integer-induction-numbers.ts": 2974, - "4730-touint32-large-magnitudes.ts": 2198, - "4731-string-mixed-ascii-slices.ts": 3160, - "4732-buffer-write-utf16le-runs.ts": 3120, - "4733-typed-array-read-compares.ts": 2977, - "4750-map-string-absent-filter.ts": 3464, - "4751-string-search-multibyte-needles.ts": 2454, - "4795-published-untyped-member-reads.ts": 3340, - "4806-uint32-loop-accumulators.ts": 2740, - "4810-union-identity-retags.ts": 4045, - "4811-union-retag-checked-cast.ts": 2819, - "4812-int32-wrapping-sums.ts": 3339, - "4813-typed-array-read-equality-bindings.ts": 3997, - "4820-sort-comparator-lent-arguments.ts": 2782, - "4821-callback-lent-arguments.ts": 3485, - "4822-stable-capture-reads.ts": 2483, - "4823-array-store-receivers.ts": 2858, - "4830-typed-teardown-chains.ts": 3292, - "4831-cycle-bypass-probe-windows.ts": 3738, - "4840-array-hole-free-prefix.ts": 3550, - "4860-int32-local-storage.ts": 3699, - "4870-array-pipeline-fusion.ts": 6694, - "4871-array-pipeline-analytics.ts": 4274, - "4872-array-pipeline-temporaries.ts": 7763, - "4875-stream-consumers-array-buffer.ts": 3017, - "4876-array-buffer-inspect.ts": 2569, - "4880-await-call-turn-order.ts": 2784, - "4881-await-call-exceptions.ts": 2757, - "4882-await-call-request-chain.ts": 2151, - "4883-await-values-and-hops.ts": 2520, - "4884-await-call-unhandled-sibling.ts": 2379, - "4885-await-call-checkpoints.ts": 2128, - "4890-regex-literal-sites.ts": 3484, - "4891-regex-plain-text-patterns.ts": 2502, - "4892-regex-exec-read-captures.ts": 3120, - "4900-bigint-division-cross-check.ts": 3532, - "4900-console-instances.ts": 3723, - "4901-bigint-radix-text.ts": 3090, - "4901-console-instance-errors.ts": 3055, - "4902-bigint-compound-assign.ts": 2449, - "4903-bigint-fixed-width.ts": 2818, - "4904-bigint-large-products.ts": 2953, - "4905-bigint-fixed-width-fusion.ts": 3047, - "4906-bigint-small-value-trees.ts": 3132, - "4907-bigint-random-trees.ts": 4068, - "4910-hole-free-prefix-upkeep.ts": 3149, - "4920-string-literal-switch.ts": 4588, - "4930-typed-record-reflection.ts": 4183, - "4931-typed-data-generic-walks.ts": 4062, - "4932-typed-json-unknown.ts": 3239, - "4940-async-return-adoption.ts": 2845, - "4941-async-return-adoption-try.ts": 3156, - "4942-async-return-adoption-values.ts": 3620, - "4943-async-return-adoption-interleaved.ts": 2831, - "4950-regex-compiled-captures.ts": 5723, - "4951-regex-compiled-last-index.ts": 3059, - "4952-regex-compiled-anchors-classes.ts": 2426, - "4953-regex-compiled-backtracking.ts": 3365, - "4954-regex-log-report.ts": 3193, - "4955-regex-compiled-differential.ts": 24862, - "4970-int32-call-abi.ts": 2508, - "4980-generator-early-exit-finally.ts": 2836, - "4981-generator-delegation-iterables.ts": 4874, - "4982-generator-sent-values.ts": 2242, - "4983-generator-reuse-iterables.ts": 3066, - "4984-generator-exceptions.ts": 2959, - "4985-generator-lazy-pipeline.ts": 2708, - "4986-generator-default-channels.ts": 3119, - "4987-generator-closures-methods.ts": 2675, - "4988-generator-async-interplay.ts": 2141, - "4989-generator-step-drives.ts": 4185, - "4990-lone-surrogates.ts": 3319, - "4991-lone-surrogate-halves.ts": 2978, - "4992-lone-surrogate-search.ts": 2759, - "4993-lone-surrogate-json.ts": 2994, - "4994-lone-surrogate-uri.ts": 2786, - "4995-lone-surrogate-regex.ts": 3169, - "4996-lone-surrogate-stdio.ts": 2201, - "4997-lone-surrogate-stdout-patch.js": 2754, - "4998-lone-surrogate-buffers.ts": 3060, - "4999-lone-surrogate-io.ts": 4219, - "500-array-basics.ts": 2646, - "501-array-push-pop.ts": 2128, - "5010-lifetime-region-generations.ts": 2950, - "5011-lifetime-region-outside-references.ts": 2816, - "5012-lifetime-region-shapes.ts": 3847, - "5013-lifetime-region-async.ts": 3198, - "5014-lifetime-region-nesting.ts": 2741, - "5015-lifetime-region-publish.ts": 2749, - "5016-lifetime-region-weak-keys.ts": 2541, - "5017-lifetime-region-cycles.ts": 2989, - "5018-lifetime-region-hierarchies.ts": 3642, - "5019-lifetime-region-values.ts": 2516, - "502-array-for-of.ts": 2614, - "5020-lifetime-region-large.ts": 3840, - "5021-lifetime-region-opaque-holders.ts": 2702, - "5022-lifetime-region-workers.ts": 3127, - "503-array-functions.ts": 2610, - "504-array-rc-stress.ts": 2247, - "5040-promise-all-race-turns.ts": 3415, - "5041-promise-all-turns.js": 5156, - "5042-async-generator-return-promise.ts": 3112, - "5043-async-generator-return-forms.ts": 3029, - "5045-generator-delegation-typed-next.ts": 3463, - "5046-generator-delegation-return-throw.ts": 2606, - "5047-generator-delegation-iterables-typed.ts": 4378, - "5048-generator-delegation-async.ts": 4885, - "5049-generator-delegation-edges.ts": 2538, - "5050-inherited-in-membership.ts": 3142, - "5051-typed-record-prototypes.ts": 3140, - "5052-class-for-in-unknown.ts": 2653, - "5053-json-replacer-arrays.ts": 4713, - "5054-required-field-delete.ts": 2632, - "5055-object-create-record-literal.ts": 2065, - "5056-generator-in-unknown.ts": 3903, - "5060-child-fork-exit-after-messages/main.ts": 2572, - "5061-child-fork-local-disconnect/main.ts": 3248, - "5062-child-fork-message-before-eof/main.ts": 4732, - "5065-global-increment-initializers.ts": 3985, - "5066-global-compound-updates.ts": 2635, - "5067-global-updates-in-functions.ts": 2589, - "5068-global-var-let-const-updates.ts": 2726, - "5069-global-update-modules/main.ts": 2372, - "5070-optional-read-bindings.ts": 2144, - "5071-optional-chain-scalars.ts": 2192, - "5072-optional-nullish-ternary.ts": 2587, - "5073-optional-results.ts": 2727, - "5074-optional-pop-shift.ts": 2568, - "5075-optional-reads-unchecked/main.ts": 4996, - "5076-optional-escapes.ts": 2735, - "5080-boolean-array-storage.ts": 5236, - "5081-boolean-array-dynamic-views.ts": 2815, - "5085-promise-allsettled-turns.ts": 3332, - "5086-promise-any-turns.ts": 3297, - "5087-promise-allsettled-any-dyn.js": 3767, - "5088-promise-combinator-thenables.js": 4248, - "5089-promise-settled-records.ts": 3528, - "5090-generator-finished-result-value.ts": 2964, - "5091-generator-delegation-arrays-strings.ts": 2768, - "5092-generator-delegation-sets-maps.ts": 3565, - "5095-console-count-group.ts": 2753, - "5096-console-assert-dir.ts": 4648, - "5097-console-table.ts": 2620, - "5098-console-time-warnings.ts": 6302, - "5099-console-methods-dynamic.cjs": 2644, - "510-array-map-filter-foreach.ts": 2991, - "511-array-indexof-includes.ts": 2657, - "5110-var-hoisting-early-reads.ts": 2806, - "5111-var-hoisting-closures-classes.ts": 2117, - "5112-var-hoisting-function-scope.ts": 2614, - "5113-tdz-let-const-class.ts": 3154, - "5114-var-hoisting-js.js": 4536, - "5115-regex-replace-compiled.ts": 2608, - "5116-regex-capture-reads.ts": 3064, - "5117-regex-log-report-spans.ts": 3404, - "5118-regex-replace-char-chains.ts": 2444, - "512-array-join-chains.ts": 2376, - "5120-frame-records.ts": 2615, - "5121-frame-objects.ts": 2616, - "5122-frame-result-slots.ts": 2622, - "5123-frame-reassigned.ts": 2564, - "5124-frame-objects-control.ts": 3061, - "5125-frame-mutating-methods.ts": 2527, - "5126-frame-returned-params.ts": 2697, - "5127-frame-loop-bindings.ts": 2824, - "513-array-methods-rc-stress.ts": 2641, - "5130-event-target-dispatch.js": 3752, - "5131-event-target-listener-errors.js": 3003, - "5132-event-target-typed.ts": 3341, - "5133-abort-signal-event-target.ts": 3302, - "5134-events-error-monitor.ts": 2664, - "5135-event-target-warnings.js": 2890, - "5136-events-error-monitor-string-name.ts": 2380, - "5137-events-error-monitor-computed-name.js": 3077, - "5138-events-error-monitor-shared-listener.ts": 2001, - "5139-event-target-listener-throw.ts": 1965, - "514-array-find-some-every.ts": 2998, - "5140-os-host-facts.ts": 3248, - "5141-os-constants.ts": 2402, - "5142-path-parse-format.ts": 2850, - "5145-path-matches-glob-basics.ts": 2904, - "5146-path-matches-glob-braces.ts": 4866, - "5147-path-matches-glob-extglob.ts": 2653, - "5148-path-matches-glob-classes.ts": 2765, - "5149-path-matches-glob-win32.ts": 2754, - "515-array-flatmap.ts": 3015, - "5150-small-array-inline-slots.ts": 3276, - "5155-cycle-header-types.ts": 3561, - "516-array-reduce.ts": 3293, - "5160-field-callback-receiver.ts": 3482, - "5161-field-callback-receiver-escape.ts": 2665, - "5162-field-method-reference-receiver.ts": 2779, - "5163-field-callback-receiver.cjs": 2875, - "5164-worker-field-callback-receiver.ts": 3147, - "5165-interface-method-dispatch.ts": 2641, - "5166-interface-method-values.ts": 4036, - "5167-interface-method-order.ts": 3679, - "5168-interface-method-hierarchy.ts": 4400, - "5169-interface-method-chains.ts": 2934, - "517-array-hof-index-args.ts": 2918, - "5170-string-scan-eviction.ts": 2885, - "5171-lone-surrogate-replace-seams.ts": 3463, - "5175-forin-typed-as-unknown.ts": 3333, - "5176-object-keys-typed-as-unknown.ts": 3148, - "5177-forin-dynamic-objects.ts": 2926, - "5178-forin-keys-js.js": 2135, - "5179-forin-typed-shapes.ts": 3197, - "518-array-sort.ts": 2699, - "518-promise-void-union-callbacks.ts": 1929, - "5180-interface-arrays.ts": 3267, - "5181-interface-array-methods.ts": 7443, - "5182-interface-array-boundaries.ts": 3225, - "5183-interface-property-reads.ts": 3018, - "5184-interface-property-objects.ts": 3161, - "5185-util-inherits.cjs": 3120, - "5186-util-inherits.ts": 3012, - "5187-util-deprecate.cjs": 3705, - "5188-util-deprecate-flags.cjs": 2866, - "5189-util-deprecate.ts": 2361, - "519-array-from-length.ts": 3817, - "519-promise-union-await-values.ts": 2296, - "5190-util-callbackify.cjs": 3512, - "5191-util-callbackify.ts": 2893, - "5192-util-debuglog.cjs": 3224, - "5193-util-debuglog.ts": 4346, - "5194-process-emit-warning-tick.cjs": 2199, - "5195-object-entries-typed-as-unknown.ts": 2787, - "5196-object-values-typed-as-unknown.ts": 2984, - "5197-object-entries-dynamic-objects.ts": 3371, - "5198-object-entries-values-js.js": 2819, - "5199-object-entries-identity.ts": 3133, - "520-map-basics.ts": 2629, - "5200-array-sort-keyed-numbers.ts": 3636, - "5201-array-sort-keyed-records.ts": 3559, - "5202-array-sort-keyed-lookalikes.ts": 3148, - "5203-typed-array-sort-default.ts": 6169, - "5204-typed-array-sort-comparators.ts": 4152, - "521-map-number-keys.ts": 2529, - "5210-process-memory-usage.ts": 3044, - "5211-process-identity.ts": 2815, - "5212-perf-marks-measures.ts": 2925, - "5213-perf-timing-errors.ts": 3203, - "5214-perf-entry-inspect.ts": 3164, - "5215-perf-timing-validation.js": 4384, - "5216-perf-spread-arguments.js": 3711, - "5217-perf-spread-typed.ts": 3324, - "522-map-foreach.ts": 2813, - "5220-url-parse-warnings.ts": 2906, - "5221-url-parse-shapes.ts": 2400, - "5222-url-parse-hosts.ts": 2972, - "5223-url-parse-query.ts": 2190, - "5224-url-format-objects.ts": 2681, - "5225-url-format-whatwg.ts": 2885, - "5226-url-resolve.ts": 2184, - "5227-url-legacy-dependency/main.ts": 3291, - "5228-url-domain-conversion.ts": 2624, - "5229-url-legacy-errors.cjs": 3698, - "523-map-ref-values.ts": 2904, - "5230-inline-union-fields.ts": 2318, - "5231-inline-union-field-kinds.ts": 3614, - "5232-inline-union-fields-dynamic.ts": 3502, - "5233-inline-union-fields-shapes.ts": 3338, - "5234-inline-union-class-fields.ts": 4285, - "5235-inline-union-fields-publish.ts": 2840, - "5236-inline-union-unchecked-reads.ts": 1998, - "5237-inline-union-frame-objects.ts": 2284, - "524-map-cycles.ts": 3272, - "5240-event-target-subclass.ts": 3668, - "5241-event-subclass.ts": 4201, - "5242-event-target-subclass-hierarchy.ts": 2218, - "5243-event-target-subclass-dynamic.ts": 2613, - "5244-event-target-subclass.js": 3715, - "5245-event-target-subclass-signals.ts": 3077, - "5246-event-target-subclass-listener-throw.ts": 2770, - "5247-event-target-subclass-lifetimes.ts": 3603, - "5248-event-target-subclass-warnings.ts": 2743, - "5249-event-target-subclass-unconstructed.ts": 1632, - "525-map-rc-stress.ts": 3853, + "4471-unassigned-field-reads.ts": 3063, + "4476-string-ascii-header-fact.ts": 3053, + "4477-buffer-write-ascii-runs.ts": 1845, + "4478-string-large-index-reads.ts": 2385, + "4481-array-optional-push.ts": 2921, + "4482-instanceof-static-class-optional.ts": 2110, + "4483-array-splice-statement.ts": 3260, + "4484-array-length-reset.ts": 2963, + "4485-array-splice-optional-item.ts": 3033, + "4486-array-field-element-borrows.ts": 2099, + "4487-array-literal-optional-values.ts": 2387, + "4520-optional-guard-narrowing.ts": 3290, + "4521-array-callback-element-presence.ts": 4205, + "4522-captured-parameter-lifetimes.ts": 3072, + "4523-array-pop-removal.ts": 2939, + "4524-array-callback-supertype-params.ts": 4250, + "4541-nullable-wrap-borrows.ts": 2850, + "4542-preserving-call-borrows.ts": 3298, + "4543-walk-borrowed-locals.ts": 3324, + "4544-checked-cast-aliases.ts": 2878, + "4545-borrowed-returns.ts": 3935, + "4546-rebound-borrowed-params.ts": 2128, + "4560-field-store-borrowed-receivers.ts": 3268, + "4561-virtual-borrowed-parameters.ts": 2119, + "4562-string-self-concat-move.ts": 2875, + "4563-array-read-projection-receivers.ts": 2961, + "4564-literal-choice-strings.ts": 3091, + "4568-for-of-hole-elements.ts": 3194, + "4569-shorthand-missing-elements.ts": 2799, + "4570-map-lookup-default-record.ts": 2885, + "4591-weak-keys-union-records.ts": 3283, + "4592-cycle-const-from-import/main.ts": 2283, + "4593-weak-keys-empty-objects.ts": 1759, + "4594-union-class-field-mixed-types.ts": 3165, + "4595-union-class-field-optional-receiver.ts": 2742, + "4596-error-subclass-int-fields.ts": 2574, + "4596-tdz-nullable-forward-capture.ts": 3762, + "4597-callback-field-method-name.ts": 3397, + "4598-live-array-ref-element-access.ts": 4852, + "4598-map-set-clear-reuse.ts": 4729, + "4598-os-available-parallelism.ts": 2510, + "4598-publish-constructor-stores.ts": 1852, + "4599-construction-only-field-borrows.ts": 3236, + "4600-construction-only-fields-dynamic-writes.ts": 3072, + "4601-cycle-holders.ts": 2734, + "4602-constructor-escape-order.ts": 2610, + "4610-array-ext-dyn-refresh.ts": 2862, + "4620-optional-chain-borrowed-receivers.ts": 3224, + "4621-edge-preserving-callees/main.ts": 3365, + "4630-contract-int32.ts": 2754, + "4630-reference-write-call-arguments.ts": 3053, + "4631-contract-nothrow.ts": 2070, + "4631-reference-write-aliases.ts": 2695, + "4632-contract-immutable.ts": 2863, + "4632-reference-write-loops-and-walks.ts": 3098, + "4633-contract-program-lifetime.ts": 3689, + "4633-reference-write-callbacks-returns.ts": 3144, + "4634-contract-program-lifetime-publish.ts": 4904, + "4634-optional-element-borrowed-returns.ts": 2709, + "4640-bitwise-identity-ranges.ts": 2778, + "4641-nothrow-try-catch.ts": 2708, + "4642-acyclic-contract.ts": 3288, + "4650-stale-property-narrowing.ts": 3851, + "4651-map-string-get-entry.ts": 3371, + "4652-stale-closure-binding-narrowing.ts": 3495, + "4660-typed-rest-spread-forwarding.ts": 2766, + "4671-scoped-array-read-borrows.ts": 3085, + "4690-cycle-bypass-long-lived.ts": 2735, + "4691-publish-constructor-self-alias.ts": 3219, + "4692-borrowed-result-mutating-callees.ts": 2601, + "4720-cold-throw-paths.ts": 3390, + "4721-integer-induction-numbers.ts": 2467, + "4730-touint32-large-magnitudes.ts": 3097, + "4731-string-mixed-ascii-slices.ts": 2704, + "4732-buffer-write-utf16le-runs.ts": 1998, + "4733-typed-array-read-compares.ts": 3234, + "4750-map-string-absent-filter.ts": 3594, + "4751-string-search-multibyte-needles.ts": 2725, + "4795-published-untyped-member-reads.ts": 3268, + "4806-uint32-loop-accumulators.ts": 3231, + "4810-union-identity-retags.ts": 4620, + "4811-union-retag-checked-cast.ts": 3091, + "4812-int32-wrapping-sums.ts": 3463, + "4813-typed-array-read-equality-bindings.ts": 4674, + "4820-sort-comparator-lent-arguments.ts": 4000, + "4821-callback-lent-arguments.ts": 2333, + "4822-stable-capture-reads.ts": 2409, + "4823-array-store-receivers.ts": 2969, + "4830-typed-teardown-chains.ts": 2905, + "4831-cycle-bypass-probe-windows.ts": 2840, + "4840-array-hole-free-prefix.ts": 2459, + "4860-int32-local-storage.ts": 4170, + "4870-array-pipeline-fusion.ts": 7346, + "4871-array-pipeline-analytics.ts": 4533, + "4872-array-pipeline-temporaries.ts": 7994, + "4875-stream-consumers-array-buffer.ts": 3281, + "4876-array-buffer-inspect.ts": 2814, + "4880-await-call-turn-order.ts": 1921, + "4881-await-call-exceptions.ts": 3225, + "4882-await-call-request-chain.ts": 3022, + "4883-await-values-and-hops.ts": 2825, + "4884-await-call-unhandled-sibling.ts": 2163, + "4885-await-call-checkpoints.ts": 2954, + "4890-regex-literal-sites.ts": 3163, + "4891-regex-plain-text-patterns.ts": 2001, + "4892-regex-exec-read-captures.ts": 3652, + "4900-bigint-division-cross-check.ts": 3357, + "4900-console-instances.ts": 3637, + "4901-bigint-radix-text.ts": 2779, + "4901-console-instance-errors.ts": 3196, + "4902-bigint-compound-assign.ts": 1706, + "4903-bigint-fixed-width.ts": 3128, + "4904-bigint-large-products.ts": 3340, + "4905-bigint-fixed-width-fusion.ts": 3031, + "4906-bigint-small-value-trees.ts": 3759, + "4907-bigint-random-trees.ts": 5188, + "4910-hole-free-prefix-upkeep.ts": 3084, + "4920-string-literal-switch.ts": 3310, + "4930-typed-record-reflection.ts": 4737, + "4931-typed-data-generic-walks.ts": 4118, + "4932-typed-json-unknown.ts": 3475, + "4940-async-return-adoption.ts": 3491, + "4941-async-return-adoption-try.ts": 3096, + "4942-async-return-adoption-values.ts": 2964, + "4943-async-return-adoption-interleaved.ts": 2876, + "4950-regex-compiled-captures.ts": 4852, + "4951-regex-compiled-last-index.ts": 2706, + "4952-regex-compiled-anchors-classes.ts": 2724, + "4953-regex-compiled-backtracking.ts": 4297, + "4954-regex-log-report.ts": 3687, + "4955-regex-compiled-differential.ts": 13757, + "4970-int32-call-abi.ts": 3580, + "4980-generator-early-exit-finally.ts": 3050, + "4981-generator-delegation-iterables.ts": 4127, + "4982-generator-sent-values.ts": 2957, + "4983-generator-reuse-iterables.ts": 3475, + "4984-generator-exceptions.ts": 3390, + "4985-generator-lazy-pipeline.ts": 3419, + "4986-generator-default-channels.ts": 3152, + "4987-generator-closures-methods.ts": 3151, + "4988-generator-async-interplay.ts": 2316, + "4989-generator-step-drives.ts": 3427, + "4990-lone-surrogates.ts": 3491, + "4991-lone-surrogate-halves.ts": 3293, + "4992-lone-surrogate-search.ts": 2456, + "4993-lone-surrogate-json.ts": 3728, + "4994-lone-surrogate-uri.ts": 1777, + "4995-lone-surrogate-regex.ts": 2799, + "4996-lone-surrogate-stdio.ts": 3100, + "4997-lone-surrogate-stdout-patch.js": 1716, + "4998-lone-surrogate-buffers.ts": 3414, + "4999-lone-surrogate-io.ts": 2886, + "500-array-basics.ts": 2955, + "501-array-push-pop.ts": 1902, + "5010-lifetime-region-generations.ts": 3477, + "5011-lifetime-region-outside-references.ts": 2843, + "5012-lifetime-region-shapes.ts": 4150, + "5013-lifetime-region-async.ts": 3814, + "5014-lifetime-region-nesting.ts": 2997, + "5015-lifetime-region-publish.ts": 2741, + "5016-lifetime-region-weak-keys.ts": 3235, + "5017-lifetime-region-cycles.ts": 3057, + "5018-lifetime-region-hierarchies.ts": 4043, + "5019-lifetime-region-values.ts": 2895, + "502-array-for-of.ts": 2808, + "5020-lifetime-region-large.ts": 3808, + "5021-lifetime-region-opaque-holders.ts": 3422, + "5022-lifetime-region-workers.ts": 2531, + "503-array-functions.ts": 2837, + "504-array-rc-stress.ts": 2722, + "5040-promise-all-race-turns.ts": 3860, + "5041-promise-all-turns.js": 3644, + "5042-async-generator-return-promise.ts": 3304, + "5043-async-generator-return-forms.ts": 3190, + "5045-generator-delegation-typed-next.ts": 3751, + "5046-generator-delegation-return-throw.ts": 2749, + "5047-generator-delegation-iterables-typed.ts": 4798, + "5048-generator-delegation-async.ts": 3315, + "5049-generator-delegation-edges.ts": 3539, + "5050-inherited-in-membership.ts": 3427, + "5051-typed-record-prototypes.ts": 2418, + "5052-class-for-in-unknown.ts": 3692, + "5053-json-replacer-arrays.ts": 3781, + "5054-required-field-delete.ts": 2108, + "5055-object-create-record-literal.ts": 2773, + "5056-generator-in-unknown.ts": 2634, + "5060-child-fork-exit-after-messages/main.ts": 2129, + "5061-child-fork-local-disconnect/main.ts": 3136, + "5062-child-fork-message-before-eof/main.ts": 3024, + "5065-global-increment-initializers.ts": 2900, + "5066-global-compound-updates.ts": 3224, + "5067-global-updates-in-functions.ts": 2208, + "5068-global-var-let-const-updates.ts": 2542, + "5069-global-update-modules/main.ts": 1962, + "5070-optional-read-bindings.ts": 2623, + "5071-optional-chain-scalars.ts": 2743, + "5072-optional-nullish-ternary.ts": 2840, + "5073-optional-results.ts": 3242, + "5074-optional-pop-shift.ts": 2144, + "5075-optional-reads-unchecked/main.ts": 3167, + "5076-optional-escapes.ts": 2155, + "5080-boolean-array-storage.ts": 4783, + "5081-boolean-array-dynamic-views.ts": 2550, + "5085-promise-allsettled-turns.ts": 4142, + "5086-promise-any-turns.ts": 3722, + "5087-promise-allsettled-any-dyn.js": 5509, + "5088-promise-combinator-thenables.js": 4706, + "5089-promise-settled-records.ts": 3855, + "5090-generator-finished-result-value.ts": 2787, + "5091-generator-delegation-arrays-strings.ts": 4059, + "5092-generator-delegation-sets-maps.ts": 3822, + "5095-console-count-group.ts": 3219, + "5096-console-assert-dir.ts": 3665, + "5097-console-table.ts": 2407, + "5098-console-time-warnings.ts": 5609, + "5099-console-methods-dynamic.cjs": 3155, + "510-array-map-filter-foreach.ts": 2313, + "511-array-indexof-includes.ts": 2884, + "5110-var-hoisting-early-reads.ts": 2759, + "5111-var-hoisting-closures-classes.ts": 2869, + "5112-var-hoisting-function-scope.ts": 2697, + "5113-tdz-let-const-class.ts": 2402, + "5114-var-hoisting-js.js": 2192, + "5115-regex-replace-compiled.ts": 2826, + "5116-regex-capture-reads.ts": 3329, + "5117-regex-log-report-spans.ts": 3686, + "5118-regex-replace-char-chains.ts": 2917, + "512-array-join-chains.ts": 1729, + "5120-frame-records.ts": 2763, + "5121-frame-objects.ts": 2346, + "5122-frame-result-slots.ts": 3086, + "5123-frame-reassigned.ts": 2807, + "5124-frame-objects-control.ts": 2789, + "5125-frame-mutating-methods.ts": 2122, + "5126-frame-returned-params.ts": 2597, + "5127-frame-loop-bindings.ts": 2498, + "513-array-methods-rc-stress.ts": 3202, + "5130-event-target-dispatch.js": 4435, + "5131-event-target-listener-errors.js": 1856, + "5132-event-target-typed.ts": 2296, + "5133-abort-signal-event-target.ts": 3474, + "5134-events-error-monitor.ts": 2972, + "5135-event-target-warnings.js": 2909, + "5136-events-error-monitor-string-name.ts": 2529, + "5137-events-error-monitor-computed-name.js": 3132, + "5138-events-error-monitor-shared-listener.ts": 2744, + "5139-event-target-listener-throw.ts": 2800, + "514-array-find-some-every.ts": 3281, + "5140-os-host-facts.ts": 3044, + "5141-os-constants.ts": 3300, + "5142-path-parse-format.ts": 2224, + "5145-path-matches-glob-basics.ts": 2906, + "5146-path-matches-glob-braces.ts": 5151, + "5147-path-matches-glob-extglob.ts": 2798, + "5148-path-matches-glob-classes.ts": 2450, + "5149-path-matches-glob-win32.ts": 3351, + "515-array-flatmap.ts": 3014, + "5150-small-array-inline-slots.ts": 3873, + "5155-cycle-header-types.ts": 3715, + "516-array-reduce.ts": 3532, + "5160-field-callback-receiver.ts": 3321, + "5161-field-callback-receiver-escape.ts": 2766, + "5162-field-method-reference-receiver.ts": 2634, + "5163-field-callback-receiver.cjs": 3329, + "5164-worker-field-callback-receiver.ts": 3447, + "5165-interface-method-dispatch.ts": 3406, + "5166-interface-method-values.ts": 4300, + "5167-interface-method-order.ts": 3903, + "5168-interface-method-hierarchy.ts": 5186, + "5169-interface-method-chains.ts": 2434, + "517-array-hof-index-args.ts": 3100, + "5170-string-scan-eviction.ts": 1929, + "5171-lone-surrogate-replace-seams.ts": 2824, + "5175-forin-typed-as-unknown.ts": 2364, + "5176-object-keys-typed-as-unknown.ts": 1967, + "5177-forin-dynamic-objects.ts": 2917, + "5178-forin-keys-js.js": 3039, + "5179-forin-typed-shapes.ts": 3389, + "518-array-sort.ts": 3117, + "518-promise-void-union-callbacks.ts": 2562, + "5180-interface-arrays.ts": 3202, + "5181-interface-array-methods.ts": 6982, + "5182-interface-array-boundaries.ts": 3287, + "5183-interface-property-reads.ts": 3238, + "5184-interface-property-objects.ts": 3177, + "5185-util-inherits.cjs": 3654, + "5186-util-inherits.ts": 3139, + "5187-util-deprecate.cjs": 2383, + "5188-util-deprecate-flags.cjs": 2907, + "5189-util-deprecate.ts": 2180, + "519-array-from-length.ts": 2896, + "519-promise-union-await-values.ts": 2702, + "5190-util-callbackify.cjs": 3059, + "5191-util-callbackify.ts": 3126, + "5192-util-debuglog.cjs": 3809, + "5193-util-debuglog.ts": 2614, + "5194-process-emit-warning-tick.cjs": 2394, + "5195-object-entries-typed-as-unknown.ts": 3883, + "5196-object-values-typed-as-unknown.ts": 3399, + "5197-object-entries-dynamic-objects.ts": 3397, + "5198-object-entries-values-js.js": 2635, + "5199-object-entries-identity.ts": 3121, + "520-map-basics.ts": 2823, + "5200-array-sort-keyed-numbers.ts": 4287, + "5201-array-sort-keyed-records.ts": 4564, + "5202-array-sort-keyed-lookalikes.ts": 3516, + "5203-typed-array-sort-default.ts": 6009, + "5204-typed-array-sort-comparators.ts": 4333, + "521-map-number-keys.ts": 2785, + "5210-process-memory-usage.ts": 2299, + "5211-process-identity.ts": 3103, + "5212-perf-marks-measures.ts": 3829, + "5213-perf-timing-errors.ts": 3477, + "5214-perf-entry-inspect.ts": 4088, + "5215-perf-timing-validation.js": 3386, + "5216-perf-spread-arguments.js": 4128, + "5217-perf-spread-typed.ts": 3454, + "522-map-foreach.ts": 2702, + "5220-url-parse-warnings.ts": 2881, + "5221-url-parse-shapes.ts": 1930, + "5222-url-parse-hosts.ts": 3064, + "5223-url-parse-query.ts": 3104, + "5224-url-format-objects.ts": 3496, + "5225-url-format-whatwg.ts": 2608, + "5226-url-resolve.ts": 2695, + "5227-url-legacy-dependency/main.ts": 2825, + "5228-url-domain-conversion.ts": 2843, + "5229-url-legacy-errors.cjs": 3833, + "523-map-ref-values.ts": 3192, + "5230-inline-union-fields.ts": 2629, + "5231-inline-union-field-kinds.ts": 2513, + "5232-inline-union-fields-dynamic.ts": 3917, + "5233-inline-union-fields-shapes.ts": 3689, + "5234-inline-union-class-fields.ts": 3417, + "5235-inline-union-fields-publish.ts": 2910, + "5236-inline-union-unchecked-reads.ts": 2919, + "5237-inline-union-frame-objects.ts": 2775, + "524-map-cycles.ts": 2820, + "5240-event-target-subclass.ts": 4712, + "5241-event-subclass.ts": 3442, + "5242-event-target-subclass-hierarchy.ts": 3429, + "5243-event-target-subclass-dynamic.ts": 3827, + "5244-event-target-subclass.js": 3772, + "5245-event-target-subclass-signals.ts": 3197, + "5246-event-target-subclass-listener-throw.ts": 1982, + "5247-event-target-subclass-lifetimes.ts": 4315, + "5248-event-target-subclass-warnings.ts": 2798, + "5249-event-target-subclass-unconstructed.ts": 2600, + "525-map-rc-stress.ts": 2751, "5250-cipher-aes-gcm.ts": 6095, "5251-cipher-aes-cbc.ts": 3544, "5252-cipher-aes-ctr.ts": 2536, @@ -1702,45 +1702,45 @@ "5257-cipher-vectors.ts": 3374, "5258-cipher-handles.js": 2798, "5259-cipher-chunked.ts": 3781, - "526-set-basics.ts": 1919, - "5260-record-unknown-identity.ts": 2937, - "5261-optional-field-identity.ts": 2860, - "5262-record-unknown-many.ts": 2984, - "527-set-foreach.ts": 3210, - "5270-url-parse-no-deprecation.cjs": 3158, - "5271-url-parse-throw-deprecation.cjs": 2975, - "5275-http-end-callback-order.ts": 2389, - "5276-style-text-hex-colors.cjs": 2820, - "5277-fs-read-file-buffer-option.cjs": 2710, - "5278-host-null-bytes.cjs": 2114, - "5279-search-params-null-init.cjs": 1781, - "528-set-seeded.ts": 2610, - "5285-blob-construct.ts": 2681, - "5286-blob-readers.ts": 3079, - "5287-blob-inspect.ts": 3817, - "5288-blob-validation.js": 3803, - "5289-blob-read-order.ts": 2829, - "529-map-seeded.ts": 2574, - "5290-blob-dynamic.js": 2354, - "5295-readline-promises-question.ts": 3709, - "5296-readline-lines.ts": 2760, - "5297-readline-callback-events.cjs": 2472, - "5298-readline-abort.cjs": 2757, - "5299-readline-stdin.ts": 3087, - "530-record-arrays.ts": 2787, - "5300-stream-add-abort-signal.ts": 3027, - "5301-stream-add-abort-signal-errors.cjs": 2717, - "5302-stream-promises-options.ts": 3120, - "5303-stream-finished-callback-opts.cjs": 2705, - "5305-json-stringify-typed-arrays.ts": 3153, - "531-record-array-hofs.ts": 2832, - "5315-map-iterate-after-front-deletes.ts": 3911, - "5316-map-lru-eviction.ts": 2782, - "5317-map-iterate-while-mutating.ts": 2769, - "5318-set-iterate-after-deletes.ts": 2291, - "5319-map-iteration-values.ts": 2689, - "532-record-arrays-rc-stress.ts": 2437, - "5320-map-iterate-across-compaction.ts": 3526, + "526-set-basics.ts": 2514, + "5260-record-unknown-identity.ts": 3342, + "5261-optional-field-identity.ts": 2813, + "5262-record-unknown-many.ts": 2768, + "527-set-foreach.ts": 2947, + "5270-url-parse-no-deprecation.cjs": 3204, + "5271-url-parse-throw-deprecation.cjs": 3229, + "5275-http-end-callback-order.ts": 3224, + "5276-style-text-hex-colors.cjs": 2193, + "5277-fs-read-file-buffer-option.cjs": 1864, + "5278-host-null-bytes.cjs": 2972, + "5279-search-params-null-init.cjs": 1662, + "528-set-seeded.ts": 1937, + "5285-blob-construct.ts": 3802, + "5286-blob-readers.ts": 2609, + "5287-blob-inspect.ts": 2930, + "5288-blob-validation.js": 4282, + "5289-blob-read-order.ts": 3276, + "529-map-seeded.ts": 2575, + "5290-blob-dynamic.js": 3409, + "5295-readline-promises-question.ts": 2860, + "5296-readline-lines.ts": 3085, + "5297-readline-callback-events.cjs": 2092, + "5298-readline-abort.cjs": 3384, + "5299-readline-stdin.ts": 2909, + "530-record-arrays.ts": 3090, + "5300-stream-add-abort-signal.ts": 2505, + "5301-stream-add-abort-signal-errors.cjs": 3168, + "5302-stream-promises-options.ts": 2812, + "5303-stream-finished-callback-opts.cjs": 2840, + "5305-json-stringify-typed-arrays.ts": 4425, + "531-record-array-hofs.ts": 3107, + "5315-map-iterate-after-front-deletes.ts": 3372, + "5316-map-lru-eviction.ts": 2980, + "5317-map-iterate-while-mutating.ts": 3025, + "5318-set-iterate-after-deletes.ts": 2325, + "5319-map-iteration-values.ts": 2767, + "532-record-arrays-rc-stress.ts": 2605, + "5320-map-iterate-across-compaction.ts": 3341, "5321-integer-closed-arithmetic-loops.ts": 2935, "5321-json-parse-cycles.ts": 2739, "5322-integer-variable-step-loops.ts": 2732, @@ -1749,29 +1749,29 @@ "5323-int32-nonnegative-slot-facts.ts": 2925, "5324-int32-initializer-locals.ts": 2126, "5324-structured-clone-documents.ts": 3093, - "5325-record-boundary-returns.ts": 1763, - "5326-record-boundary-params.ts": 2634, - "5327-record-boundary-identity.ts": 2323, - "5328-record-boundary-open.ts": 2561, - "5329-record-boundary-recursion.ts": 2680, - "533-array-element-cycles.ts": 2932, - "5330-record-boundary-fields.ts": 1977, - "5331-record-boundary-methods.ts": 3130, + "5325-record-boundary-returns.ts": 2952, + "5326-record-boundary-params.ts": 3045, + "5327-record-boundary-identity.ts": 2913, + "5328-record-boundary-open.ts": 2787, + "5329-record-boundary-recursion.ts": 2543, + "533-array-element-cycles.ts": 2595, + "5330-record-boundary-fields.ts": 2690, + "5331-record-boundary-methods.ts": 2941, "5332-int32-narrowed-slot-facts.ts": 3036, "5333-integer-guarded-while-counters.ts": 2907, - "5333-record-boundary-nullable-argument.ts": 3012, - "5334-fetch-mentions-without-calls.ts": 2532, + "5333-record-boundary-nullable-argument.ts": 3066, + "5334-fetch-mentions-without-calls.ts": 2537, "5335-stream-operators-values.ts": 3463, - "5335-top-level-await-pending-exit-code.ts": 1919, + "5335-top-level-await-pending-exit-code.ts": 2626, "5336-stream-operators-promise-timing.ts": 3056, - "5336-top-level-await-pending-exit-listener.ts": 3734, - "5337-dc-subscriber-throw-next-tick.cjs": 2604, + "5336-top-level-await-pending-exit-listener.ts": 2547, + "5337-dc-subscriber-throw-next-tick.cjs": 2655, "5337-stream-operators-concurrency.ts": 2539, - "5338-js-tdz-function-element.js": 2562, + "5338-js-tdz-function-element.js": 2247, "5338-stream-operators-checks.cjs": 3619, - "5339-array-buffer-constructor.js": 2502, + "5339-array-buffer-constructor.js": 3106, "5339-stream-for-await-hops.ts": 2525, - "534-record-width-subtyping.ts": 2615, + "534-record-width-subtyping.ts": 2764, "5340-readable-from-options.ts": 3427, "5341-compound-any-operand.ts": 3571, "5341-generator-callback-params.ts": 3696, @@ -1787,28 +1787,28 @@ "5343-stream-compose-edges.ts": 3167, "5344-json-parse-undeclared-keys.ts": 4016, "5344-stream-pipeline-timing.ts": 3216, - "5345-object-values-for-of-unknown.ts": 3008, - "5346-object-values-length-dynamic.ts": 3055, - "5347-object-values-loop-control.ts": 3030, - "5348-object-values-for-of-js.js": 2732, - "5349-object-entries-values-optional.ts": 2083, - "535-object-statics.ts": 2312, - "5350-object-values-wide-record.ts": 2790, - "5351-object-values-methods-index.ts": 3275, + "5345-object-values-for-of-unknown.ts": 2662, + "5346-object-values-length-dynamic.ts": 3253, + "5347-object-values-loop-control.ts": 3534, + "5348-object-values-for-of-js.js": 3133, + "5349-object-entries-values-optional.ts": 3434, + "535-object-statics.ts": 3684, + "5350-object-values-wide-record.ts": 3383, + "5351-object-values-methods-index.ts": 4044, "5352-final-field-loop-reads.ts": 2982, "5353-captured-const-values.ts": 3255, "5354-captured-const-tdz.ts": 1913, "5355-captured-function-declarations.ts": 2960, "5356-captured-tdz-ordering.ts": 2164, "5357-init-only-module-bindings.ts": 3203, - "536-map-seed-array.ts": 2712, - "5360-array-sort-comparator-calls.ts": 3175, - "5361-array-sort-inconsistent-comparators.ts": 3161, - "5362-array-sort-comparator-throws.ts": 2896, - "5363-array-sort-comparator-writes.ts": 6813, - "5364-array-sort-union-and-boolean-elements.ts": 8514, - "5365-array-sort-dynamic-values.js": 2402, - "537-map-iter-drains.ts": 2867, + "536-map-seed-array.ts": 2803, + "5360-array-sort-comparator-calls.ts": 2961, + "5361-array-sort-inconsistent-comparators.ts": 2659, + "5362-array-sort-comparator-throws.ts": 2991, + "5363-array-sort-comparator-writes.ts": 5900, + "5364-array-sort-union-and-boolean-elements.ts": 10497, + "5365-array-sort-dynamic-values.js": 3189, + "537-map-iter-drains.ts": 2987, "5370-zlib-stream-roundtrip.ts": 3454, "5371-zlib-stream-chunking.cjs": 3925, "5372-zlib-stream-errors.cjs": 2700, @@ -1819,29 +1819,29 @@ "5377-zlib-stream-backpressure.cjs": 3427, "5378-zlib-sync-options.cjs": 2176, "5379-zlib-callback-options.ts": 3566, - "538-map-set-for-of.ts": 2756, - "5390-interface-loop-element-lifetimes.ts": 2999, - "5391-interface-dispatch-hierarchies.ts": 3168, - "5392-interface-receiver-bindings.ts": 2015, - "5393-interface-array-holes.ts": 2530, - "5394-interface-implementers.ts": 2992, - "5395-locale-compare-ascii.ts": 3026, - "5396-locale-compare-latin.ts": 3119, - "5397-locale-compare-sorting.ts": 3179, - "540-tuples-basics.ts": 2776, - "5400-json-parse-typed-keys.ts": 3131, - "5405-buffer-arraybuffer-window.ts": 2729, - "5406-util-types-keys.ts": 2747, - "5407-http-header-field-limit.ts": 2785, - "5408-http-unread-request-end.ts": 3226, - "5409-http-held-request-body.ts": 3218, - "541-ref-array-json.ts": 3099, - "5410-inspect-class-values.ts": 1875, - "5411-inspect-class-hierarchies.ts": 2712, - "5412-inspect-dynamic-collections.ts": 2792, - "5413-inspect-class-values.cjs": 3020, + "538-map-set-for-of.ts": 2976, + "5390-interface-loop-element-lifetimes.ts": 3153, + "5391-interface-dispatch-hierarchies.ts": 3899, + "5392-interface-receiver-bindings.ts": 3131, + "5393-interface-array-holes.ts": 3093, + "5394-interface-implementers.ts": 3579, + "5395-locale-compare-ascii.ts": 2963, + "5396-locale-compare-latin.ts": 1885, + "5397-locale-compare-sorting.ts": 3156, + "540-tuples-basics.ts": 2555, + "5400-json-parse-typed-keys.ts": 3448, + "5405-buffer-arraybuffer-window.ts": 3039, + "5406-util-types-keys.ts": 2823, + "5407-http-header-field-limit.ts": 3316, + "5408-http-unread-request-end.ts": 3667, + "5409-http-held-request-body.ts": 2506, + "541-ref-array-json.ts": 2521, + "5410-inspect-class-values.ts": 2528, + "5411-inspect-class-hierarchies.ts": 3094, + "5412-inspect-dynamic-collections.ts": 3071, + "5413-inspect-class-values.cjs": 3263, "5415-zlib-dynamic-inputs.cjs": 2520, - "542-union-element-arrays.ts": 2846, + "542-union-element-arrays.ts": 2223, "5420-readable-from-generators.ts": 3661, "5421-readable-from-generators.cjs": 3036, "5422-stream-async-push-wakeup.ts": 3138, @@ -1852,43 +1852,43 @@ "5427-pipeline-generator-backpressure.ts": 2729, "5428-pipeline-generator-stages.cjs": 3499, "5429-pipeline-generator-buffers.ts": 3223, - "5430-dyn-number-string-boxes.ts": 3059, - "5435-crypto-hash-algorithms.ts": 2030, - "5436-crypto-hash-names.js": 2098, - "5437-crypto-hmac-algorithms.ts": 2699, - "5438-crypto-kdf-digests.ts": 2741, - "5439-crypto-kdf-callbacks.js": 2685, - "5440-crypto-hash-encodings.js": 4004, - "5441-crypto-hash-output-length.ts": 3671, - "5442-crypto-random-values.ts": 3947, - "5443-crypto-random-arguments.js": 3548, - "5444-crypto-timing-safe-equal.js": 3213, - "5445-crypto-secret-key-objects.ts": 3869, - "5445-stream-buffer-chunks.ts": 2881, - "5446-crypto-secret-key-errors.js": 3035, - "5446-stream-buffer-chunks-dynamic.js": 2859, - "5447-fs-readdir-order.ts": 2639, - "5448-fs-glob-patterns.ts": 2837, - "5449-fs-glob-options.ts": 3025, - "5450-fs-glob-validation.js": 3327, - "5451-fs-promises-glob.ts": 3059, - "5452-fs-glob-callback.ts": 2936, - "5455-power-of-two-remainder.ts": 2837, - "5456-remainder-large-integer-dividends.ts": 2786, - "5457-lcg-modulus.ts": 1426, - "5458-fractional-remainder.ts": 1394, - "5460-locale-compare-contractions.ts": 2979, - "5461-locale-compare-equivalents.ts": 2661, - "5462-locale-compare-probe-sweep.ts": 3400, - "5463-locale-compare-combining-letters.ts": 2733, - "5464-locale-compare-fractions.ts": 2833, + "5430-dyn-number-string-boxes.ts": 3048, + "5435-crypto-hash-algorithms.ts": 2461, + "5436-crypto-hash-names.js": 3064, + "5437-crypto-hmac-algorithms.ts": 3107, + "5438-crypto-kdf-digests.ts": 3109, + "5439-crypto-kdf-callbacks.js": 2368, + "5440-crypto-hash-encodings.js": 4093, + "5441-crypto-hash-output-length.ts": 3652, + "5442-crypto-random-values.ts": 4190, + "5443-crypto-random-arguments.js": 3529, + "5444-crypto-timing-safe-equal.js": 3508, + "5445-crypto-secret-key-objects.ts": 3186, + "5445-stream-buffer-chunks.ts": 3012, + "5446-crypto-secret-key-errors.js": 3785, + "5446-stream-buffer-chunks-dynamic.js": 3127, + "5447-fs-readdir-order.ts": 2143, + "5448-fs-glob-patterns.ts": 3113, + "5449-fs-glob-options.ts": 3649, + "5450-fs-glob-validation.js": 2855, + "5451-fs-promises-glob.ts": 3569, + "5452-fs-glob-callback.ts": 2885, + "5455-power-of-two-remainder.ts": 3093, + "5456-remainder-large-integer-dividends.ts": 2991, + "5457-lcg-modulus.ts": 2871, + "5458-fractional-remainder.ts": 2988, + "5460-locale-compare-contractions.ts": 2881, + "5461-locale-compare-equivalents.ts": 2942, + "5462-locale-compare-probe-sweep.ts": 2752, + "5463-locale-compare-combining-letters.ts": 3006, + "5464-locale-compare-fractions.ts": 2946, "5465-dyn-index-read-arrays.ts": 3424, "5466-dyn-index-read-special.ts": 2632, - "5470-strip-vt-osc.cjs": 2497, - "5471-strip-vt-csi.cjs": 2651, - "5472-strip-vt-random.cjs": 2375, - "5473-strip-vt-unterminated.cjs": 3521, - "5474-strip-vt-surrogates.ts": 2534, + "5470-strip-vt-osc.cjs": 2376, + "5471-strip-vt-csi.cjs": 2167, + "5472-strip-vt-random.cjs": 3001, + "5473-strip-vt-unterminated.cjs": 3560, + "5474-strip-vt-surrogates.ts": 3301, "5510-assert-error-properties.js": 3653, "5511-assert-error-class.ts": 3637, "5512-assert-error-options.js": 3115, @@ -1909,20 +1909,20 @@ "5530-buffer-pool.ts": 3971, "5531-buffer-pool-first-slab.ts": 5569, "5532-buffer-pool-first-slab-untyped.mjs": 40038, - "5540-fs-callback-forms.cjs": 3233, - "5541-fs-stats-fields.cjs": 3564, - "5542-fs-promises-parity.cjs": 3940, - "5543-fs-promises-typed.ts": 1655, - "5544-fs-opendir.cjs": 3024, - "5545-fs-options-encoding.cjs": 2994, + "5540-fs-callback-forms.cjs": 3631, + "5541-fs-stats-fields.cjs": 3800, + "5542-fs-promises-parity.cjs": 3962, + "5543-fs-promises-typed.ts": 2212, + "5544-fs-opendir.cjs": 3332, + "5545-fs-options-encoding.cjs": 4482, "5546-fs-read-stream.cjs": 4502, "5547-fs-write-stream.cjs": 5101, - "5548-fs-callback-arguments.cjs": 4041, - "5549-fs-callback-option-checks.cjs": 3738, - "5550-locale-compare-ascii-words.ts": 2509, - "5551-array-search-references.ts": 3475, - "5552-string-appends.ts": 2703, - "5553-string-append-char-code.ts": 2870, + "5548-fs-callback-arguments.cjs": 4306, + "5549-fs-callback-option-checks.cjs": 4187, + "5550-locale-compare-ascii-words.ts": 2669, + "5551-array-search-references.ts": 3663, + "5552-string-appends.ts": 3195, + "5553-string-append-char-code.ts": 2446, "5554-fs-streams-typed.ts": 3785, "5555-fs-callback-turns.cjs": 3093, "5555-http-server-close-keep-alive.ts": 7242, @@ -1935,15 +1935,15 @@ "5562-https-verify-errors.ts": 3494, "5563-http-keep-alive-timeout.ts": 11607, "5564-http-request-signal.ts": 3916, - "5565-fs-dirent-untyped.mjs": 2600, - "5566-fs-dirent-dyn-boundaries/main.mjs": 2607, + "5565-fs-dirent-untyped.mjs": 3810, + "5566-fs-dirent-dyn-boundaries/main.mjs": 3533, "5567-fs-cpsync.ts": 3626, "5568-fs-cp-errors.js": 3163, "5569-fs-cp-symlinks.ts": 3704, "5570-fs-cp-async.ts": 3480, "5571-fs-cp-deep.ts": 4934, - "5585-record-results-inlined.ts": 2922, - "5595-net-ref-unref.ts": 2593, + "5585-record-results-inlined.ts": 3154, + "5595-net-ref-unref.ts": 2641, "5600-dyn-cycle-self.ts": 2124, "5601-dyn-cycle-mutual.ts": 3279, "5602-dyn-cycle-arrays.ts": 2568, @@ -1974,13 +1974,13 @@ "5630-promisify-zlib.ts": 1934, "5631-promisify-crypto.ts": 2200, "5632-promisify-dns.ts": 1700, - "5644-net-socket-addresses.ts": 2220, - "5645-net-socket-callbacks.ts": 2442, - "5646-net-server-connections.ts": 2389, - "5647-net-is-ip.ts": 2776, - "5648-dns-lookup-forms.ts": 2992, - "5649-dns-service-servers.ts": 2712, - "5650-dns-lookup-errors-untyped.cjs": 2822, + "5644-net-socket-addresses.ts": 3275, + "5645-net-socket-callbacks.ts": 3377, + "5646-net-server-connections.ts": 2448, + "5647-net-is-ip.ts": 2731, + "5648-dns-lookup-forms.ts": 3763, + "5649-dns-service-servers.ts": 2892, + "5650-dns-lookup-errors-untyped.cjs": 2811, "5651-tls-socket-protocol.ts": 3198, "5652-http-client-trailer-overflow.ts": 2916, "5653-net-socket-read-ahead.ts": 4816, @@ -1993,7 +1993,7 @@ "5664-tls-client-identity.ts": 2704, "5674-union-instanceof-array-arms.ts": 3663, "5680-array-growth-after-copy.ts": 3726, - "5681-array-pop-and-length.ts": 3754, + "5681-array-pop-and-length.ts": 4270, "5682-publish-wide-objects.ts": 3077, "5700-cycle-release-retained.ts": 2148, "5701-cycle-release-old-edges.ts": 2696, @@ -2054,36 +2054,36 @@ "5795-worker-message-port-batches.ts": 2254, "5796-worker-message-channel.cjs": 3566, "5797-worker-message-port-transfer.ts": 3180, - "5800-broadcast-channel.ts": 2899, - "5801-broadcast-channel.cjs": 2727, - "5802-broadcast-channel-workers.ts": 2809, - "5803-worker-environment-data.ts": 2748, - "5804-worker-environment-data.cjs": 2469, - "5805-worker-receive-message-parent-port.ts": 2839, - "5806-worker-resource-limits.ts": 3153, - "5807-worker-error-values.ts": 3304, - "5808-worker-unhandled-rejections.ts": 3430, - "5809-process-exit-and-rejections.cjs": 3294, - "5810-mock-method-records.ts": 3976, - "5811-mock-tracker-restore.ts": 3698, - "5812-dyn-box-async-fields.ts": 3522, - "5813-mock-timers-module.ts": 3766, - "5814-mock-timers-date.ts": 3760, + "5800-broadcast-channel.ts": 3206, + "5801-broadcast-channel.cjs": 3035, + "5802-broadcast-channel-workers.ts": 3120, + "5803-worker-environment-data.ts": 3113, + "5804-worker-environment-data.cjs": 3000, + "5805-worker-receive-message-parent-port.ts": 3259, + "5806-worker-resource-limits.ts": 3191, + "5807-worker-error-values.ts": 3239, + "5808-worker-unhandled-rejections.ts": 3439, + "5809-process-exit-and-rejections.cjs": 3393, + "5810-mock-method-records.ts": 3670, + "5811-mock-tracker-restore.ts": 3216, + "5812-dyn-box-async-fields.ts": 2941, + "5813-mock-timers-module.ts": 3052, + "5814-mock-timers-date.ts": 3365, "5830-timers-promises-signal.ts": 3771, - "5831-util-types-brands.ts": 3347, - "5832-util-types-brands-dynamic.js": 3250, - "5833-url-search-params-iterators.ts": 2678, - "5834-url-search-params-iterators-dynamic.mjs": 2696, - "5835-util-format-integer-specifiers.ts": 2534, - "5836-url-search-params-tuple-pairs.ts": 2118, - "5837-util-format-json-circular.ts": 3117, - "5838-qs-stringify-bigint.ts": 2207, + "5831-util-types-brands.ts": 3300, + "5832-util-types-brands-dynamic.js": 3811, + "5833-url-search-params-iterators.ts": 3578, + "5834-url-search-params-iterators-dynamic.mjs": 3566, + "5835-util-format-integer-specifiers.ts": 2544, + "5836-url-search-params-tuple-pairs.ts": 2830, + "5837-util-format-json-circular.ts": 2387, + "5838-qs-stringify-bigint.ts": 3072, "5839-timers-promises-scheduler.ts": 2609, "5840-promise-with-resolvers-js.js": 2922, - "5841-json-typed-dyn-members.ts": 5467, - "5842-qs-parse-null-prototype.ts": 1774, - "5843-qs-parse-null-prototype-js.mjs": 1559, - "5844-date-unknown-values.ts": 3969, + "5841-json-typed-dyn-members.ts": 3536, + "5842-qs-parse-null-prototype.ts": 3138, + "5843-qs-parse-null-prototype-js.mjs": 2658, + "5844-date-unknown-values.ts": 3255, "5845-groupby-null-prototype.ts": 3675, "5846-events-esm-default-max.ts": 2633, "5847-events-cjs-default-max.cjs": 2823, @@ -2095,45 +2095,45 @@ "5854-array-from-async.ts": 3165, "5855-array-from-async-js.js": 3186, "5856-error-is-error.ts": 3631, - "5857-regexp-unicode-sets.ts": 3350, - "5858-disposable-stack.ts": 3050, - "5859-disposable-stack-js.js": 3100, + "5857-regexp-unicode-sets.ts": 2021, + "5858-disposable-stack.ts": 4753, + "5859-disposable-stack-js.js": 3636, "5860-url-ipv4-hosts.ts": 3030, - "5870-worker-thread-names.ts": 3106, - "5871-worker-untransferable.cjs": 2786, + "5870-worker-thread-names.ts": 3457, + "5871-worker-untransferable.cjs": 2368, "5872-readline-positional-create-interface.mjs": 2993, "5873-readline-promises-namespace.cjs": 2951, - "5874-worker-stdio-streams.ts": 2839, - "5875-worker-stdout-pipe.cjs": 2740, - "5879-worker-stdin.ts": 3158, + "5874-worker-stdio-streams.ts": 2974, + "5875-worker-stdout-pipe.cjs": 3115, + "5879-worker-stdin.ts": 3644, "5880-emitter-leak-warning-delivery.ts": 2660, - "5881-inspect-weak-collections.ts": 2615, - "5882-string-decoder-runtime-encoding.ts": 2541, - "5883-os-set-priority.ts": 2380, - "5884-inspect-layout-options.ts": 3108, + "5881-inspect-weak-collections.ts": 2621, + "5882-string-decoder-runtime-encoding.ts": 2742, + "5883-os-set-priority.ts": 2927, + "5884-inspect-layout-options.ts": 3552, "5885-events-max-listener-helpers.ts": 3645, - "5886-inspect-dates.ts": 2559, - "5887-inspect-typed-arrays.ts": 3448, - "5888-inspect-sorted.ts": 2998, + "5886-inspect-dates.ts": 2931, + "5887-inspect-typed-arrays.ts": 2476, + "5888-inspect-sorted.ts": 3227, "5889-timers-scheduler-signal.ts": 2549, "5890-while-string-length-counters.ts": 3080, "5892-buffer-write-utf16le-runs.ts": 3098, - "5900-float16-array.ts": 3000, - "5901-float16-array-js.js": 2900, - "5904-async-generator-completion.ts": 2950, - "5905-array-from-async-generator.ts": 2750, - "5906-array-from-async-generator-js.js": 2950, + "5900-float16-array.ts": 3586, + "5901-float16-array-js.js": 3449, + "5904-async-generator-completion.ts": 5816, + "5905-array-from-async-generator.ts": 2793, + "5906-array-from-async-generator-js.js": 3377, "5907-regex-groups-match-rows.ts": 3150, - "5910-set-prototype-of-primitive-object-kinds.ts": 2719, - "5911-dyn-class-to-primitive.ts": 2850, - "5912-dyn-class-conversion-methods.ts": 3251, - "5913-prototype-type-error-messages.ts": 2484, - "5914-dyn-in-class-prototype-members.ts": 3169, - "5915-dyn-error-string-conversions.ts": 3200, + "5910-set-prototype-of-primitive-object-kinds.ts": 2148, + "5911-dyn-class-to-primitive.ts": 6231, + "5912-dyn-class-conversion-methods.ts": 4317, + "5913-prototype-type-error-messages.ts": 2831, + "5914-dyn-in-class-prototype-members.ts": 2811, + "5915-dyn-error-string-conversions.ts": 3158, "5920-promise-try-args.ts": 3150, "5921-promise-try-args-js.js": 2112, - "5922-matchall-groups-callbacks.ts": 3650, - "5923-matchall-groups-js.js": 3970, + "5922-matchall-groups-callbacks.ts": 4259, + "5923-matchall-groups-js.js": 4523, "5924-js-literal-identity.js": 3064, "5925-class-view-identity-observers.ts": 2653, "5926-class-view-switch-js.js": 1690, @@ -2150,7 +2150,7 @@ "5936-checked-js-class-types.js": 2384, "5937-override-narrowed-union-returns.ts": 3039, "5938-object-literal-computed-keys-keep-methods.ts": 3195, - "5939-js-let-object-reassigned-wider.js": 1945, + "5939-js-let-object-reassigned-wider.js": 2362, "5940-callback-helper-specialization.ts": 3130, "5941-callback-specialization-recursion.ts": 3996, "5942-callback-specialization-throws.ts": 2908, @@ -2158,2534 +2158,2534 @@ "5944-js-fields-read-before-assignment.js": 4247, "5945-local-class-observed-methods.ts": 5063, "5946-nested-record-field-optional-writes.ts": 6045, - "5950-tuple-predicate-methods.ts": 5990, - "5951-result-never-widening.ts": 4710, + "5950-tuple-predicate-methods.ts": 3865, + "5951-result-never-widening.ts": 3022, "5952-record-missing-keys.ts": 6090, "5953-nan-coded-method-returns.ts": 4100, - "5955-any-promise-methods.js": 3940, - "5956-erased-generic-members.ts": 6730, - "5958-asserted-union-receiver.ts": 2430, - "5959-date-to-json.ts": 3330, - "5960-generic-mapped-types.ts": 2540, - "5970-net-connect-host-name.ts": 2400, - "5971-buffer-chunks-to-string.ts": 2700, - "5972-net-set-encoding-listeners.ts": 2550, - "5974-typeof-module-exports.cjs": 2000, + "5955-any-promise-methods.js": 3111, + "5956-erased-generic-members.ts": 5669, + "5958-asserted-union-receiver.ts": 1929, + "5959-date-to-json.ts": 2922, + "5960-generic-mapped-types.ts": 3167, + "5970-net-connect-host-name.ts": 1992, + "5971-buffer-chunks-to-string.ts": 3183, + "5972-net-set-encoding-listeners.ts": 2129, + "5974-typeof-module-exports.cjs": 2008, "5975-zlib-class-values.ts": 2800, - "5990-worker-uncloneable.mjs": 3283, - "5991-worker-async-dispose.mjs": 5699, - "5992-worker-thread-name-lifetime.mjs": 2687, + "5990-worker-uncloneable.mjs": 3202, + "5991-worker-async-dispose.mjs": 5853, + "5992-worker-thread-name-lifetime.mjs": 2058, "5993-array-length-loop-resizing.ts": 3187, "5994-array-length-sparse-loops.ts": 3292, "5995-array-dense-loop-boundaries.ts": 2596, - "600-closures-basic.ts": 2349, - "601-closures-loops.ts": 1788, - "602-closures-identity-recursion.ts": 2372, - "6020-class-extends-function-constructor.js": 4300, + "600-closures-basic.ts": 2637, + "601-closures-loops.ts": 2250, + "602-closures-identity-recursion.ts": 2821, + "6020-class-extends-function-constructor.js": 3026, "6021-asserted-literal-union-arm.ts": 3400, - "603-closures-rc-stress.ts": 1832, - "604-closures-for-of.ts": 2639, - "605-closures-forward-capture-tdz.ts": 3277, - "700-classes-basic.ts": 2530, - "701-classes-composition.ts": 2357, - "702-classes-this-capture.ts": 2140, - "703-classes-rc-stress.ts": 2186, - "710-inheritance-basics.ts": 2728, - "711-inheritance-dispatch.ts": 2360, - "712-inheritance-instanceof.ts": 2715, - "713-inheritance-rc-stress.ts": 2448, - "720-accessors-basics.ts": 2562, - "721-accessors-eval-order.ts": 2406, - "722-accessors-inheritance.ts": 2543, - "723-accessors-rc-stress.ts": 2054, - "750-cycle-closure-box.ts": 2227, - "751-cycle-records-mutual.ts": 2118, - "752-cycle-classes.ts": 2207, - "753-cycle-owned-arrays.ts": 2148, - "754-cycle-external-ref.ts": 2118, - "755-cycle-async-promise.ts": 2303, - "756-cycle-inheritance.ts": 2162, - "757-cycle-cross-generation.ts": 2893, - "762-any-boundary.ts": 2310, - "764-any-async.ts": 2553, - "765-any-optional-chain.ts": 2593, - "766-any-union-boundary.ts": 3292, - "767-string-literal-keys.ts": 2238, - "768-any-uninitialized.ts": 2264, - "800-switch-basics.ts": 2244, - "801-switch-lazy-tests.ts": 2610, - "802-switch-loops.ts": 2329, - "803-switch-rc-stress.ts": 2314, - "804-switch-braced-blocks.ts": 2594, - "810-do-while.ts": 2658, - "820-multi-decl.ts": 2315, - "830-let-uninitialized.ts": 2519, - "900-records-basics.ts": 2736, - "901-records-eval-order.ts": 2544, - "902-records-functions-closures.ts": 2645, - "903-records-rc-stress.ts": 2871, - "904-records-optional-fields.ts": 1801, - "905-records-optional-rc-stress.ts": 2425, - "906-records-utility-types.ts": 2878, - "907-records-utility-generics.ts": 2738, - "908-records-index-signatures.ts": 2545, - "909-records-index-json.ts": 2019, - "910-records-index-rc-stress.ts": 1878, - "911-records-index-dot-access.ts": 3510, - "912-unknown-slots.ts": 2427, - "913-records-index-iteration.ts": 3462, - "914-records-from-entries.ts": 3129, - "915-unknown-tostring-eq.ts": 3072, - "916-unknown-bytes.ts": 2767, - "917-record-array-index-dot.ts": 2445, - "950-modules-basic/main.ts": 2473, - "951-modules-diamond/main.ts": 1969, - "952-modules-cross/main.ts": 2427, - "953-modules-default/main.ts": 2409, - "954-modules-reexport/main.ts": 2586, - "957-builtins-namespace.ts": 2102, - "960-generics-basics.ts": 2487, - "961-generics-recursion.ts": 2589, - "962-generics-closures.ts": 2098, - "963-generics-modules/main.ts": 2726, - "964-generics-rc-stress.ts": 2825, - "965-generics-async.ts": 2802, - "965-unions-retag.ts": 2772, - "966-unions-retag-rc-stress.ts": 2336, - "967-record-field-widening.ts": 2097, - "969-unions-arm-matrix.ts": 2419, - "970-unions-basics.ts": 2692, - "971-unions-switch.ts": 2491, - "972-unions-nested.ts": 3069, - "973-unions-rc-stress.ts": 2478, - "974-unions-modules/main.ts": 2052, - "975-unions-undefined.ts": 2811, - "976-unions-null.ts": 2344, - "977-unions-unit-rc-stress.ts": 2013, - "978-unions-nullish.ts": 2330, - "979-unions-optional-chaining.ts": 2341, - "980-exceptions-basics.ts": 1988, - "981-exceptions-values.ts": 2615, - "982-exceptions-rc-stress.ts": 2259, - "983-exceptions-control-flow.ts": 2004, - "984-exceptions-finally.ts": 2140, - "985-exceptions-call-chains.ts": 2787, - "986-exceptions-uncaught.ts": 2529, - "987-exceptions-result-unions.ts": 2390, - "990-process-basics.ts": 2623, - "991-process-exit.ts": 2155, - "992-fs-roundtrip.ts": 2680, - "993-fs-readdir.ts": 2781, - "994-fs-errors.ts": 2322, - "995-fs-uncaught.ts": 2134, - "996-fs-rc-stress.ts": 2214, - "997-fs-modules/main.ts": 2230, - "998-process-env.ts": 2196, - "abstract-property-dispatch.ts": 2956, - "arguments-arrow-capture.mjs": 2802, - "arguments-reexport/main.ts": 2655, - "array-argument-lifetimes-exits.ts": 2164, - "array-argument-lifetimes-mutation.ts": 2547, - "array-argument-lifetimes-strings.ts": 2738, - "array-argument-lifetimes-values.ts": 3081, - "array-buffer-conversions.js": 1978, - "array-buffer-storage.ts": 3147, - "array-checked-callback-results.mjs": 3053, - "array-checked-constructor.js": 3001, - "array-concat-widening.ts": 2947, + "603-closures-rc-stress.ts": 2800, + "604-closures-for-of.ts": 1980, + "605-closures-forward-capture-tdz.ts": 2765, + "700-classes-basic.ts": 1650, + "701-classes-composition.ts": 2262, + "702-classes-this-capture.ts": 1945, + "703-classes-rc-stress.ts": 2498, + "710-inheritance-basics.ts": 1936, + "711-inheritance-dispatch.ts": 2643, + "712-inheritance-instanceof.ts": 2608, + "713-inheritance-rc-stress.ts": 2855, + "720-accessors-basics.ts": 2703, + "721-accessors-eval-order.ts": 2000, + "722-accessors-inheritance.ts": 2558, + "723-accessors-rc-stress.ts": 2721, + "750-cycle-closure-box.ts": 2521, + "751-cycle-records-mutual.ts": 2024, + "752-cycle-classes.ts": 2646, + "753-cycle-owned-arrays.ts": 2810, + "754-cycle-external-ref.ts": 2655, + "755-cycle-async-promise.ts": 2228, + "756-cycle-inheritance.ts": 2657, + "757-cycle-cross-generation.ts": 2901, + "762-any-boundary.ts": 2854, + "764-any-async.ts": 2890, + "765-any-optional-chain.ts": 2394, + "766-any-union-boundary.ts": 2672, + "767-string-literal-keys.ts": 2479, + "768-any-uninitialized.ts": 2844, + "800-switch-basics.ts": 2758, + "801-switch-lazy-tests.ts": 2588, + "802-switch-loops.ts": 1780, + "803-switch-rc-stress.ts": 2015, + "804-switch-braced-blocks.ts": 2537, + "810-do-while.ts": 1969, + "820-multi-decl.ts": 1629, + "830-let-uninitialized.ts": 2899, + "900-records-basics.ts": 2778, + "901-records-eval-order.ts": 2686, + "902-records-functions-closures.ts": 2628, + "903-records-rc-stress.ts": 2550, + "904-records-optional-fields.ts": 3083, + "905-records-optional-rc-stress.ts": 2791, + "906-records-utility-types.ts": 1783, + "907-records-utility-generics.ts": 2604, + "908-records-index-signatures.ts": 2041, + "909-records-index-json.ts": 3081, + "910-records-index-rc-stress.ts": 2746, + "911-records-index-dot-access.ts": 3174, + "912-unknown-slots.ts": 2915, + "913-records-index-iteration.ts": 3669, + "914-records-from-entries.ts": 3427, + "915-unknown-tostring-eq.ts": 3373, + "916-unknown-bytes.ts": 2791, + "917-record-array-index-dot.ts": 2745, + "950-modules-basic/main.ts": 2721, + "951-modules-diamond/main.ts": 1492, + "952-modules-cross/main.ts": 1431, + "953-modules-default/main.ts": 2552, + "954-modules-reexport/main.ts": 2362, + "957-builtins-namespace.ts": 2216, + "960-generics-basics.ts": 2982, + "961-generics-recursion.ts": 2893, + "962-generics-closures.ts": 2684, + "963-generics-modules/main.ts": 2595, + "964-generics-rc-stress.ts": 3029, + "965-generics-async.ts": 3085, + "965-unions-retag.ts": 2457, + "966-unions-retag-rc-stress.ts": 2098, + "967-record-field-widening.ts": 2939, + "969-unions-arm-matrix.ts": 2998, + "970-unions-basics.ts": 2779, + "971-unions-switch.ts": 2261, + "972-unions-nested.ts": 2825, + "973-unions-rc-stress.ts": 2576, + "974-unions-modules/main.ts": 2186, + "975-unions-undefined.ts": 2396, + "976-unions-null.ts": 2274, + "977-unions-unit-rc-stress.ts": 2486, + "978-unions-nullish.ts": 2487, + "979-unions-optional-chaining.ts": 2987, + "980-exceptions-basics.ts": 2385, + "981-exceptions-values.ts": 2867, + "982-exceptions-rc-stress.ts": 1550, + "983-exceptions-control-flow.ts": 2778, + "984-exceptions-finally.ts": 2144, + "985-exceptions-call-chains.ts": 3115, + "986-exceptions-uncaught.ts": 2615, + "987-exceptions-result-unions.ts": 1576, + "990-process-basics.ts": 2148, + "991-process-exit.ts": 2021, + "992-fs-roundtrip.ts": 2662, + "993-fs-readdir.ts": 2790, + "994-fs-errors.ts": 2954, + "995-fs-uncaught.ts": 2485, + "996-fs-rc-stress.ts": 2801, + "997-fs-modules/main.ts": 1791, + "998-process-env.ts": 2322, + "abstract-property-dispatch.ts": 3676, + "arguments-arrow-capture.mjs": 2969, + "arguments-reexport/main.ts": 2670, + "array-argument-lifetimes-exits.ts": 3229, + "array-argument-lifetimes-mutation.ts": 2355, + "array-argument-lifetimes-strings.ts": 2875, + "array-argument-lifetimes-values.ts": 3135, + "array-buffer-conversions.js": 2768, + "array-buffer-storage.ts": 2184, + "array-checked-callback-results.mjs": 3207, + "array-checked-constructor.js": 2168, + "array-concat-widening.ts": 3084, "array-deque-unshift.ts": 3209, - "array-element-compound-updates.ts": 3325, - "array-fill-unit-values.ts": 2281, - "array-from-checked.js": 3228, - "array-from-value.mjs": 2658, - "array-isarray-value/main.js": 2180, - "array-numeric-own-keys.ts": 2770, - "array-optional-number-write-index.ts": 2584, - "array-primitive-ordering.ts": 3806, + "array-element-compound-updates.ts": 4339, + "array-fill-unit-values.ts": 2510, + "array-from-checked.js": 4274, + "array-from-value.mjs": 3224, + "array-isarray-value/main.js": 2742, + "array-numeric-own-keys.ts": 1884, + "array-optional-number-write-index.ts": 2617, + "array-primitive-ordering.ts": 2544, "array-queue-head-room.ts": 3344, - "array-read-helper-effects.ts": 3223, - "array-refined-storage.ts": 3132, - "array-sort-dense-effects.ts": 2813, - "array-sort-dense-values.ts": 3705, - "array-sort-holes-published.ts": 6604, - "array-sort-runs.ts": 5713, - "array-sort-runtime-comparator.ts": 5050, - "array-sort-unknown-comparator.ts": 1888, - "array-storage-transitions.ts": 3122, - "array-truncate-reuse.ts": 2475, - "async-backend-factory.mjs": 2638, - "async-local-typed-results.ts": 2579, - "atomics-integer-operations.ts": 3320, - "bigint-checked-casts.ts": 2572, - "bigint-checked-storage.js": 3519, - "bigint-union-conversion.ts": 2774, - "boxed-error-rethrows.mjs": 2034, - "buffer-codec-boundaries.ts": 3206, - "buffer-primitive-predicate.ts": 2712, - "builtin-prototype-method-values.mjs": 3158, - "byte-loop-bounds.ts": 2922, - "byte-number-pipeline.ts": 2738, - "byte-record-windows.ts": 2668, - "call-lifetimes-argument-order.ts": 1933, - "call-lifetimes-control-flow.ts": 2653, - "call-lifetimes-owned-boundaries.ts": 2979, - "call-lifetimes-projections.ts": 3011, - "call-lifetimes-union-values.ts": 2366, - "call-lifetimes-virtual-optionals.ts": 2747, - "callable-module-members.mjs": 2647, - "callable-properties.mjs": 3266, - "callable-property-cycles.js": 2241, - "callable-reexport/main.ts": 2809, - "captured-class-refinement.ts": 2580, - "catch-capture.ts": 2050, - "caught-class-identity.ts": 3173, - "caught-standalone-class.ts": 2858, - "caught-system-error-fields.ts": 2612, + "array-read-helper-effects.ts": 2217, + "array-refined-storage.ts": 2827, + "array-sort-dense-effects.ts": 3621, + "array-sort-dense-values.ts": 3004, + "array-sort-holes-published.ts": 7729, + "array-sort-runs.ts": 4117, + "array-sort-runtime-comparator.ts": 4714, + "array-sort-unknown-comparator.ts": 2824, + "array-storage-transitions.ts": 3984, + "array-truncate-reuse.ts": 2234, + "async-backend-factory.mjs": 1807, + "async-local-typed-results.ts": 2185, + "atomics-integer-operations.ts": 2603, + "bigint-checked-casts.ts": 2636, + "bigint-checked-storage.js": 3528, + "bigint-union-conversion.ts": 2763, + "boxed-error-rethrows.mjs": 2627, + "buffer-codec-boundaries.ts": 2453, + "buffer-primitive-predicate.ts": 2183, + "builtin-prototype-method-values.mjs": 3361, + "byte-loop-bounds.ts": 3029, + "byte-number-pipeline.ts": 3197, + "byte-record-windows.ts": 2142, + "call-lifetimes-argument-order.ts": 2451, + "call-lifetimes-control-flow.ts": 2879, + "call-lifetimes-owned-boundaries.ts": 3007, + "call-lifetimes-projections.ts": 1722, + "call-lifetimes-union-values.ts": 2751, + "call-lifetimes-virtual-optionals.ts": 3153, + "callable-module-members.mjs": 2485, + "callable-properties.mjs": 3432, + "callable-property-cycles.js": 3096, + "callable-reexport/main.ts": 3039, + "captured-class-refinement.ts": 3032, + "catch-capture.ts": 2928, + "caught-class-identity.ts": 2572, + "caught-standalone-class.ts": 3034, + "caught-system-error-fields.ts": 2540, "checked-addition.js": 2460, - "checked-any-addition.ts": 2551, - "checked-array-assignment.ts": 2273, - "checked-array-flat/main.ts": 2256, - "checked-bitwise/main.js": 2560, - "checked-builder-cycles.js": 3055, - "checked-byte-storage/main.ts": 3171, - "checked-callback-options.ts": 2385, - "checked-class-descriptors.mjs": 3021, - "checked-class-factory.mjs": 2266, - "checked-collection-iterators.ts": 2906, - "checked-collection-symbol-methods.ts": 2575, - "checked-dispatch-input-lifetimes.js": 3038, - "checked-increment/main.js": 2332, - "checked-inherited-fields.ts": 2382, - "checked-iterator-consumption.js": 3603, - "checked-numeric-arithmetic.js": 2783, - "checked-object-module-alias.js": 2898, - "checked-optional-calls.mjs": 2763, - "checked-promise-recovery.ts": 2689, - "checked-proxy-callback/main.ts": 2754, - "checked-record-constructor.ts": 2506, - "checked-renderer-defaults.js": 2308, - "checked-rest-function-adapters.js": 2312, - "checked-storage-transitions.js": 2557, - "checked-symbol-array.ts": 1859, - "checked-value-input-lifetimes.ts": 2728, - "class-accessor-returned-function.js": 2068, - "class-array-optional-return.ts": 2589, - "class-bracket-method-calls.js": 2833, - "class-brand-overload.js": 2700, - "class-callback-replacement.js": 3640, - "class-callback-storage.ts": 3803, - "class-checked-composites.ts": 2846, - "class-checked-upcast.ts": 2625, - "class-collection-insertion.ts": 3901, - "class-computed-presence.ts": 3018, - "class-computed-symbols.js": 3495, - "class-covariant-returns.ts": 3069, - "class-curried-factory.mjs": 3062, - "class-data-descriptors.js": 3732, - "class-factory-inherited-statics.mjs": 2710, - "class-factory-parameter-base.mjs": 2492, - "class-factory-record-base.mjs": 4680, - "class-factory-recursive-statics.mjs": 2820, - "class-factory-static-members.mjs": 2990, - "class-function-base/main.js": 2706, - "class-instance-constructor.js": 2628, - "class-interface-protocols.ts": 3911, - "class-interface-refinements.ts": 2967, - "class-json-checked.ts": 2638, - "class-local-function-base.mjs": 2970, - "class-method-spreads.ts": 3142, - "class-narrowed-views.ts": 2862, - "class-property-call-values.mjs": 3343, - "class-prototype-data.js": 3393, - "class-prototype-descriptor-copy.mjs": 3870, - "class-specialized-computed-base.mjs": 3439, - "class-static-data.js": 2153, - "class-subclass-assertions.ts": 2814, - "class-super-surplus-spread.mjs": 2024, - "class-symbol-accessors.ts": 2458, - "class-symbol-cache.mjs": 2883, - "class-value-constructor-exceptions.ts": 2222, + "checked-any-addition.ts": 2597, + "checked-array-assignment.ts": 1938, + "checked-array-flat/main.ts": 2376, + "checked-bitwise/main.js": 2931, + "checked-builder-cycles.js": 2124, + "checked-byte-storage/main.ts": 2136, + "checked-callback-options.ts": 2655, + "checked-class-descriptors.mjs": 3730, + "checked-class-factory.mjs": 2259, + "checked-collection-iterators.ts": 3189, + "checked-collection-symbol-methods.ts": 2758, + "checked-dispatch-input-lifetimes.js": 3290, + "checked-increment/main.js": 2209, + "checked-inherited-fields.ts": 1885, + "checked-iterator-consumption.js": 3562, + "checked-numeric-arithmetic.js": 2775, + "checked-object-module-alias.js": 2993, + "checked-optional-calls.mjs": 2857, + "checked-promise-recovery.ts": 2965, + "checked-proxy-callback/main.ts": 2460, + "checked-record-constructor.ts": 2536, + "checked-renderer-defaults.js": 2974, + "checked-rest-function-adapters.js": 2402, + "checked-storage-transitions.js": 3227, + "checked-symbol-array.ts": 2138, + "checked-value-input-lifetimes.ts": 2968, + "class-accessor-returned-function.js": 2548, + "class-array-optional-return.ts": 2505, + "class-bracket-method-calls.js": 3232, + "class-brand-overload.js": 2772, + "class-callback-replacement.js": 4256, + "class-callback-storage.ts": 3103, + "class-checked-composites.ts": 2644, + "class-checked-upcast.ts": 2728, + "class-collection-insertion.ts": 4030, + "class-computed-presence.ts": 3380, + "class-computed-symbols.js": 2436, + "class-covariant-returns.ts": 3091, + "class-curried-factory.mjs": 3427, + "class-data-descriptors.js": 3815, + "class-factory-inherited-statics.mjs": 3016, + "class-factory-parameter-base.mjs": 3162, + "class-factory-record-base.mjs": 5127, + "class-factory-recursive-statics.mjs": 2561, + "class-factory-static-members.mjs": 3200, + "class-function-base/main.js": 3392, + "class-instance-constructor.js": 3735, + "class-interface-protocols.ts": 5264, + "class-interface-refinements.ts": 2054, + "class-json-checked.ts": 2470, + "class-local-function-base.mjs": 3094, + "class-method-spreads.ts": 4098, + "class-narrowed-views.ts": 1811, + "class-property-call-values.mjs": 3042, + "class-prototype-data.js": 2959, + "class-prototype-descriptor-copy.mjs": 3884, + "class-specialized-computed-base.mjs": 3695, + "class-static-data.js": 2083, + "class-subclass-assertions.ts": 2716, + "class-super-surplus-spread.mjs": 3129, + "class-symbol-accessors.ts": 2288, + "class-symbol-cache.mjs": 3599, + "class-value-constructor-exceptions.ts": 2725, "closed-virtual-dispatch-modules/main.ts": 2752, "closed-virtual-dispatch.ts": 3200, - "closure-nullable-union-return.ts": 2472, - "closure-union-locals.ts": 2465, - "collection-array-cycles.ts": 2552, - "collection-array-maps.ts": 3481, - "collection-array-missing.ts": 2873, - "collection-array-sets.ts": 3383, - "collection-copy-identities.ts": 2585, - "collection-data-unions.ts": 2565, - "collection-ingestion-mappers.ts": 3262, - "collection-ingestion-protocol/main.ts": 3814, - "collection-ingestion-references.ts": 3375, - "collection-ingestion.ts": 3053, - "collection-storage-copies.ts": 3096, - "collection-value-keys.ts": 3176, - "compound-field-receivers.ts": 2272, - "compound-presence-guards.ts": 3094, - "conditional-tuple-destructuring.ts": 2487, - "console-imports.cjs": 2314, - "console-native-value.js": 2165, - "const-enum-module-cycle/main.ts": 2618, - "constant-callback-dispatch.ts": 2539, - "constant-module-globals/main.ts": 2455, - "constant-number-remainders.ts": 2350, - "constructed-class-dispatch.ts": 3014, - "contextual-array-union-write.ts": 5379, - "contextual-return-layouts.ts": 2919, - "counted-loop-numbers.ts": 2515, - "counted-loop-storage.ts": 2556, - "crypto-hash-optional-input.ts": 2860, - "cycle-generations-long-lived.ts": 2691, - "cycle-growth-yield.ts": 2929, - "date-checked-native.js": 2323, - "declared-index-spread.ts": 2660, - "deep-reference-teardown.ts": 3136, - "default-undefined-parameters.ts": 2589, - "deferred-field-updates.ts": 2347, - "deferred-registry-many.ts": 2661, - "derived-numeric-updates.ts": 1907, - "destructure-call-assignment.js": 2267, - "destructure-inferred-row-defaults.js": 2538, - "destructure-union-arrays.ts": 2379, - "dynamic-function-descriptors.js": 2763, - "error-cause-writes.js": 2954, - "error-inherited-message.mjs": 2631, - "error-inherited-name.mjs": 2285, - "error-property-writes.mjs": 2636, - "error-prototype-tostring.js": 3155, - "error-stack-frames.ts": 2206, - "error-stack-limit.ts": 2510, - "error-tostring-overrides.ts": 2305, - "error-values-inspect.ts": 2398, - "exact-index-round-trip.ts": 2801, - "expression-runtime-values.ts": 2027, - "fiber-switch-stress.ts": 2898, - "fiberless-async-ordering.ts": 2908, - "fiberless-async-unhandled.ts": 2133, - "field-assignment-values.ts": 2107, - "file-handle-values.ts": 2357, - "file-read-storage.ts": 2439, - "file-url-percent-decoding.ts": 2222, - "final-field-borrows.ts": 2890, - "for-multiple-bindings.ts": 2286, - "for-multiple-lexical-bindings.ts": 2283, - "for-of-checked-iterator.js": 3511, - "for-of-subclass-elements.ts": 2219, - "forward-generic-signatures.ts": 2294, - "fresh-array-union-layout.js": 2480, - "frozen-checked-dictionaries.mjs": 2629, - "fs-native-realpath.ts": 2351, + "closure-nullable-union-return.ts": 2492, + "closure-union-locals.ts": 2959, + "collection-array-cycles.ts": 3095, + "collection-array-maps.ts": 3559, + "collection-array-missing.ts": 3686, + "collection-array-sets.ts": 3501, + "collection-copy-identities.ts": 2360, + "collection-data-unions.ts": 3003, + "collection-ingestion-mappers.ts": 2535, + "collection-ingestion-protocol/main.ts": 3823, + "collection-ingestion-references.ts": 2342, + "collection-ingestion.ts": 3093, + "collection-storage-copies.ts": 2080, + "collection-value-keys.ts": 2956, + "compound-field-receivers.ts": 1671, + "compound-presence-guards.ts": 3200, + "conditional-tuple-destructuring.ts": 2750, + "console-imports.cjs": 1673, + "console-native-value.js": 2807, + "const-enum-module-cycle/main.ts": 2704, + "constant-callback-dispatch.ts": 1960, + "constant-module-globals/main.ts": 1705, + "constant-number-remainders.ts": 2349, + "constructed-class-dispatch.ts": 3130, + "contextual-array-union-write.ts": 6681, + "contextual-return-layouts.ts": 3422, + "counted-loop-numbers.ts": 2709, + "counted-loop-storage.ts": 2965, + "crypto-hash-optional-input.ts": 2865, + "cycle-generations-long-lived.ts": 2572, + "cycle-growth-yield.ts": 3019, + "date-checked-native.js": 2742, + "declared-index-spread.ts": 3806, + "deep-reference-teardown.ts": 3156, + "default-undefined-parameters.ts": 2963, + "deferred-field-updates.ts": 1865, + "deferred-registry-many.ts": 3051, + "derived-numeric-updates.ts": 1958, + "destructure-call-assignment.js": 2640, + "destructure-inferred-row-defaults.js": 2122, + "destructure-union-arrays.ts": 2784, + "dynamic-function-descriptors.js": 2749, + "error-cause-writes.js": 2022, + "error-inherited-message.mjs": 2684, + "error-inherited-name.mjs": 2378, + "error-property-writes.mjs": 2676, + "error-prototype-tostring.js": 3103, + "error-stack-frames.ts": 2531, + "error-stack-limit.ts": 2338, + "error-tostring-overrides.ts": 2421, + "error-values-inspect.ts": 2394, + "exact-index-round-trip.ts": 2708, + "expression-runtime-values.ts": 2672, + "fiber-switch-stress.ts": 2404, + "fiberless-async-ordering.ts": 2698, + "fiberless-async-unhandled.ts": 2605, + "field-assignment-values.ts": 2753, + "file-handle-values.ts": 2888, + "file-read-storage.ts": 3335, + "file-url-percent-decoding.ts": 1678, + "final-field-borrows.ts": 2810, + "for-multiple-bindings.ts": 2621, + "for-multiple-lexical-bindings.ts": 2696, + "for-of-checked-iterator.js": 2735, + "for-of-subclass-elements.ts": 2538, + "forward-generic-signatures.ts": 1734, + "fresh-array-union-layout.js": 2661, + "frozen-checked-dictionaries.mjs": 2513, + "fs-native-realpath.ts": 2900, "fs-null-byte-paths-js.cjs": 2166, "fs-null-byte-paths.ts": 3560, - "fs-read-encodings.ts": 2505, + "fs-read-encodings.ts": 2192, "fs-read-utf8-edges.ts": 3494, "fs-read-utf8-handle-forms.ts": 1894, - "fs-remove-readonly.ts": 2354, - "fs-write-string-bytes-union.ts": 2286, - "function-apply-value.mjs": 2558, - "function-constructor-global.mjs": 1848, - "function-constructor-kinds/main.js": 2532, - "function-custom-prototype.js": 2604, - "function-custom-to-string.mjs": 2607, - "function-object-assign.js": 2509, - "function-own-prototype/main.js": 2423, - "generator-checked-protocol.ts": 2631, - "generator-checked-return.js": 2326, - "generator-custom-delegation/main.ts": 3343, - "generator-default-return-pattern.ts": 2653, - "generator-delegation-values.ts": 2368, - "generator-inferred-date.js": 2465, - "generator-mixed-checked-channels.ts": 2662, - "generator-untyped-consumer/main.ts": 2958, - "generic-base-specializations.ts": 2073, - "generic-binding-ownership.ts": 2817, - "generic-class-js-functions/main.ts": 2051, - "generic-class-recovery.ts": 2415, - "generic-namespace-factories/main.ts": 2073, - "generic-nullable-collections.ts": 2677, - "generic-pattern-bindings.ts": 2698, - "generic-record-index.ts": 2753, - "generic-visitor-void.ts": 2405, + "fs-remove-readonly.ts": 2005, + "fs-write-string-bytes-union.ts": 2781, + "function-apply-value.mjs": 2795, + "function-constructor-global.mjs": 2338, + "function-constructor-kinds/main.js": 3030, + "function-custom-prototype.js": 2801, + "function-custom-to-string.mjs": 1937, + "function-object-assign.js": 1754, + "function-own-prototype/main.js": 2470, + "generator-checked-protocol.ts": 2909, + "generator-checked-return.js": 3084, + "generator-custom-delegation/main.ts": 5038, + "generator-default-return-pattern.ts": 2685, + "generator-delegation-values.ts": 1962, + "generator-inferred-date.js": 3181, + "generator-mixed-checked-channels.ts": 2887, + "generator-untyped-consumer/main.ts": 2216, + "generic-base-specializations.ts": 2930, + "generic-binding-ownership.ts": 2565, + "generic-class-js-functions/main.ts": 2055, + "generic-class-recovery.ts": 2723, + "generic-namespace-factories/main.ts": 2103, + "generic-nullable-collections.ts": 2282, + "generic-pattern-bindings.ts": 2536, + "generic-record-index.ts": 2488, + "generic-visitor-void.ts": 2848, "global-accumulator-loops.ts": 2271, - "global-error-subclasses.ts": 1773, - "global-runtime-probes.js": 2288, - "global-stored-probes.js": 2726, - "global-string-cache/main.js": 1889, - "global-symbol-cache/main.js": 3399, - "guarded-native-iterables.ts": 2496, - "heap-input-aliases.ts": 2746, - "heap-input-collections.ts": 2558, - "in-array-runtime-index.ts": 2579, - "indexed-assignment-values.js": 2971, - "indexed-assignment-values.ts": 1852, - "indexed-element-field-reads.ts": 2452, - "inferred-array-assignment-values.mjs": 2352, - "inferred-class-default.mjs": 2460, - "inferred-compound-values.mjs": 2473, - "inferred-conditional-class.mjs": 2635, - "inferred-error-fields.js": 2509, - "inferred-map-patterns.mjs": 2353, - "inferred-method-override.js": 2137, - "inferred-partial-destructuring.mjs": 2205, - "inferred-primitive-properties.mjs": 2135, - "inferred-record-return.mjs": 1793, - "inferred-recursive-record.mjs": 1833, - "inferred-undefined-field.mjs": 1777, - "input-lifetime-intervals.ts": 2714, - "input-lifetimes-modules/main.ts": 3258, - "instanceof-class-record-union.ts": 2400, - "integer-flow-arithmetic.ts": 3652, - "integer-loop-forms.ts": 2368, - "integer-view-control.ts": 1809, - "integer-view-numbers.ts": 2394, - "integer-view-storage.ts": 2439, - "intl-grapheme-conformance/main.ts": 3718, - "intl-grapheme.ts": 2449, - "iterator-typed-returns.ts": 3400, - "js-abort-portable.js": 2829, - "js-array-constructor.js": 3163, - "js-array-default-buffer.js": 2537, - "js-array-iterators.js": 2559, - "js-arrow-bind.cjs": 3343, - "js-buffer-callback-brand.cjs": 2262, - "js-callable-proxy.js": 3516, - "js-chained-native-results.mjs": 2641, - "js-checked-array-iterator.js": 2670, - "js-checked-array-reference.js": 2270, - "js-checked-number-negation.mjs": 1915, - "js-checked-sort-result.js": 2373, - "js-child-error-listener.cjs": 2357, - "js-cjs-callable-snapshots/main.cjs": 1981, - "js-class-added-parameters.js": 2472, - "js-class-checked-overrides.js": 2571, - "js-class-computed-fields.js": 1830, - "js-class-enumeration.js": 3296, - "js-class-field-accessor-override.js": 2567, - "js-class-fluent-overrides.js": 2822, - "js-class-late-method-values.js": 2309, - "js-class-member-dispatch.js": 3016, - "js-class-return-shapes.js": 2231, - "js-class-shadowed-methods.js": 2942, - "js-class-stored-method-receiver.js": 2382, - "js-class-subclass-properties.js": 3695, - "js-class-symbol-spread.cjs": 2704, - "js-computed-prototype-additions.js": 3142, - "js-constructor-returned-callable.js": 2605, - "js-constructor-spread.js": 2289, - "js-dataview-dispatch.js": 2273, - "js-declared-fields.cjs": 3263, - "js-default-listener-arguments.cjs": 2549, - "js-default-options/main.ts": 3044, - "js-deferred-field-initializers.js": 2121, - "js-deferred-registry-effects.js": 2381, - "js-derived-constructor-hoisting.js": 1805, - "js-dormant-array-write.js": 1888, - "js-dormant-overrides.js": 2569, - "js-expando-records.js": 2454, - "js-implicit-call-results.js": 3064, - "js-inferred-callback-exports/main.js": 3830, - "js-inferred-class-array-return.js": 2570, - "js-inferred-object-values.js": 2380, - "js-inherited-field-storage.js": 3121, - "js-inherited-parameter-abi.js": 2210, - "js-iterable-spread.js": 2950, - "js-loose-dynamic-primitives.js": 1960, - "js-map-object-seeds.js": 2610, - "js-member-increment.js": 2926, - "js-module-function-values.js": 2014, - "js-mutable-null-members.js": 2370, - "js-nested-native-descriptors.js": 2412, - "js-normalize-dispatch.js": 2793, - "js-nullish-inherited-fields.mjs": 2710, - "js-object-receiver-storage.js": 2613, - "js-object-returning-constructors.mjs": 2186, - "js-object-shared-arrays.js": 2465, - "js-omitted-typed-arguments.js": 2236, - "js-open-binding-writes.js": 1787, - "js-optional-class-fields.js": 2266, - "js-optional-member-call.js": 1883, - "js-primitive-union-addition.js": 2256, - "js-promise-all-values.js": 3079, - "js-promise-catch-handler.js": 1749, - "js-promise-finally-order.js": 1913, - "js-promise-pending-reactions.js": 2644, - "js-prototype-host-boundary.js": 2224, - "js-reflect-receivers.js": 3119, - "js-regex-record-captures.js": 2010, - "js-scalar-iterables.js": 2477, - "js-shared-method-dispatch.js": 2033, - "js-specialized-field-method.js": 2335, - "js-static-accessors.js": 2520, - "js-static-method-values.js": 2194, - "js-static-registries.cjs": 2703, - "js-super-accessor-initialization.js": 2100, - "js-uninitialized-native-fields.js": 2180, - "json-guarded-map-values.ts": 2374, - "json-output-bulk.ts": 2827, - "json-runtime-options.mjs": 1997, - "json-stringify-value.js": 2563, - "json-typed-parse-direct.ts": 2355, + "global-error-subclasses.ts": 1850, + "global-runtime-probes.js": 3085, + "global-stored-probes.js": 3029, + "global-string-cache/main.js": 2487, + "global-symbol-cache/main.js": 2631, + "guarded-native-iterables.ts": 2969, + "heap-input-aliases.ts": 2864, + "heap-input-collections.ts": 2900, + "in-array-runtime-index.ts": 3065, + "indexed-assignment-values.js": 2826, + "indexed-assignment-values.ts": 1639, + "indexed-element-field-reads.ts": 1506, + "inferred-array-assignment-values.mjs": 2520, + "inferred-class-default.mjs": 2339, + "inferred-compound-values.mjs": 2708, + "inferred-conditional-class.mjs": 2429, + "inferred-error-fields.js": 2383, + "inferred-map-patterns.mjs": 2476, + "inferred-method-override.js": 2284, + "inferred-partial-destructuring.mjs": 1972, + "inferred-primitive-properties.mjs": 2268, + "inferred-record-return.mjs": 2543, + "inferred-recursive-record.mjs": 2822, + "inferred-undefined-field.mjs": 2615, + "input-lifetime-intervals.ts": 2188, + "input-lifetimes-modules/main.ts": 2672, + "instanceof-class-record-union.ts": 2441, + "integer-flow-arithmetic.ts": 1990, + "integer-loop-forms.ts": 2426, + "integer-view-control.ts": 2085, + "integer-view-numbers.ts": 2088, + "integer-view-storage.ts": 2560, + "intl-grapheme-conformance/main.ts": 4354, + "intl-grapheme.ts": 1787, + "iterator-typed-returns.ts": 2556, + "js-abort-portable.js": 3289, + "js-array-constructor.js": 3326, + "js-array-default-buffer.js": 2785, + "js-array-iterators.js": 2367, + "js-arrow-bind.cjs": 3832, + "js-buffer-callback-brand.cjs": 2996, + "js-callable-proxy.js": 3619, + "js-chained-native-results.mjs": 2794, + "js-checked-array-iterator.js": 2235, + "js-checked-array-reference.js": 3562, + "js-checked-number-negation.mjs": 2819, + "js-checked-sort-result.js": 2743, + "js-child-error-listener.cjs": 2228, + "js-cjs-callable-snapshots/main.cjs": 2256, + "js-class-added-parameters.js": 2567, + "js-class-checked-overrides.js": 2547, + "js-class-computed-fields.js": 2943, + "js-class-enumeration.js": 3714, + "js-class-field-accessor-override.js": 3000, + "js-class-fluent-overrides.js": 2749, + "js-class-late-method-values.js": 2358, + "js-class-member-dispatch.js": 3594, + "js-class-return-shapes.js": 3435, + "js-class-shadowed-methods.js": 3639, + "js-class-stored-method-receiver.js": 2943, + "js-class-subclass-properties.js": 3662, + "js-class-symbol-spread.cjs": 2503, + "js-computed-prototype-additions.js": 2456, + "js-constructor-returned-callable.js": 2517, + "js-constructor-spread.js": 3593, + "js-dataview-dispatch.js": 2188, + "js-declared-fields.cjs": 4540, + "js-default-listener-arguments.cjs": 2448, + "js-default-options/main.ts": 3104, + "js-deferred-field-initializers.js": 2710, + "js-deferred-registry-effects.js": 2361, + "js-derived-constructor-hoisting.js": 2306, + "js-dormant-array-write.js": 2104, + "js-dormant-overrides.js": 1741, + "js-expando-records.js": 2473, + "js-implicit-call-results.js": 2893, + "js-inferred-callback-exports/main.js": 4125, + "js-inferred-class-array-return.js": 2816, + "js-inferred-object-values.js": 2369, + "js-inherited-field-storage.js": 3308, + "js-inherited-parameter-abi.js": 2238, + "js-iterable-spread.js": 2086, + "js-loose-dynamic-primitives.js": 2810, + "js-map-object-seeds.js": 2592, + "js-member-increment.js": 3352, + "js-module-function-values.js": 2994, + "js-mutable-null-members.js": 2723, + "js-nested-native-descriptors.js": 2548, + "js-normalize-dispatch.js": 2929, + "js-nullish-inherited-fields.mjs": 2189, + "js-object-receiver-storage.js": 2175, + "js-object-returning-constructors.mjs": 2945, + "js-object-shared-arrays.js": 2935, + "js-omitted-typed-arguments.js": 2736, + "js-open-binding-writes.js": 2167, + "js-optional-class-fields.js": 3219, + "js-optional-member-call.js": 3110, + "js-primitive-union-addition.js": 2549, + "js-promise-all-values.js": 3527, + "js-promise-catch-handler.js": 2649, + "js-promise-finally-order.js": 2445, + "js-promise-pending-reactions.js": 2595, + "js-prototype-host-boundary.js": 2723, + "js-reflect-receivers.js": 3391, + "js-regex-record-captures.js": 3115, + "js-scalar-iterables.js": 2746, + "js-shared-method-dispatch.js": 2796, + "js-specialized-field-method.js": 2049, + "js-static-accessors.js": 3053, + "js-static-method-values.js": 2375, + "js-static-registries.cjs": 2790, + "js-super-accessor-initialization.js": 2104, + "js-uninitialized-native-fields.js": 1764, + "json-guarded-map-values.ts": 3144, + "json-output-bulk.ts": 2572, + "json-runtime-options.mjs": 2583, + "json-stringify-value.js": 2182, + "json-typed-parse-direct.ts": 3644, "json-typed-parse-index-signatures.ts": 4122, "json-typed-parse-optional-members.ts": 3273, "json-typed-parse-union-members.ts": 3078, - "literal-switch-dispatch.ts": 2500, - "live-reference-shared-converters.ts": 2552, - "llvm-read-receiver-lifetime.ts": 2343, - "local-class-call-spreads.js": 3208, - "local-class-declaration.ts": 2486, - "local-class-evaluation.ts": 2605, - "local-class-inheritance.ts": 2327, - "local-class-lifetimes.ts": 2376, - "local-class-namespace/main.js": 2940, - "local-class-prototype-data.js": 2781, - "local-class-specialization.js": 2399, - "local-class-unknown.ts": 2443, - "local-class-values.ts": 1784, - "local-union-storage.ts": 2967, - "locale-compare-root-order.ts": 2518, - "logical-assignment-dynamic.js": 2592, - "logical-assignment-values.ts": 2497, - "logical-runtime-optional-record.ts": 2944, - "loop-reference-lifetimes.ts": 2542, - "map-checked-boundary/main.ts": 2629, - "map-checked-seed.js": 3013, + "literal-switch-dispatch.ts": 2252, + "live-reference-shared-converters.ts": 3470, + "llvm-read-receiver-lifetime.ts": 3118, + "local-class-call-spreads.js": 2490, + "local-class-declaration.ts": 2302, + "local-class-evaluation.ts": 2915, + "local-class-inheritance.ts": 2396, + "local-class-lifetimes.ts": 2780, + "local-class-namespace/main.js": 3248, + "local-class-prototype-data.js": 3273, + "local-class-specialization.js": 2054, + "local-class-unknown.ts": 1964, + "local-class-values.ts": 2059, + "local-union-storage.ts": 2500, + "locale-compare-root-order.ts": 2609, + "logical-assignment-dynamic.js": 2892, + "logical-assignment-values.ts": 2287, + "logical-runtime-optional-record.ts": 2390, + "loop-reference-lifetimes.ts": 2959, + "map-checked-boundary/main.ts": 2651, + "map-checked-seed.js": 1821, "map-get-set-fusion.ts": 3131, - "map-number-keys-dense.ts": 2562, - "map-read-lifetimes-exits.ts": 2227, - "map-read-lifetimes.ts": 2725, - "map-seeds-and-spreads.ts": 2719, - "map-typed-array-values.ts": 2850, - "math-function-values.js": 2367, - "missing-read-lambda-results.ts": 2379, - "missing-read-narrowed-storage.ts": 2498, - "missing-read-number-conversions.ts": 2181, - "module-byte-loops.ts": 2636, - "module-fallback-functions/main.js": 2148, - "narrowed-nullish-values.ts": 2410, - "native-any-timer-callback.ts": 1834, - "native-array-borrowed-find-last.js": 2515, - "native-array-borrowed-slice.js": 2404, - "native-array-copying-methods.js": 2076, - "native-array-fill-copywithin.js": 2636, - "native-array-frozen-noops.js": 2476, - "native-array-index-boundaries.js": 1913, - "native-array-integrity.js": 2429, - "native-array-length.js": 2568, - "native-array-named-properties.js": 2390, - "native-array-prototype/main.js": 2161, - "native-array-read-lifetimes.ts": 2771, - "native-array-reduce-find-last.js": 2375, - "native-array-search-from-index.js": 1823, - "native-array-splice-coercion.js": 2296, - "native-array-splice-flat.js": 1933, - "native-buffer-coercion.js": 2389, - "native-callback-dispatch.ts": 3007, - "native-class-array-boundaries.ts": 2676, - "native-class-cache.js": 3391, - "native-class-properties.cjs": 3541, - "native-class-property-cycles.cjs": 2291, - "native-class-property-order.cjs": 1867, - "native-class-type-predicates.ts": 2386, - "native-factory-records.js": 2851, - "native-method-values.js": 2903, - "native-method-values.ts": 2495, - "native-npm-imports/main.ts": 2716, - "native-object-descriptors.js": 2717, - "native-object-for-in-minimal.js": 2536, - "native-object-property-attributes.js": 3149, - "native-object-prototype.js": 3180, - "native-property-names.ts": 1827, - "native-proxy-env.js": 3519, - "native-worker-arena-reuse.ts": 4699, - "native-worker-bounded-errors.ts": 2268, - "native-worker-buffer-consumers.ts": 2531, - "native-worker-cancel-hot.ts": 2446, - "native-worker-class-fields.ts": 2650, - "native-worker-clone-errors.ts": 2347, - "native-worker-commonjs.cjs": 2188, - "native-worker-delayed-messages.ts": 3114, - "native-worker-discarded-heaps.ts": 4430, - "native-worker-environment.ts": 3538, - "native-worker-error.ts": 2810, - "native-worker-exception-state.ts": 3938, - "native-worker-exit-listeners.ts": 2965, - "native-worker-io.ts": 3018, - "native-worker-loop-cancellation.ts": 2773, - "native-worker-message-graphs.ts": 2440, - "native-worker-messages.ts": 2911, - "native-worker-poll-exceptions.ts": 2706, - "native-worker-port-lifetime.ts": 3175, - "native-worker-process-exit.ts": 2168, - "native-worker-publish-classes.ts": 2797, - "native-worker-publish-refusals.ts": 2330, - "native-worker-published-graphs.ts": 3411, - "native-worker-references.ts": 2156, - "native-worker-roots/main.ts": 2962, - "native-worker-shared-views.ts": 2377, - "native-worker-stack-overflow.ts": 2443, - "native-worker-terminate-exception-state.ts": 3368, - "native-worker-terminate-loop.ts": 1929, - "native-worker-terminate-recursion.ts": 2935, - "native-worker-terminate-suspended.ts": 2843, - "native-worker-terminate-tested-loops.ts": 3082, - "native-worker-terminate-wait.ts": 2267, - "native-worker-typed-arrays.ts": 2361, - "nested-map-cycles.ts": 2306, - "nested-map-values.ts": 2038, - "never-returning-calls.ts": 2680, - "next-tick-commonjs-entry.cjs": 1924, - "node24-buffer-encoding-errors.ts": 2742, - "node24-buffer-encoding.ts": 2822, - "node24-crypto-kdf-errors.ts": 2607, - "node24-crypto-kdf-options.ts": 1925, - "node24-crypto-kdf.ts": 3401, - "node24-crypto-sha2.ts": 2336, - "node24-deep-equality-properties.js": 2551, - "node24-deep-equality.cjs": 2373, - "node24-deep-equality.ts": 3193, - "node24-env-files-errors.ts": 2555, - "node24-env-files.ts": 2556, - "node24-env-imports.cjs": 2518, - "node24-env-parse-errors.ts": 2083, - "node24-env-parse.ts": 2189, - "node24-esm-metadata/main.mjs": 2257, - "node24-file-url-buffer.ts": 1904, - "node24-file-url-errors.js": 2838, - "node24-file-url-options.ts": 2563, - "node24-fs-links-callbacks.cjs": 2964, - "node24-fs-links-errors.cjs": 2795, - "node24-fs-links-options.cjs": 3096, - "node24-fs-links-promise-errors.cjs": 2481, - "node24-fs-links-promises.ts": 2014, - "node24-fs-links.ts": 3060, - "node24-fs-statfs-callbacks.cjs": 2761, - "node24-fs-statfs-errors.cjs": 3068, - "node24-fs-statfs-options.cjs": 2927, - "node24-fs-statfs.ts": 2192, - "node24-fs-timestamps-callbacks.cjs": 2865, - "node24-fs-timestamps-errors.cjs": 2733, - "node24-fs-timestamps-promises.ts": 2476, - "node24-fs-timestamps-symlinks.ts": 2406, - "node24-fs-timestamps.ts": 2758, - "node24-no-error-assertions-coercion.js": 2950, - "node24-no-error-assertions.cjs": 2361, - "node24-no-error-assertions.ts": 2895, - "node24-parseargs.js": 3512, - "node24-string-decoder.ts": 2569, - "node24-style-text-environment.js": 2370, - "node24-style-text-validation.js": 2999, - "node24-style-text.cjs": 1883, - "node24-style-text.ts": 2102, - "node24-system-error-validation.js": 2003, - "node24-system-errors.cjs": 2247, - "node24-system-errors.ts": 2302, - "node24-text-codec-properties.ts": 2178, - "node24-text-encode-into.ts": 2427, - "node24-text-utilities-coercion.js": 2867, - "node24-text-utilities-validation.js": 1874, - "node24-text-utilities.cjs": 2132, - "node24-text-utilities.ts": 2215, - "node24-url-authority-coercion.js": 2529, - "node24-url-authority.ts": 2720, - "node24-url-factories.ts": 2586, - "node24-url-factory-errors.ts": 1931, - "node24-url-mutation-coercion.js": 2518, - "node24-url-mutation.ts": 2194, - "node24-util-types.cjs": 3057, - "node24-util-types.js": 1900, - "node24-util-types.ts": 2935, - "non-null-class-iteration.ts": 2350, - "nonnull-element-arguments.ts": 2545, - "nonnull-forwarded-class-values.ts": 2532, - "nullable-object-extension.mjs": 1922, - "nullish-asserted-class-arms.ts": 2485, - "nullish-assignment-values.ts": 1745, - "nullish-long-chain.ts": 2326, - "number-parse-statics.ts": 2443, - "number-predicates-unknown.ts": 2375, - "numeric-call-specialization.ts": 2588, - "object-enumeration-array-reads.ts": 1967, - "object-from-checked-entries.js": 2542, - "object-inherited-to-string.js": 2670, - "object-key-indexes.js": 2753, - "object-prototype-identity.mjs": 2064, - "object-reexport/main.js": 2482, - "object-spread-computed.ts": 2578, - "opentui-byte-queue.js": 2802, - "optional-callback-arity.ts": 2348, - "optional-class-flows.ts": 2247, - "optional-element-defaults.ts": 2052, - "optional-flag-comparisons.ts": 2527, - "optional-native-callables.js": 2309, - "optional-node-list-iteration.ts": 2316, - "optional-string-index/main.ts": 2950, - "path-to-file-url-options.ts": 2299, - "performance-presence.ts": 2043, - "primitive-and-function-descriptors.js": 2222, - "primitive-union-string.ts": 2856, - "process-builtin-values.js": 2616, - "process-constrained-memory.ts": 2105, - "process-env-computed-keys.js": 2252, - "process-hrtime.js": 2596, - "process-named-signals.cjs": 2604, - "process-uncaught-handler-throws.cjs": 2306, - "process-uncaught-loop.cjs": 2320, - "process-uncaught-module.mjs": 1832, - "process-uncaught-monitor.cjs": 2077, - "process-uncaught-rejection.cjs": 2431, - "process-uncaught-sync.cjs": 2425, - "process-version-pin.ts": 2418, - "process-versions-storage.ts": 2051, - "projected-collection-lifetimes.ts": 2409, - "promise-checked-rejections.ts": 1985, - "promise-resolve-void.ts": 2341, - "prototype-method-overrides.mjs": 4870, - "prototype-named-data-records.ts": 2513, + "map-number-keys-dense.ts": 2480, + "map-read-lifetimes-exits.ts": 2004, + "map-read-lifetimes.ts": 2956, + "map-seeds-and-spreads.ts": 2807, + "map-typed-array-values.ts": 2864, + "math-function-values.js": 2704, + "missing-read-lambda-results.ts": 2964, + "missing-read-narrowed-storage.ts": 2975, + "missing-read-number-conversions.ts": 2247, + "module-byte-loops.ts": 2710, + "module-fallback-functions/main.js": 2953, + "narrowed-nullish-values.ts": 2689, + "native-any-timer-callback.ts": 2256, + "native-array-borrowed-find-last.js": 2331, + "native-array-borrowed-slice.js": 2738, + "native-array-copying-methods.js": 2547, + "native-array-fill-copywithin.js": 2422, + "native-array-frozen-noops.js": 1940, + "native-array-index-boundaries.js": 1855, + "native-array-integrity.js": 3078, + "native-array-length.js": 2779, + "native-array-named-properties.js": 2991, + "native-array-prototype/main.js": 1536, + "native-array-read-lifetimes.ts": 3338, + "native-array-reduce-find-last.js": 2328, + "native-array-search-from-index.js": 2430, + "native-array-splice-coercion.js": 2633, + "native-array-splice-flat.js": 2555, + "native-buffer-coercion.js": 2993, + "native-callback-dispatch.ts": 3551, + "native-class-array-boundaries.ts": 2938, + "native-class-cache.js": 4207, + "native-class-properties.cjs": 3301, + "native-class-property-cycles.cjs": 2085, + "native-class-property-order.cjs": 2417, + "native-class-type-predicates.ts": 2597, + "native-factory-records.js": 2167, + "native-method-values.js": 3675, + "native-method-values.ts": 2504, + "native-npm-imports/main.ts": 3572, + "native-object-descriptors.js": 2795, + "native-object-for-in-minimal.js": 2689, + "native-object-property-attributes.js": 2700, + "native-object-prototype.js": 2600, + "native-property-names.ts": 2409, + "native-proxy-env.js": 3746, + "native-worker-arena-reuse.ts": 4764, + "native-worker-bounded-errors.ts": 3072, + "native-worker-buffer-consumers.ts": 2989, + "native-worker-cancel-hot.ts": 2633, + "native-worker-class-fields.ts": 3458, + "native-worker-clone-errors.ts": 2734, + "native-worker-commonjs.cjs": 2159, + "native-worker-delayed-messages.ts": 2169, + "native-worker-discarded-heaps.ts": 5523, + "native-worker-environment.ts": 3190, + "native-worker-error.ts": 2740, + "native-worker-exception-state.ts": 4140, + "native-worker-exit-listeners.ts": 2056, + "native-worker-io.ts": 2596, + "native-worker-loop-cancellation.ts": 2554, + "native-worker-message-graphs.ts": 3182, + "native-worker-messages.ts": 2651, + "native-worker-poll-exceptions.ts": 3212, + "native-worker-port-lifetime.ts": 3033, + "native-worker-process-exit.ts": 2692, + "native-worker-publish-classes.ts": 4065, + "native-worker-publish-refusals.ts": 3039, + "native-worker-published-graphs.ts": 3663, + "native-worker-references.ts": 2640, + "native-worker-roots/main.ts": 3080, + "native-worker-shared-views.ts": 3041, + "native-worker-stack-overflow.ts": 2862, + "native-worker-terminate-exception-state.ts": 3985, + "native-worker-terminate-loop.ts": 2725, + "native-worker-terminate-recursion.ts": 3128, + "native-worker-terminate-suspended.ts": 2867, + "native-worker-terminate-tested-loops.ts": 3161, + "native-worker-terminate-wait.ts": 1905, + "native-worker-typed-arrays.ts": 2971, + "nested-map-cycles.ts": 2802, + "nested-map-values.ts": 3022, + "never-returning-calls.ts": 2411, + "next-tick-commonjs-entry.cjs": 2251, + "node24-buffer-encoding-errors.ts": 2393, + "node24-buffer-encoding.ts": 2789, + "node24-crypto-kdf-errors.ts": 2833, + "node24-crypto-kdf-options.ts": 2131, + "node24-crypto-kdf.ts": 4066, + "node24-crypto-sha2.ts": 1593, + "node24-deep-equality-properties.js": 2924, + "node24-deep-equality.cjs": 2596, + "node24-deep-equality.ts": 3235, + "node24-env-files-errors.ts": 2781, + "node24-env-files.ts": 2586, + "node24-env-imports.cjs": 1729, + "node24-env-parse-errors.ts": 2642, + "node24-env-parse.ts": 2636, + "node24-esm-metadata/main.mjs": 2627, + "node24-file-url-buffer.ts": 2669, + "node24-file-url-errors.js": 2467, + "node24-file-url-options.ts": 3030, + "node24-fs-links-callbacks.cjs": 3015, + "node24-fs-links-errors.cjs": 2843, + "node24-fs-links-options.cjs": 3229, + "node24-fs-links-promise-errors.cjs": 2844, + "node24-fs-links-promises.ts": 2107, + "node24-fs-links.ts": 1958, + "node24-fs-statfs-callbacks.cjs": 2203, + "node24-fs-statfs-errors.cjs": 2705, + "node24-fs-statfs-options.cjs": 2846, + "node24-fs-statfs.ts": 2174, + "node24-fs-timestamps-callbacks.cjs": 2972, + "node24-fs-timestamps-errors.cjs": 1969, + "node24-fs-timestamps-promises.ts": 2959, + "node24-fs-timestamps-symlinks.ts": 2931, + "node24-fs-timestamps.ts": 1989, + "node24-no-error-assertions-coercion.js": 3207, + "node24-no-error-assertions.cjs": 1972, + "node24-no-error-assertions.ts": 2214, + "node24-parseargs.js": 4158, + "node24-string-decoder.ts": 2635, + "node24-style-text-environment.js": 2062, + "node24-style-text-validation.js": 3237, + "node24-style-text.cjs": 2491, + "node24-style-text.ts": 2829, + "node24-system-error-validation.js": 2660, + "node24-system-errors.cjs": 2361, + "node24-system-errors.ts": 2897, + "node24-text-codec-properties.ts": 2383, + "node24-text-encode-into.ts": 2992, + "node24-text-utilities-coercion.js": 2902, + "node24-text-utilities-validation.js": 2997, + "node24-text-utilities.cjs": 2432, + "node24-text-utilities.ts": 1910, + "node24-url-authority-coercion.js": 2861, + "node24-url-authority.ts": 2689, + "node24-url-factories.ts": 1863, + "node24-url-factory-errors.ts": 1955, + "node24-url-mutation-coercion.js": 2400, + "node24-url-mutation.ts": 2663, + "node24-util-types.cjs": 3712, + "node24-util-types.js": 2869, + "node24-util-types.ts": 3395, + "non-null-class-iteration.ts": 2220, + "nonnull-element-arguments.ts": 2568, + "nonnull-forwarded-class-values.ts": 2603, + "nullable-object-extension.mjs": 2408, + "nullish-asserted-class-arms.ts": 2116, + "nullish-assignment-values.ts": 2517, + "nullish-long-chain.ts": 2430, + "number-parse-statics.ts": 1887, + "number-predicates-unknown.ts": 1974, + "numeric-call-specialization.ts": 2627, + "object-enumeration-array-reads.ts": 2586, + "object-from-checked-entries.js": 2775, + "object-inherited-to-string.js": 2674, + "object-key-indexes.js": 2909, + "object-prototype-identity.mjs": 2317, + "object-reexport/main.js": 2625, + "object-spread-computed.ts": 2429, + "opentui-byte-queue.js": 3139, + "optional-callback-arity.ts": 2294, + "optional-class-flows.ts": 2613, + "optional-element-defaults.ts": 2793, + "optional-flag-comparisons.ts": 2714, + "optional-native-callables.js": 2344, + "optional-node-list-iteration.ts": 2344, + "optional-string-index/main.ts": 2788, + "path-to-file-url-options.ts": 2568, + "performance-presence.ts": 2450, + "primitive-and-function-descriptors.js": 2677, + "primitive-union-string.ts": 1777, + "process-builtin-values.js": 3974, + "process-constrained-memory.ts": 1850, + "process-env-computed-keys.js": 2019, + "process-hrtime.js": 2975, + "process-named-signals.cjs": 2191, + "process-uncaught-handler-throws.cjs": 2460, + "process-uncaught-loop.cjs": 2411, + "process-uncaught-module.mjs": 1942, + "process-uncaught-monitor.cjs": 1718, + "process-uncaught-rejection.cjs": 2645, + "process-uncaught-sync.cjs": 2436, + "process-version-pin.ts": 1717, + "process-versions-storage.ts": 2502, + "projected-collection-lifetimes.ts": 2791, + "promise-checked-rejections.ts": 2434, + "promise-resolve-void.ts": 2330, + "prototype-method-overrides.mjs": 4995, + "prototype-named-data-records.ts": 2858, "rc-last-use-moves.ts": 2819, "rc-private-array-writes.ts": 2121, - "record-field-presence.ts": 3025, - "record-key-order.ts": 2807, - "record-optional-json-presence.ts": 2623, - "record-presence-copies.ts": 2693, - "record-presence-delete-json.ts": 2748, - "record-unchecked-read-presence.ts": 2103, - "record-unknown-values.ts": 3450, - "reflect-own-keys.mjs": 2583, - "reflect-record-union-keys.mjs": 2454, - "reflect-typed-record-keys.ts": 1855, - "regex-callback-replacements.ts": 2492, - "regex-callback-values.js": 2733, - "regex-checked-casts.ts": 2350, - "regex-checked-storage.js": 2669, - "regex-exec-long-subject.ts": 4533, + "record-field-presence.ts": 3356, + "record-key-order.ts": 2943, + "record-optional-json-presence.ts": 2861, + "record-presence-copies.ts": 2372, + "record-presence-delete-json.ts": 3243, + "record-unchecked-read-presence.ts": 2717, + "record-unknown-values.ts": 3976, + "reflect-own-keys.mjs": 2238, + "reflect-record-union-keys.mjs": 2626, + "reflect-typed-record-keys.ts": 2852, + "regex-callback-replacements.ts": 2111, + "regex-callback-values.js": 2464, + "regex-checked-casts.ts": 2160, + "regex-checked-storage.js": 2310, + "regex-exec-long-subject.ts": 4567, "regex-exec-result-arrays.ts": 3123, "regex-fs-text-surfaces.ts": 2847, - "regex-input-lifetimes.ts": 2535, - "regex-native-matcher.ts": 3683, - "regex-optional-captures.ts": 2606, - "regex-optional-templates.ts": 2338, - "regex-split-captures.ts": 2583, - "regex-text-paths.ts": 2889, - "regexp-constructor-repeat.ts": 2351, - "regexp-optional-constructor.ts": 2315, - "regexp-string-coercion.js": 1897, - "renderer-export-dictionaries.js": 2582, - "renderer-null-state.js": 2185, - "renderer-specializations.js": 2653, - "repeat-and-typed-read-errors.ts": 2751, - "rest-optional-array-arguments.ts": 2671, - "rest-optional-elements.ts": 2289, - "return-void-through-finally.ts": 2486, - "runtime-optional-string-flows.ts": 2406, - "scalar-string-slices.ts": 2175, - "set-checked-methods.js": 2631, - "set-checked-storage.ts": 2064, - "set-iterator-seed-references.ts": 2863, - "set-iterator-seeds.ts": 2896, - "set-optional-seeds.ts": 2121, - "small-collection-transitions.ts": 2645, + "regex-input-lifetimes.ts": 2221, + "regex-native-matcher.ts": 4414, + "regex-optional-captures.ts": 3043, + "regex-optional-templates.ts": 2695, + "regex-split-captures.ts": 2413, + "regex-text-paths.ts": 3078, + "regexp-constructor-repeat.ts": 2829, + "regexp-optional-constructor.ts": 2162, + "regexp-string-coercion.js": 2219, + "renderer-export-dictionaries.js": 2331, + "renderer-null-state.js": 1751, + "renderer-specializations.js": 2860, + "repeat-and-typed-read-errors.ts": 2689, + "rest-optional-array-arguments.ts": 2219, + "rest-optional-elements.ts": 2503, + "return-void-through-finally.ts": 2582, + "runtime-optional-string-flows.ts": 2381, + "scalar-string-slices.ts": 2256, + "set-checked-methods.js": 2598, + "set-checked-storage.ts": 2088, + "set-iterator-seed-references.ts": 2454, + "set-iterator-seeds.ts": 3016, + "set-optional-seeds.ts": 2563, + "small-collection-transitions.ts": 2967, "speculative-integer-globals.ts": 2480, "speculative-integer-loops.ts": 3219, "speculative-integer-reads.ts": 2852, - "stack-depth-async-bodies.ts": 1910, - "stack-overflow-async.ts": 2447, - "stack-overflow-caught.ts": 2424, - "stack-overflow-finally.ts": 2613, - "stack-overflow-shapes.ts": 2534, - "stack-overflow-uncaught.ts": 2317, + "stack-depth-async-bodies.ts": 2421, + "stack-overflow-async.ts": 1922, + "stack-overflow-caught.ts": 2542, + "stack-overflow-finally.ts": 2607, + "stack-overflow-shapes.ts": 3083, + "stack-overflow-uncaught.ts": 2465, "stackless-async-concurrency.ts": 2441, "stackless-async-context.ts": 2934, "stackless-async-exceptions.ts": 2936, "stackless-async-ordering.ts": 2618, "stackless-async-unhandled.ts": 2477, - "static-field-updates/main.ts": 2050, - "static-method-receivers.ts": 2243, - "stdio-values.mjs": 2578, - "stdio-write-errors.mjs": 1977, - "stdio-write-overrides.mjs": 2495, - "stored-native-builtins.js": 2831, - "stored-object-helpers.js": 2747, + "static-field-updates/main.ts": 2461, + "static-method-receivers.ts": 1849, + "stdio-values.mjs": 2236, + "stdio-write-errors.mjs": 2342, + "stdio-write-overrides.mjs": 2002, + "stored-native-builtins.js": 2708, + "stored-object-helpers.js": 2808, "stream-dynamic-entry-kinds.cjs": 3015, "stream-dynamic-entry-kinds.ts": 1582, "stream-encoded-from-entries.cjs": 3058, "stream-encoded-from-entries.ts": 2590, - "string-char-code-integer-loops.ts": 2495, - "string-code-points.ts": 1970, - "string-concat-number-parts.ts": 2044, - "string-construction-order.ts": 2502, + "string-char-code-integer-loops.ts": 2802, + "string-code-points.ts": 2658, + "string-concat-number-parts.ts": 2339, + "string-construction-order.ts": 2902, "string-field-append.ts": 3251, - "string-lifetimes-boundaries.ts": 2481, - "string-lifetimes-evaluation.ts": 2486, - "string-lifetimes-iteration.ts": 2043, - "string-lifetimes-operations.ts": 2490, - "string-normalize.ts": 2391, - "string-pattern-replacement.ts": 3527, - "string-scan-fast-paths.ts": 2272, - "string-split-checked-separator.mjs": 2144, - "string-split-traversal.ts": 3038, - "structural-class-properties.ts": 2610, - "structured-text-boundaries.js": 2792, - "structured-text-storage.ts": 2942, - "switch-integer-dispatch.ts": 2290, - "symbol-checked-boundary/main.ts": 2273, - "symbol-class-fields.ts": 2065, - "symbol-class-fields/main.cjs": 2595, - "symbol-class-methods/main.ts": 1855, - "symbol-fields-deferred-factory.ts": 2253, - "symbol-fields-inferred.js": 2329, - "symbol-object-properties/main.js": 2835, - "synchronous-callback-lifetimes.ts": 2768, - "terminal-stream-properties.ts": 2586, - "text-codec-values/main.ts": 2158, - "text-codec-var.ts": 2182, - "text-encode-into-boundaries.ts": 1971, - "timers-clear-many.ts": 2704, - "tuple-and-string-search.ts": 2663, - "tuple-array-union.ts": 2706, - "tuple-callback-visitation.ts": 3464, - "tuple-forof-visitation.ts": 2357, - "typed-array-bulk-conversion.mjs": 3837, - "typed-array-byte-io.js": 2552, - "typed-array-checked-index.js": 2420, - "typed-array-constructor-alias.ts": 2507, - "typed-array-constructor-identity.js": 2453, - "typed-array-constructor-union.ts": 2428, - "typed-array-constructor-values.mjs": 2571, - "typed-array-dynamic-methods.js": 2604, - "typed-array-integer-widths.ts": 2747, - "typed-array-nan-coded-reads.ts": 2921, - "typed-array-numeric-import.ts": 2450, - "typed-array-present-reads.ts": 2582, - "typed-array-reversed-storage.ts": 2168, - "typed-array-unknown.ts": 2500, - "typed-collection-iterator-references.ts": 3186, - "typed-collection-iterators.ts": 2946, - "typed-collection-views/main.ts": 2523, - "typed-index-arguments.ts": 2494, - "typed-prototype-methods.ts": 2527, - "typed-rest-callables.ts": 2391, - "typed-rest-filtered-return.ts": 2578, - "typedarray-native-inputs.js": 3104, - "typeof-checked-comparison.js": 2116, - "uint8array-sort-domains.ts": 2494, - "unicode-case-paths.ts": 2356, - "unicode-process-argv.ts": 2569, - "union-discriminant-width.ts": 2670, - "union-literal-scalar-discriminants.ts": 2869, - "union-literal-slot-conversion.ts": 2792, - "union-nested-layout-discriminant.ts": 2120, - "union-optional-semantic-identity.ts": 2455, - "union-record-clone.ts": 2790, - "union-record-structural-copy.ts": 2905, - "union-reference-comparison.ts": 2401, - "unknown-array-holes.ts": 1853, - "unknown-collections.ts": 3166, - "unknown-object-enumeration.ts": 3783, - "unknown-record-views.ts": 3243, - "url-runtime-base.ts": 2584, - "utf8-span-decoding.ts": 2564, - "util-parseargs-wrapped/main.ts": 2257, - "virtual-runtime-optional-returns.ts": 2981, - "weak-map-array-buffer.ts": 2435, - "weak-map-fresh-array.js": 2341, - "weak-map-native.js": 3068, - "weak-native-class-identity.ts": 2403, - "weak-set-native.js": 2924, - "worker-class-instance-clone.ts": 3052 + "string-lifetimes-boundaries.ts": 2858, + "string-lifetimes-evaluation.ts": 1805, + "string-lifetimes-iteration.ts": 2235, + "string-lifetimes-operations.ts": 2468, + "string-normalize.ts": 2348, + "string-pattern-replacement.ts": 1662, + "string-scan-fast-paths.ts": 2133, + "string-split-checked-separator.mjs": 2285, + "string-split-traversal.ts": 1939, + "structural-class-properties.ts": 3139, + "structured-text-boundaries.js": 3111, + "structured-text-storage.ts": 2912, + "switch-integer-dispatch.ts": 2264, + "symbol-checked-boundary/main.ts": 2800, + "symbol-class-fields.ts": 2364, + "symbol-class-fields/main.cjs": 2507, + "symbol-class-methods/main.ts": 2255, + "symbol-fields-deferred-factory.ts": 2386, + "symbol-fields-inferred.js": 2386, + "symbol-object-properties/main.js": 3085, + "synchronous-callback-lifetimes.ts": 2296, + "terminal-stream-properties.ts": 2094, + "text-codec-values/main.ts": 2338, + "text-codec-var.ts": 2708, + "text-encode-into-boundaries.ts": 2679, + "timers-clear-many.ts": 2665, + "tuple-and-string-search.ts": 2567, + "tuple-array-union.ts": 2150, + "tuple-callback-visitation.ts": 3321, + "tuple-forof-visitation.ts": 2818, + "typed-array-bulk-conversion.mjs": 4061, + "typed-array-byte-io.js": 3073, + "typed-array-checked-index.js": 2572, + "typed-array-constructor-alias.ts": 2243, + "typed-array-constructor-identity.js": 2693, + "typed-array-constructor-union.ts": 2646, + "typed-array-constructor-values.mjs": 2380, + "typed-array-dynamic-methods.js": 2112, + "typed-array-integer-widths.ts": 2661, + "typed-array-nan-coded-reads.ts": 3761, + "typed-array-numeric-import.ts": 2783, + "typed-array-present-reads.ts": 3074, + "typed-array-reversed-storage.ts": 2650, + "typed-array-unknown.ts": 2830, + "typed-collection-iterator-references.ts": 3315, + "typed-collection-iterators.ts": 3098, + "typed-collection-views/main.ts": 1720, + "typed-index-arguments.ts": 2531, + "typed-prototype-methods.ts": 3386, + "typed-rest-callables.ts": 2393, + "typed-rest-filtered-return.ts": 2745, + "typedarray-native-inputs.js": 3102, + "typeof-checked-comparison.js": 2558, + "uint8array-sort-domains.ts": 2057, + "unicode-case-paths.ts": 2222, + "unicode-process-argv.ts": 2491, + "union-discriminant-width.ts": 2970, + "union-literal-scalar-discriminants.ts": 3053, + "union-literal-slot-conversion.ts": 2820, + "union-nested-layout-discriminant.ts": 1976, + "union-optional-semantic-identity.ts": 3464, + "union-record-clone.ts": 2368, + "union-record-structural-copy.ts": 3130, + "union-reference-comparison.ts": 2882, + "unknown-array-holes.ts": 1889, + "unknown-collections.ts": 3133, + "unknown-object-enumeration.ts": 4341, + "unknown-record-views.ts": 3288, + "url-runtime-base.ts": 2471, + "utf8-span-decoding.ts": 2821, + "util-parseargs-wrapped/main.ts": 2971, + "virtual-runtime-optional-returns.ts": 3001, + "weak-map-array-buffer.ts": 1951, + "weak-map-fresh-array.js": 2498, + "weak-map-native.js": 3238, + "weak-native-class-identity.ts": 2197, + "weak-set-native.js": 2814, + "worker-class-instance-clone.ts": 3421 }, "san": { - "001-hello.ts": 38244, - "002-log-args.ts": 31270, - "100-number-format.ts": 45195, - "1000-json-stringify-basics.ts": 46332, - "1001-json-escapes-unicode.ts": 4513, - "1002-json-parse-cast.ts": 35521, - "1003-json-parse-unions.ts": 3512, - "1004-json-parse-errors.ts": 3903, - "1005-json-nested.ts": 3425, - "1006-json-fs-config.ts": 3347, - "1007-json-rc-stress.ts": 34305, - "1008-json-null-arms.ts": 3422, - "1009-json-optional-fields.ts": 4004, - "101-arithmetic.ts": 4655, - "1010-json-stringify-space.ts": 45417, - "1011-json-unknown-typeof.ts": 4001, - "102-comparisons.ts": 3774, - "1020-async-basics.ts": 3697, - "1021-async-ordering.ts": 3078, - "1022-async-exceptions.ts": 3780, - "1023-async-rc-stress.ts": 3889, - "1024-async-pending-exit.ts": 3389, - "1025-async-promise-capture.ts": 42296, - "1026-throw-promise.ts": 4482, - "1027-async-return-promise.ts": 3534, - "1028-async-return-record-literals.ts": 3843, - "1029-async-eager-chains.ts": 4890, - "103-ternary.ts": 3470, - "104-ternary-empty-arrays.ts": 7056, - "1050-comptime-tables.ts": 4643, - "1051-comptime-strings.ts": 42895, - "1052-comptime-records.ts": 44375, - "1053-comptime-json.ts": 4497, - "1054-comptime-modules/main.ts": 4326, - "110-number-radix.ts": 3100, - "111-record-entries.ts": 7961, - "1110-math-members.ts": 3457, - "1111-math-random.ts": 4321, - "1113-string-methods.ts": 23286, - "1114-string-unicode-island.ts": 45718, - "1115-parse-globals.ts": 3277, - "1116-island-static-mix.ts": 3738, - "1117-typeof-static-union.ts": 4351, - "1118-object-spread-conditional.ts": 3602, - "1119-switch-union.ts": 4833, - "112-class-descriptor-key.js": 4674, - "1121-infinity-number-tostring.ts": 4470, - "1122-any-captures.ts": 7125, - "1124-union-narrowed-retag.ts": 3484, - "113-promise-checked-exits.ts": 4562, - "114-live-record-delete.ts": 3572, - "115-array-compound.js": 6457, - "116-text-decoder-runtime.js": 33483, - "117-weak-cache-cycle.js": 5789, - "118-fs-stored-callbacks.cjs": 52946, - "119-native-patterns.js": 6101, - "1200-regex-test-basics.ts": 47554, - "1201-regex-replace.ts": 3959, - "1202-regex-substitutions.ts": 3855, - "1203-regex-split.ts": 31517, - "1204-regex-empty-unicode.ts": 4662, - "1205-regex-rc-stress.ts": 36658, - "1300-errors-basics.ts": 4354, - "1301-errors-subclass.ts": 4687, - "1302-errors-typed-catch.ts": 4229, - "1303-errors-rc-stress.ts": 3431, - "1304-errors-uncaught.ts": 3763, - "1305-errors-async-rejections.ts": 4254, - "1306-errors-runtime-instances.ts": 4140, - "1350-path-normalize-join.ts": 4224, - "1351-path-parts.ts": 4167, - "1352-path-resolve-relative.ts": 4382, - "1353-os-basics.ts": 4007, - "1354-builtin-bare-specifiers.ts": 3999, - "1355-url-parse.ts": 3346, - "1356-url-file-bridge.ts": 3553, - "1357-fsp-roundtrip.ts": 4325, - "1358-crypto-random.ts": 3398, - "1359-json-module/main.ts": 4414, - "1360-spawn-sync.ts": 4387, - "1361-spawn-events.ts": 4260, - "1362-spawn-timers.ts": 9971, - "1363-spawn-unhandled-error.ts": 3744, - "1364-union-truthiness.ts": 3907, - "1365-union-logical.ts": 4258, - "1366-union-equality.ts": 3058, - "1367-destructuring.ts": 5461, - "1368-constructor-functions.ts": 3781, - "1369-promise-union.ts": 3864, - "1370-spread.ts": 3429, - "1371-union-template-tostring.ts": 3265, - "1372-loose-null-tests.ts": 3885, - "1373-union-array-arms.ts": 3435, - "140-bitwise-operators.ts": 4527, - "1400-typedarray-basics.ts": 5395, - "1401-typedarray-slice-set.ts": 3626, - "1402-buffer-encodings.ts": 4871, - "1403-buffer-fs.ts": 4268, - "1404-zlib-crypto-bytes.ts": 5331, - "1405-bytes-unions-arrays.ts": 3838, - "1406-dataview-mp4.ts": 3661, - "1407-dataview-bounds.ts": 5553, - "1408-string-indexing.ts": 5392, - "1409-typedarray-integer-loops.ts": 4558, - "1420-number-statics.ts": 3886, - "1421-number-parse-strings.ts": 4644, - "1422-date-iso.ts": 4015, - "1423-text-codec.ts": 38476, - "1424-fs-options.ts": 3473, - "1425-stdin-tty.ts": 4093, - "1426-stdin-read.ts": 3982, - "1427-fromcharcode-lastindexof.ts": 2946, - "1428-settled-await-order.ts": 3794, - "1429-promise-catch-finally.ts": 4465, - "1430-promise-race.ts": 4414, - "1431-caught-tostring.ts": 2971, - "1432-destructured-params.ts": 3941, - "1433-filter-narrow.ts": 3907, - "1434-async-never.ts": 3465, - "1435-math-spread.ts": 3652, - "1436-default-undef-param.ts": 3877, - "1437-pad-default.ts": 3475, - "1438-promise-all.ts": 7297, - "1440-interval-basics.ts": 4144, - "1441-interval-clear-cross.ts": 7176, - "1442-interval-throw.ts": 3609, - "1443-signal-handlers.ts": 7600, - "1444-exit-listeners.ts": 4768, - "1445-exit-process-exit.ts": 5403, - "1446-exit-uncaught.ts": 4319, - "1447-stdin-closed-events.ts": 4894, - "1448-stream-columns.ts": 4014, - "1450-incdec-expression.ts": 3639, - "1451-instanceof-uint8array-unknown.ts": 3654, - "1452-return-through-finally.ts": 4057, - "1453-pmap-settled.ts": 4531, - "1454-nonnull-narrow-and-fcc-bytes.ts": 3459, - "1455-lambda-union-return-adoption.ts": 3583, - "1460-console-error-warn.ts": 3484, - "1461-process-pid-getuid-kill.ts": 3345, - "1462-exec-sync.ts": 5307, - "1463-timeout-unref.ts": 3316, - "1464-env-writes.ts": 3946, - "1465-env-value.ts": 3554, - "1466-child-containers.ts": 4064, - "1467-string-match.ts": 3329, - "1468-exec-path.ts": 3588, - "1469-remove-listener.ts": 5747, - "1470-child-lifecycle.ts": 2972, - "1471-child-unref.ts": 8472, - "1472-errno-code.ts": 3388, - "1473-promisify-execfile.ts": 5200, - "1474-string-decoder.ts": 3868, - "1475-readline-closed-stdin.ts": 3587, - "1476-assign-expression.ts": 4319, - "1477-in-expressions.ts": 3951, - "1478-promise-reject.ts": 4331, - "1479-destructuring-assign.ts": 3821, - "1480-os-network-interfaces.ts": 4186, - "1481-string-case-static.ts": 2782, - "1482-spawnsync-error.ts": 2721, - "1483-array-slice.ts": 52661, - "1520-fs-wider-surface.ts": 3691, - "1520-string-split-static.ts": 3432, - "1521-fs-lstat-lock.ts": 3409, - "1521-string-trim-pad-static.ts": 4078, - "1522-parseint-static.ts": 3461, - "1522-spawnsync-options.ts": 5773, - "1523-isnan-floor-static.ts": 3552, - "1523-spawn-options.ts": 5294, - "1524-atomics-sleep-static.ts": 4028, - "1524-catch-narrowing.ts": 2626, - "1525-child-exit-signal.ts": 3477, - "1525-unknown-typeof-validation.ts": 2889, - "1526-set-spread.ts": 3802, - "1527-logical-mixed-operands.ts": 4773, - "1528-delete-records-env.ts": 3621, - "1529-class-with-statics.ts": 3381, - "1530-array-push-variadic.ts": 2970, - "1530-spread-override-completion.ts": 2499, - "1531-delete-optional-fields.ts": 3623, - "1531-process-arch-versions.ts": 2740, - "1532-array-splice-shift.ts": 4204, - "1532-union-shared-field-read.ts": 2834, - "1533-bool-equality.ts": 4076, - "1533-path-platform-namespaces.ts": 3406, - "1534-crypto-hash-chain.ts": 4097, - "1534-union-as-arm-cast.ts": 45787, - "1535-spawn-fd-stdio.ts": 3840, - "1535-union-param-defaults.ts": 4358, - "1536-destructuring-defaults.ts": 3812, - "1536-string-array-sweep.ts": 3859, - "1537-chalk-hybrid/main.ts": 4683, - "1537-os-release-spawnsync-stdio.ts": 2674, - "1538-await-promiselike-return.ts": 2642, - "1538-math-static-scalar.ts": 3735, - "1539-readonly-set-map.ts": 3299, - "1539-unknown-truthiness.ts": 3045, - "1540-os-userinfo.ts": 4119, - "1540-void-statement.ts": 2941, - "1541-fs-readdir-dirent.ts": 5432, - "1541-union-keyed-reads.ts": 4646, - "1542-map-promise-values.ts": 33000, - "1542-record-literal-into-union.ts": 2885, - "1543-rest-destructuring.ts": 3500, - "1543-set-server-handles.ts": 6770, - "1544-dyn-json-reads.ts": 4863, - "1544-string-matchall.ts": 4770, - "1545-spread-order-and-optional.ts": 4536, - "1546-union-element-reads.ts": 4536, - "1547-computed-key-fold.ts": 3960, - "1548-boolean-condition-forms.ts": 4649, - "1549-array-isarray-unions.ts": 4084, - "1550-param-defaults-func-set.ts": 3020, - "1551-dyn-receiver-methods.ts": 3403, - "1552-exec-options-record.ts": 2877, - "1553-truthy-hof-predicates.ts": 3895, - "1554-caught-into-unknown.ts": 3417, - "1555-index-spread-into-declared.ts": 4534, - "1556-union-retag-width-arms.ts": 3587, - "1557-url-host.ts": 2566, - "1558-any-joins-and-dyn-validation.ts": 33883, - "1559-conditional-spread-index-merge.ts": 3282, - "1560-forof-homogeneous-tuples.ts": 3680, - "1561-forof-strings.ts": 2878, - "1561-promise-then.ts": 3851, - "1562-optional-chain-tails.ts": 4618, - "1562-spawn-conditional-spread.ts": 4043, - "1563-forof-iterator-projections.ts": 3930, - "1563-string-raw-fold.ts": 3100, - "1564-fs-watch.ts": 4051, - "1564-string-raw.ts": 3075, - "1565-spawn-pipe-streams.ts": 3895, - "1565-union-element-join.ts": 4167, - "1566-child-duck-interface.ts": 3875, - "1567-server-close-override.ts": 3304, - "1568-x509-fingerprint.ts": 2839, - "1569-fsp-mkdir-unlink-chmod.ts": 3012, - "1570-child-unref-kill-reffed.ts": 9046, - "1571-optional-call-tostring-tail.ts": 26380, - "1571-stdin-set-raw-mode-non-tty.ts": 4151, - "1572-promise-reject-all-tuple.ts": 4201, - "1572-x509-validity-date-gettime.ts": 3944, - "1573-promisify-execfile-env-spread.ts": 4480, - "1573-tdz-scalar-forward-capture.ts": 2862, - "1574-dyn-optional-method-number-keys.ts": 3192, - "1574-promise-all-tuple-literal.ts": 4410, - "1575-unknown-assert-into-record.ts": 3424, - "1576-width-coercions.ts": 4144, - "1577-url-hostname.ts": 4030, - "1578-exec-input-optional.ts": 4028, - "1579-matchall-index.ts": 4108, - "1580-exec-env-conditional-spread.ts": 3516, - "1581-declare-const-read.ts": 3997, - "1582-timer-sleep-resolve.ts": 4177, - "1583-loops-and-stream-captures.ts": 4450, - "1584-union-field-unassigned.ts": 3964, - "1585-union-field-conditional-ctor.ts": 3070, - "1586-derived-field-before-super-init.ts": 4073, - "1590-js-unannotated.js": 4738, - "1591-js-closures.js": 3535, - "1592-js-classes.js": 7400, - "1593-js-jsdoc-records.js": 4695, - "1594-js-async.js": 3836, - "1595-js-island-gap/main.js": 3139, - "1596-cjs-modules/main.js": 3283, - "1597-mjs-graph/main.mjs": 3605, - "1598-cjs-builtin-require/main.js": 2977, - "1599-js-uncaught-throw.js": 3196, - "1600-assert-passing.ts": 4333, - "1601-assert-fail-exit.ts": 3725, - "1602-assert-caught-error.ts": 3373, - "1603-assert-scalar-messages.ts": 5128, - "1604-assert-deep-structures.ts": 4364, - "1605-assert-import-forms.ts": 4371, - "1606-assert-strict-module.ts": 2984, - "1607-assert-throws-match.ts": 4301, - "1608-cjs-assert/main.js": 3820, - "1609-assert-async.ts": 2695, - "1610-path-win32-full.ts": 2757, - "1611-url-file-bridge-neutral.ts": 4375, - "1612-cjs-module-globals.cjs": 3706, - "1613-cjs-esm-proxy-named/main.mjs": 3290, - "1614-js-fence-dodges.cjs": 2861, - "1615-cjs-export-shapes/main.cjs": 4723, - "1616-cjs-esm-lexer-invisible/main.mjs": 2991, - "1617-cjs-esm-lexer-visible/main.mjs": 3860, - "1618-cjs-esm-poisoned-tail/main.mjs": 3236, - "1619-cjs-esm-reexport-invisible/main.mjs": 3244, - "1620-cjs-require-effects-order/main.js": 2604, - "1621-cjs-require-cache-hit/main.js": 3531, - "1622-cjs-require-conditional/main.js": 3501, - "1623-cjs-require-diamond/main.js": 4051, - "1624-cjs-require-dir-mid-file/main.js": 2658, - "1625-cjs-require-lazy-fn/main.js": 3635, - "1626-cjs-require-mjs/main.js": 2942, - "1627-mjs-import-cjs-requires/main.mjs": 3236, - "1628-checked-dynamic-builtin-args.cjs": 2968, - "1629-require-main-filename.cjs": 2826, - "1630-inspect-scalars.ts": 3908, - "1630-rmsync-retry-options.cjs": 3797, - "1631-inspect-arrays.ts": 4065, - "1632-inspect-records.ts": 4843, - "1633-inspect-map-set.ts": 3133, - "1634-inspect-classes.ts": 3805, - "1635-inspect-buffer.ts": 3530, - "1636-util-format.ts": 2945, - "1637-inspect-dyn.ts": 3297, - "1638-inspect-cjs.cjs": 3549, - "1639-versions-openssl-probe.ts": 3544, - "1640-fd-read-decode.ts": 2932, - "1641-string-search.ts": 3476, - "1642-object-fromentries-rows.ts": 3699, - "1643-metadata-dyn-return.cjs": 4074, - "1644-ee-basics.ts": 4205, - "1645-ee-extends.ts": 3512, - "1646-ee-once-remove.ts": 3828, - "1647-ee-meta-events.ts": 3673, - "1648-ee-error-event.ts": 3271, - "1649-ee-names-counts.ts": 3057, - "1650-ee-prepend.ts": 3927, - "1651-ee-max-listeners.ts": 4648, - "1652-ee-snapshot.ts": 4220, - "1653-ee-cjs.cjs": 3230, - "1654-ee-namespace.ts": 3631, - "1655-spawnsync-neutral.ts": 5393, - "1656-execsync-neutral.ts": 3546, - "1657-spawn-async-neutral.ts": 3320, - "1660-buffer-read-write-num.ts": 4303, - "1661-buffer-encodings-full.ts": 3877, - "1662-string-decoder-encodings.ts": 3423, - "1663-buffer-compare-search-fill.ts": 4770, - "1664-dyn-fn-boundary.cjs": 3405, - "1665-dyn-fn-mustcall/main.cjs": 2819, - "1666-dyn-fn-identity.ts": 2740, - "1667-dyn-fn-not-callable.cjs": 3303, - "1668-dyn-fn-throws.cjs": 3745, - "1669-symbol-identity.ts": 3617, - "1670-symbol-registry.ts": 4207, - "1671-symbol-typeof.ts": 3400, - "1672-symbol-containers.ts": 3581, - "1673-symbol-cjs.cjs": 3624, - "1674-symbol-inspect.ts": 2758, - "1676-func-array-surface.ts": 2900, - "1677-emitter-listeners.ts": 4932, - "1678-emitter-dyn-listeners.cjs": 3287, - "1679-console-dyn.js": 3576, - "1680-assert-bytes.ts": 3903, - "1681-assert-funcs.ts": 3918, - "1685-stream-readable-basics.ts": 6503, - "1686-stream-readable-paused.ts": 6965, - "1687-stream-readable-flow-control.ts": 3669, - "1688-stream-writable-basics.ts": 3711, - "1689-stream-writable-async-drain.ts": 6004, - "1690-stream-duplex.ts": 6220, - "1691-stream-transform.ts": 6193, - "1692-stream-pipe.ts": 6662, - "1693-stream-pipe-backpressure.ts": 3700, - "1694-stream-destroy.ts": 3259, - "1695-stream-props.ts": 4843, - "1696-stream-read-inside-read.ts": 3524, - "1697-stream-tick-vs-timer.ts": 3256, - "1698-stream-uncaught-error.ts": 4826, - "1699-stream-callback-shapes.ts": 3791, - "1700-mustcall-common/main.cjs": 4329, - "1701-mustcall-exit-report/main.cjs": 3995, - "1702-dyn-proto-dispatch.cjs": 4694, - "1703-arguments-rest-props.cjs": 3485, - "1710-cjs-export-class/main.js": 2945, - "1711-cjs-export-single-values/main.js": 3527, - "1712-field-incdec.ts": 3301, - "1713-js-dyn-fields.js": 3702, - "1720-assert-throws-shape.ts": 3665, - "1721-assert-throws-regex-class.ts": 3205, - "1722-assert-rejects.ts": 3941, - "1723-assert-does-not-reject.ts": 3991, - "1724-assert-iferror.ts": 2922, - "1725-assert-symbols.ts": 4117, - "1726-promise-with-resolvers.ts": 3773, - "1727-assert-throws-shape-exit.ts": 4180, - "1730-countdown-symbol-keys/main.js": 3717, - "1731-symbol-field-shapes.cjs": 4041, - "1732-symbol-field-cross-module/main.js": 3671, - "1740-stream-extends-readable.ts": 5413, - "1741-stream-extends-writable.ts": 6469, - "1742-stream-extends-duplex-transform.ts": 6437, - "1743-stream-extends-vt-dispatch.ts": 7212, - "1744-stream-set-encoding.ts": 3635, - "1745-stream-encoding-js.cjs": 2973, - "1746-stream-for-await.ts": 4707, - "1747-stream-for-await-js.cjs": 4902, - "1750-http-agent-options.ts": 7371, - "1751-options-record-stance.ts": 4112, - "1760-surplus-args-drop.cjs": 3672, - "1761-emitter-special-event-names.cjs": 5508, - "1770-assert-dyn-strict.ts": 4072, - "1771-assert-dyn-deep.ts": 3521, - "1772-assert-dyn-js.cjs": 3744, - "1773-assert-dyn-exit.ts": 3156, - "1780-http-res-surface.ts": 7173, - "1781-http-server-shapes.cjs": 3500, - "1790-computed-key-folds.ts": 3641, - "1791-searchparams-core.ts": 3206, - "1792-searchparams-encoding.ts": 3500, - "1793-searchparams-iteration.ts": 3620, - "1794-searchparams-url-live.ts": 3114, - "1795-dyn-handle-request.cjs": 6764, - "1796-dyn-handle-body.cjs": 6226, - "1797-dyn-handle-socket.cjs": 3886, - "1798-dyn-handle-typed-box.ts": 6248, - "1800-immediate-basics.ts": 3211, - "1801-immediate-handle.ts": 3455, - "1802-immediate-unref-exit.ts": 3001, - "1803-timeout-refresh.ts": 3714, - "1804-timers-module.ts": 3580, - "1805-timer-callback-args.ts": 3293, - "1806-timer-delay-trunc.ts": 3354, - "1810-stream-options-const-record.ts": 4095, - "1811-stream-option-value-callbacks.cjs": 3113, - "1812-stream-super-options-forwarding.cjs": 3239, - "1813-stream-finished.ts": 3753, - "1814-stream-pipeline.cjs": 3633, - "1815-stream-state-reads.cjs": 3723, - "1820-static-block-basics.ts": 3496, - "1821-static-block-order.ts": 3121, - "1822-static-block-js.js": 2926, - "1823-static-instance-method-names.ts": 2971, - "1824-for-of-destructuring-defaults.ts": 3389, - "1825-exhaustive-typeof-switch.ts": 2558, - "1826-settimeout-arguments-callback.js": 3292, - "1830-enum-numeric-basics.ts": 3721, - "1831-enum-string-const-reverse.ts": 3386, - "1832-enum-modules/main.ts": 3491, - "1835-var-basics.ts": 3090, - "1836-var-loop-capture.ts": 4227, - "1837-var-undefined-hoisting.ts": 3129, - "1838-var-modules/main.ts": 3442, - "1839-var-js/main.cjs": 2943, - "1840-jsdoc-import-type-only/main.js": 3153, - "1850-overload-basics.ts": 3527, - "1851-overload-return-narrowing.ts": 3485, - "1852-overload-class-members.ts": 3165, - "1853-overload-modules/main.ts": 3369, - "1854-ambient-declare-fn.ts": 3339, - "1855-ambient-declare-fn-uncaught.ts": 2825, - "1870-unit-type-values.ts": 3760, - "1871-empty-array-never.ts": 2995, - "1872-template-tostring-composite.ts": 3281, - "1880-json-declared-field-order.ts": 3669, - "1881-default-anon/main.ts": 3229, - "1882-default-cjs-interop/main.ts": 3282, - "1883-default-exports/main.ts": 3775, - "1890-ns-imports/main.ts": 3324, - "1891-ns-reexport/main.ts": 3059, - "1940-class-values-basics.ts": 3481, - "1941-class-values-registry.ts": 3018, - "1942-class-expressions.ts": 2837, - "1943-class-statics-expanded.ts": 3294, - "1944-class-values-modules/main.ts": 3634, - "1950-generic-fn-values.ts": 3713, - "1951-generic-classes-basics.ts": 3449, - "1952-generic-class-statics-values.ts": 3863, - "1953-generic-class-hierarchy.ts": 3771, - "1954-generic-modules/main.ts": 3506, - "1960-namespace-basics.ts": 3039, - "1961-namespace-nested.ts": 2879, - "1962-namespace-classes.ts": 3820, - "1963-namespace-aliases.ts": 2943, - "1964-namespace-type-only.ts": 3637, - "1965-namespace-ambient.ts": 3549, - "1966-namespace-modules/main.ts": 3116, - "1967-namespace-alias-typeonly.ts": 2879, - "1968-namespace-import-eq-snapshot.ts": 3284, - "1970-decorators-basics.ts": 3029, - "1971-decorators-rebinding.ts": 3079, - "1972-decorators-throwing.ts": 2634, - "1973-decorators-ambient.ts": 3508, - "1980-primitive-proto-statics.ts": 3768, - "1981-date-utc.ts": 3681, - "1982-freeze-resolve-passthrough.ts": 3352, - "1983-array-tuple-surfaces.ts": 3130, - "1990-labels-basics.ts": 3662, - "1991-for-in-loops.ts": 4312, - "1992-small-syntax.ts": 3036, - "200-strings.ts": 3188, - "2000-generic-methods-basic.ts": 3233, - "2001-generic-methods-generic-class.ts": 3654, - "2002-generic-methods-inheritance.ts": 3883, - "2003-generic-methods-object-literal.ts": 4002, - "2004-generic-methods-statics.ts": 2781, - "201-templates.ts": 3259, - "2010-generators-basics.ts": 2930, - "2011-generators-forof.ts": 3439, - "2012-generators-return-throw.ts": 3077, - "2013-generators-sent-values.ts": 3157, - "2014-generators-values.ts": 3230, - "2015-generators-yieldstar.ts": 2691, - "2016-generators-rc-stress.ts": 3408, - "2017-generators-async.ts": 3645, - "2018-generators-uncaught.ts": 3372, - "2019-generators-loops.ts": 3684, - "2020-generic-value-bindings.ts": 4814, - "2021-generic-value-binding-modules/main.ts": 2613, - "2022-width-index-capture.ts": 4066, - "2023-width-readonly.ts": 3988, - "2024-width-array-elems.ts": 3088, - "2025-width-union-compose.ts": 3148, - "2026-width-spread.ts": 3721, - "2030-width-nested.ts": 3956, - "2031-width-tuples.ts": 3454, - "2032-cjs-export-assigned-class-expression/main.cjs": 3771, - "2033-property-assigned-class-extends.cjs": 2857, - "2035-ternary-array-retag.cjs": 3742, - "2036-evolving-array-decl.cjs": 3733, - "2037-fn-decl-hoisting.cjs": 3504, - "2038-evolving-array-js.cjs": 4258, - "2040-any-bindings.ts": 3664, - "2040-mixin-heritage.ts": 3192, - "2041-any-params-returns.ts": 3362, - "2041-mixin-values.ts": 3893, - "2042-any-flow-loops.ts": 3770, - "2042-mixin-modules/main.ts": 3144, - "2043-any-dom-values.ts": 3779, - "2043-mixin-rc-stress.ts": 4190, - "2044-vtable-sibling-slots.ts": 4054, - "2045-objlit-accessors-basic.ts": 3443, - "2045-parameter-properties.ts": 3049, - "2046-abstract-classes.ts": 4183, - "2046-objlit-accessors-effects.ts": 3215, - "2047-objlit-accessors-shapes.ts": 3091, - "2047-optional-class-fields.ts": 4146, - "2050-dynamic-import-own-module/main.ts": 3451, - "2051-dynamic-import-then/main.ts": 3601, - "2052-dynamic-import-self.ts": 3591, - "2053-typeof-static-fold.ts": 3479, - "2054-destructuring-island-source.ts": 3225, - "2060-empty-tuple.ts": 3198, - "2070-computed-key-folds.ts": 3432, - "2071-integer-key-enumeration-order.ts": 3897, - "2072-expando-function-members.ts": 3830, - "2073-destructuring-assignment.ts": 3540, - "2074-island-destructuring.ts": 3784, - "2075-index-signature-runtime-keys.ts": 2791, - "2080-destructuring-defaults.ts": 3781, - "2081-destructuring-rest.ts": 3728, - "2082-destructuring-assignment.ts": 3505, - "2085-destructuring-heads-rest-params.ts": 3490, - "2087-destructuring-for-heads.ts": 3190, - "2090-index-signature-number-keys.ts": 2803, - "2091-index-signature-string-intersection.ts": 2723, - "2092-package-imports/main.ts": 2857, - "2093-timers-promises.ts": 4034, - "2094-diagnostics-channel.ts": 3375, - "2095-js-catch-unknown.js": 3448, - "2096-os-type.ts": 3784, - "2097-js-evolving-globals.js": 3531, - "210-string-methods.ts": 3602, - "2100-stream-default-hwm.ts": 3572, - "2101-dyn-param-defaults.ts": 2799, - "2102-empty-pattern-decls.ts": 3305, - "2105-computed-key-static-folds.ts": 3458, - "2106-comma-expressions.ts": 3662, - "211-string-unicode.ts": 2722, - "2110-top-object-types.ts": 2930, - "2111-json-stringify-unknown.ts": 2894, - "2112-array-at-findlast.ts": 3347, - "2113-string-index-methods.js": 2954, - "212-string-aliasing-append.ts": 2936, - "2120-package-self-import/main.ts": 2637, - "2121-esm-cycle-inert-backedge/main.ts": 2688, - "2123-ambient-import-crash/main.ts": 2830, - "2124-imports-field-wildcard/main.ts": 2779, - "2140-uri-component-codecs.ts": 3028, - "2160-dc-tracing-channel.cjs": 3125, - "2161-js-object-literal-identity.cjs": 3710, - "2162-js-dyn-destructure.cjs": 2745, - "2163-js-selfref-const.cjs": 4243, - "2164-js-then-dyn-handler.cjs": 4454, - "2165-js-throw-dyn.cjs": 3859, - "2166-cjs-getter-this/main.cjs": 3481, - "2170-island-array-exits.ts": 5249, - "2171-island-json-stringify.ts": 3408, - "2172-island-regexp-boundary.ts": 4656, - "2190-new-object-and-string-wrappers.ts": 2892, - "2191-uri-encoders.ts": 2460, - "2192-object-default-tostring.ts": 3152, - "2193-discarded-stdlib-reads.ts": 3436, - "2194-ambient-undef-chains.ts": 3329, - "2195-require-missing-package/main.mjs": 3396, - "2196-island-computed-key-chain.ts": 4364, - "2210-dyn-promise-crossing.cjs": 3412, - "2211-dc-trace-promise.cjs": 4496, - "2212-unhandled-rejection-listener.cjs": 3503, - "2213-async-local-storage.cjs": 3304, - "2214-dc-bind-store.cjs": 4372, - "2215-process-emit-warning-exit.cjs": 4385, - "2240-width-class-into-record.ts": 3816, - "2241-width-record-into-class.ts": 3107, - "2242-width-statics-into-record.ts": 3187, - "2243-width-assert-satisfies-shapes.ts": 3725, - "2250-tagged-templates.ts": 2802, - "2252-class-iterators.ts": 4024, - "2253-union-coercions.ts": 2969, - "2260-http2-constants.cjs": 2611, - "2280-builtin-namespace-destructure.cjs": 2964, - "2281-domexception-atob-btoa.cjs": 3116, - "2282-queue-microtask.cjs": 3672, - "2283-structured-clone.cjs": 3661, - "2284-regexp-constructor.cjs": 2921, - "2285-iferror-dyn.cjs": 2815, - "2286-dyn-object-walks.cjs": 2814, - "2300-dyn-record-spread-and-keyed-access.cjs": 3340, - "2301-cjs-export-table-dom-attach.cjs": 2994, - "2310-process-next-tick.ts": 3462, - "2311-next-tick-js-callbacks.js": 3541, - "2312-stream-underscore-assign.ts": 4210, - "2313-stream-underscore-assign-js.cjs": 3281, - "2314-process-introspection.ts": 4007, - "2320-await-unit.ts": 2773, - "2321-emitter-static-setmax.cjs": 3576, - "2322-dyn-array-sort.cjs": 2683, - "2323-timer-callback-returns.ts": 3611, - "2330-tls-server-runtime-options.cjs": 22007, - "2331-tls-server-options-typed.ts": 22550, - "2350-nan-global.ts": 3586, - "2351-async-methods.ts": 3496, - "2352-void-coercions.ts": 2875, - "2353-decorators-member-ambient.ts": 2855, - "2354-decorators-expression-ambient.ts": 2445, - "2360-tuple-to-array.ts": 3725, - "2361-assign-index-record.ts": 3918, - "2362-execsync-inherit.ts": 3204, - "2363-nullish-retag.ts": 3277, - "2364-in-runtime-key.ts": 3653, - "2365-dyn-into-island.ts": 2967, - "2366-string-well-formed.ts": 3530, - "2367-regexp-escape.ts": 3537, - "2368-set-methods.ts": 3321, - "2369-promise-try.ts": 3477, - "2370-group-by.ts": 3834, - "2371-iterator-helpers.ts": 3503, - "2380-buffer-module-named-import.ts": 3337, - "2381-builtin-default-imports.js": 3386, - "2382-cycle-two-decl/main.ts": 2540, - "2383-cycle-assertdoc/main.js": 3635, - "2384-cycle-mixed-bindings/main.ts": 2680, - "2385-builtin-reexport-facade/main.ts": 2415, - "2386-string-to-chars.ts": 3358, - "2387-tonumber-argv.ts": 3189, - "2388-tonumber-grammar-zoo.ts": 2478, - "2389-tonumber-unary-plus.ts": 3505, - "2390-dot-requires/main.cjs": 3502, - "2391-default-builtin-imports/main.ts": 3560, - "2392-block-guard-alias-scope.ts": 2811, - "2393-loop-exit-guard-narrow.ts": 3396, - "2394-loop-narrow-containment.ts": 3368, - "2395-while-cond-guard.ts": 2736, - "2396-born-narrowed-decl.ts": 3324, - "2397-branch-kill-merge.ts": 2593, - "2398-switch-arm-kill.ts": 3348, - "2399-reassign-kill-polarity.ts": 3637, - "240-stdout-write.ts": 3882, - "2400-kill-return-edge.ts": 3195, - "2401-kill-break-staging.ts": 3449, - "2402-labeled-break-kill.ts": 2813, - "2403-kill-continue-backedge.ts": 3428, - "2404-kill-throw-catch.ts": 2824, - "2405-sibling-arm-narrow.ts": 2442, - "2406-switch-clause-sibling-narrow.ts": 2665, - "2407-infinite-loop-seal.ts": 3312, - "2408-loop-terminality-reopen.ts": 3281, - "2409-loop-body-return-not-terminal.ts": 3145, - "2410-stacked-cases-terminality.ts": 3627, - "2411-exhaustive-switch-terminality.ts": 3158, - "2412-dowhile-guard-trailing-test.ts": 3265, - "2413-dowhile-kill-renarrow.ts": 2701, - "2414-dowhile-continue-kill.ts": 3317, - "2415-dowhile-break-trailing-test.ts": 3362, - "2416-spread-ternary-positions.ts": 3467, - "2417-ternary-local-inference.ts": 3368, - "2418-wrapped-ternary-arms.ts": 3310, - "2419-selector-ternary-union.ts": 3702, - "2420-nullish-null-identity.ts": 2553, - "2421-float-lane-inference.ts": 3344, - "2422-ieee-div-rem-corners.ts": 3186, - "2423-param-null-reassign.ts": 3025, - "2424-ternary-miss-first-narrowing.ts": 3552, - "2425-elseif-head-exit-narrow.ts": 3257, - "2426-default-snapshot-mutable/main.ts": 3423, - "2427-perf-hooks-now.ts": 3049, - "2428-field-redeclare-inherited.ts": 3585, - "2429-destructure-class-instance.ts": 2694, - "2430-empty-literal-unknown-field.js": 3401, - "2431-primitive-ctor-values.ts": 2884, - "2432-generic-member-fields-async.ts": 5845, - "2433-as-const-command-tables.ts": 3180, - "2434-deferred-init-fields.ts": 3249, - "2435-loose-same-kind-equality.ts": 3363, - "2440-console-inspect-args.ts": 5418, - "2441-console-process-argv.ts": 3041, - "2442-union-literal-arm-widening.ts": 2555, - "2443-union-literal-shadow-narrowing.ts": 3302, - "2444-union-literal-reducer-spread.ts": 3618, - "2445-math-minmax-nary.ts": 2645, - "2446-performance-global.ts": 3980, - "2447-island-boundary-slots/main.ts": 6217, - "2448-entries-null-arms-regex-arrays.ts": 3545, - "2450-private-instance-methods.ts": 2931, - "2451-private-fields.ts": 3694, - "2452-private-statics.ts": 2965, - "2453-private-accessors.ts": 3478, - "2454-private-generator-methods.ts": 3697, - "2455-private-brand-checks.ts": 3515, - "2456-private-async-methods.ts": 3535, - "2457-private-members.js": 2780, - "2460-qs-parse-grammar.ts": 4534, - "2461-qs-parse-options.ts": 4115, - "2462-qs-stringify.ts": 3434, - "2463-qs-escape-unescape.ts": 3311, - "2464-qs-require-forms.cjs": 2821, - "2470-mockable-module-shape.js": 2978, - "2471-record-keyed-write-hasown.js": 2970, - "2472-string-regexp-union.ts": 3393, - "2473-option-table-widths.js": 3653, - "2474-island-literal-forms.ts": 3643, - "2475-variadic-wrapper-island.js": 3606, - "2476-map-regex-values.ts": 3711, - "2480-recursive-record-tree.ts": 3376, - "2481-mutual-recursive-records.ts": 3699, - "2482-recursive-union-tree.ts": 3347, - "2483-recursive-record-cycles.ts": 2764, - "2484-json-stringify-circular.ts": 3845, - "2485-inspect-circular-refs.ts": 3694, - "2486-recursive-record-boundaries.ts": 3988, - "2487-recursive-deep-equal.ts": 3416, - "2488-ast-walker.ts": 3100, - "2490-find-miss-null-compare.ts": 3107, - "2491-strict-unit-compare-no-arm.ts": 2820, - "2492-loose-null-compare-unions.ts": 3683, - "2493-switch-unit-cases.ts": 3703, - "2494-no-arm-compare-effects.ts": 3089, - "2500-net-autosel-timeout.ts": 3775, - "2510-dyn-evolving-array-map.ts": 3265, - "2511-dyn-evolving-array-filter-foreach.ts": 2885, - "2512-dyn-evolving-array-mixed-push.ts": 3639, - "2520-private-statics-class-name-calls.ts": 3155, - "2521-private-statics-class-expression.ts": 3520, - "2522-private-statics-decorated.ts": 3673, - "2523-private-statics-aliased-class.ts": 3795, - "2530-object-destructuring-decl.ts": 2869, - "2531-array-tuple-destructuring-decl.ts": 3168, - "2532-param-destructuring-options.ts": 2906, - "2533-forof-destructuring.ts": 2840, - "2534-object-rest-decl.ts": 3199, - "2535-destructuring-assign-basics.ts": 3816, - "2536-destructuring-assign-nested.ts": 3047, - "2537-destructuring-assign-member-targets.ts": 3590, - "2538-destructuring-assign-class-source.ts": 3544, - "2539-class-instance-rest.ts": 3764, - "2540-accessor-destructuring-defaults.ts": 3201, - "2541-destructuring-eval-order.ts": 2670, - "2550-generics-keyof-pick.ts": 3947, - "2551-generics-value-aliases.ts": 3227, - "2552-generics-iface-methods.ts": 3318, - "2553-generics-signature-bindings.ts": 3442, - "2554-generics-frontier-mix.ts": 3344, - "2555-generics-keyof-writes.ts": 3448, - "2556-crypto-introspection.ts": 3351, - "2556-width-hybrid-shapes.ts": 3462, - "2557-tls-ca-store.ts": 4438, - "2557-width-field-lifts.ts": 4453, - "2558-index-signature-func-values.ts": 3590, - "2558-rejection-events.cjs": 3641, - "2559-index-signature-container-values.ts": 4066, - "2560-arraybuffer-dataview-set.ts": 3614, - "2561-object-is.ts": 3391, - "2562-intl-numberformat-en-us.ts": 3241, - "2563-stream-promises-pipeline.ts": 3490, - "2564-stream-promises-finished.ts": 2994, - "2565-stream-promises-js.cjs": 2616, - "2566-promise-reject-dyn-reason.js": 3548, - "2567-rest-spread-forward.js": 3292, - "2568-rest-spread-forward-dynamic.js": 3367, - "2569-upcast-identity.ts": 2553, - "2570-buffer-arg-validation.cjs": 5779, - "2571-searchparams-arg-validation.cjs": 3913, - "2572-readable-emitted-readable-flag.cjs": 3556, - "2573-fs-url-arg-ladders.cjs": 3502, - "2574-emitter-max-listeners-ladders.cjs": 2895, - "2575-string-destructuring-decl.ts": 3433, - "2576-string-destructuring-assign.ts": 2984, - "2577-builtin-global-destructuring.js": 3466, - "2578-jsval-into-unknown-rows.ts": 3398, - "2579-jsval-object-param-crossing.js": 3294, - "2580-jsval-routed-keyed-ops.js": 3298, - "2581-jsval-routed-calls.js": 3542, - "2582-jsval-object-statics.js": 3509, - "2582-jsval-routed-keyed-ops.js": 3136, - "2583-dyn-nullish-coalesce.js": 2976, - "2583-jsval-routed-calls.js": 2950, - "2584-jsval-object-statics.js": 3305, - "2584-union-dyn-collapse.ts": 2970, - "2585-dyn-nullish-coalesce.js": 3632, - "2585-unknown-array.ts": 3809, - "2586-object-assign-spread.js": 4084, - "2587-array-entries-forof.ts": 2633, - "2588-array-entries-chains.ts": 4097, - "2589-object-create-null.cjs": 3112, - "2590-object-create-dynamic.js": 4279, - "2591-ambient-generic-traps.ts": 3216, - "2592-ambient-trap-uncaught.ts": 3198, - "2593-generic-inert-bindings.ts": 3007, - "2594-nullish-generic-bindings.ts": 3321, - "2595-fs-arg-ladders.cjs": 3930, - "2596-net-arg-ladders.cjs": 3528, - "2597-dgram-send-ladders.cjs": 4536, - "2598-tls-arg-ladders.cjs": 4142, - "2599-stream-arg-ladders.cjs": 5465, - "2600-dyn-keyed-write-harness.js": 2800, - "2601-dyn-keyed-write-ops.js": 3269, - "2602-dyn-array-destructure.js": 3207, - "2603-island-keyed-write-dyn.js": 3608, - "2604-cycle-classes-mutual/main.ts": 3410, - "2605-cycle-three-module/main.ts": 2592, - "2606-dynamic-import-cycle/main.ts": 2445, - "2608-regex-named-groups.ts": 3896, - "2609-regex-named-replace.ts": 3215, - "2610-regex-named-matchall.ts": 3887, - "2611-regex-named-groups-js.cjs": 3523, - "2613-for-init-uninitialized-let.ts": 3167, - "2614-trap-binding-later-writes.ts": 3345, - "2615-nullish-field-record-binding.ts": 2720, - "2616-js-collect-probe-defers.js": 3534, - "2617-enum-static-field-import/main.ts": 3068, - "2618-ee-emit-override.ts": 3915, - "2619-ee-override-chain.ts": 2567, - "2620-ee-override-once-order.ts": 3439, - "2621-ee-override-error-throw.ts": 3265, - "2622-ee-override-filter.ts": 3339, - "2623-ee-job-queue.ts": 3586, - "2624-ee-override-js.cjs": 2637, - "2625-bytes-views.ts": 2847, - "2626-stream-event-names.ts": 3436, - "2627-stream-ticks-are-nextticks.ts": 4048, - "2628-stream-push-encodings.cjs": 3219, - "2629-stream-consumers.ts": 4523, - "2630-stream-consumers-errors.ts": 3353, - "2631-create-require/main.ts": 2869, - "2632-dyn-jsval-iterate.js": 3938, - "2633-island-promise-crossing.js": 3898, - "2634-stream-pipeline-arg-ladders.cjs": 2829, - "2635-trap-binding-unmappable-written.ts": 3493, - "2636-trap-binding-ambient-rooted-rewrite.ts": 3155, - "2637-create-require-bare/main.ts": 3093, - "2638-http-dyn-res-compat.cjs": 7897, - "2639-http-dyn-req-pause.cjs": 4028, - "2640-net-dyn-socket-compat.cjs": 3877, - "2641-http-agent-surface.cjs": 6286, - "2642-http-agent-maxsockets.cjs": 4681, - "2643-or-default-retag.ts": 3292, - "2644-http-client-url-argument.ts": 3256, - "2645-https-client-url-argument.ts": 24258, - "2646-top-level-await.ts": 3392, - "2647-top-level-await-modules/main.ts": 3047, - "2648-top-level-await-rejection.ts": 3150, - "2649-top-level-await-pending.ts": 3160, - "2650-top-level-await-self-import.ts": 2440, - "2651-top-level-await-pending-unhandled.ts": 2762, - "2652-top-level-await-dynamic/main.ts": 3760, - "2653-top-level-await-rejection-stops-loop.ts": 2631, - "2654-top-level-await-unrelated-rejection.ts": 2643, - "2655-top-level-await-cycle/main.ts": 3098, - "2656-top-level-await-cycle-order/main.ts": 3167, - "2657-top-level-await-cycle-dynamic/main.ts": 2957, - "2658-top-level-await-sync-completion/main.ts": 3318, - "2659-top-level-await-dynamic-cycle/main.ts": 2585, - "2660-top-level-await-cycle-rejection/main.ts": 3210, - "2661-top-level-await-dynamic-runtime-root/main.ts": 3366, - "2662-top-level-await-cycle-external-wait/main.ts": 3005, - "2663-top-level-await-dependency-errors/main.ts": 2847, - "2664-top-level-await-same-checkpoint-rejection.ts": 3116, - "2665-top-level-await-unhandled-listener-liveness.ts": 2875, - "2666-array-to-sorted.ts": 7633, - "2668-stored-number-array-iterator.ts": 3253, - "2669-array-copying-methods.ts": 3549, - "2670-uint8array-copy-iterate.ts": 3853, - "2671-array-copying-js.cjs": 3682, - "2672-http-request-response-callback.ts": 4143, - "2673-top-level-await-implicit-module.ts": 3247, - "2674-top-level-for-await-implicit-module.ts": 3134, - "2675-create-require-nested-esm.js": 2364, - "2675-process-self-reexec.ts": 2727, - "2676-indexed-read-strict-equality.ts": 2731, - "2676-record-clone-overrides.ts": 2957, - "2676-top-level-await-ambiguous/main.ts": 2732, - "2677-runtime-optional-closure.ts": 4013, - "2677-top-level-await-module-scope/main.ts": 3413, - "2678-date-instances.ts": 2682, - "2678-large-string-sparse-index.ts": 3695, - "2678-util-parseargs.ts": 6509, - "2679-util-parseargs-cjs.cjs": 4674, - "2680-util-parseargs-default.ts": 2968, - "2681-util-parseargs-dynamic.js": 4805, - "2682-fs-rename.ts": 3870, - "2683-filter-truthy-predicate.ts": 3057, - "2683-fs-rename-js.cjs": 3194, - "2684-filter-no-predicate-dyn.cjs": 2886, - "2684-fs-rename-abort.ts": 4187, - "2685-array-unshift-reverse.ts": 3336, - "2685-fs-write-sync.ts": 3018, - "2686-fs-file-handle.ts": 4533, - "2687-fsp-write-file-options.ts": 3468, - "2687-process-write-args.ts": 4056, - "2688-fs-stats-disk-fields.ts": 3885, - "2689-http-server-timeout-properties.ts": 3928, - "2690-https-server-timeout-option.ts": 21635, - "2691-retained-lowering-record-order.ts": 4394, - "2692-inline-record-assert-index.ts": 4260, - "2692-string-accumulation.ts": 2769, - "2693-math-constants.ts": 2825, - "2700-array-sort-complexity.ts": 3067, - "2700-http-static-trailers.ts": 3428, - "2700-wasi-core.ts": 3839, - "2701-array-sort-snapshot.ts": 3995, - "2701-http-static-trailer-wire.ts": 3237, - "2701-import-meta/main.mjs": 2794, - "2702-http-static-trailer-end.ts": 3525, - "2702-type-import-link-static/main.ts": 3217, - "2702-uint8array-to-sorted.ts": 3838, - "2703-array-sparse-sort.ts": 7138, - "2703-type-import-link-static-reexport/main.ts": 2989, - "2704-array-sparse-to-sorted.ts": 7251, - "2704-type-import-link-static-success/main.ts": 3249, - "2705-array-sparse-sort-append.ts": 6240, - "2705-type-import-link-dynamic/main.ts": 2760, - "2706-array-search-missing-needle.ts": 3091, - "2706-type-import-link-dynamic-success/main.ts": 3330, - "2707-array-search-huge-sparse.ts": 45179, - "2707-type-import-link-static-default-reexport/main.ts": 2758, - "2708-type-import-link-dynamic/main.ts": 4132, - "2720-array-read-parity.ts": 3456, - "2721-array-nested-missing-receiver.ts": 3322, - "2750-array-sparse-foundation.ts": 3816, - "2751-buffer-concat-sparse-list.ts": 3043, - "2752-array-optional-stores.ts": 3548, - "2753-array-optional-method-values.ts": 3422, - "2754-array-property-undefined.ts": 3456, - "2755-array-optional-literal-forwarding.ts": 3507, - "2780-array-parity-composition.ts": 9748, - "2781-array-missing-value-escape.ts": 2984, - "2782-array-sparse-callbacks.ts": 3368, - "2783-array-defaults-rest.ts": 3426, - "2784-array-reduce-missing-result.ts": 2920, - "2785-array-missing-destructuring.ts": 4220, - "2786-array-sparse-serialization.ts": 3688, - "2787-array-missing-string-arithmetic.ts": 2565, - "2788-array-missing-builtin-conversions.ts": 2767, - "2789-array-missing-optional-tostring.ts": 3009, - "2790-dynamic-import-self-name/main.ts": 3621, - "2791-record-optional-keys.ts": 3660, - "2792-record-optional-spread-entries.ts": 3741, - "2793-union-conversion-identity-capture.ts": 3519, - "2794-array-generic-callback-values.ts": 2842, - "2795-array-optional-typedarray-source.ts": 29642, - "2796-array-sparse-class-value-instanceof.ts": 4014, - "2800-array-expression-consumers.ts": 2964, - "2801-array-switch-consumers.ts": 3634, - "2820-array-missing-method-receivers.ts": 3219, - "2821-array-optional-numeric-comparisons.ts": 3648, - "2830-cjs-require-self-name/main.cjs": 2817, - "2840-finally-completions.ts": 2484, - "2841-using-sync.ts": 3654, - "2842-await-using.ts": 3139, - "2843-using-suppressed-error.ts": 3369, - "2844-node-disposable-resources.ts": 3909, - "2845-for-using-of.ts": 3562, - "2846-generator-using.ts": 3676, - "2850-async-generators-protocol.ts": 4224, - "2851-async-generators-values.ts": 3418, - "2852-timers-promises-interval.ts": 3999, - "2854-leading-bom-literals.ts": 3644, - "2855-searchparams-sort-complexity.ts": 2896, - "2856-dynamic-any-local-operators.ts": 3122, - "2857-branded-primitives.ts": 2535, - "2858-import-meta-resolve/main.mjs": 2803, - "2859-import-meta-resolve-dynamic/main.mjs": 2791, - "2860-require-resolve/main.cjs": 3416, - "2861-readable-iterator-close.ts": 3965, - "2862-web-readable-async-iteration.ts": 48807, - "2863-class-async-iterator.ts": 3227, - "2864-array-class-method-receivers.ts": 2404, - "2865-cjs-process-alias.cjs": 3403, - "2866-dyn-switch.ts": 2311, - "2867-array-shift-length.js": 3507, - "2868-empty-record-promise-presence.js": 2925, - "2869-nullish-mixed-lazy.ts": 2958, - "2870-and-dropped-truthy-arm.ts": 2834, - "2871-optional-promise-to-unknown.ts": 3267, - "2872-unobserved-dynamic-event.ts": 3355, - "2873-optional-receiver-loop-lifetime.js": 3047, - "2874-nullable-callback-field-cycle.js": 3534, - "2875-evolving-let-read-before-write.js": 2810, - "2876-class-unknown-roundtrip.ts": 3764, - "2877-child-unknown-roundtrip.ts": 2785, - "2878-class-private-unknown.cjs": 3352, - "2880-cjs-module-graph/main.cjs": 3782, - "2890-crypto-static-utility.ts": 2826, - "2891-json-record-key-escapes.ts": 3816, - "2892-windows-console-unicode.ts": 3563, - "2893-child-stdin-duplex.ts": 3578, - "2894-child-stdin-backpressure.ts": 3536, - "2895-child-stdin-write-after-end.ts": 3038, - "2896-child-stdin-write-after-finish.ts": 3391, - "2897-child-stdin-destroy.ts": 3563, - "2898-child-stdin-spawn-failure.ts": 3036, - "2899-nested-mutual-recursion.ts": 3350, - "2900-float64array-static.ts": 3865, - "2900-void-conditional-arrow.ts": 2828, - "2901-bigint-core.ts": 3440, - "2902-bigint-bytes.ts": 2684, - "2903-bigint-storage.ts": 3029, - "2904-bigint-errors.ts": 3660, - "2905-bigint-edges.ts": 3424, - "2906-bigint-wasi-width.ts": 3017, - "2910-overloaded-callable-alias.ts": 3175, - "2911-execfile-callback.ts": 3152, - "2912-execfile-callback-options.ts": 3514, - "2912-promisify-fs-readfile.ts": 3307, - "2913-builtin-callable-alias.ts": 4333, - "2914-fixed-tuple-call-spread.ts": 3657, - "2915-path-function-values.ts": 2684, - "2916-path-function-values-cjs.ts": 3544, - "2917-builtin-callable-widths.ts": 3312, - "2918-builtin-callable-widths-cjs.ts": 4040, - "2919-fs-function-values.ts": 4214, - "2920-fs-promises-function-values.ts": 2447, - "2921-zlib-callbacks.ts": 4192, - "2922-dyn-bitwise-not.cjs": 2704, - "2923-cjs-factory-export/main.cjs": 3106, - "2930-union-receiver-calls.ts": 3700, - "2931-union-dynamic-field-call.js": 3466, - "2932-create-require-program/main.ts": 3686, - "2933-static-dynamic-import/main.ts": 3405, - "2934-static-import-stored.ts": 2381, - "2935-module-namespace-values/main.ts": 3289, - "2936-static-loose-equality.ts": 3642, - "2937-bitwise-hot-loop.ts": 3298, - "2938-fs-sync-overloads.cjs": 2598, - "2939-child-shell-text.ts": 2919, - "2940-date-parse.ts": 3171, - "2940-fsp-realpath.ts": 3497, - "2941-fsp-lstat-identity.ts": 3608, - "2941-process-exit-code.ts": 3007, - "2942-fsp-readdir-dirent.ts": 3744, - "2942-process-exit-code-override.ts": 2479, - "2943-process-exit-code-invalid.ts": 3225, - "2944-process-exit-code-wrap.ts": 3249, - "2945-url-origin-username.ts": 2371, - "2946-child-fork-ipc/main.ts": 4191, - "2946-url-port-hash.ts": 2720, - "2947-set-readonly-seeds.ts": 3363, - "2948-child-fork-eof-callback/main.ts": 3691, - "2948-stdio-callback-record.ts": 3021, - "2949-child-fork-default/main.mjs": 3752, - "2949-url-password.ts": 3268, - "2950-fs-descriptor-publication.ts": 3039, - "2951-math-static-analytic.ts": 2897, - "2952-math-static-remaining.ts": 3708, - "2953-http-header-validation.ts": 2926, - "2954-http-outgoing-headers.ts": 3568, - "2955-http-static-state.ts": 3392, - "2956-http-static-informational.ts": 3156, - "2957-http-static-response-controls.ts": 3011, - "2961-emitter-computed-names.cjs": 3061, - "2962-emitter-computed-optional.ts": 3117, - "2963-child-fork-dispatch/main.ts": 3069, - "2964-indexed-compound.ts": 4283, - "2966-numeric-array-read-fusion.ts": 2881, - "2967-numeric-array-read-lifetime.ts": 3327, - "2968-numeric-array-borrow.ts": 3624, - "2969-scalar-record-results.ts": 3705, - "2970-constant-numeric-tables.ts": 3396, - "2971-constant-table-modules/main.ts": 2786, - "2972-http-static-distinct-snapshots.ts": 3464, - "2972-math-receiver-borrow.ts": 4257, - "2973-http-static-agent.ts": 3844, - "2973-integer-bitwise-arithmetic.ts": 3703, - "2974-array-search-from-index.ts": 120829, - "2974-http-static-module-values.ts": 5733, - "2974-numeric-remainder.ts": 3749, - "2975-bigint-default-radix.ts": 2671, - "2975-http-static-client-controls.ts": 3229, - "2976-http-static-incoming-state.ts": 3560, - "2976-json-stringify-no-arguments.js": 3221, - "2977-http-static-incoming-timeout.ts": 3554, - "2977-nested-array-binding-defaults.js": 3145, - "2978-http-static-client-timeout.ts": 3607, - "2978-regexp-optional-subject.js": 3504, - "2979-array-search-mixed-needles.js": 2692, - "2979-http-static-server-timeout.ts": 3769, - "2980-http-static-server-timeout-default.ts": 3050, - "2980-string-position-arguments.js": 3269, - "2981-http-static-events.ts": 2644, - "2981-string-optional-positions.ts": 2494, - "2982-http-static-close-all.ts": 2737, - "2982-string-position-coercion-order.js": 3410, - "2983-http-static-close-idle.ts": 3031, - "2984-http-static-close-upgrade.ts": 3101, - "2985-http-static-message-destroy.ts": 3632, - "2986-http-static-client-socket-finish.ts": 2911, - "2987-http-static-timeout-errors.ts": 3301, - "2988-http-static-client-abort.ts": 2940, - "2989-http-static-response-timeout-handled.ts": 3640, - "2990-http-static-request-timeout-handled.ts": 3597, - "2991-array-indexed-equality.ts": 3696, - "2992-stream-rows.ts": 3357, - "2993-fiber-stack-lifetimes.ts": 3545, - "2994-fromcharcode-scalar.ts": 3381, - "2995-math-hyperbolic.ts": 3225, - "2996-math-near-one.ts": 2714, - "2997-math-integer-float.ts": 3635, - "300-if-else.ts": 2510, - "3001-caught-typeof-object.js": 3444, - "3002-promise-then-two.ts": 3645, - "301-while.ts": 3200, - "302-for.ts": 2865, - "3020-string-last-index-position.ts": 3627, - "3021-buffer-union-narrow-callback.ts": 3829, - "3022-string-affix-positions.ts": 3463, - "3023-string-affix-position-coercion.js": 3644, - "3024-string-number-narrow-for-in.ts": 3394, - "3025-string-search-position-coercion.js": 3367, - "3026-array-last-index-of.js": 2868, - "3027-array-last-index-of-records.ts": 3472, - "3028-string-search-dynamic-needle.js": 2934, - "3029-string-search-union-needle.js": 3701, - "303-break-continue.ts": 2701, - "3030-array-search-no-arg.js": 3806, - "3031-array-relative-index-coercion.js": 3498, - "3031-string-last-index-search-value.js": 2610, - "3032-string-search-value.js": 3067, - "3033-string-search-needle-coercion.js": 3292, - "3034-arguments-with-parameters.js": 2687, - "3035-string-positioned-search-value.js": 3575, - "3036-string-object-search-value.js": 2688, - "3037-number-nullish-conversion.js": 3018, - "3038-number-scalar-unions.ts": 2381, - "3039-string-repeat-count.js": 2336, - "304-compound-incdec.ts": 3307, - "3040-string-prototype-call.js": 3584, - "3041-string-prototype-object-call.js": 3163, - "3042-string-padding-coercion.js": 3486, - "3043-string-split-arguments.js": 3038, - "3044-array-slice-splice-positions.js": 3582, - "3045-array-indexed-mutation.js": 4003, - "3046-array-indexed-ref-identity.ts": 2594, - "3047-object-prototype-tag.js": 5012, - "3048-object-own-prototype.ts": 4080, - "3049-array-flat-depth.ts": 3414, - "305-truthiness.ts": 2664, - "3050-array-splice-insert.ts": 2966, - "3051-array-join-default.ts": 3468, - "3052-array-construction.ts": 4201, - "3053-array-construction-js.js": 2937, - "3054-dynamic-abort-record.ts": 25141, - "3055-default-builtin-nodenext/main.ts": 2702, - "3056-default-builtin-bundler/main.ts": 3487, - "3057-default-builtin-nodenext-dynamic/main.ts": 2447, - "3058-optional-array-chain-join.ts": 3991, - "3059-arguments-property-names.ts": 2550, - "3061-concurrent-fiber-stacks.ts": 3788, - "3062-runtime-optional-record-guards.ts": 3181, - "3063-runtime-optional-class-guards.ts": 3568, - "3064-installed-entry-imports/main.ts": 2606, - "3065-installed-entry-js/main.js": 3045, - "3066-source-debugging/main.ts": 3383, - "3067-cjs-function-export-require/main.cjs": 2939, - "3068-debug-variables/main.ts": 2618, - "3068-url-checked-identity.ts": 3006, - "3069-set-checked-seed.js": 3140, - "3069-tuple-spread.ts": 3376, - "3070-checked-object-accessors.js": 3573, - "3070-collection-views.ts": 3175, - "3071-checked-specialization-narrowing.js": 3321, - "3071-map-contextual-record-seeds.ts": 4329, - "3072-optional-union-receivers.ts": 3610, - "3072-weak-process-streams.js": 2918, - "3073-optional-callable-module.js": 3300, - "3073-union-keyed-reads.ts": 3869, - "3074-discriminated-intersections.ts": 3384, - "3075-recursive-contextual-literals.ts": 4502, - "3076-nullish-record-defaults.ts": 3009, - "3077-optional-union-array-reads.ts": 3992, - "3078-forward-mutable-captures.ts": 3466, - "3079-forward-mutable-tdz.ts": 3489, - "3080-exhaustive-never-bindings.ts": 3664, - "3081-recursive-array-destinations.ts": 3893, - "3082-forward-write-unwind.ts": 3471, - "3083-set-string-seed.ts": 3139, - "3084-record-own-membership.ts": 2971, - "3085-conditional-record-construction.ts": 3822, - "3086-error-constructor-options.ts": 3660, - "3087-error-options-lifetime.ts": 2905, - "3088-array-wide-callbacks.ts": 3195, - "3089-array-find-narrowing.ts": 4220, - "3090-json-discriminated-records.ts": 3463, - "3091-json-recursive-discriminants.ts": 3555, - "3092-number-union-predicates.ts": 2884, - "3093-error-option-data.ts": 2574, - "3094-json-replacer-traversal.ts": 3823, - "3095-json-reviver-traversal.ts": 3825, - "3096-json-callback-nonfinite.ts": 3620, - "3097-json-callback-reentrancy.ts": 2760, - "3098-json-callback-space.ts": 3696, - "3099-json-callback-functions.ts": 4108, - "3100-json-callback-holder.js": 3675, - "3101-json-callback-bytes.ts": 3250, - "3102-json-unknown-fields.ts": 2925, - "3103-scalar-record-nested-control-flow.ts": 3592, - "3104-native-analysis-tables-loops.ts": 3494, - "3105-nullable-collections.ts": 3244, - "3106-mixed-insertion-spreads.ts": 4146, - "3107-nullable-collection-lifetimes.ts": 3486, - "3108-for-await-sync-arrays.js": 4312, - "3108-identity-map-keys.ts": 3894, - "3109-destructuring-unknown-defaults.js": 3234, - "3109-identity-union-collections.ts": 3977, - "3110-builtin-error-families.ts": 3250, - "3110-identity-collection-mutation.ts": 3825, - "3111-identity-collection-cycles.ts": 3640, - "3112-union-switch-control-flow.ts": 2681, - "3113-union-array-removal.ts": 3778, - "3114-union-record-field-write.ts": 3884, - "3115-zlib-static-compression-levels.ts": 4085, - "3116-sequence-expression-lifetimes.ts": 3245, - "3117-unknown-switch-control-flow.ts": 3706, - "3118-recursive-union-spread.ts": 3476, - "3119-runtime-optional-spread.ts": 4508, - "3120-dynamic-property-descriptors.js": 3228, - "3120-generator-method-loop-bindings.ts": 3222, - "3120-ir-nonfinite-numbers.ts": 3251, - "3121-compound-assignment-values.js": 3525, - "3121-dynamic-accessor-descriptors.js": 4470, - "3122-dynamic-delete-descriptors.cjs": 3353, - "3122-dynamic-delete-descriptors.js": 3300, - "3122-js-async-class-methods.js": 3524, - "3123-destructured-global-tdz.js": 3896, - "3124-array-prototype-borrow.js": 4000, - "3125-regex-global-match.ts": 2889, - "3126-js-number-radix/main.ts": 3491, - "3127-spawn-runtime-options.ts": 3338, - "3128-regex-last-index.ts": 3768, - "3129-js-token-union/main.ts": 3461, - "3130-child-generic-streams.ts": 3435, - "3131-child-rest-listeners.js": 3280, - "3132-child-generic-stream-completion.ts": 6821, - "3133-text-decoder-streaming.ts": 32031, - "3134-fs-vectors.ts": 3621, - "3135-fs-file-handle-controls.ts": 3152, - "3136-fs-file-handle-options.ts": 4992, - "3137-fs-vector-callbacks.cjs": 3636, - "3138-array-large-storage.ts": 5104, - "3139-regex-native-deep-alternatives.ts": 38096, - "3140-array-dense-access.ts": 4712, - "3141-map-string-key-hash.ts": 3358, - "3150-integer-remainder.ts": 3568, - "3151-array-push-writes.ts": 3892, - "3170-number-conversion-fast-paths.ts": 2663, - "3171-method-census-data-writes.ts": 4253, - "400-fib.ts": 3919, - "401-mutual-recursion.ts": 2844, - "402-string-functions.ts": 3081, - "403-void-and-params.ts": 3112, - "4030-runtime-object-truthiness.ts": 3275, - "4031-event-emitter-long-tuples.ts": 3646, - "4032-inline-rc-fast-paths.ts": 4866, - "404-rc-stress.ts": 2781, - "4040-adapted-function-identity.ts": 3610, - "4041-adapted-function-properties.ts": 3413, - "4042-object-is-union-subclass.ts": 2746, - "4043-nonnull-missing-element.ts": 3815, - "4044-adapted-callback-modules/main.ts": 2918, - "4045-optional-element-projections.ts": 4182, - "4046-captured-parameter-values.ts": 4191, - "4047-captured-parameter-rebinding.ts": 2867, - "405-params-optional.ts": 2408, - "406-params-defaults.ts": 2614, - "4060-cycle-shared-instance/main.ts": 2758, - "4060-stack-union-reads.ts": 4386, - "4061-cycle-evaluation-order/main.ts": 3229, - "4061-nullable-ref-fields.ts": 6151, - "4062-cycle-tdz-read/main.ts": 3056, - "4063-cycle-hoisted-calls/main.ts": 3238, - "4064-cycle-classes-after-init/main.ts": 2548, - "4065-cycle-init-throws/main.ts": 2955, - "4066-cycle-top-level-tdz/main.ts": 3040, - "4067-dynamic-import-cycle-tdz/main.ts": 3004, - "407-params-rest.ts": 3335, - "408-params-ctors-inheritance.ts": 3021, - "4080-optional-read-presence-tests.ts": 3095, - "4080-string-index-bounds.ts": 3083, - "4081-hoisted-function-tdz.ts": 3193, - "4081-string-index-unproven.ts": 3273, - "4082-hoisted-function-tdz-uncaught.ts": 2845, - "4083-dynamic-import-failure/main.ts": 3748, - "4084-record-optional-field-copies.ts": 4118, - "4085-generator-loop-close.ts": 3638, - "4086-optional-capture-defaults.ts": 3227, - "4088-class-static-tdz.ts": 3234, - "4089-class-wrapper-tdz.js": 3393, - "409-params-async-generics.ts": 2742, - "4090-computed-key-tdz.js": 2796, - "4091-class-evaluation-deferred.ts": 3464, - "410-params-rc-stress.ts": 3461, - "4140-array-callback-split-visit.ts": 7289, - "4141-array-callback-ambient-receiver/main.ts": 3100, - "4142-array-callback-factories.ts": 4541, - "4143-union-refinement-intersection-arms.ts": 3822, - "420-dead-strip-modules/main.ts": 3118, - "4290-acyclic-immutable-trees.ts": 3580, - "4291-acyclic-constructor-escapes.ts": 3039, - "4292-acyclic-readonly-bypass.ts": 4316, - "4293-acyclic-dynamic-writes.ts": 3268, - "4294-console-line-sizes.ts": 6986, - "4295-console-template-parts.ts": 3358, - "4296-console-glued-long-parts.ts": 3290, - "4410-inline-object-allocation.ts": 3305, - "4411-nullable-ref-values.ts": 5301, - "4412-nullable-record-values.ts": 5088, - "4413-cycle-old-late-death.ts": 4012, - "4413-nullable-null-and-undefined.ts": 4328, - "4414-cycle-old-weak-keys.ts": 4005, - "4414-nullable-string-values.ts": 5044, - "4415-identity-borrowed-operands.ts": 3101, - "4415-nullable-container-values.ts": 4932, - "4431-exception-pending-contexts.ts": 3487, - "4432-checked-downcast-failures.ts": 3971, - "4451-int32-field-storage.ts": 3668, - "4452-int32-field-dynamic-writes.ts": 4531, - "4453-int32-closed-locals.ts": 2786, + "001-hello.ts": 47467, + "002-log-args.ts": 4723, + "100-number-format.ts": 49913, + "1000-json-stringify-basics.ts": 49071, + "1001-json-escapes-unicode.ts": 5167, + "1002-json-parse-cast.ts": 48226, + "1003-json-parse-unions.ts": 5247, + "1004-json-parse-errors.ts": 4196, + "1005-json-nested.ts": 8262, + "1006-json-fs-config.ts": 36095, + "1007-json-rc-stress.ts": 30487, + "1008-json-null-arms.ts": 48758, + "1009-json-optional-fields.ts": 3469, + "101-arithmetic.ts": 49638, + "1010-json-stringify-space.ts": 48585, + "1011-json-unknown-typeof.ts": 52058, + "102-comparisons.ts": 47851, + "1020-async-basics.ts": 4722, + "1021-async-ordering.ts": 4973, + "1022-async-exceptions.ts": 49732, + "1023-async-rc-stress.ts": 6131, + "1024-async-pending-exit.ts": 48202, + "1025-async-promise-capture.ts": 3959, + "1026-throw-promise.ts": 4948, + "1027-async-return-promise.ts": 4908, + "1028-async-return-record-literals.ts": 4271, + "1029-async-eager-chains.ts": 3619, + "103-ternary.ts": 5182, + "104-ternary-empty-arrays.ts": 7669, + "1050-comptime-tables.ts": 4897, + "1051-comptime-strings.ts": 47107, + "1052-comptime-records.ts": 39735, + "1053-comptime-json.ts": 5104, + "1054-comptime-modules/main.ts": 48253, + "110-number-radix.ts": 3792, + "111-record-entries.ts": 7069, + "1110-math-members.ts": 5365, + "1111-math-random.ts": 4260, + "1113-string-methods.ts": 54370, + "1114-string-unicode-island.ts": 52372, + "1115-parse-globals.ts": 3948, + "1116-island-static-mix.ts": 42223, + "1117-typeof-static-union.ts": 4732, + "1118-object-spread-conditional.ts": 39126, + "1119-switch-union.ts": 28754, + "112-class-descriptor-key.js": 39424, + "1121-infinity-number-tostring.ts": 4725, + "1122-any-captures.ts": 7404, + "1124-union-narrowed-retag.ts": 6000, + "113-promise-checked-exits.ts": 3453, + "114-live-record-delete.ts": 4924, + "115-array-compound.js": 5191, + "116-text-decoder-runtime.js": 46050, + "117-weak-cache-cycle.js": 5083, + "118-fs-stored-callbacks.cjs": 56960, + "119-native-patterns.js": 8396, + "1200-regex-test-basics.ts": 52932, + "1201-regex-replace.ts": 57037, + "1202-regex-substitutions.ts": 57467, + "1203-regex-split.ts": 3335, + "1204-regex-empty-unicode.ts": 42721, + "1205-regex-rc-stress.ts": 4531, + "1300-errors-basics.ts": 4518, + "1301-errors-subclass.ts": 4955, + "1302-errors-typed-catch.ts": 4560, + "1303-errors-rc-stress.ts": 3938, + "1304-errors-uncaught.ts": 4101, + "1305-errors-async-rejections.ts": 3614, + "1306-errors-runtime-instances.ts": 4054, + "1350-path-normalize-join.ts": 3568, + "1351-path-parts.ts": 4963, + "1352-path-resolve-relative.ts": 4503, + "1353-os-basics.ts": 4704, + "1354-builtin-bare-specifiers.ts": 4189, + "1355-url-parse.ts": 3863, + "1356-url-file-bridge.ts": 4207, + "1357-fsp-roundtrip.ts": 4886, + "1358-crypto-random.ts": 4050, + "1359-json-module/main.ts": 3853, + "1360-spawn-sync.ts": 4896, + "1361-spawn-events.ts": 3844, + "1362-spawn-timers.ts": 9749, + "1363-spawn-unhandled-error.ts": 5302, + "1364-union-truthiness.ts": 4307, + "1365-union-logical.ts": 4482, + "1366-union-equality.ts": 4253, + "1367-destructuring.ts": 5033, + "1368-constructor-functions.ts": 4831, + "1369-promise-union.ts": 3513, + "1370-spread.ts": 3969, + "1371-union-template-tostring.ts": 4126, + "1372-loose-null-tests.ts": 4513, + "1373-union-array-arms.ts": 3764, + "140-bitwise-operators.ts": 5173, + "1400-typedarray-basics.ts": 5411, + "1401-typedarray-slice-set.ts": 6335, + "1402-buffer-encodings.ts": 3500, + "1403-buffer-fs.ts": 7777, + "1404-zlib-crypto-bytes.ts": 6742, + "1405-bytes-unions-arrays.ts": 3762, + "1406-dataview-mp4.ts": 4549, + "1407-dataview-bounds.ts": 3820, + "1408-string-indexing.ts": 4530, + "1409-typedarray-integer-loops.ts": 4694, + "1420-number-statics.ts": 2928, + "1421-number-parse-strings.ts": 4454, + "1422-date-iso.ts": 3607, + "1423-text-codec.ts": 45738, + "1424-fs-options.ts": 3565, + "1425-stdin-tty.ts": 3853, + "1426-stdin-read.ts": 4250, + "1427-fromcharcode-lastindexof.ts": 3449, + "1428-settled-await-order.ts": 3904, + "1429-promise-catch-finally.ts": 6712, + "1430-promise-race.ts": 5576, + "1431-caught-tostring.ts": 4594, + "1432-destructured-params.ts": 5133, + "1433-filter-narrow.ts": 5015, + "1434-async-never.ts": 4402, + "1435-math-spread.ts": 4605, + "1436-default-undef-param.ts": 3807, + "1437-pad-default.ts": 3436, + "1438-promise-all.ts": 7568, + "1440-interval-basics.ts": 4290, + "1441-interval-clear-cross.ts": 7227, + "1442-interval-throw.ts": 4291, + "1443-signal-handlers.ts": 9442, + "1444-exit-listeners.ts": 5858, + "1445-exit-process-exit.ts": 5492, + "1446-exit-uncaught.ts": 4521, + "1447-stdin-closed-events.ts": 5005, + "1448-stream-columns.ts": 4280, + "1450-incdec-expression.ts": 3444, + "1451-instanceof-uint8array-unknown.ts": 4098, + "1452-return-through-finally.ts": 4660, + "1453-pmap-settled.ts": 7068, + "1454-nonnull-narrow-and-fcc-bytes.ts": 4716, + "1455-lambda-union-return-adoption.ts": 4826, + "1460-console-error-warn.ts": 4457, + "1461-process-pid-getuid-kill.ts": 4447, + "1462-exec-sync.ts": 4723, + "1463-timeout-unref.ts": 3720, + "1464-env-writes.ts": 4414, + "1465-env-value.ts": 4722, + "1466-child-containers.ts": 3465, + "1467-string-match.ts": 3798, + "1468-exec-path.ts": 4492, + "1469-remove-listener.ts": 6954, + "1470-child-lifecycle.ts": 4162, + "1471-child-unref.ts": 8772, + "1472-errno-code.ts": 5205, + "1473-promisify-execfile.ts": 5324, + "1474-string-decoder.ts": 4470, + "1475-readline-closed-stdin.ts": 55374, + "1476-assign-expression.ts": 4697, + "1477-in-expressions.ts": 3393, + "1478-promise-reject.ts": 4340, + "1479-destructuring-assign.ts": 4907, + "1480-os-network-interfaces.ts": 5202, + "1481-string-case-static.ts": 5232, + "1482-spawnsync-error.ts": 4518, + "1483-array-slice.ts": 47847, + "1520-fs-wider-surface.ts": 4261, + "1520-string-split-static.ts": 3932, + "1521-fs-lstat-lock.ts": 4472, + "1521-string-trim-pad-static.ts": 3262, + "1522-parseint-static.ts": 4734, + "1522-spawnsync-options.ts": 5888, + "1523-isnan-floor-static.ts": 4375, + "1523-spawn-options.ts": 4320, + "1524-atomics-sleep-static.ts": 4175, + "1524-catch-narrowing.ts": 4322, + "1525-child-exit-signal.ts": 4107, + "1525-unknown-typeof-validation.ts": 4804, + "1526-set-spread.ts": 5272, + "1527-logical-mixed-operands.ts": 3380, + "1528-delete-records-env.ts": 26816, + "1529-class-with-statics.ts": 3554, + "1530-array-push-variadic.ts": 4410, + "1530-spread-override-completion.ts": 4642, + "1531-delete-optional-fields.ts": 4468, + "1531-process-arch-versions.ts": 4294, + "1532-array-splice-shift.ts": 4135, + "1532-union-shared-field-read.ts": 3539, + "1533-bool-equality.ts": 3797, + "1533-path-platform-namespaces.ts": 4105, + "1534-crypto-hash-chain.ts": 4243, + "1534-union-as-arm-cast.ts": 3852, + "1535-spawn-fd-stdio.ts": 3827, + "1535-union-param-defaults.ts": 3756, + "1536-destructuring-defaults.ts": 4441, + "1536-string-array-sweep.ts": 4773, + "1537-chalk-hybrid/main.ts": 4555, + "1537-os-release-spawnsync-stdio.ts": 3030, + "1538-await-promiselike-return.ts": 4081, + "1538-math-static-scalar.ts": 2688, + "1539-readonly-set-map.ts": 4386, + "1539-unknown-truthiness.ts": 4573, + "1540-os-userinfo.ts": 4277, + "1540-void-statement.ts": 3770, + "1541-fs-readdir-dirent.ts": 5970, + "1541-union-keyed-reads.ts": 5137, + "1542-map-promise-values.ts": 3680, + "1542-record-literal-into-union.ts": 4161, + "1543-rest-destructuring.ts": 5386, + "1543-set-server-handles.ts": 8749, + "1544-dyn-json-reads.ts": 5370, + "1544-string-matchall.ts": 4375, + "1545-spread-order-and-optional.ts": 4546, + "1546-union-element-reads.ts": 50679, + "1547-computed-key-fold.ts": 5436, + "1548-boolean-condition-forms.ts": 3960, + "1549-array-isarray-unions.ts": 3329, + "1550-param-defaults-func-set.ts": 3161, + "1551-dyn-receiver-methods.ts": 6009, + "1552-exec-options-record.ts": 3255, + "1553-truthy-hof-predicates.ts": 4287, + "1554-caught-into-unknown.ts": 3533, + "1555-index-spread-into-declared.ts": 4772, + "1556-union-retag-width-arms.ts": 4319, + "1557-url-host.ts": 4070, + "1558-any-joins-and-dyn-validation.ts": 54305, + "1559-conditional-spread-index-merge.ts": 2926, + "1560-forof-homogeneous-tuples.ts": 32566, + "1561-forof-strings.ts": 3862, + "1561-promise-then.ts": 4850, + "1562-optional-chain-tails.ts": 4960, + "1562-spawn-conditional-spread.ts": 3616, + "1563-forof-iterator-projections.ts": 4225, + "1563-string-raw-fold.ts": 4244, + "1564-fs-watch.ts": 5142, + "1564-string-raw.ts": 4078, + "1565-spawn-pipe-streams.ts": 4189, + "1565-union-element-join.ts": 3622, + "1566-child-duck-interface.ts": 4142, + "1567-server-close-override.ts": 8728, + "1568-x509-fingerprint.ts": 3542, + "1569-fsp-mkdir-unlink-chmod.ts": 4083, + "1570-child-unref-kill-reffed.ts": 9583, + "1571-optional-call-tostring-tail.ts": 28217, + "1571-stdin-set-raw-mode-non-tty.ts": 3839, + "1572-promise-reject-all-tuple.ts": 4539, + "1572-x509-validity-date-gettime.ts": 4354, + "1573-promisify-execfile-env-spread.ts": 5359, + "1573-tdz-scalar-forward-capture.ts": 4394, + "1574-dyn-optional-method-number-keys.ts": 4461, + "1574-promise-all-tuple-literal.ts": 5082, + "1575-unknown-assert-into-record.ts": 4680, + "1576-width-coercions.ts": 4595, + "1577-url-hostname.ts": 3199, + "1578-exec-input-optional.ts": 3688, + "1579-matchall-index.ts": 4163, + "1580-exec-env-conditional-spread.ts": 3992, + "1581-declare-const-read.ts": 3904, + "1582-timer-sleep-resolve.ts": 5122, + "1583-loops-and-stream-captures.ts": 2955, + "1584-union-field-unassigned.ts": 4202, + "1585-union-field-conditional-ctor.ts": 4837, + "1586-derived-field-before-super-init.ts": 3740, + "1590-js-unannotated.js": 5105, + "1591-js-closures.js": 4745, + "1592-js-classes.js": 5879, + "1593-js-jsdoc-records.js": 4650, + "1594-js-async.js": 4426, + "1595-js-island-gap/main.js": 26477, + "1596-cjs-modules/main.js": 3160, + "1597-mjs-graph/main.mjs": 4960, + "1598-cjs-builtin-require/main.js": 3030, + "1599-js-uncaught-throw.js": 4259, + "1600-assert-passing.ts": 4325, + "1601-assert-fail-exit.ts": 4804, + "1602-assert-caught-error.ts": 5361, + "1603-assert-scalar-messages.ts": 4806, + "1604-assert-deep-structures.ts": 6023, + "1605-assert-import-forms.ts": 5339, + "1606-assert-strict-module.ts": 4600, + "1607-assert-throws-match.ts": 4414, + "1608-cjs-assert/main.js": 5188, + "1609-assert-async.ts": 4729, + "1610-path-win32-full.ts": 2755, + "1611-url-file-bridge-neutral.ts": 3733, + "1612-cjs-module-globals.cjs": 4516, + "1613-cjs-esm-proxy-named/main.mjs": 4105, + "1614-js-fence-dodges.cjs": 5207, + "1615-cjs-export-shapes/main.cjs": 5553, + "1616-cjs-esm-lexer-invisible/main.mjs": 3099, + "1617-cjs-esm-lexer-visible/main.mjs": 4087, + "1618-cjs-esm-poisoned-tail/main.mjs": 2476, + "1619-cjs-esm-reexport-invisible/main.mjs": 3415, + "1620-cjs-require-effects-order/main.js": 2713, + "1621-cjs-require-cache-hit/main.js": 3783, + "1622-cjs-require-conditional/main.js": 3828, + "1623-cjs-require-diamond/main.js": 3626, + "1624-cjs-require-dir-mid-file/main.js": 2336, + "1625-cjs-require-lazy-fn/main.js": 3015, + "1626-cjs-require-mjs/main.js": 2250, + "1627-mjs-import-cjs-requires/main.mjs": 2873, + "1628-checked-dynamic-builtin-args.cjs": 3077, + "1629-require-main-filename.cjs": 3479, + "1630-inspect-scalars.ts": 3977, + "1630-rmsync-retry-options.cjs": 3932, + "1631-inspect-arrays.ts": 5457, + "1632-inspect-records.ts": 4882, + "1633-inspect-map-set.ts": 4086, + "1634-inspect-classes.ts": 5725, + "1635-inspect-buffer.ts": 5155, + "1636-util-format.ts": 5015, + "1637-inspect-dyn.ts": 4071, + "1638-inspect-cjs.cjs": 3892, + "1639-versions-openssl-probe.ts": 4020, + "1640-fd-read-decode.ts": 4014, + "1641-string-search.ts": 21121, + "1642-object-fromentries-rows.ts": 4097, + "1643-metadata-dyn-return.cjs": 56433, + "1644-ee-basics.ts": 3623, + "1645-ee-extends.ts": 5009, + "1646-ee-once-remove.ts": 3768, + "1647-ee-meta-events.ts": 3840, + "1648-ee-error-event.ts": 2892, + "1649-ee-names-counts.ts": 4454, + "1650-ee-prepend.ts": 2707, + "1651-ee-max-listeners.ts": 4174, + "1652-ee-snapshot.ts": 5505, + "1653-ee-cjs.cjs": 4390, + "1654-ee-namespace.ts": 4636, + "1655-spawnsync-neutral.ts": 6342, + "1656-execsync-neutral.ts": 4702, + "1657-spawn-async-neutral.ts": 4011, + "1660-buffer-read-write-num.ts": 4936, + "1661-buffer-encodings-full.ts": 4916, + "1662-string-decoder-encodings.ts": 4639, + "1663-buffer-compare-search-fill.ts": 4818, + "1664-dyn-fn-boundary.cjs": 3636, + "1665-dyn-fn-mustcall/main.cjs": 4145, + "1666-dyn-fn-identity.ts": 3840, + "1667-dyn-fn-not-callable.cjs": 2882, + "1668-dyn-fn-throws.cjs": 3462, + "1669-symbol-identity.ts": 4719, + "1670-symbol-registry.ts": 4117, + "1671-symbol-typeof.ts": 5887, + "1672-symbol-containers.ts": 4625, + "1673-symbol-cjs.cjs": 6028, + "1674-symbol-inspect.ts": 4649, + "1676-func-array-surface.ts": 3616, + "1677-emitter-listeners.ts": 5664, + "1678-emitter-dyn-listeners.cjs": 6093, + "1679-console-dyn.js": 4398, + "1680-assert-bytes.ts": 3589, + "1681-assert-funcs.ts": 4450, + "1685-stream-readable-basics.ts": 8176, + "1686-stream-readable-paused.ts": 8142, + "1687-stream-readable-flow-control.ts": 6069, + "1688-stream-writable-basics.ts": 9377, + "1689-stream-writable-async-drain.ts": 7873, + "1690-stream-duplex.ts": 8422, + "1691-stream-transform.ts": 6383, + "1692-stream-pipe.ts": 5114, + "1693-stream-pipe-backpressure.ts": 3801, + "1694-stream-destroy.ts": 3612, + "1695-stream-props.ts": 8560, + "1696-stream-read-inside-read.ts": 4132, + "1697-stream-tick-vs-timer.ts": 7129, + "1698-stream-uncaught-error.ts": 4025, + "1699-stream-callback-shapes.ts": 4137, + "1700-mustcall-common/main.cjs": 4739, + "1701-mustcall-exit-report/main.cjs": 4788, + "1702-dyn-proto-dispatch.cjs": 4406, + "1703-arguments-rest-props.cjs": 3234, + "1710-cjs-export-class/main.js": 4152, + "1711-cjs-export-single-values/main.js": 3547, + "1712-field-incdec.ts": 3906, + "1713-js-dyn-fields.js": 5278, + "1720-assert-throws-shape.ts": 4205, + "1721-assert-throws-regex-class.ts": 3161, + "1722-assert-rejects.ts": 4021, + "1723-assert-does-not-reject.ts": 4049, + "1724-assert-iferror.ts": 3854, + "1725-assert-symbols.ts": 3165, + "1726-promise-with-resolvers.ts": 2792, + "1727-assert-throws-shape-exit.ts": 4670, + "1730-countdown-symbol-keys/main.js": 3893, + "1731-symbol-field-shapes.cjs": 4357, + "1732-symbol-field-cross-module/main.js": 4117, + "1740-stream-extends-readable.ts": 5412, + "1741-stream-extends-writable.ts": 7703, + "1742-stream-extends-duplex-transform.ts": 8664, + "1743-stream-extends-vt-dispatch.ts": 7746, + "1744-stream-set-encoding.ts": 3694, + "1745-stream-encoding-js.cjs": 3919, + "1746-stream-for-await.ts": 6732, + "1747-stream-for-await-js.cjs": 11913, + "1750-http-agent-options.ts": 7010, + "1751-options-record-stance.ts": 4331, + "1760-surplus-args-drop.cjs": 3419, + "1761-emitter-special-event-names.cjs": 3326, + "1770-assert-dyn-strict.ts": 4129, + "1771-assert-dyn-deep.ts": 4621, + "1772-assert-dyn-js.cjs": 3690, + "1773-assert-dyn-exit.ts": 3870, + "1780-http-res-surface.ts": 7391, + "1781-http-server-shapes.cjs": 11204, + "1790-computed-key-folds.ts": 3769, + "1791-searchparams-core.ts": 2566, + "1792-searchparams-encoding.ts": 3926, + "1793-searchparams-iteration.ts": 3839, + "1794-searchparams-url-live.ts": 3667, + "1795-dyn-handle-request.cjs": 7469, + "1796-dyn-handle-body.cjs": 4708, + "1797-dyn-handle-socket.cjs": 6317, + "1798-dyn-handle-typed-box.ts": 12433, + "1800-immediate-basics.ts": 3461, + "1801-immediate-handle.ts": 2828, + "1802-immediate-unref-exit.ts": 3773, + "1803-timeout-refresh.ts": 2890, + "1804-timers-module.ts": 4324, + "1805-timer-callback-args.ts": 4084, + "1806-timer-delay-trunc.ts": 3166, + "1810-stream-options-const-record.ts": 3962, + "1811-stream-option-value-callbacks.cjs": 3964, + "1812-stream-super-options-forwarding.cjs": 8384, + "1813-stream-finished.ts": 5772, + "1814-stream-pipeline.cjs": 8091, + "1815-stream-state-reads.cjs": 7977, + "1820-static-block-basics.ts": 3028, + "1821-static-block-order.ts": 2726, + "1822-static-block-js.js": 4178, + "1823-static-instance-method-names.ts": 2438, + "1824-for-of-destructuring-defaults.ts": 3053, + "1825-exhaustive-typeof-switch.ts": 3216, + "1826-settimeout-arguments-callback.js": 2649, + "1830-enum-numeric-basics.ts": 3631, + "1831-enum-string-const-reverse.ts": 3353, + "1832-enum-modules/main.ts": 3697, + "1835-var-basics.ts": 3553, + "1836-var-loop-capture.ts": 3991, + "1837-var-undefined-hoisting.ts": 3692, + "1838-var-modules/main.ts": 2987, + "1839-var-js/main.cjs": 3074, + "1840-jsdoc-import-type-only/main.js": 3723, + "1850-overload-basics.ts": 3730, + "1851-overload-return-narrowing.ts": 3097, + "1852-overload-class-members.ts": 4001, + "1853-overload-modules/main.ts": 4277, + "1854-ambient-declare-fn.ts": 2860, + "1855-ambient-declare-fn-uncaught.ts": 4252, + "1870-unit-type-values.ts": 3913, + "1871-empty-array-never.ts": 2656, + "1872-template-tostring-composite.ts": 3669, + "1880-json-declared-field-order.ts": 5166, + "1881-default-anon/main.ts": 3155, + "1882-default-cjs-interop/main.ts": 4152, + "1883-default-exports/main.ts": 4005, + "1890-ns-imports/main.ts": 4423, + "1891-ns-reexport/main.ts": 2975, + "1940-class-values-basics.ts": 2991, + "1941-class-values-registry.ts": 4395, + "1942-class-expressions.ts": 4086, + "1943-class-statics-expanded.ts": 3500, + "1944-class-values-modules/main.ts": 3932, + "1950-generic-fn-values.ts": 4360, + "1951-generic-classes-basics.ts": 4948, + "1952-generic-class-statics-values.ts": 4310, + "1953-generic-class-hierarchy.ts": 3171, + "1954-generic-modules/main.ts": 3610, + "1960-namespace-basics.ts": 3656, + "1961-namespace-nested.ts": 4076, + "1962-namespace-classes.ts": 3740, + "1963-namespace-aliases.ts": 3282, + "1964-namespace-type-only.ts": 3064, + "1965-namespace-ambient.ts": 3659, + "1966-namespace-modules/main.ts": 4077, + "1967-namespace-alias-typeonly.ts": 2697, + "1968-namespace-import-eq-snapshot.ts": 2527, + "1970-decorators-basics.ts": 4151, + "1971-decorators-rebinding.ts": 2897, + "1972-decorators-throwing.ts": 2556, + "1973-decorators-ambient.ts": 3932, + "1980-primitive-proto-statics.ts": 4096, + "1981-date-utc.ts": 3463, + "1982-freeze-resolve-passthrough.ts": 4042, + "1983-array-tuple-surfaces.ts": 4356, + "1990-labels-basics.ts": 3887, + "1991-for-in-loops.ts": 5008, + "1992-small-syntax.ts": 3829, + "200-strings.ts": 3521, + "2000-generic-methods-basic.ts": 4027, + "2001-generic-methods-generic-class.ts": 3431, + "2002-generic-methods-inheritance.ts": 3737, + "2003-generic-methods-object-literal.ts": 4544, + "2004-generic-methods-statics.ts": 3642, + "201-templates.ts": 2558, + "2010-generators-basics.ts": 3652, + "2011-generators-forof.ts": 3852, + "2012-generators-return-throw.ts": 3950, + "2013-generators-sent-values.ts": 4017, + "2014-generators-values.ts": 4246, + "2015-generators-yieldstar.ts": 3908, + "2016-generators-rc-stress.ts": 4275, + "2017-generators-async.ts": 2845, + "2018-generators-uncaught.ts": 3328, + "2019-generators-loops.ts": 3191, + "2020-generic-value-bindings.ts": 5274, + "2021-generic-value-binding-modules/main.ts": 3546, + "2022-width-index-capture.ts": 4336, + "2023-width-readonly.ts": 3104, + "2024-width-array-elems.ts": 3482, + "2025-width-union-compose.ts": 4076, + "2026-width-spread.ts": 3943, + "2030-width-nested.ts": 4567, + "2031-width-tuples.ts": 2753, + "2032-cjs-export-assigned-class-expression/main.cjs": 4056, + "2033-property-assigned-class-extends.cjs": 3174, + "2035-ternary-array-retag.cjs": 4091, + "2036-evolving-array-decl.cjs": 3778, + "2037-fn-decl-hoisting.cjs": 2776, + "2038-evolving-array-js.cjs": 4351, + "2040-any-bindings.ts": 3377, + "2040-mixin-heritage.ts": 3511, + "2041-any-params-returns.ts": 3626, + "2041-mixin-values.ts": 4380, + "2042-any-flow-loops.ts": 3135, + "2042-mixin-modules/main.ts": 4398, + "2043-any-dom-values.ts": 3973, + "2043-mixin-rc-stress.ts": 3648, + "2044-vtable-sibling-slots.ts": 3788, + "2045-objlit-accessors-basic.ts": 3867, + "2045-parameter-properties.ts": 4798, + "2046-abstract-classes.ts": 5738, + "2046-objlit-accessors-effects.ts": 3922, + "2047-objlit-accessors-shapes.ts": 3974, + "2047-optional-class-fields.ts": 5957, + "2050-dynamic-import-own-module/main.ts": 4276, + "2051-dynamic-import-then/main.ts": 3569, + "2052-dynamic-import-self.ts": 2505, + "2053-typeof-static-fold.ts": 3591, + "2054-destructuring-island-source.ts": 4039, + "2060-empty-tuple.ts": 3547, + "2070-computed-key-folds.ts": 5392, + "2071-integer-key-enumeration-order.ts": 4114, + "2072-expando-function-members.ts": 3911, + "2073-destructuring-assignment.ts": 3331, + "2074-island-destructuring.ts": 2722, + "2075-index-signature-runtime-keys.ts": 2808, + "2080-destructuring-defaults.ts": 4723, + "2081-destructuring-rest.ts": 3815, + "2082-destructuring-assignment.ts": 4463, + "2085-destructuring-heads-rest-params.ts": 3370, + "2087-destructuring-for-heads.ts": 3817, + "2090-index-signature-number-keys.ts": 3307, + "2091-index-signature-string-intersection.ts": 4503, + "2092-package-imports/main.ts": 3209, + "2093-timers-promises.ts": 4576, + "2094-diagnostics-channel.ts": 5184, + "2095-js-catch-unknown.js": 3505, + "2096-os-type.ts": 3468, + "2097-js-evolving-globals.js": 3426, + "210-string-methods.ts": 3239, + "2100-stream-default-hwm.ts": 4068, + "2101-dyn-param-defaults.ts": 4169, + "2102-empty-pattern-decls.ts": 3916, + "2105-computed-key-static-folds.ts": 3626, + "2106-comma-expressions.ts": 4728, + "211-string-unicode.ts": 3897, + "2110-top-object-types.ts": 3438, + "2111-json-stringify-unknown.ts": 3888, + "2112-array-at-findlast.ts": 3424, + "2113-string-index-methods.js": 3570, + "212-string-aliasing-append.ts": 3570, + "2120-package-self-import/main.ts": 3971, + "2121-esm-cycle-inert-backedge/main.ts": 2650, + "2123-ambient-import-crash/main.ts": 3746, + "2124-imports-field-wildcard/main.ts": 2731, + "2140-uri-component-codecs.ts": 3381, + "2160-dc-tracing-channel.cjs": 4690, + "2161-js-object-literal-identity.cjs": 4257, + "2162-js-dyn-destructure.cjs": 3551, + "2163-js-selfref-const.cjs": 4654, + "2164-js-then-dyn-handler.cjs": 5156, + "2165-js-throw-dyn.cjs": 3523, + "2166-cjs-getter-this/main.cjs": 3882, + "2170-island-array-exits.ts": 3858, + "2171-island-json-stringify.ts": 3712, + "2172-island-regexp-boundary.ts": 3327, + "2190-new-object-and-string-wrappers.ts": 2850, + "2191-uri-encoders.ts": 2942, + "2192-object-default-tostring.ts": 3177, + "2193-discarded-stdlib-reads.ts": 3355, + "2194-ambient-undef-chains.ts": 3563, + "2195-require-missing-package/main.mjs": 4117, + "2196-island-computed-key-chain.ts": 3932, + "2210-dyn-promise-crossing.cjs": 5102, + "2211-dc-trace-promise.cjs": 4621, + "2212-unhandled-rejection-listener.cjs": 4270, + "2213-async-local-storage.cjs": 4068, + "2214-dc-bind-store.cjs": 5707, + "2215-process-emit-warning-exit.cjs": 4386, + "2240-width-class-into-record.ts": 3665, + "2241-width-record-into-class.ts": 3361, + "2242-width-statics-into-record.ts": 3708, + "2243-width-assert-satisfies-shapes.ts": 3967, + "2250-tagged-templates.ts": 3434, + "2252-class-iterators.ts": 4459, + "2253-union-coercions.ts": 2359, + "2260-http2-constants.cjs": 3538, + "2280-builtin-namespace-destructure.cjs": 3057, + "2281-domexception-atob-btoa.cjs": 3389, + "2282-queue-microtask.cjs": 5820, + "2283-structured-clone.cjs": 4600, + "2284-regexp-constructor.cjs": 3741, + "2285-iferror-dyn.cjs": 2861, + "2286-dyn-object-walks.cjs": 3243, + "2300-dyn-record-spread-and-keyed-access.cjs": 2809, + "2301-cjs-export-table-dom-attach.cjs": 2887, + "2310-process-next-tick.ts": 4130, + "2311-next-tick-js-callbacks.js": 4068, + "2312-stream-underscore-assign.ts": 6594, + "2313-stream-underscore-assign-js.cjs": 4269, + "2314-process-introspection.ts": 3297, + "2320-await-unit.ts": 3657, + "2321-emitter-static-setmax.cjs": 4316, + "2322-dyn-array-sort.cjs": 3658, + "2323-timer-callback-returns.ts": 4288, + "2330-tls-server-runtime-options.cjs": 57265, + "2331-tls-server-options-typed.ts": 24831, + "2350-nan-global.ts": 3780, + "2351-async-methods.ts": 4037, + "2352-void-coercions.ts": 4230, + "2353-decorators-member-ambient.ts": 3783, + "2354-decorators-expression-ambient.ts": 3425, + "2360-tuple-to-array.ts": 4066, + "2361-assign-index-record.ts": 3954, + "2362-execsync-inherit.ts": 3811, + "2363-nullish-retag.ts": 4019, + "2364-in-runtime-key.ts": 3905, + "2365-dyn-into-island.ts": 4006, + "2366-string-well-formed.ts": 2861, + "2367-regexp-escape.ts": 3081, + "2368-set-methods.ts": 3869, + "2369-promise-try.ts": 4228, + "2370-group-by.ts": 4759, + "2371-iterator-helpers.ts": 4028, + "2380-buffer-module-named-import.ts": 3715, + "2381-builtin-default-imports.js": 3602, + "2382-cycle-two-decl/main.ts": 2942, + "2383-cycle-assertdoc/main.js": 2814, + "2384-cycle-mixed-bindings/main.ts": 2985, + "2385-builtin-reexport-facade/main.ts": 2368, + "2386-string-to-chars.ts": 3688, + "2387-tonumber-argv.ts": 4524, + "2388-tonumber-grammar-zoo.ts": 3447, + "2389-tonumber-unary-plus.ts": 3631, + "2390-dot-requires/main.cjs": 3823, + "2391-default-builtin-imports/main.ts": 4261, + "2392-block-guard-alias-scope.ts": 3432, + "2393-loop-exit-guard-narrow.ts": 4204, + "2394-loop-narrow-containment.ts": 3545, + "2395-while-cond-guard.ts": 3342, + "2396-born-narrowed-decl.ts": 3204, + "2397-branch-kill-merge.ts": 2872, + "2398-switch-arm-kill.ts": 2478, + "2399-reassign-kill-polarity.ts": 3975, + "240-stdout-write.ts": 3714, + "2400-kill-return-edge.ts": 2788, + "2401-kill-break-staging.ts": 3266, + "2402-labeled-break-kill.ts": 3546, + "2403-kill-continue-backedge.ts": 3341, + "2404-kill-throw-catch.ts": 3390, + "2405-sibling-arm-narrow.ts": 3636, + "2406-switch-clause-sibling-narrow.ts": 3321, + "2407-infinite-loop-seal.ts": 3706, + "2408-loop-terminality-reopen.ts": 3556, + "2409-loop-body-return-not-terminal.ts": 2952, + "2410-stacked-cases-terminality.ts": 2785, + "2411-exhaustive-switch-terminality.ts": 2898, + "2412-dowhile-guard-trailing-test.ts": 3018, + "2413-dowhile-kill-renarrow.ts": 3619, + "2414-dowhile-continue-kill.ts": 3030, + "2415-dowhile-break-trailing-test.ts": 3541, + "2416-spread-ternary-positions.ts": 3398, + "2417-ternary-local-inference.ts": 2779, + "2418-wrapped-ternary-arms.ts": 3414, + "2419-selector-ternary-union.ts": 2916, + "2420-nullish-null-identity.ts": 2738, + "2421-float-lane-inference.ts": 3483, + "2422-ieee-div-rem-corners.ts": 3493, + "2423-param-null-reassign.ts": 2469, + "2424-ternary-miss-first-narrowing.ts": 2704, + "2425-elseif-head-exit-narrow.ts": 3239, + "2426-default-snapshot-mutable/main.ts": 3047, + "2427-perf-hooks-now.ts": 3594, + "2428-field-redeclare-inherited.ts": 3306, + "2429-destructure-class-instance.ts": 3925, + "2430-empty-literal-unknown-field.js": 3247, + "2431-primitive-ctor-values.ts": 4135, + "2432-generic-member-fields-async.ts": 4525, + "2433-as-const-command-tables.ts": 4328, + "2434-deferred-init-fields.ts": 3024, + "2435-loose-same-kind-equality.ts": 3478, + "2440-console-inspect-args.ts": 5890, + "2441-console-process-argv.ts": 3753, + "2442-union-literal-arm-widening.ts": 3136, + "2443-union-literal-shadow-narrowing.ts": 3135, + "2444-union-literal-reducer-spread.ts": 2966, + "2445-math-minmax-nary.ts": 3844, + "2446-performance-global.ts": 3708, + "2447-island-boundary-slots/main.ts": 4610, + "2448-entries-null-arms-regex-arrays.ts": 4797, + "2450-private-instance-methods.ts": 4126, + "2451-private-fields.ts": 3682, + "2452-private-statics.ts": 3833, + "2453-private-accessors.ts": 3714, + "2454-private-generator-methods.ts": 4326, + "2455-private-brand-checks.ts": 2955, + "2456-private-async-methods.ts": 4273, + "2457-private-members.js": 3893, + "2460-qs-parse-grammar.ts": 5096, + "2461-qs-parse-options.ts": 3628, + "2462-qs-stringify.ts": 4992, + "2463-qs-escape-unescape.ts": 3734, + "2464-qs-require-forms.cjs": 4220, + "2470-mockable-module-shape.js": 2876, + "2471-record-keyed-write-hasown.js": 4081, + "2472-string-regexp-union.ts": 2606, + "2473-option-table-widths.js": 4586, + "2474-island-literal-forms.ts": 4522, + "2475-variadic-wrapper-island.js": 3845, + "2476-map-regex-values.ts": 3182, + "2480-recursive-record-tree.ts": 3879, + "2481-mutual-recursive-records.ts": 3675, + "2482-recursive-union-tree.ts": 3577, + "2483-recursive-record-cycles.ts": 3205, + "2484-json-stringify-circular.ts": 3643, + "2485-inspect-circular-refs.ts": 3845, + "2486-recursive-record-boundaries.ts": 2991, + "2487-recursive-deep-equal.ts": 4100, + "2488-ast-walker.ts": 4477, + "2490-find-miss-null-compare.ts": 3671, + "2491-strict-unit-compare-no-arm.ts": 3227, + "2492-loose-null-compare-unions.ts": 3901, + "2493-switch-unit-cases.ts": 3674, + "2494-no-arm-compare-effects.ts": 3403, + "2500-net-autosel-timeout.ts": 3482, + "2510-dyn-evolving-array-map.ts": 3667, + "2511-dyn-evolving-array-filter-foreach.ts": 4096, + "2512-dyn-evolving-array-mixed-push.ts": 4423, + "2520-private-statics-class-name-calls.ts": 3265, + "2521-private-statics-class-expression.ts": 3750, + "2522-private-statics-decorated.ts": 3195, + "2523-private-statics-aliased-class.ts": 3584, + "2530-object-destructuring-decl.ts": 3283, + "2531-array-tuple-destructuring-decl.ts": 4032, + "2532-param-destructuring-options.ts": 4645, + "2533-forof-destructuring.ts": 4187, + "2534-object-rest-decl.ts": 4358, + "2535-destructuring-assign-basics.ts": 3621, + "2536-destructuring-assign-nested.ts": 3573, + "2537-destructuring-assign-member-targets.ts": 3272, + "2538-destructuring-assign-class-source.ts": 3962, + "2539-class-instance-rest.ts": 4142, + "2540-accessor-destructuring-defaults.ts": 3446, + "2541-destructuring-eval-order.ts": 3928, + "2550-generics-keyof-pick.ts": 3409, + "2551-generics-value-aliases.ts": 3346, + "2552-generics-iface-methods.ts": 3488, + "2553-generics-signature-bindings.ts": 3749, + "2554-generics-frontier-mix.ts": 3794, + "2555-generics-keyof-writes.ts": 3364, + "2556-crypto-introspection.ts": 3435, + "2556-width-hybrid-shapes.ts": 4079, + "2557-tls-ca-store.ts": 3530, + "2557-width-field-lifts.ts": 4176, + "2558-index-signature-func-values.ts": 4225, + "2558-rejection-events.cjs": 3844, + "2559-index-signature-container-values.ts": 4449, + "2560-arraybuffer-dataview-set.ts": 3087, + "2561-object-is.ts": 4355, + "2562-intl-numberformat-en-us.ts": 3901, + "2563-stream-promises-pipeline.ts": 3564, + "2564-stream-promises-finished.ts": 6034, + "2565-stream-promises-js.cjs": 4473, + "2566-promise-reject-dyn-reason.js": 3377, + "2567-rest-spread-forward.js": 3534, + "2568-rest-spread-forward-dynamic.js": 4104, + "2569-upcast-identity.ts": 3496, + "2570-buffer-arg-validation.cjs": 5910, + "2571-searchparams-arg-validation.cjs": 4428, + "2572-readable-emitted-readable-flag.cjs": 3512, + "2573-fs-url-arg-ladders.cjs": 3763, + "2574-emitter-max-listeners-ladders.cjs": 3689, + "2575-string-destructuring-decl.ts": 4712, + "2576-string-destructuring-assign.ts": 3735, + "2577-builtin-global-destructuring.js": 4445, + "2578-jsval-into-unknown-rows.ts": 3828, + "2579-jsval-object-param-crossing.js": 3036, + "2580-jsval-routed-keyed-ops.js": 3956, + "2581-jsval-routed-calls.js": 3809, + "2582-jsval-object-statics.js": 3967, + "2582-jsval-routed-keyed-ops.js": 2714, + "2583-dyn-nullish-coalesce.js": 3955, + "2583-jsval-routed-calls.js": 4033, + "2584-jsval-object-statics.js": 3852, + "2584-union-dyn-collapse.ts": 3199, + "2585-dyn-nullish-coalesce.js": 4086, + "2585-unknown-array.ts": 3037, + "2586-object-assign-spread.js": 4129, + "2587-array-entries-forof.ts": 3963, + "2588-array-entries-chains.ts": 4778, + "2589-object-create-null.cjs": 3994, + "2590-object-create-dynamic.js": 3840, + "2591-ambient-generic-traps.ts": 3572, + "2592-ambient-trap-uncaught.ts": 3517, + "2593-generic-inert-bindings.ts": 3984, + "2594-nullish-generic-bindings.ts": 3028, + "2595-fs-arg-ladders.cjs": 6103, + "2596-net-arg-ladders.cjs": 3811, + "2597-dgram-send-ladders.cjs": 4888, + "2598-tls-arg-ladders.cjs": 26930, + "2599-stream-arg-ladders.cjs": 6141, + "2600-dyn-keyed-write-harness.js": 2931, + "2601-dyn-keyed-write-ops.js": 2148, + "2602-dyn-array-destructure.js": 2954, + "2603-island-keyed-write-dyn.js": 2848, + "2604-cycle-classes-mutual/main.ts": 3417, + "2605-cycle-three-module/main.ts": 3678, + "2606-dynamic-import-cycle/main.ts": 3530, + "2608-regex-named-groups.ts": 4497, + "2609-regex-named-replace.ts": 3665, + "2610-regex-named-matchall.ts": 3003, + "2611-regex-named-groups-js.cjs": 4787, + "2613-for-init-uninitialized-let.ts": 3768, + "2614-trap-binding-later-writes.ts": 2989, + "2615-nullish-field-record-binding.ts": 3529, + "2616-js-collect-probe-defers.js": 3466, + "2617-enum-static-field-import/main.ts": 3293, + "2618-ee-emit-override.ts": 3565, + "2619-ee-override-chain.ts": 3727, + "2620-ee-override-once-order.ts": 4249, + "2621-ee-override-error-throw.ts": 3855, + "2622-ee-override-filter.ts": 3910, + "2623-ee-job-queue.ts": 3743, + "2624-ee-override-js.cjs": 3084, + "2625-bytes-views.ts": 3970, + "2626-stream-event-names.ts": 4359, + "2627-stream-ticks-are-nextticks.ts": 7617, + "2628-stream-push-encodings.cjs": 3343, + "2629-stream-consumers.ts": 4441, + "2630-stream-consumers-errors.ts": 5041, + "2631-create-require/main.ts": 3703, + "2632-dyn-jsval-iterate.js": 3831, + "2633-island-promise-crossing.js": 5160, + "2634-stream-pipeline-arg-ladders.cjs": 3923, + "2635-trap-binding-unmappable-written.ts": 3043, + "2636-trap-binding-ambient-rooted-rewrite.ts": 3569, + "2637-create-require-bare/main.ts": 2767, + "2638-http-dyn-res-compat.cjs": 8125, + "2639-http-dyn-req-pause.cjs": 8808, + "2640-net-dyn-socket-compat.cjs": 4119, + "2641-http-agent-surface.cjs": 8974, + "2642-http-agent-maxsockets.cjs": 7586, + "2643-or-default-retag.ts": 3938, + "2644-http-client-url-argument.ts": 8788, + "2645-https-client-url-argument.ts": 5188, + "2646-top-level-await.ts": 3543, + "2647-top-level-await-modules/main.ts": 3228, + "2648-top-level-await-rejection.ts": 3718, + "2649-top-level-await-pending.ts": 3680, + "2650-top-level-await-self-import.ts": 3580, + "2651-top-level-await-pending-unhandled.ts": 3616, + "2652-top-level-await-dynamic/main.ts": 3624, + "2653-top-level-await-rejection-stops-loop.ts": 3405, + "2654-top-level-await-unrelated-rejection.ts": 3746, + "2655-top-level-await-cycle/main.ts": 3633, + "2656-top-level-await-cycle-order/main.ts": 3581, + "2657-top-level-await-cycle-dynamic/main.ts": 3334, + "2658-top-level-await-sync-completion/main.ts": 3454, + "2659-top-level-await-dynamic-cycle/main.ts": 2695, + "2660-top-level-await-cycle-rejection/main.ts": 3883, + "2661-top-level-await-dynamic-runtime-root/main.ts": 3717, + "2662-top-level-await-cycle-external-wait/main.ts": 3322, + "2663-top-level-await-dependency-errors/main.ts": 4049, + "2664-top-level-await-same-checkpoint-rejection.ts": 4075, + "2665-top-level-await-unhandled-listener-liveness.ts": 3625, + "2666-array-to-sorted.ts": 8369, + "2668-stored-number-array-iterator.ts": 3915, + "2669-array-copying-methods.ts": 4422, + "2670-uint8array-copy-iterate.ts": 4692, + "2671-array-copying-js.cjs": 3615, + "2672-http-request-response-callback.ts": 3326, + "2673-top-level-await-implicit-module.ts": 2622, + "2674-top-level-for-await-implicit-module.ts": 3487, + "2675-create-require-nested-esm.js": 3107, + "2675-process-self-reexec.ts": 3537, + "2676-indexed-read-strict-equality.ts": 3497, + "2676-record-clone-overrides.ts": 3652, + "2676-top-level-await-ambiguous/main.ts": 3641, + "2677-runtime-optional-closure.ts": 4530, + "2677-top-level-await-module-scope/main.ts": 3142, + "2678-date-instances.ts": 4477, + "2678-large-string-sparse-index.ts": 3931, + "2678-util-parseargs.ts": 7627, + "2679-util-parseargs-cjs.cjs": 4984, + "2680-util-parseargs-default.ts": 2670, + "2681-util-parseargs-dynamic.js": 3233, + "2682-fs-rename.ts": 4087, + "2683-filter-truthy-predicate.ts": 4348, + "2683-fs-rename-js.cjs": 2621, + "2684-filter-no-predicate-dyn.cjs": 3942, + "2684-fs-rename-abort.ts": 3403, + "2685-array-unshift-reverse.ts": 3942, + "2685-fs-write-sync.ts": 4263, + "2686-fs-file-handle.ts": 6233, + "2687-fsp-write-file-options.ts": 3951, + "2687-process-write-args.ts": 2844, + "2688-fs-stats-disk-fields.ts": 4789, + "2689-http-server-timeout-properties.ts": 3279, + "2690-https-server-timeout-option.ts": 56311, + "2691-retained-lowering-record-order.ts": 5946, + "2692-inline-record-assert-index.ts": 3857, + "2692-string-accumulation.ts": 3602, + "2693-math-constants.ts": 3816, + "2700-array-sort-complexity.ts": 3912, + "2700-http-static-trailers.ts": 6657, + "2700-wasi-core.ts": 3863, + "2701-array-sort-snapshot.ts": 3906, + "2701-http-static-trailer-wire.ts": 3412, + "2701-import-meta/main.mjs": 4097, + "2702-http-static-trailer-end.ts": 8433, + "2702-type-import-link-static/main.ts": 2947, + "2702-uint8array-to-sorted.ts": 3549, + "2703-array-sparse-sort.ts": 8716, + "2703-type-import-link-static-reexport/main.ts": 3510, + "2704-array-sparse-to-sorted.ts": 8447, + "2704-type-import-link-static-success/main.ts": 3172, + "2705-array-sparse-sort-append.ts": 7740, + "2705-type-import-link-dynamic/main.ts": 3687, + "2706-array-search-missing-needle.ts": 3192, + "2706-type-import-link-dynamic-success/main.ts": 4191, + "2707-array-search-huge-sparse.ts": 48438, + "2707-type-import-link-static-default-reexport/main.ts": 3502, + "2708-type-import-link-dynamic/main.ts": 3358, + "2720-array-read-parity.ts": 3686, + "2721-array-nested-missing-receiver.ts": 2904, + "2750-array-sparse-foundation.ts": 3895, + "2751-buffer-concat-sparse-list.ts": 3589, + "2752-array-optional-stores.ts": 3503, + "2753-array-optional-method-values.ts": 2814, + "2754-array-property-undefined.ts": 2681, + "2755-array-optional-literal-forwarding.ts": 3614, + "2780-array-parity-composition.ts": 12116, + "2781-array-missing-value-escape.ts": 3458, + "2782-array-sparse-callbacks.ts": 3870, + "2783-array-defaults-rest.ts": 3473, + "2784-array-reduce-missing-result.ts": 3973, + "2785-array-missing-destructuring.ts": 4123, + "2786-array-sparse-serialization.ts": 4457, + "2787-array-missing-string-arithmetic.ts": 3381, + "2788-array-missing-builtin-conversions.ts": 3415, + "2789-array-missing-optional-tostring.ts": 2621, + "2790-dynamic-import-self-name/main.ts": 3399, + "2791-record-optional-keys.ts": 3271, + "2792-record-optional-spread-entries.ts": 4055, + "2793-union-conversion-identity-capture.ts": 4295, + "2794-array-generic-callback-values.ts": 3662, + "2795-array-optional-typedarray-source.ts": 38684, + "2796-array-sparse-class-value-instanceof.ts": 3585, + "2800-array-expression-consumers.ts": 3265, + "2801-array-switch-consumers.ts": 4057, + "2820-array-missing-method-receivers.ts": 3301, + "2821-array-optional-numeric-comparisons.ts": 2316, + "2830-cjs-require-self-name/main.cjs": 3030, + "2840-finally-completions.ts": 3523, + "2841-using-sync.ts": 3234, + "2842-await-using.ts": 3418, + "2843-using-suppressed-error.ts": 3352, + "2844-node-disposable-resources.ts": 5430, + "2845-for-using-of.ts": 3355, + "2846-generator-using.ts": 3702, + "2850-async-generators-protocol.ts": 4747, + "2851-async-generators-values.ts": 4111, + "2852-timers-promises-interval.ts": 3376, + "2854-leading-bom-literals.ts": 2675, + "2855-searchparams-sort-complexity.ts": 2462, + "2856-dynamic-any-local-operators.ts": 3959, + "2857-branded-primitives.ts": 3738, + "2858-import-meta-resolve/main.mjs": 2597, + "2859-import-meta-resolve-dynamic/main.mjs": 2565, + "2860-require-resolve/main.cjs": 3076, + "2861-readable-iterator-close.ts": 3422, + "2862-web-readable-async-iteration.ts": 55094, + "2863-class-async-iterator.ts": 3586, + "2864-array-class-method-receivers.ts": 4152, + "2865-cjs-process-alias.cjs": 3499, + "2866-dyn-switch.ts": 3318, + "2867-array-shift-length.js": 3797, + "2868-empty-record-promise-presence.js": 3592, + "2869-nullish-mixed-lazy.ts": 3886, + "2870-and-dropped-truthy-arm.ts": 3748, + "2871-optional-promise-to-unknown.ts": 3966, + "2872-unobserved-dynamic-event.ts": 3095, + "2873-optional-receiver-loop-lifetime.js": 3310, + "2874-nullable-callback-field-cycle.js": 4239, + "2875-evolving-let-read-before-write.js": 2007, + "2876-class-unknown-roundtrip.ts": 3485, + "2877-child-unknown-roundtrip.ts": 3462, + "2878-class-private-unknown.cjs": 3481, + "2880-cjs-module-graph/main.cjs": 4418, + "2890-crypto-static-utility.ts": 3693, + "2891-json-record-key-escapes.ts": 3227, + "2892-windows-console-unicode.ts": 3154, + "2893-child-stdin-duplex.ts": 3517, + "2894-child-stdin-backpressure.ts": 4232, + "2895-child-stdin-write-after-end.ts": 3755, + "2896-child-stdin-write-after-finish.ts": 4128, + "2897-child-stdin-destroy.ts": 2592, + "2898-child-stdin-spawn-failure.ts": 3984, + "2899-nested-mutual-recursion.ts": 3524, + "2900-float64array-static.ts": 2647, + "2900-void-conditional-arrow.ts": 3544, + "2901-bigint-core.ts": 3085, + "2902-bigint-bytes.ts": 3574, + "2903-bigint-storage.ts": 4190, + "2904-bigint-errors.ts": 3820, + "2905-bigint-edges.ts": 3695, + "2906-bigint-wasi-width.ts": 3566, + "2910-overloaded-callable-alias.ts": 2729, + "2911-execfile-callback.ts": 3798, + "2912-execfile-callback-options.ts": 3803, + "2912-promisify-fs-readfile.ts": 3648, + "2913-builtin-callable-alias.ts": 5737, + "2914-fixed-tuple-call-spread.ts": 3851, + "2915-path-function-values.ts": 4013, + "2916-path-function-values-cjs.ts": 3957, + "2917-builtin-callable-widths.ts": 3640, + "2918-builtin-callable-widths-cjs.ts": 3701, + "2919-fs-function-values.ts": 3810, + "2920-fs-promises-function-values.ts": 3724, + "2921-zlib-callbacks.ts": 5492, + "2922-dyn-bitwise-not.cjs": 3645, + "2923-cjs-factory-export/main.cjs": 3645, + "2930-union-receiver-calls.ts": 4841, + "2931-union-dynamic-field-call.js": 3975, + "2932-create-require-program/main.ts": 4060, + "2933-static-dynamic-import/main.ts": 3736, + "2934-static-import-stored.ts": 3490, + "2935-module-namespace-values/main.ts": 3371, + "2936-static-loose-equality.ts": 4954, + "2937-bitwise-hot-loop.ts": 3448, + "2938-fs-sync-overloads.cjs": 3181, + "2939-child-shell-text.ts": 4371, + "2940-date-parse.ts": 3212, + "2940-fsp-realpath.ts": 3484, + "2941-fsp-lstat-identity.ts": 3903, + "2941-process-exit-code.ts": 3406, + "2942-fsp-readdir-dirent.ts": 4202, + "2942-process-exit-code-override.ts": 3082, + "2943-process-exit-code-invalid.ts": 3479, + "2944-process-exit-code-wrap.ts": 3266, + "2945-url-origin-username.ts": 2899, + "2946-child-fork-ipc/main.ts": 4761, + "2946-url-port-hash.ts": 2865, + "2947-set-readonly-seeds.ts": 3446, + "2948-child-fork-eof-callback/main.ts": 3476, + "2948-stdio-callback-record.ts": 3365, + "2949-child-fork-default/main.mjs": 3332, + "2949-url-password.ts": 3628, + "2950-fs-descriptor-publication.ts": 3569, + "2951-math-static-analytic.ts": 3919, + "2952-math-static-remaining.ts": 3652, + "2953-http-header-validation.ts": 7274, + "2954-http-outgoing-headers.ts": 9450, + "2955-http-static-state.ts": 6516, + "2956-http-static-informational.ts": 6092, + "2957-http-static-response-controls.ts": 6929, + "2961-emitter-computed-names.cjs": 4004, + "2962-emitter-computed-optional.ts": 2860, + "2963-child-fork-dispatch/main.ts": 3483, + "2964-indexed-compound.ts": 4204, + "2966-numeric-array-read-fusion.ts": 4381, + "2967-numeric-array-read-lifetime.ts": 3892, + "2968-numeric-array-borrow.ts": 3610, + "2969-scalar-record-results.ts": 4035, + "2970-constant-numeric-tables.ts": 2720, + "2971-constant-table-modules/main.ts": 3311, + "2972-http-static-distinct-snapshots.ts": 4474, + "2972-math-receiver-borrow.ts": 4401, + "2973-http-static-agent.ts": 3997, + "2973-integer-bitwise-arithmetic.ts": 3629, + "2974-array-search-from-index.ts": 116997, + "2974-http-static-module-values.ts": 7598, + "2974-numeric-remainder.ts": 3511, + "2975-bigint-default-radix.ts": 3179, + "2975-http-static-client-controls.ts": 3852, + "2976-http-static-incoming-state.ts": 8478, + "2976-json-stringify-no-arguments.js": 3354, + "2977-http-static-incoming-timeout.ts": 3463, + "2977-nested-array-binding-defaults.js": 2952, + "2978-http-static-client-timeout.ts": 4066, + "2978-regexp-optional-subject.js": 2771, + "2979-array-search-mixed-needles.js": 3599, + "2979-http-static-server-timeout.ts": 3821, + "2980-http-static-server-timeout-default.ts": 3238, + "2980-string-position-arguments.js": 3754, + "2981-http-static-events.ts": 3579, + "2981-string-optional-positions.ts": 3623, + "2982-http-static-close-all.ts": 2800, + "2982-string-position-coercion-order.js": 4005, + "2983-http-static-close-idle.ts": 3208, + "2984-http-static-close-upgrade.ts": 3773, + "2985-http-static-message-destroy.ts": 3787, + "2986-http-static-client-socket-finish.ts": 3574, + "2987-http-static-timeout-errors.ts": 3533, + "2988-http-static-client-abort.ts": 4341, + "2989-http-static-response-timeout-handled.ts": 3444, + "2990-http-static-request-timeout-handled.ts": 3719, + "2991-array-indexed-equality.ts": 3650, + "2992-stream-rows.ts": 3551, + "2993-fiber-stack-lifetimes.ts": 3792, + "2994-fromcharcode-scalar.ts": 4459, + "2995-math-hyperbolic.ts": 3860, + "2996-math-near-one.ts": 3086, + "2997-math-integer-float.ts": 3955, + "300-if-else.ts": 3194, + "3001-caught-typeof-object.js": 4263, + "3002-promise-then-two.ts": 4357, + "301-while.ts": 3525, + "302-for.ts": 3433, + "3020-string-last-index-position.ts": 3282, + "3021-buffer-union-narrow-callback.ts": 3951, + "3022-string-affix-positions.ts": 2990, + "3023-string-affix-position-coercion.js": 3327, + "3024-string-number-narrow-for-in.ts": 3695, + "3025-string-search-position-coercion.js": 3055, + "3026-array-last-index-of.js": 3971, + "3027-array-last-index-of-records.ts": 3174, + "3028-string-search-dynamic-needle.js": 3488, + "3029-string-search-union-needle.js": 2317, + "303-break-continue.ts": 3497, + "3030-array-search-no-arg.js": 3148, + "3031-array-relative-index-coercion.js": 4248, + "3031-string-last-index-search-value.js": 2998, + "3032-string-search-value.js": 3484, + "3033-string-search-needle-coercion.js": 3256, + "3034-arguments-with-parameters.js": 3316, + "3035-string-positioned-search-value.js": 3436, + "3036-string-object-search-value.js": 3562, + "3037-number-nullish-conversion.js": 3657, + "3038-number-scalar-unions.ts": 2371, + "3039-string-repeat-count.js": 3353, + "304-compound-incdec.ts": 3802, + "3040-string-prototype-call.js": 4850, + "3041-string-prototype-object-call.js": 3234, + "3042-string-padding-coercion.js": 3916, + "3043-string-split-arguments.js": 3976, + "3044-array-slice-splice-positions.js": 4465, + "3045-array-indexed-mutation.js": 3477, + "3046-array-indexed-ref-identity.ts": 3717, + "3047-object-prototype-tag.js": 7241, + "3048-object-own-prototype.ts": 2902, + "3049-array-flat-depth.ts": 4100, + "305-truthiness.ts": 3370, + "3050-array-splice-insert.ts": 4056, + "3051-array-join-default.ts": 3538, + "3052-array-construction.ts": 4542, + "3053-array-construction-js.js": 3392, + "3054-dynamic-abort-record.ts": 30732, + "3055-default-builtin-nodenext/main.ts": 3399, + "3056-default-builtin-bundler/main.ts": 3748, + "3057-default-builtin-nodenext-dynamic/main.ts": 3727, + "3058-optional-array-chain-join.ts": 3025, + "3059-arguments-property-names.ts": 3619, + "3061-concurrent-fiber-stacks.ts": 4083, + "3062-runtime-optional-record-guards.ts": 4619, + "3063-runtime-optional-class-guards.ts": 4458, + "3064-installed-entry-imports/main.ts": 2755, + "3065-installed-entry-js/main.js": 2496, + "3066-source-debugging/main.ts": 3345, + "3067-cjs-function-export-require/main.cjs": 3584, + "3068-debug-variables/main.ts": 2803, + "3068-url-checked-identity.ts": 3525, + "3069-set-checked-seed.js": 3730, + "3069-tuple-spread.ts": 3638, + "3070-checked-object-accessors.js": 3937, + "3070-collection-views.ts": 3112, + "3071-checked-specialization-narrowing.js": 4666, + "3071-map-contextual-record-seeds.ts": 3637, + "3072-optional-union-receivers.ts": 4348, + "3072-weak-process-streams.js": 3937, + "3073-optional-callable-module.js": 3783, + "3073-union-keyed-reads.ts": 3349, + "3074-discriminated-intersections.ts": 3833, + "3075-recursive-contextual-literals.ts": 4956, + "3076-nullish-record-defaults.ts": 3537, + "3077-optional-union-array-reads.ts": 4192, + "3078-forward-mutable-captures.ts": 4709, + "3079-forward-mutable-tdz.ts": 4069, + "3080-exhaustive-never-bindings.ts": 3678, + "3081-recursive-array-destinations.ts": 3824, + "3082-forward-write-unwind.ts": 3698, + "3083-set-string-seed.ts": 3916, + "3084-record-own-membership.ts": 4502, + "3085-conditional-record-construction.ts": 4272, + "3086-error-constructor-options.ts": 2549, + "3087-error-options-lifetime.ts": 3996, + "3088-array-wide-callbacks.ts": 4379, + "3089-array-find-narrowing.ts": 4095, + "3090-json-discriminated-records.ts": 4621, + "3091-json-recursive-discriminants.ts": 4799, + "3092-number-union-predicates.ts": 3661, + "3093-error-option-data.ts": 3834, + "3094-json-replacer-traversal.ts": 3366, + "3095-json-reviver-traversal.ts": 3492, + "3096-json-callback-nonfinite.ts": 3652, + "3097-json-callback-reentrancy.ts": 4051, + "3098-json-callback-space.ts": 4000, + "3099-json-callback-functions.ts": 4355, + "3100-json-callback-holder.js": 4131, + "3101-json-callback-bytes.ts": 4053, + "3102-json-unknown-fields.ts": 3096, + "3103-scalar-record-nested-control-flow.ts": 3773, + "3104-native-analysis-tables-loops.ts": 3270, + "3105-nullable-collections.ts": 3945, + "3106-mixed-insertion-spreads.ts": 4363, + "3107-nullable-collection-lifetimes.ts": 4026, + "3108-for-await-sync-arrays.js": 5613, + "3108-identity-map-keys.ts": 3552, + "3109-destructuring-unknown-defaults.js": 3464, + "3109-identity-union-collections.ts": 4940, + "3110-builtin-error-families.ts": 3056, + "3110-identity-collection-mutation.ts": 4022, + "3111-identity-collection-cycles.ts": 4287, + "3112-union-switch-control-flow.ts": 3956, + "3113-union-array-removal.ts": 4360, + "3114-union-record-field-write.ts": 3442, + "3115-zlib-static-compression-levels.ts": 5168, + "3116-sequence-expression-lifetimes.ts": 4189, + "3117-unknown-switch-control-flow.ts": 4180, + "3118-recursive-union-spread.ts": 3041, + "3119-runtime-optional-spread.ts": 3381, + "3120-dynamic-property-descriptors.js": 2965, + "3120-generator-method-loop-bindings.ts": 4201, + "3120-ir-nonfinite-numbers.ts": 4055, + "3121-compound-assignment-values.js": 3508, + "3121-dynamic-accessor-descriptors.js": 5206, + "3122-dynamic-delete-descriptors.cjs": 3618, + "3122-dynamic-delete-descriptors.js": 3463, + "3122-js-async-class-methods.js": 3826, + "3123-destructured-global-tdz.js": 3445, + "3124-array-prototype-borrow.js": 4427, + "3125-regex-global-match.ts": 2948, + "3126-js-number-radix/main.ts": 3569, + "3127-spawn-runtime-options.ts": 3489, + "3128-regex-last-index.ts": 4225, + "3129-js-token-union/main.ts": 4007, + "3130-child-generic-streams.ts": 4070, + "3131-child-rest-listeners.js": 3532, + "3132-child-generic-stream-completion.ts": 11386, + "3133-text-decoder-streaming.ts": 19582, + "3134-fs-vectors.ts": 4100, + "3135-fs-file-handle-controls.ts": 5084, + "3136-fs-file-handle-options.ts": 5319, + "3137-fs-vector-callbacks.cjs": 4121, + "3138-array-large-storage.ts": 5662, + "3139-regex-native-deep-alternatives.ts": 37923, + "3140-array-dense-access.ts": 5683, + "3141-map-string-key-hash.ts": 3292, + "3150-integer-remainder.ts": 4041, + "3151-array-push-writes.ts": 4409, + "3170-number-conversion-fast-paths.ts": 3918, + "3171-method-census-data-writes.ts": 4678, + "400-fib.ts": 3649, + "401-mutual-recursion.ts": 2468, + "402-string-functions.ts": 3526, + "403-void-and-params.ts": 3277, + "4030-runtime-object-truthiness.ts": 4681, + "4031-event-emitter-long-tuples.ts": 3970, + "4032-inline-rc-fast-paths.ts": 6135, + "404-rc-stress.ts": 3734, + "4040-adapted-function-identity.ts": 4226, + "4041-adapted-function-properties.ts": 3785, + "4042-object-is-union-subclass.ts": 3204, + "4043-nonnull-missing-element.ts": 4658, + "4044-adapted-callback-modules/main.ts": 3502, + "4045-optional-element-projections.ts": 4551, + "4046-captured-parameter-values.ts": 4678, + "4047-captured-parameter-rebinding.ts": 3804, + "405-params-optional.ts": 3480, + "406-params-defaults.ts": 3673, + "4060-cycle-shared-instance/main.ts": 2973, + "4060-stack-union-reads.ts": 3684, + "4061-cycle-evaluation-order/main.ts": 3762, + "4061-nullable-ref-fields.ts": 5610, + "4062-cycle-tdz-read/main.ts": 3351, + "4063-cycle-hoisted-calls/main.ts": 3608, + "4064-cycle-classes-after-init/main.ts": 3570, + "4065-cycle-init-throws/main.ts": 3220, + "4066-cycle-top-level-tdz/main.ts": 2340, + "4067-dynamic-import-cycle-tdz/main.ts": 3378, + "407-params-rest.ts": 3809, + "408-params-ctors-inheritance.ts": 4026, + "4080-optional-read-presence-tests.ts": 3072, + "4080-string-index-bounds.ts": 2694, + "4081-hoisted-function-tdz.ts": 4427, + "4081-string-index-unproven.ts": 3902, + "4082-hoisted-function-tdz-uncaught.ts": 2748, + "4083-dynamic-import-failure/main.ts": 3742, + "4084-record-optional-field-copies.ts": 4621, + "4085-generator-loop-close.ts": 4491, + "4086-optional-capture-defaults.ts": 2947, + "4088-class-static-tdz.ts": 3366, + "4089-class-wrapper-tdz.js": 2781, + "409-params-async-generics.ts": 4252, + "4090-computed-key-tdz.js": 3408, + "4091-class-evaluation-deferred.ts": 2828, + "410-params-rc-stress.ts": 2917, + "4140-array-callback-split-visit.ts": 6798, + "4141-array-callback-ambient-receiver/main.ts": 3870, + "4142-array-callback-factories.ts": 4472, + "4143-union-refinement-intersection-arms.ts": 4107, + "420-dead-strip-modules/main.ts": 2681, + "4290-acyclic-immutable-trees.ts": 3286, + "4291-acyclic-constructor-escapes.ts": 3619, + "4292-acyclic-readonly-bypass.ts": 4006, + "4293-acyclic-dynamic-writes.ts": 3787, + "4294-console-line-sizes.ts": 5430, + "4295-console-template-parts.ts": 3102, + "4296-console-glued-long-parts.ts": 4254, + "4410-inline-object-allocation.ts": 4263, + "4411-nullable-ref-values.ts": 5324, + "4412-nullable-record-values.ts": 4337, + "4413-cycle-old-late-death.ts": 3017, + "4413-nullable-null-and-undefined.ts": 4035, + "4414-cycle-old-weak-keys.ts": 3820, + "4414-nullable-string-values.ts": 5821, + "4415-identity-borrowed-operands.ts": 4327, + "4415-nullable-container-values.ts": 5953, + "4431-exception-pending-contexts.ts": 5399, + "4432-checked-downcast-failures.ts": 4507, + "4451-int32-field-storage.ts": 5079, + "4452-int32-field-dynamic-writes.ts": 4478, + "4453-int32-closed-locals.ts": 3221, "4454-int32-field-reflection-reads.ts": 4583, "4455-live-view-reads-without-stores.ts": 4961, - "4471-unassigned-field-reads.ts": 3896, - "4476-string-ascii-header-fact.ts": 3522, - "4477-buffer-write-ascii-runs.ts": 3321, - "4478-string-large-index-reads.ts": 4146, - "4481-array-optional-push.ts": 3259, - "4482-instanceof-static-class-optional.ts": 3786, - "4483-array-splice-statement.ts": 4036, - "4484-array-length-reset.ts": 2849, - "4485-array-splice-optional-item.ts": 3817, - "4486-array-field-element-borrows.ts": 2903, - "4487-array-literal-optional-values.ts": 3145, - "4520-optional-guard-narrowing.ts": 2774, - "4521-array-callback-element-presence.ts": 5601, - "4522-captured-parameter-lifetimes.ts": 3907, - "4523-array-pop-removal.ts": 3769, - "4524-array-callback-supertype-params.ts": 4594, - "4541-nullable-wrap-borrows.ts": 3939, - "4542-preserving-call-borrows.ts": 3361, - "4543-walk-borrowed-locals.ts": 3633, - "4544-checked-cast-aliases.ts": 3723, - "4545-borrowed-returns.ts": 4116, - "4546-rebound-borrowed-params.ts": 2930, - "4560-field-store-borrowed-receivers.ts": 4438, - "4561-virtual-borrowed-parameters.ts": 3634, - "4562-string-self-concat-move.ts": 2703, - "4563-array-read-projection-receivers.ts": 3601, - "4564-literal-choice-strings.ts": 3137, - "4568-for-of-hole-elements.ts": 3387, - "4569-shorthand-missing-elements.ts": 3958, - "4570-map-lookup-default-record.ts": 3112, - "4591-weak-keys-union-records.ts": 3556, - "4592-cycle-const-from-import/main.ts": 3467, - "4593-weak-keys-empty-objects.ts": 2938, - "4594-union-class-field-mixed-types.ts": 4040, - "4595-union-class-field-optional-receiver.ts": 3379, - "4596-error-subclass-int-fields.ts": 3559, - "4596-tdz-nullable-forward-capture.ts": 4676, - "4597-callback-field-method-name.ts": 4014, - "4598-live-array-ref-element-access.ts": 8384, - "4598-map-set-clear-reuse.ts": 4224, - "4598-os-available-parallelism.ts": 3815, - "4598-publish-constructor-stores.ts": 3618, - "4599-construction-only-field-borrows.ts": 3619, - "4600-construction-only-fields-dynamic-writes.ts": 3184, - "4601-cycle-holders.ts": 3348, - "4602-constructor-escape-order.ts": 3674, - "4610-array-ext-dyn-refresh.ts": 4598, - "4620-optional-chain-borrowed-receivers.ts": 3411, - "4621-edge-preserving-callees/main.ts": 3288, - "4630-contract-int32.ts": 2810, - "4630-reference-write-call-arguments.ts": 3333, - "4631-contract-nothrow.ts": 3196, - "4631-reference-write-aliases.ts": 4264, - "4632-contract-immutable.ts": 3449, - "4632-reference-write-loops-and-walks.ts": 3791, - "4633-contract-program-lifetime.ts": 4644, - "4633-reference-write-callbacks-returns.ts": 4024, - "4634-contract-program-lifetime-publish.ts": 42618, - "4634-optional-element-borrowed-returns.ts": 3411, - "4640-bitwise-identity-ranges.ts": 3713, - "4641-nothrow-try-catch.ts": 3056, - "4642-acyclic-contract.ts": 4040, - "4650-stale-property-narrowing.ts": 3665, - "4651-map-string-get-entry.ts": 3369, - "4652-stale-closure-binding-narrowing.ts": 3504, - "4660-typed-rest-spread-forwarding.ts": 3148, - "4671-scoped-array-read-borrows.ts": 3020, - "4690-cycle-bypass-long-lived.ts": 5374, - "4691-publish-constructor-self-alias.ts": 38620, - "4692-borrowed-result-mutating-callees.ts": 3592, - "4720-cold-throw-paths.ts": 4339, - "4721-integer-induction-numbers.ts": 3854, - "4730-touint32-large-magnitudes.ts": 3431, - "4731-string-mixed-ascii-slices.ts": 4436, - "4732-buffer-write-utf16le-runs.ts": 4084, - "4733-typed-array-read-compares.ts": 3240, - "4750-map-string-absent-filter.ts": 3584, - "4751-string-search-multibyte-needles.ts": 3227, - "4795-published-untyped-member-reads.ts": 3450, - "4806-uint32-loop-accumulators.ts": 3543, - "4810-union-identity-retags.ts": 34911, - "4811-union-retag-checked-cast.ts": 3044, - "4812-int32-wrapping-sums.ts": 3457, - "4813-typed-array-read-equality-bindings.ts": 4853, - "4820-sort-comparator-lent-arguments.ts": 3579, - "4821-callback-lent-arguments.ts": 4210, - "4822-stable-capture-reads.ts": 3094, - "4823-array-store-receivers.ts": 3774, - "4830-typed-teardown-chains.ts": 3908, - "4831-cycle-bypass-probe-windows.ts": 6157, - "4840-array-hole-free-prefix.ts": 3932, - "4860-int32-local-storage.ts": 5136, - "4870-array-pipeline-fusion.ts": 6645, - "4871-array-pipeline-analytics.ts": 4575, - "4872-array-pipeline-temporaries.ts": 10635, - "4875-stream-consumers-array-buffer.ts": 4120, - "4876-array-buffer-inspect.ts": 2819, - "4880-await-call-turn-order.ts": 3872, - "4881-await-call-exceptions.ts": 3027, - "4882-await-call-request-chain.ts": 2730, - "4883-await-values-and-hops.ts": 3412, - "4884-await-call-unhandled-sibling.ts": 3410, - "4885-await-call-checkpoints.ts": 2703, - "4890-regex-literal-sites.ts": 3712, - "4891-regex-plain-text-patterns.ts": 3018, - "4892-regex-exec-read-captures.ts": 4130, - "4900-bigint-division-cross-check.ts": 3763, - "4900-console-instances.ts": 4286, - "4901-bigint-radix-text.ts": 3099, - "4901-console-instance-errors.ts": 3171, - "4902-bigint-compound-assign.ts": 3431, - "4903-bigint-fixed-width.ts": 3707, - "4904-bigint-large-products.ts": 3972, - "4905-bigint-fixed-width-fusion.ts": 3443, - "4906-bigint-small-value-trees.ts": 4875, - "4907-bigint-random-trees.ts": 5277, - "4910-hole-free-prefix-upkeep.ts": 4073, - "4920-string-literal-switch.ts": 3607, - "4930-typed-record-reflection.ts": 4869, - "4931-typed-data-generic-walks.ts": 5228, - "4932-typed-json-unknown.ts": 3250, - "4940-async-return-adoption.ts": 4405, - "4941-async-return-adoption-try.ts": 3533, - "4942-async-return-adoption-values.ts": 4824, - "4943-async-return-adoption-interleaved.ts": 3851, - "4950-regex-compiled-captures.ts": 5146, - "4951-regex-compiled-last-index.ts": 4316, - "4952-regex-compiled-anchors-classes.ts": 3149, - "4953-regex-compiled-backtracking.ts": 3822, - "4954-regex-log-report.ts": 4449, - "4955-regex-compiled-differential.ts": 20102, - "4970-int32-call-abi.ts": 3029, - "4980-generator-early-exit-finally.ts": 3262, - "4981-generator-delegation-iterables.ts": 5306, - "4982-generator-sent-values.ts": 3649, - "4983-generator-reuse-iterables.ts": 4023, - "4984-generator-exceptions.ts": 4220, - "4985-generator-lazy-pipeline.ts": 3164, - "4986-generator-default-channels.ts": 3434, - "4987-generator-closures-methods.ts": 3505, - "4988-generator-async-interplay.ts": 2790, - "4989-generator-step-drives.ts": 3509, - "4990-lone-surrogates.ts": 3213, - "4991-lone-surrogate-halves.ts": 4020, - "4992-lone-surrogate-search.ts": 3375, - "4993-lone-surrogate-json.ts": 3473, - "4994-lone-surrogate-uri.ts": 3848, - "4995-lone-surrogate-regex.ts": 4302, - "4996-lone-surrogate-stdio.ts": 2592, - "4997-lone-surrogate-stdout-patch.js": 3072, - "4998-lone-surrogate-buffers.ts": 3134, - "4999-lone-surrogate-io.ts": 3225, - "500-array-basics.ts": 2886, - "501-array-push-pop.ts": 2682, - "5010-lifetime-region-generations.ts": 4147, - "5011-lifetime-region-outside-references.ts": 3407, - "5012-lifetime-region-shapes.ts": 4861, - "5013-lifetime-region-async.ts": 3124, - "5014-lifetime-region-nesting.ts": 3259, - "5015-lifetime-region-publish.ts": 27669, - "5016-lifetime-region-weak-keys.ts": 2554, - "5017-lifetime-region-cycles.ts": 3105, - "5018-lifetime-region-hierarchies.ts": 4007, - "5019-lifetime-region-values.ts": 2888, - "502-array-for-of.ts": 3621, - "5020-lifetime-region-large.ts": 4812, - "5021-lifetime-region-opaque-holders.ts": 3957, - "5022-lifetime-region-workers.ts": 38841, - "503-array-functions.ts": 2982, - "504-array-rc-stress.ts": 3289, - "5040-promise-all-race-turns.ts": 4439, - "5041-promise-all-turns.js": 3708, - "5042-async-generator-return-promise.ts": 3292, - "5043-async-generator-return-forms.ts": 3922, - "5045-generator-delegation-typed-next.ts": 4740, - "5046-generator-delegation-return-throw.ts": 3192, - "5047-generator-delegation-iterables-typed.ts": 4558, - "5048-generator-delegation-async.ts": 3457, - "5049-generator-delegation-edges.ts": 3057, - "5050-inherited-in-membership.ts": 4297, - "5051-typed-record-prototypes.ts": 3534, - "5052-class-for-in-unknown.ts": 3663, - "5053-json-replacer-arrays.ts": 4093, - "5054-required-field-delete.ts": 3619, - "5055-object-create-record-literal.ts": 3237, - "5056-generator-in-unknown.ts": 3060, - "5060-child-fork-exit-after-messages/main.ts": 3584, - "5061-child-fork-local-disconnect/main.ts": 4277, - "5062-child-fork-message-before-eof/main.ts": 3570, - "5065-global-increment-initializers.ts": 2946, - "5066-global-compound-updates.ts": 3425, - "5067-global-updates-in-functions.ts": 3465, - "5068-global-var-let-const-updates.ts": 3395, - "5069-global-update-modules/main.ts": 3167, - "5070-optional-read-bindings.ts": 3316, - "5071-optional-chain-scalars.ts": 3214, - "5072-optional-nullish-ternary.ts": 2900, - "5073-optional-results.ts": 3751, - "5074-optional-pop-shift.ts": 3099, - "5075-optional-reads-unchecked/main.ts": 3754, - "5076-optional-escapes.ts": 3593, - "5080-boolean-array-storage.ts": 7564, - "5081-boolean-array-dynamic-views.ts": 3915, - "5085-promise-allsettled-turns.ts": 4557, - "5086-promise-any-turns.ts": 3994, - "5087-promise-allsettled-any-dyn.js": 5205, - "5088-promise-combinator-thenables.js": 5007, - "5089-promise-settled-records.ts": 4859, - "5090-generator-finished-result-value.ts": 3648, - "5091-generator-delegation-arrays-strings.ts": 3362, - "5092-generator-delegation-sets-maps.ts": 4496, - "5095-console-count-group.ts": 3356, - "5096-console-assert-dir.ts": 3645, - "5097-console-table.ts": 3255, - "5098-console-time-warnings.ts": 7324, - "5099-console-methods-dynamic.cjs": 3314, - "510-array-map-filter-foreach.ts": 3232, - "511-array-indexof-includes.ts": 3286, - "5110-var-hoisting-early-reads.ts": 4048, - "5111-var-hoisting-closures-classes.ts": 2474, - "5112-var-hoisting-function-scope.ts": 3383, - "5113-tdz-let-const-class.ts": 3628, - "5114-var-hoisting-js.js": 3550, - "5115-regex-replace-compiled.ts": 3344, - "5116-regex-capture-reads.ts": 3874, - "5117-regex-log-report-spans.ts": 3719, - "5118-regex-replace-char-chains.ts": 3632, - "512-array-join-chains.ts": 3268, - "5120-frame-records.ts": 3221, - "5121-frame-objects.ts": 3861, - "5122-frame-result-slots.ts": 3008, - "5123-frame-reassigned.ts": 3589, - "5124-frame-objects-control.ts": 3184, - "5125-frame-mutating-methods.ts": 3607, - "5126-frame-returned-params.ts": 3362, - "5127-frame-loop-bindings.ts": 4392, - "513-array-methods-rc-stress.ts": 3208, - "5130-event-target-dispatch.js": 4958, - "5131-event-target-listener-errors.js": 4558, - "5132-event-target-typed.ts": 5171, - "5133-abort-signal-event-target.ts": 22917, - "5134-events-error-monitor.ts": 3499, - "5135-event-target-warnings.js": 9058, - "5136-events-error-monitor-string-name.ts": 3057, - "5137-events-error-monitor-computed-name.js": 4052, - "5138-events-error-monitor-shared-listener.ts": 2466, - "5139-event-target-listener-throw.ts": 2925, - "514-array-find-some-every.ts": 3925, - "5140-os-host-facts.ts": 3438, - "5141-os-constants.ts": 2815, - "5142-path-parse-format.ts": 3808, - "5145-path-matches-glob-basics.ts": 3287, - "5146-path-matches-glob-braces.ts": 4987, - "5147-path-matches-glob-extglob.ts": 3938, - "5148-path-matches-glob-classes.ts": 3973, - "5149-path-matches-glob-win32.ts": 3835, - "515-array-flatmap.ts": 3688, - "5150-small-array-inline-slots.ts": 4419, - "5155-cycle-header-types.ts": 38708, - "516-array-reduce.ts": 4017, - "5160-field-callback-receiver.ts": 3678, - "5161-field-callback-receiver-escape.ts": 2857, - "5162-field-method-reference-receiver.ts": 2944, - "5163-field-callback-receiver.cjs": 3655, - "5164-worker-field-callback-receiver.ts": 30046, - "5165-interface-method-dispatch.ts": 2969, - "5166-interface-method-values.ts": 4129, - "5167-interface-method-order.ts": 3988, - "5168-interface-method-hierarchy.ts": 4483, - "5169-interface-method-chains.ts": 3336, - "517-array-hof-index-args.ts": 3024, - "5170-string-scan-eviction.ts": 3285, - "5171-lone-surrogate-replace-seams.ts": 3558, - "5175-forin-typed-as-unknown.ts": 4230, - "5176-object-keys-typed-as-unknown.ts": 3721, - "5177-forin-dynamic-objects.ts": 2893, - "5178-forin-keys-js.js": 2555, - "5179-forin-typed-shapes.ts": 4446, - "518-array-sort.ts": 3134, - "518-promise-void-union-callbacks.ts": 2401, - "5180-interface-arrays.ts": 3230, - "5181-interface-array-methods.ts": 11973, - "5182-interface-array-boundaries.ts": 3847, - "5183-interface-property-reads.ts": 3799, - "5184-interface-property-objects.ts": 3828, - "5185-util-inherits.cjs": 5041, - "5186-util-inherits.ts": 4542, - "5187-util-deprecate.cjs": 5818, - "5188-util-deprecate-flags.cjs": 4078, - "5189-util-deprecate.ts": 3798, - "519-array-from-length.ts": 2988, - "519-promise-union-await-values.ts": 3664, - "5190-util-callbackify.cjs": 5115, - "5191-util-callbackify.ts": 4367, - "5192-util-debuglog.cjs": 5096, - "5193-util-debuglog.ts": 4056, - "5194-process-emit-warning-tick.cjs": 2761, - "5195-object-entries-typed-as-unknown.ts": 3177, - "5196-object-values-typed-as-unknown.ts": 4077, - "5197-object-entries-dynamic-objects.ts": 4742, - "5198-object-entries-values-js.js": 3089, - "5199-object-entries-identity.ts": 3679, - "520-map-basics.ts": 3767, - "5200-array-sort-keyed-numbers.ts": 4618, - "5201-array-sort-keyed-records.ts": 5422, - "5202-array-sort-keyed-lookalikes.ts": 4034, - "5203-typed-array-sort-default.ts": 7941, - "5204-typed-array-sort-comparators.ts": 4085, - "521-map-number-keys.ts": 3317, - "5210-process-memory-usage.ts": 3262, - "5211-process-identity.ts": 3448, - "5212-perf-marks-measures.ts": 4026, - "5213-perf-timing-errors.ts": 4151, - "5214-perf-entry-inspect.ts": 4315, - "5215-perf-timing-validation.js": 2982, - "5216-perf-spread-arguments.js": 3745, - "5217-perf-spread-typed.ts": 4057, - "522-map-foreach.ts": 2964, - "5220-url-parse-warnings.ts": 4859, - "5221-url-parse-shapes.ts": 3814, - "5222-url-parse-hosts.ts": 3398, - "5223-url-parse-query.ts": 2653, - "5224-url-format-objects.ts": 5550, - "5225-url-format-whatwg.ts": 5213, - "5226-url-resolve.ts": 2600, - "5227-url-legacy-dependency/main.ts": 5803, - "5228-url-domain-conversion.ts": 4876, - "5229-url-legacy-errors.cjs": 5195, - "523-map-ref-values.ts": 4321, - "5230-inline-union-fields.ts": 3644, - "5231-inline-union-field-kinds.ts": 4871, - "5232-inline-union-fields-dynamic.ts": 3887, - "5233-inline-union-fields-shapes.ts": 4145, - "5234-inline-union-class-fields.ts": 3244, - "5235-inline-union-fields-publish.ts": 3360, - "5236-inline-union-unchecked-reads.ts": 3108, - "5237-inline-union-frame-objects.ts": 2533, - "524-map-cycles.ts": 3943, - "5240-event-target-subclass.ts": 5571, - "5241-event-subclass.ts": 4311, - "5242-event-target-subclass-hierarchy.ts": 4079, - "5243-event-target-subclass-dynamic.ts": 3528, - "5244-event-target-subclass.js": 4645, - "5245-event-target-subclass-signals.ts": 9410, - "5246-event-target-subclass-listener-throw.ts": 3995, - "5247-event-target-subclass-lifetimes.ts": 5991, - "5248-event-target-subclass-warnings.ts": 4513, - "5249-event-target-subclass-unconstructed.ts": 2679, - "525-map-rc-stress.ts": 2764, + "4471-unassigned-field-reads.ts": 4391, + "4476-string-ascii-header-fact.ts": 4538, + "4477-buffer-write-ascii-runs.ts": 4115, + "4478-string-large-index-reads.ts": 4211, + "4481-array-optional-push.ts": 3640, + "4482-instanceof-static-class-optional.ts": 2991, + "4483-array-splice-statement.ts": 5079, + "4484-array-length-reset.ts": 3655, + "4485-array-splice-optional-item.ts": 4264, + "4486-array-field-element-borrows.ts": 3950, + "4487-array-literal-optional-values.ts": 5139, + "4520-optional-guard-narrowing.ts": 4441, + "4521-array-callback-element-presence.ts": 6451, + "4522-captured-parameter-lifetimes.ts": 3198, + "4523-array-pop-removal.ts": 4334, + "4524-array-callback-supertype-params.ts": 5586, + "4541-nullable-wrap-borrows.ts": 4310, + "4542-preserving-call-borrows.ts": 4231, + "4543-walk-borrowed-locals.ts": 3976, + "4544-checked-cast-aliases.ts": 4280, + "4545-borrowed-returns.ts": 4524, + "4546-rebound-borrowed-params.ts": 4010, + "4560-field-store-borrowed-receivers.ts": 3877, + "4561-virtual-borrowed-parameters.ts": 4633, + "4562-string-self-concat-move.ts": 3881, + "4563-array-read-projection-receivers.ts": 4188, + "4564-literal-choice-strings.ts": 4026, + "4568-for-of-hole-elements.ts": 4432, + "4569-shorthand-missing-elements.ts": 4672, + "4570-map-lookup-default-record.ts": 3777, + "4591-weak-keys-union-records.ts": 3889, + "4592-cycle-const-from-import/main.ts": 2581, + "4593-weak-keys-empty-objects.ts": 3813, + "4594-union-class-field-mixed-types.ts": 7147, + "4595-union-class-field-optional-receiver.ts": 3827, + "4596-error-subclass-int-fields.ts": 3477, + "4596-tdz-nullable-forward-capture.ts": 3990, + "4597-callback-field-method-name.ts": 4176, + "4598-live-array-ref-element-access.ts": 9941, + "4598-map-set-clear-reuse.ts": 5807, + "4598-os-available-parallelism.ts": 3624, + "4598-publish-constructor-stores.ts": 3208, + "4599-construction-only-field-borrows.ts": 5064, + "4600-construction-only-fields-dynamic-writes.ts": 3234, + "4601-cycle-holders.ts": 3389, + "4602-constructor-escape-order.ts": 3798, + "4610-array-ext-dyn-refresh.ts": 4533, + "4620-optional-chain-borrowed-receivers.ts": 4161, + "4621-edge-preserving-callees/main.ts": 4709, + "4630-contract-int32.ts": 4369, + "4630-reference-write-call-arguments.ts": 4010, + "4631-contract-nothrow.ts": 4027, + "4631-reference-write-aliases.ts": 4138, + "4632-contract-immutable.ts": 3925, + "4632-reference-write-loops-and-walks.ts": 4126, + "4633-contract-program-lifetime.ts": 5198, + "4633-reference-write-callbacks-returns.ts": 4361, + "4634-contract-program-lifetime-publish.ts": 51728, + "4634-optional-element-borrowed-returns.ts": 3758, + "4640-bitwise-identity-ranges.ts": 4521, + "4641-nothrow-try-catch.ts": 3856, + "4642-acyclic-contract.ts": 4836, + "4650-stale-property-narrowing.ts": 5065, + "4651-map-string-get-entry.ts": 3204, + "4652-stale-closure-binding-narrowing.ts": 4161, + "4660-typed-rest-spread-forwarding.ts": 2965, + "4671-scoped-array-read-borrows.ts": 4639, + "4690-cycle-bypass-long-lived.ts": 6384, + "4691-publish-constructor-self-alias.ts": 43679, + "4692-borrowed-result-mutating-callees.ts": 4134, + "4720-cold-throw-paths.ts": 3925, + "4721-integer-induction-numbers.ts": 3986, + "4730-touint32-large-magnitudes.ts": 3378, + "4731-string-mixed-ascii-slices.ts": 3992, + "4732-buffer-write-utf16le-runs.ts": 4419, + "4733-typed-array-read-compares.ts": 3723, + "4750-map-string-absent-filter.ts": 4339, + "4751-string-search-multibyte-needles.ts": 2934, + "4795-published-untyped-member-reads.ts": 4864, + "4806-uint32-loop-accumulators.ts": 4131, + "4810-union-identity-retags.ts": 45852, + "4811-union-retag-checked-cast.ts": 3777, + "4812-int32-wrapping-sums.ts": 4491, + "4813-typed-array-read-equality-bindings.ts": 5104, + "4820-sort-comparator-lent-arguments.ts": 4547, + "4821-callback-lent-arguments.ts": 4044, + "4822-stable-capture-reads.ts": 3520, + "4823-array-store-receivers.ts": 3708, + "4830-typed-teardown-chains.ts": 5155, + "4831-cycle-bypass-probe-windows.ts": 6539, + "4840-array-hole-free-prefix.ts": 5312, + "4860-int32-local-storage.ts": 5193, + "4870-array-pipeline-fusion.ts": 9277, + "4871-array-pipeline-analytics.ts": 4466, + "4872-array-pipeline-temporaries.ts": 8037, + "4875-stream-consumers-array-buffer.ts": 4195, + "4876-array-buffer-inspect.ts": 3460, + "4880-await-call-turn-order.ts": 3196, + "4881-await-call-exceptions.ts": 3913, + "4882-await-call-request-chain.ts": 3966, + "4883-await-values-and-hops.ts": 3305, + "4884-await-call-unhandled-sibling.ts": 3775, + "4885-await-call-checkpoints.ts": 3389, + "4890-regex-literal-sites.ts": 4481, + "4891-regex-plain-text-patterns.ts": 4954, + "4892-regex-exec-read-captures.ts": 5836, + "4900-bigint-division-cross-check.ts": 4132, + "4900-console-instances.ts": 3398, + "4901-bigint-radix-text.ts": 4240, + "4901-console-instance-errors.ts": 4118, + "4902-bigint-compound-assign.ts": 3348, + "4903-bigint-fixed-width.ts": 4053, + "4904-bigint-large-products.ts": 4084, + "4905-bigint-fixed-width-fusion.ts": 4866, + "4906-bigint-small-value-trees.ts": 4495, + "4907-bigint-random-trees.ts": 6985, + "4910-hole-free-prefix-upkeep.ts": 3869, + "4920-string-literal-switch.ts": 3948, + "4930-typed-record-reflection.ts": 6446, + "4931-typed-data-generic-walks.ts": 6005, + "4932-typed-json-unknown.ts": 4690, + "4940-async-return-adoption.ts": 4747, + "4941-async-return-adoption-try.ts": 4808, + "4942-async-return-adoption-values.ts": 4525, + "4943-async-return-adoption-interleaved.ts": 4076, + "4950-regex-compiled-captures.ts": 5853, + "4951-regex-compiled-last-index.ts": 4237, + "4952-regex-compiled-anchors-classes.ts": 2970, + "4953-regex-compiled-backtracking.ts": 4881, + "4954-regex-log-report.ts": 4017, + "4955-regex-compiled-differential.ts": 17656, + "4970-int32-call-abi.ts": 4034, + "4980-generator-early-exit-finally.ts": 4293, + "4981-generator-delegation-iterables.ts": 4701, + "4982-generator-sent-values.ts": 3850, + "4983-generator-reuse-iterables.ts": 4013, + "4984-generator-exceptions.ts": 3941, + "4985-generator-lazy-pipeline.ts": 5191, + "4986-generator-default-channels.ts": 4218, + "4987-generator-closures-methods.ts": 3564, + "4988-generator-async-interplay.ts": 4129, + "4989-generator-step-drives.ts": 3945, + "4990-lone-surrogates.ts": 4283, + "4991-lone-surrogate-halves.ts": 3965, + "4992-lone-surrogate-search.ts": 4450, + "4993-lone-surrogate-json.ts": 4533, + "4994-lone-surrogate-uri.ts": 3275, + "4995-lone-surrogate-regex.ts": 4305, + "4996-lone-surrogate-stdio.ts": 3980, + "4997-lone-surrogate-stdout-patch.js": 3708, + "4998-lone-surrogate-buffers.ts": 3397, + "4999-lone-surrogate-io.ts": 4183, + "500-array-basics.ts": 3681, + "501-array-push-pop.ts": 3744, + "5010-lifetime-region-generations.ts": 4361, + "5011-lifetime-region-outside-references.ts": 3723, + "5012-lifetime-region-shapes.ts": 5352, + "5013-lifetime-region-async.ts": 4836, + "5014-lifetime-region-nesting.ts": 4098, + "5015-lifetime-region-publish.ts": 44284, + "5016-lifetime-region-weak-keys.ts": 4090, + "5017-lifetime-region-cycles.ts": 2993, + "5018-lifetime-region-hierarchies.ts": 4448, + "5019-lifetime-region-values.ts": 4593, + "502-array-for-of.ts": 3697, + "5020-lifetime-region-large.ts": 6810, + "5021-lifetime-region-opaque-holders.ts": 3221, + "5022-lifetime-region-workers.ts": 43902, + "503-array-functions.ts": 3221, + "504-array-rc-stress.ts": 3902, + "5040-promise-all-race-turns.ts": 3963, + "5041-promise-all-turns.js": 3961, + "5042-async-generator-return-promise.ts": 4464, + "5043-async-generator-return-forms.ts": 3956, + "5045-generator-delegation-typed-next.ts": 4940, + "5046-generator-delegation-return-throw.ts": 4744, + "5047-generator-delegation-iterables-typed.ts": 5495, + "5048-generator-delegation-async.ts": 4004, + "5049-generator-delegation-edges.ts": 3818, + "5050-inherited-in-membership.ts": 2952, + "5051-typed-record-prototypes.ts": 4128, + "5052-class-for-in-unknown.ts": 4437, + "5053-json-replacer-arrays.ts": 4585, + "5054-required-field-delete.ts": 3565, + "5055-object-create-record-literal.ts": 3433, + "5056-generator-in-unknown.ts": 3552, + "5060-child-fork-exit-after-messages/main.ts": 4059, + "5061-child-fork-local-disconnect/main.ts": 3921, + "5062-child-fork-message-before-eof/main.ts": 5311, + "5065-global-increment-initializers.ts": 3409, + "5066-global-compound-updates.ts": 3878, + "5067-global-updates-in-functions.ts": 3060, + "5068-global-var-let-const-updates.ts": 3099, + "5069-global-update-modules/main.ts": 3105, + "5070-optional-read-bindings.ts": 3986, + "5071-optional-chain-scalars.ts": 4053, + "5072-optional-nullish-ternary.ts": 3786, + "5073-optional-results.ts": 3653, + "5074-optional-pop-shift.ts": 3809, + "5075-optional-reads-unchecked/main.ts": 4486, + "5076-optional-escapes.ts": 3781, + "5080-boolean-array-storage.ts": 9389, + "5081-boolean-array-dynamic-views.ts": 5005, + "5085-promise-allsettled-turns.ts": 5227, + "5086-promise-any-turns.ts": 4926, + "5087-promise-allsettled-any-dyn.js": 5648, + "5088-promise-combinator-thenables.js": 6097, + "5089-promise-settled-records.ts": 4902, + "5090-generator-finished-result-value.ts": 3980, + "5091-generator-delegation-arrays-strings.ts": 4920, + "5092-generator-delegation-sets-maps.ts": 5655, + "5095-console-count-group.ts": 4543, + "5096-console-assert-dir.ts": 3659, + "5097-console-table.ts": 4019, + "5098-console-time-warnings.ts": 7779, + "5099-console-methods-dynamic.cjs": 4211, + "510-array-map-filter-foreach.ts": 3693, + "511-array-indexof-includes.ts": 2587, + "5110-var-hoisting-early-reads.ts": 3722, + "5111-var-hoisting-closures-classes.ts": 3558, + "5112-var-hoisting-function-scope.ts": 3736, + "5113-tdz-let-const-class.ts": 3427, + "5114-var-hoisting-js.js": 2426, + "5115-regex-replace-compiled.ts": 4045, + "5116-regex-capture-reads.ts": 3563, + "5117-regex-log-report-spans.ts": 3810, + "5118-regex-replace-char-chains.ts": 3242, + "512-array-join-chains.ts": 3887, + "5120-frame-records.ts": 4007, + "5121-frame-objects.ts": 3950, + "5122-frame-result-slots.ts": 3225, + "5123-frame-reassigned.ts": 3642, + "5124-frame-objects-control.ts": 2980, + "5125-frame-mutating-methods.ts": 3316, + "5126-frame-returned-params.ts": 3759, + "5127-frame-loop-bindings.ts": 4535, + "513-array-methods-rc-stress.ts": 3991, + "5130-event-target-dispatch.js": 5194, + "5131-event-target-listener-errors.js": 5170, + "5132-event-target-typed.ts": 5485, + "5133-abort-signal-event-target.ts": 30480, + "5134-events-error-monitor.ts": 3910, + "5135-event-target-warnings.js": 38892, + "5136-events-error-monitor-string-name.ts": 3923, + "5137-events-error-monitor-computed-name.js": 4432, + "5138-events-error-monitor-shared-listener.ts": 3642, + "5139-event-target-listener-throw.ts": 4714, + "514-array-find-some-every.ts": 3747, + "5140-os-host-facts.ts": 4713, + "5141-os-constants.ts": 3991, + "5142-path-parse-format.ts": 3463, + "5145-path-matches-glob-basics.ts": 4364, + "5146-path-matches-glob-braces.ts": 5382, + "5147-path-matches-glob-extglob.ts": 3804, + "5148-path-matches-glob-classes.ts": 3686, + "5149-path-matches-glob-win32.ts": 4358, + "515-array-flatmap.ts": 4323, + "5150-small-array-inline-slots.ts": 4485, + "5155-cycle-header-types.ts": 32161, + "516-array-reduce.ts": 4410, + "5160-field-callback-receiver.ts": 4515, + "5161-field-callback-receiver-escape.ts": 3931, + "5162-field-method-reference-receiver.ts": 3961, + "5163-field-callback-receiver.cjs": 4008, + "5164-worker-field-callback-receiver.ts": 43587, + "5165-interface-method-dispatch.ts": 4146, + "5166-interface-method-values.ts": 5178, + "5167-interface-method-order.ts": 4344, + "5168-interface-method-hierarchy.ts": 5405, + "5169-interface-method-chains.ts": 5047, + "517-array-hof-index-args.ts": 3899, + "5170-string-scan-eviction.ts": 2657, + "5171-lone-surrogate-replace-seams.ts": 3047, + "5175-forin-typed-as-unknown.ts": 3918, + "5176-object-keys-typed-as-unknown.ts": 2645, + "5177-forin-dynamic-objects.ts": 3654, + "5178-forin-keys-js.js": 2761, + "5179-forin-typed-shapes.ts": 3622, + "518-array-sort.ts": 4004, + "518-promise-void-union-callbacks.ts": 3964, + "5180-interface-arrays.ts": 4400, + "5181-interface-array-methods.ts": 13672, + "5182-interface-array-boundaries.ts": 3272, + "5183-interface-property-reads.ts": 4146, + "5184-interface-property-objects.ts": 3495, + "5185-util-inherits.cjs": 6043, + "5186-util-inherits.ts": 6829, + "5187-util-deprecate.cjs": 6304, + "5188-util-deprecate-flags.cjs": 4852, + "5189-util-deprecate.ts": 5176, + "519-array-from-length.ts": 4670, + "519-promise-union-await-values.ts": 3522, + "5190-util-callbackify.cjs": 4881, + "5191-util-callbackify.ts": 5163, + "5192-util-debuglog.cjs": 5490, + "5193-util-debuglog.ts": 3737, + "5194-process-emit-warning-tick.cjs": 4043, + "5195-object-entries-typed-as-unknown.ts": 3294, + "5196-object-values-typed-as-unknown.ts": 4153, + "5197-object-entries-dynamic-objects.ts": 4163, + "5198-object-entries-values-js.js": 3223, + "5199-object-entries-identity.ts": 4287, + "520-map-basics.ts": 3177, + "5200-array-sort-keyed-numbers.ts": 5498, + "5201-array-sort-keyed-records.ts": 6386, + "5202-array-sort-keyed-lookalikes.ts": 3643, + "5203-typed-array-sort-default.ts": 7538, + "5204-typed-array-sort-comparators.ts": 5252, + "521-map-number-keys.ts": 3394, + "5210-process-memory-usage.ts": 2806, + "5211-process-identity.ts": 3698, + "5212-perf-marks-measures.ts": 4803, + "5213-perf-timing-errors.ts": 4464, + "5214-perf-entry-inspect.ts": 4525, + "5215-perf-timing-validation.js": 4263, + "5216-perf-spread-arguments.js": 4935, + "5217-perf-spread-typed.ts": 3571, + "522-map-foreach.ts": 2998, + "5220-url-parse-warnings.ts": 5276, + "5221-url-parse-shapes.ts": 5152, + "5222-url-parse-hosts.ts": 5614, + "5223-url-parse-query.ts": 5852, + "5224-url-format-objects.ts": 5092, + "5225-url-format-whatwg.ts": 5939, + "5226-url-resolve.ts": 4968, + "5227-url-legacy-dependency/main.ts": 5444, + "5228-url-domain-conversion.ts": 2782, + "5229-url-legacy-errors.cjs": 6339, + "523-map-ref-values.ts": 3549, + "5230-inline-union-fields.ts": 4686, + "5231-inline-union-field-kinds.ts": 4192, + "5232-inline-union-fields-dynamic.ts": 4074, + "5233-inline-union-fields-shapes.ts": 4531, + "5234-inline-union-class-fields.ts": 4699, + "5235-inline-union-fields-publish.ts": 3783, + "5236-inline-union-unchecked-reads.ts": 3109, + "5237-inline-union-frame-objects.ts": 2338, + "524-map-cycles.ts": 3268, + "5240-event-target-subclass.ts": 5177, + "5241-event-subclass.ts": 5478, + "5242-event-target-subclass-hierarchy.ts": 4631, + "5243-event-target-subclass-dynamic.ts": 4520, + "5244-event-target-subclass.js": 5329, + "5245-event-target-subclass-signals.ts": 33048, + "5246-event-target-subclass-listener-throw.ts": 3829, + "5247-event-target-subclass-lifetimes.ts": 6504, + "5248-event-target-subclass-warnings.ts": 4300, + "5249-event-target-subclass-unconstructed.ts": 4427, + "525-map-rc-stress.ts": 3704, "5250-cipher-aes-gcm.ts": 7929, "5251-cipher-aes-cbc.ts": 15678, "5252-cipher-aes-ctr.ts": 26018, @@ -4696,45 +4696,45 @@ "5257-cipher-vectors.ts": 18839, "5258-cipher-handles.js": 21996, "5259-cipher-chunked.ts": 21780, - "526-set-basics.ts": 2480, - "5260-record-unknown-identity.ts": 3505, - "5261-optional-field-identity.ts": 3914, - "5262-record-unknown-many.ts": 3839, - "527-set-foreach.ts": 3683, - "5270-url-parse-no-deprecation.cjs": 4076, - "5271-url-parse-throw-deprecation.cjs": 3487, - "5275-http-end-callback-order.ts": 3028, - "5276-style-text-hex-colors.cjs": 4502, - "5277-fs-read-file-buffer-option.cjs": 2635, - "5278-host-null-bytes.cjs": 16385, - "5279-search-params-null-init.cjs": 2915, - "528-set-seeded.ts": 3643, - "5285-blob-construct.ts": 3124, - "5286-blob-readers.ts": 3309, - "5287-blob-inspect.ts": 2504, - "5288-blob-validation.js": 3775, - "5289-blob-read-order.ts": 3614, - "529-map-seeded.ts": 3331, - "5290-blob-dynamic.js": 2674, - "5295-readline-promises-question.ts": 2401, - "5296-readline-lines.ts": 3088, - "5297-readline-callback-events.cjs": 2975, - "5298-readline-abort.cjs": 6980, - "5299-readline-stdin.ts": 3836, - "530-record-arrays.ts": 3125, - "5300-stream-add-abort-signal.ts": 7154, - "5301-stream-add-abort-signal-errors.cjs": 7763, - "5302-stream-promises-options.ts": 8927, - "5303-stream-finished-callback-opts.cjs": 7119, - "5305-json-stringify-typed-arrays.ts": 4254, - "531-record-array-hofs.ts": 3609, - "5315-map-iterate-after-front-deletes.ts": 2759, - "5316-map-lru-eviction.ts": 3688, - "5317-map-iterate-while-mutating.ts": 3035, - "5318-set-iterate-after-deletes.ts": 2543, - "5319-map-iteration-values.ts": 4062, - "532-record-arrays-rc-stress.ts": 2708, - "5320-map-iterate-across-compaction.ts": 2736, + "526-set-basics.ts": 3497, + "5260-record-unknown-identity.ts": 3759, + "5261-optional-field-identity.ts": 3633, + "5262-record-unknown-many.ts": 4065, + "527-set-foreach.ts": 3282, + "5270-url-parse-no-deprecation.cjs": 4123, + "5271-url-parse-throw-deprecation.cjs": 5457, + "5275-http-end-callback-order.ts": 4317, + "5276-style-text-hex-colors.cjs": 4489, + "5277-fs-read-file-buffer-option.cjs": 3576, + "5278-host-null-bytes.cjs": 8285, + "5279-search-params-null-init.cjs": 3511, + "528-set-seeded.ts": 3372, + "5285-blob-construct.ts": 4331, + "5286-blob-readers.ts": 3684, + "5287-blob-inspect.ts": 4285, + "5288-blob-validation.js": 4292, + "5289-blob-read-order.ts": 3682, + "529-map-seeded.ts": 3677, + "5290-blob-dynamic.js": 4399, + "5295-readline-promises-question.ts": 3697, + "5296-readline-lines.ts": 3534, + "5297-readline-callback-events.cjs": 3926, + "5298-readline-abort.cjs": 12732, + "5299-readline-stdin.ts": 4774, + "530-record-arrays.ts": 3665, + "5300-stream-add-abort-signal.ts": 34654, + "5301-stream-add-abort-signal-errors.cjs": 12589, + "5302-stream-promises-options.ts": 13246, + "5303-stream-finished-callback-opts.cjs": 9506, + "5305-json-stringify-typed-arrays.ts": 5926, + "531-record-array-hofs.ts": 3761, + "5315-map-iterate-after-front-deletes.ts": 3399, + "5316-map-lru-eviction.ts": 4060, + "5317-map-iterate-while-mutating.ts": 3994, + "5318-set-iterate-after-deletes.ts": 3956, + "5319-map-iteration-values.ts": 4002, + "532-record-arrays-rc-stress.ts": 3024, + "5320-map-iterate-across-compaction.ts": 4445, "5321-integer-closed-arithmetic-loops.ts": 3363, "5321-json-parse-cycles.ts": 3162, "5322-integer-variable-step-loops.ts": 3747, @@ -4743,29 +4743,29 @@ "5323-int32-nonnegative-slot-facts.ts": 3657, "5324-int32-initializer-locals.ts": 2946, "5324-structured-clone-documents.ts": 4653, - "5325-record-boundary-returns.ts": 3046, - "5326-record-boundary-params.ts": 2989, - "5327-record-boundary-identity.ts": 3529, - "5328-record-boundary-open.ts": 3718, - "5329-record-boundary-recursion.ts": 3361, - "533-array-element-cycles.ts": 3118, - "5330-record-boundary-fields.ts": 3048, - "5331-record-boundary-methods.ts": 2560, + "5325-record-boundary-returns.ts": 3627, + "5326-record-boundary-params.ts": 3878, + "5327-record-boundary-identity.ts": 2625, + "5328-record-boundary-open.ts": 3032, + "5329-record-boundary-recursion.ts": 3600, + "533-array-element-cycles.ts": 3019, + "5330-record-boundary-fields.ts": 3682, + "5331-record-boundary-methods.ts": 3949, "5332-int32-narrowed-slot-facts.ts": 3391, "5333-integer-guarded-while-counters.ts": 3537, - "5333-record-boundary-nullable-argument.ts": 3100, - "5334-fetch-mentions-without-calls.ts": 4032, + "5333-record-boundary-nullable-argument.ts": 4003, + "5334-fetch-mentions-without-calls.ts": 3134, "5335-stream-operators-values.ts": 5552, - "5335-top-level-await-pending-exit-code.ts": 2383, + "5335-top-level-await-pending-exit-code.ts": 3309, "5336-stream-operators-promise-timing.ts": 3761, - "5336-top-level-await-pending-exit-listener.ts": 2814, - "5337-dc-subscriber-throw-next-tick.cjs": 3273, + "5336-top-level-await-pending-exit-listener.ts": 4072, + "5337-dc-subscriber-throw-next-tick.cjs": 4314, "5337-stream-operators-concurrency.ts": 9296, - "5338-js-tdz-function-element.js": 3733, + "5338-js-tdz-function-element.js": 2718, "5338-stream-operators-checks.cjs": 4825, - "5339-array-buffer-constructor.js": 2884, + "5339-array-buffer-constructor.js": 3399, "5339-stream-for-await-hops.ts": 5761, - "534-record-width-subtyping.ts": 3530, + "534-record-width-subtyping.ts": 3917, "5340-readable-from-options.ts": 4100, "5341-compound-any-operand.ts": 4139, "5341-generator-callback-params.ts": 4032, @@ -4781,28 +4781,28 @@ "5343-stream-compose-edges.ts": 8761, "5344-json-parse-undeclared-keys.ts": 4683, "5344-stream-pipeline-timing.ts": 3627, - "5345-object-values-for-of-unknown.ts": 4013, - "5346-object-values-length-dynamic.ts": 3930, - "5347-object-values-loop-control.ts": 3598, - "5348-object-values-for-of-js.js": 2760, - "5349-object-entries-values-optional.ts": 3370, - "535-object-statics.ts": 2862, - "5350-object-values-wide-record.ts": 3272, - "5351-object-values-methods-index.ts": 3637, + "5345-object-values-for-of-unknown.ts": 3893, + "5346-object-values-length-dynamic.ts": 4302, + "5347-object-values-loop-control.ts": 3777, + "5348-object-values-for-of-js.js": 3584, + "5349-object-entries-values-optional.ts": 3677, + "535-object-statics.ts": 4668, + "5350-object-values-wide-record.ts": 4386, + "5351-object-values-methods-index.ts": 3615, "5352-final-field-loop-reads.ts": 3880, "5353-captured-const-values.ts": 4470, "5354-captured-const-tdz.ts": 3331, "5355-captured-function-declarations.ts": 3574, "5356-captured-tdz-ordering.ts": 3626, "5357-init-only-module-bindings.ts": 3698, - "536-map-seed-array.ts": 3237, - "5360-array-sort-comparator-calls.ts": 4265, - "5361-array-sort-inconsistent-comparators.ts": 4181, - "5362-array-sort-comparator-throws.ts": 2826, - "5363-array-sort-comparator-writes.ts": 10362, - "5364-array-sort-union-and-boolean-elements.ts": 14300, - "5365-array-sort-dynamic-values.js": 2919, - "537-map-iter-drains.ts": 3050, + "536-map-seed-array.ts": 3057, + "5360-array-sort-comparator-calls.ts": 4503, + "5361-array-sort-inconsistent-comparators.ts": 4396, + "5362-array-sort-comparator-throws.ts": 3173, + "5363-array-sort-comparator-writes.ts": 12179, + "5364-array-sort-union-and-boolean-elements.ts": 14770, + "5365-array-sort-dynamic-values.js": 4175, + "537-map-iter-drains.ts": 3108, "5370-zlib-stream-roundtrip.ts": 6069, "5371-zlib-stream-chunking.cjs": 3999, "5372-zlib-stream-errors.cjs": 4377, @@ -4813,29 +4813,29 @@ "5377-zlib-stream-backpressure.cjs": 5428, "5378-zlib-sync-options.cjs": 5415, "5379-zlib-callback-options.ts": 5768, - "538-map-set-for-of.ts": 3029, - "5390-interface-loop-element-lifetimes.ts": 3566, - "5391-interface-dispatch-hierarchies.ts": 3731, - "5392-interface-receiver-bindings.ts": 3061, - "5393-interface-array-holes.ts": 2702, - "5394-interface-implementers.ts": 3603, - "5395-locale-compare-ascii.ts": 3587, - "5396-locale-compare-latin.ts": 4291, - "5397-locale-compare-sorting.ts": 3576, - "540-tuples-basics.ts": 3420, - "5400-json-parse-typed-keys.ts": 3141, - "5405-buffer-arraybuffer-window.ts": 3036, - "5406-util-types-keys.ts": 2954, - "5407-http-header-field-limit.ts": 3052, - "5408-http-unread-request-end.ts": 3992, - "5409-http-held-request-body.ts": 3771, - "541-ref-array-json.ts": 3761, - "5410-inspect-class-values.ts": 3124, - "5411-inspect-class-hierarchies.ts": 2423, - "5412-inspect-dynamic-collections.ts": 3042, - "5413-inspect-class-values.cjs": 3217, + "538-map-set-for-of.ts": 3575, + "5390-interface-loop-element-lifetimes.ts": 4065, + "5391-interface-dispatch-hierarchies.ts": 4925, + "5392-interface-receiver-bindings.ts": 3293, + "5393-interface-array-holes.ts": 3549, + "5394-interface-implementers.ts": 4320, + "5395-locale-compare-ascii.ts": 4299, + "5396-locale-compare-latin.ts": 3694, + "5397-locale-compare-sorting.ts": 4218, + "540-tuples-basics.ts": 3768, + "5400-json-parse-typed-keys.ts": 4494, + "5405-buffer-arraybuffer-window.ts": 3875, + "5406-util-types-keys.ts": 4065, + "5407-http-header-field-limit.ts": 2684, + "5408-http-unread-request-end.ts": 4832, + "5409-http-held-request-body.ts": 4395, + "541-ref-array-json.ts": 4658, + "5410-inspect-class-values.ts": 4013, + "5411-inspect-class-hierarchies.ts": 3695, + "5412-inspect-dynamic-collections.ts": 2565, + "5413-inspect-class-values.cjs": 4189, "5415-zlib-dynamic-inputs.cjs": 3913, - "542-union-element-arrays.ts": 2812, + "542-union-element-arrays.ts": 4031, "5420-readable-from-generators.ts": 5476, "5421-readable-from-generators.cjs": 3700, "5422-stream-async-push-wakeup.ts": 4528, @@ -4846,43 +4846,43 @@ "5427-pipeline-generator-backpressure.ts": 3689, "5428-pipeline-generator-stages.cjs": 5519, "5429-pipeline-generator-buffers.ts": 4449, - "5430-dyn-number-string-boxes.ts": 3930, - "5435-crypto-hash-algorithms.ts": 3451, - "5436-crypto-hash-names.js": 3185, - "5437-crypto-hmac-algorithms.ts": 3269, - "5438-crypto-kdf-digests.ts": 3099, - "5439-crypto-kdf-callbacks.js": 4398, - "5440-crypto-hash-encodings.js": 4908, - "5441-crypto-hash-output-length.ts": 3959, - "5442-crypto-random-values.ts": 4791, - "5443-crypto-random-arguments.js": 3724, - "5444-crypto-timing-safe-equal.js": 4074, - "5445-crypto-secret-key-objects.ts": 4784, - "5445-stream-buffer-chunks.ts": 5661, - "5446-crypto-secret-key-errors.js": 3275, - "5446-stream-buffer-chunks-dynamic.js": 5780, - "5447-fs-readdir-order.ts": 3355, - "5448-fs-glob-patterns.ts": 3298, - "5449-fs-glob-options.ts": 3827, - "5450-fs-glob-validation.js": 4321, - "5451-fs-promises-glob.ts": 3074, - "5452-fs-glob-callback.ts": 3887, - "5455-power-of-two-remainder.ts": 4228, - "5456-remainder-large-integer-dividends.ts": 3551, - "5457-lcg-modulus.ts": 2909, - "5458-fractional-remainder.ts": 2650, - "5460-locale-compare-contractions.ts": 3201, - "5461-locale-compare-equivalents.ts": 3410, - "5462-locale-compare-probe-sweep.ts": 4164, - "5463-locale-compare-combining-letters.ts": 3755, - "5464-locale-compare-fractions.ts": 3312, + "5430-dyn-number-string-boxes.ts": 3851, + "5435-crypto-hash-algorithms.ts": 4090, + "5436-crypto-hash-names.js": 3513, + "5437-crypto-hmac-algorithms.ts": 3873, + "5438-crypto-kdf-digests.ts": 4076, + "5439-crypto-kdf-callbacks.js": 3741, + "5440-crypto-hash-encodings.js": 5108, + "5441-crypto-hash-output-length.ts": 5257, + "5442-crypto-random-values.ts": 4596, + "5443-crypto-random-arguments.js": 4093, + "5444-crypto-timing-safe-equal.js": 3904, + "5445-crypto-secret-key-objects.ts": 3885, + "5445-stream-buffer-chunks.ts": 4371, + "5446-crypto-secret-key-errors.js": 3542, + "5446-stream-buffer-chunks-dynamic.js": 5530, + "5447-fs-readdir-order.ts": 3865, + "5448-fs-glob-patterns.ts": 3617, + "5449-fs-glob-options.ts": 4047, + "5450-fs-glob-validation.js": 4514, + "5451-fs-promises-glob.ts": 4041, + "5452-fs-glob-callback.ts": 3311, + "5455-power-of-two-remainder.ts": 3496, + "5456-remainder-large-integer-dividends.ts": 3106, + "5457-lcg-modulus.ts": 3217, + "5458-fractional-remainder.ts": 3231, + "5460-locale-compare-contractions.ts": 4279, + "5461-locale-compare-equivalents.ts": 4168, + "5462-locale-compare-probe-sweep.ts": 5118, + "5463-locale-compare-combining-letters.ts": 4089, + "5464-locale-compare-fractions.ts": 3465, "5465-dyn-index-read-arrays.ts": 2910, "5466-dyn-index-read-special.ts": 3472, - "5470-strip-vt-osc.cjs": 2708, - "5471-strip-vt-csi.cjs": 3038, - "5472-strip-vt-random.cjs": 2850, - "5473-strip-vt-unterminated.cjs": 4462, - "5474-strip-vt-surrogates.ts": 3554, + "5470-strip-vt-osc.cjs": 2950, + "5471-strip-vt-csi.cjs": 3252, + "5472-strip-vt-random.cjs": 3939, + "5473-strip-vt-unterminated.cjs": 4153, + "5474-strip-vt-surrogates.ts": 3689, "5510-assert-error-properties.js": 3848, "5511-assert-error-class.ts": 3354, "5512-assert-error-options.js": 3961, @@ -4903,20 +4903,20 @@ "5530-buffer-pool.ts": 4954, "5531-buffer-pool-first-slab.ts": 4419, "5532-buffer-pool-first-slab-untyped.mjs": 156958, - "5540-fs-callback-forms.cjs": 3079, - "5541-fs-stats-fields.cjs": 4039, - "5542-fs-promises-parity.cjs": 3312, - "5543-fs-promises-typed.ts": 2944, - "5544-fs-opendir.cjs": 3622, - "5545-fs-options-encoding.cjs": 3497, + "5540-fs-callback-forms.cjs": 5033, + "5541-fs-stats-fields.cjs": 5031, + "5542-fs-promises-parity.cjs": 3782, + "5543-fs-promises-typed.ts": 4425, + "5544-fs-opendir.cjs": 4598, + "5545-fs-options-encoding.cjs": 3812, "5546-fs-read-stream.cjs": 4053, "5547-fs-write-stream.cjs": 5026, - "5548-fs-callback-arguments.cjs": 3905, - "5549-fs-callback-option-checks.cjs": 3471, - "5550-locale-compare-ascii-words.ts": 2824, - "5551-array-search-references.ts": 3964, - "5552-string-appends.ts": 3653, - "5553-string-append-char-code.ts": 3292, + "5548-fs-callback-arguments.cjs": 3447, + "5549-fs-callback-option-checks.cjs": 4220, + "5550-locale-compare-ascii-words.ts": 3391, + "5551-array-search-references.ts": 4559, + "5552-string-appends.ts": 3836, + "5553-string-append-char-code.ts": 3220, "5554-fs-streams-typed.ts": 4826, "5555-fs-callback-turns.cjs": 4160, "5555-http-server-close-keep-alive.ts": 16562, @@ -4929,15 +4929,15 @@ "5562-https-verify-errors.ts": 5339, "5563-http-keep-alive-timeout.ts": 18223, "5564-http-request-signal.ts": 6038, - "5565-fs-dirent-untyped.mjs": 2898, - "5566-fs-dirent-dyn-boundaries/main.mjs": 3333, + "5565-fs-dirent-untyped.mjs": 4190, + "5566-fs-dirent-dyn-boundaries/main.mjs": 4370, "5567-fs-cpsync.ts": 4231, "5568-fs-cp-errors.js": 4710, "5569-fs-cp-symlinks.ts": 3975, "5570-fs-cp-async.ts": 4871, "5571-fs-cp-deep.ts": 4651, - "5585-record-results-inlined.ts": 3681, - "5595-net-ref-unref.ts": 3036, + "5585-record-results-inlined.ts": 3799, + "5595-net-ref-unref.ts": 2930, "5600-dyn-cycle-self.ts": 2377, "5601-dyn-cycle-mutual.ts": 3087, "5602-dyn-cycle-arrays.ts": 3074, @@ -4968,13 +4968,13 @@ "5630-promisify-zlib.ts": 3777, "5631-promisify-crypto.ts": 2600, "5632-promisify-dns.ts": 2000, - "5644-net-socket-addresses.ts": 2393, - "5645-net-socket-callbacks.ts": 2060, - "5646-net-server-connections.ts": 2755, - "5647-net-is-ip.ts": 2560, - "5648-dns-lookup-forms.ts": 3416, - "5649-dns-service-servers.ts": 4916, - "5650-dns-lookup-errors-untyped.cjs": 3889, + "5644-net-socket-addresses.ts": 3299, + "5645-net-socket-callbacks.ts": 4363, + "5646-net-server-connections.ts": 4089, + "5647-net-is-ip.ts": 3406, + "5648-dns-lookup-forms.ts": 4891, + "5649-dns-service-servers.ts": 4574, + "5650-dns-lookup-errors-untyped.cjs": 4634, "5651-tls-socket-protocol.ts": 4232, "5652-http-client-trailer-overflow.ts": 3846, "5653-net-socket-read-ahead.ts": 5725, @@ -4987,7 +4987,7 @@ "5664-tls-client-identity.ts": 5675, "5674-union-instanceof-array-arms.ts": 4342, "5680-array-growth-after-copy.ts": 5326, - "5681-array-pop-and-length.ts": 3216, + "5681-array-pop-and-length.ts": 4603, "5682-publish-wide-objects.ts": 2847, "5700-cycle-release-retained.ts": 2881, "5701-cycle-release-old-edges.ts": 2910, @@ -5048,36 +5048,36 @@ "5795-worker-message-port-batches.ts": 3502, "5796-worker-message-channel.cjs": 4995, "5797-worker-message-port-transfer.ts": 23371, - "5800-broadcast-channel.ts": 28374, - "5801-broadcast-channel.cjs": 27251, - "5802-broadcast-channel-workers.ts": 27251, - "5803-worker-environment-data.ts": 29298, - "5804-worker-environment-data.cjs": 26404, - "5805-worker-receive-message-parent-port.ts": 30268, - "5806-worker-resource-limits.ts": 29711, - "5807-worker-error-values.ts": 35248, - "5808-worker-unhandled-rejections.ts": 33209, - "5809-process-exit-and-rejections.cjs": 30261, - "5810-mock-method-records.ts": 6363, - "5811-mock-tracker-restore.ts": 4503, - "5812-dyn-box-async-fields.ts": 5278, - "5813-mock-timers-module.ts": 4227, - "5814-mock-timers-date.ts": 17708, + "5800-broadcast-channel.ts": 4829, + "5801-broadcast-channel.cjs": 36650, + "5802-broadcast-channel-workers.ts": 3203, + "5803-worker-environment-data.ts": 6261, + "5804-worker-environment-data.cjs": 3356, + "5805-worker-receive-message-parent-port.ts": 3933, + "5806-worker-resource-limits.ts": 22085, + "5807-worker-error-values.ts": 5689, + "5808-worker-unhandled-rejections.ts": 6775, + "5809-process-exit-and-rejections.cjs": 38724, + "5810-mock-method-records.ts": 6060, + "5811-mock-tracker-restore.ts": 5297, + "5812-dyn-box-async-fields.ts": 4153, + "5813-mock-timers-module.ts": 3845, + "5814-mock-timers-date.ts": 10489, "5830-timers-promises-signal.ts": 5868, - "5831-util-types-brands.ts": 4380, - "5832-util-types-brands-dynamic.js": 3658, - "5833-url-search-params-iterators.ts": 5339, - "5834-url-search-params-iterators-dynamic.mjs": 3797, - "5835-util-format-integer-specifiers.ts": 2768, - "5836-url-search-params-tuple-pairs.ts": 3193, - "5837-util-format-json-circular.ts": 3408, - "5838-qs-stringify-bigint.ts": 3519, + "5831-util-types-brands.ts": 3846, + "5832-util-types-brands-dynamic.js": 3912, + "5833-url-search-params-iterators.ts": 3034, + "5834-url-search-params-iterators-dynamic.mjs": 3877, + "5835-util-format-integer-specifiers.ts": 2899, + "5836-url-search-params-tuple-pairs.ts": 2897, + "5837-util-format-json-circular.ts": 2745, + "5838-qs-stringify-bigint.ts": 2868, "5839-timers-promises-scheduler.ts": 3136, "5840-promise-with-resolvers-js.js": 2701, - "5841-json-typed-dyn-members.ts": 3238, - "5842-qs-parse-null-prototype.ts": 7077, - "5843-qs-parse-null-prototype-js.mjs": 5395, - "5844-date-unknown-values.ts": 4543, + "5841-json-typed-dyn-members.ts": 4508, + "5842-qs-parse-null-prototype.ts": 3749, + "5843-qs-parse-null-prototype-js.mjs": 3308, + "5844-date-unknown-values.ts": 3966, "5845-groupby-null-prototype.ts": 3946, "5846-events-esm-default-max.ts": 3102, "5847-events-cjs-default-max.cjs": 3039, @@ -5089,45 +5089,45 @@ "5854-array-from-async.ts": 4644, "5855-array-from-async-js.js": 3880, "5856-error-is-error.ts": 3947, - "5857-regexp-unicode-sets.ts": 3900, - "5858-disposable-stack.ts": 3750, - "5859-disposable-stack-js.js": 3600, + "5857-regexp-unicode-sets.ts": 3156, + "5858-disposable-stack.ts": 4000, + "5859-disposable-stack-js.js": 4197, "5860-url-ipv4-hosts.ts": 3379, - "5870-worker-thread-names.ts": 31697, - "5871-worker-untransferable.cjs": 27481, + "5870-worker-thread-names.ts": 5388, + "5871-worker-untransferable.cjs": 38904, "5872-readline-positional-create-interface.mjs": 4683, "5873-readline-promises-namespace.cjs": 3786, - "5874-worker-stdio-streams.ts": 27801, - "5875-worker-stdout-pipe.cjs": 31391, - "5879-worker-stdin.ts": 33232, + "5874-worker-stdio-streams.ts": 8408, + "5875-worker-stdout-pipe.cjs": 36125, + "5879-worker-stdin.ts": 56815, "5880-emitter-leak-warning-delivery.ts": 3928, - "5881-inspect-weak-collections.ts": 2915, - "5882-string-decoder-runtime-encoding.ts": 3854, - "5883-os-set-priority.ts": 3417, - "5884-inspect-layout-options.ts": 3596, + "5881-inspect-weak-collections.ts": 3161, + "5882-string-decoder-runtime-encoding.ts": 3686, + "5883-os-set-priority.ts": 2593, + "5884-inspect-layout-options.ts": 3958, "5885-events-max-listener-helpers.ts": 3524, - "5886-inspect-dates.ts": 2736, - "5887-inspect-typed-arrays.ts": 2997, - "5888-inspect-sorted.ts": 2861, + "5886-inspect-dates.ts": 3606, + "5887-inspect-typed-arrays.ts": 3660, + "5888-inspect-sorted.ts": 2960, "5889-timers-scheduler-signal.ts": 3671, "5890-while-string-length-counters.ts": 3347, "5892-buffer-write-utf16le-runs.ts": 3722, - "5900-float16-array.ts": 3750, - "5901-float16-array-js.js": 3700, - "5904-async-generator-completion.ts": 3800, - "5905-array-from-async-generator.ts": 3500, - "5906-array-from-async-generator-js.js": 3750, + "5900-float16-array.ts": 3748, + "5901-float16-array-js.js": 3979, + "5904-async-generator-completion.ts": 6741, + "5905-array-from-async-generator.ts": 4080, + "5906-array-from-async-generator-js.js": 3999, "5907-regex-groups-match-rows.ts": 3750, - "5910-set-prototype-of-primitive-object-kinds.ts": 5033, - "5911-dyn-class-to-primitive.ts": 4732, - "5912-dyn-class-conversion-methods.ts": 4424, - "5913-prototype-type-error-messages.ts": 4068, - "5914-dyn-in-class-prototype-members.ts": 4327, - "5915-dyn-error-string-conversions.ts": 4247, + "5910-set-prototype-of-primitive-object-kinds.ts": 4285, + "5911-dyn-class-to-primitive.ts": 6260, + "5912-dyn-class-conversion-methods.ts": 4623, + "5913-prototype-type-error-messages.ts": 3542, + "5914-dyn-in-class-prototype-members.ts": 2963, + "5915-dyn-error-string-conversions.ts": 2860, "5920-promise-try-args.ts": 2731, "5921-promise-try-args-js.js": 2533, - "5922-matchall-groups-callbacks.ts": 5960, - "5923-matchall-groups-js.js": 6650, + "5922-matchall-groups-callbacks.ts": 4812, + "5923-matchall-groups-js.js": 4191, "5924-js-literal-identity.js": 2661, "5925-class-view-identity-observers.ts": 2640, "5926-class-view-switch-js.js": 2843, @@ -5144,7 +5144,7 @@ "5936-checked-js-class-types.js": 3902, "5937-override-narrowed-union-returns.ts": 3617, "5938-object-literal-computed-keys-keep-methods.ts": 7194, - "5939-js-let-object-reassigned-wider.js": 4436, + "5939-js-let-object-reassigned-wider.js": 3070, "5940-callback-helper-specialization.ts": 5355, "5941-callback-specialization-recursion.ts": 4385, "5942-callback-specialization-throws.ts": 3535, @@ -5152,840 +5152,840 @@ "5944-js-fields-read-before-assignment.js": 40310, "5945-local-class-observed-methods.ts": 6212, "5946-nested-record-field-optional-writes.ts": 68117, - "5950-tuple-predicate-methods.ts": 7790, - "5951-result-never-widening.ts": 6120, + "5950-tuple-predicate-methods.ts": 5999, + "5951-result-never-widening.ts": 3370, "5952-record-missing-keys.ts": 20400, "5953-nan-coded-method-returns.ts": 15600, - "5955-any-promise-methods.js": 5120, - "5956-erased-generic-members.ts": 8750, - "5958-asserted-union-receiver.ts": 3160, - "5959-date-to-json.ts": 4330, - "5960-generic-mapped-types.ts": 3300, - "5970-net-connect-host-name.ts": 2800, - "5971-buffer-chunks-to-string.ts": 3100, - "5972-net-set-encoding-listeners.ts": 3000, - "5974-typeof-module-exports.cjs": 2500, + "5955-any-promise-methods.js": 3616, + "5956-erased-generic-members.ts": 6191, + "5958-asserted-union-receiver.ts": 2929, + "5959-date-to-json.ts": 2856, + "5960-generic-mapped-types.ts": 3526, + "5970-net-connect-host-name.ts": 2998, + "5971-buffer-chunks-to-string.ts": 3483, + "5972-net-set-encoding-listeners.ts": 7935, + "5974-typeof-module-exports.cjs": 2121, "5975-zlib-class-values.ts": 4200, - "5990-worker-uncloneable.mjs": 22432, - "5991-worker-async-dispose.mjs": 25768, - "5992-worker-thread-name-lifetime.mjs": 28932, + "5990-worker-uncloneable.mjs": 37308, + "5991-worker-async-dispose.mjs": 7506, + "5992-worker-thread-name-lifetime.mjs": 44550, "5993-array-length-loop-resizing.ts": 4127, "5994-array-length-sparse-loops.ts": 2815, "5995-array-dense-loop-boundaries.ts": 4171, - "600-closures-basic.ts": 2534, - "601-closures-loops.ts": 2297, - "602-closures-identity-recursion.ts": 2427, - "6020-class-extends-function-constructor.js": 7500, + "600-closures-basic.ts": 3477, + "601-closures-loops.ts": 2866, + "602-closures-identity-recursion.ts": 3704, + "6020-class-extends-function-constructor.js": 3671, "6021-asserted-literal-union-arm.ts": 7200, - "603-closures-rc-stress.ts": 2589, - "604-closures-for-of.ts": 3514, - "605-closures-forward-capture-tdz.ts": 4638, - "700-classes-basic.ts": 2674, - "701-classes-composition.ts": 2606, - "702-classes-this-capture.ts": 2403, - "703-classes-rc-stress.ts": 3477, - "710-inheritance-basics.ts": 2972, - "711-inheritance-dispatch.ts": 2507, - "712-inheritance-instanceof.ts": 2847, - "713-inheritance-rc-stress.ts": 3484, - "720-accessors-basics.ts": 3144, - "721-accessors-eval-order.ts": 3241, - "722-accessors-inheritance.ts": 3694, - "723-accessors-rc-stress.ts": 2838, - "750-cycle-closure-box.ts": 3262, - "751-cycle-records-mutual.ts": 3163, - "752-cycle-classes.ts": 2239, - "753-cycle-owned-arrays.ts": 2204, - "754-cycle-external-ref.ts": 2593, - "755-cycle-async-promise.ts": 3154, - "756-cycle-inheritance.ts": 2213, - "757-cycle-cross-generation.ts": 3118, - "762-any-boundary.ts": 3063, - "764-any-async.ts": 3129, - "765-any-optional-chain.ts": 3899, - "766-any-union-boundary.ts": 3346, - "767-string-literal-keys.ts": 2340, - "768-any-uninitialized.ts": 2983, - "800-switch-basics.ts": 3128, - "801-switch-lazy-tests.ts": 2842, - "802-switch-loops.ts": 3486, - "803-switch-rc-stress.ts": 2321, - "804-switch-braced-blocks.ts": 3234, - "810-do-while.ts": 3326, - "820-multi-decl.ts": 2338, - "830-let-uninitialized.ts": 2579, - "900-records-basics.ts": 3473, - "901-records-eval-order.ts": 2890, - "902-records-functions-closures.ts": 3085, - "903-records-rc-stress.ts": 3146, - "904-records-optional-fields.ts": 2930, - "905-records-optional-rc-stress.ts": 2986, - "906-records-utility-types.ts": 2822, - "907-records-utility-generics.ts": 3048, - "908-records-index-signatures.ts": 2695, - "909-records-index-json.ts": 3037, - "910-records-index-rc-stress.ts": 2958, - "911-records-index-dot-access.ts": 4686, - "912-unknown-slots.ts": 3359, - "913-records-index-iteration.ts": 3265, - "914-records-from-entries.ts": 3414, - "915-unknown-tostring-eq.ts": 3349, - "916-unknown-bytes.ts": 3729, - "917-record-array-index-dot.ts": 3331, - "950-modules-basic/main.ts": 2717, - "951-modules-diamond/main.ts": 2315, - "952-modules-cross/main.ts": 2751, - "953-modules-default/main.ts": 3300, - "954-modules-reexport/main.ts": 2770, - "957-builtins-namespace.ts": 2759, - "960-generics-basics.ts": 3631, - "961-generics-recursion.ts": 3262, - "962-generics-closures.ts": 2245, - "963-generics-modules/main.ts": 2769, - "964-generics-rc-stress.ts": 3123, - "965-generics-async.ts": 3925, - "965-unions-retag.ts": 3882, - "966-unions-retag-rc-stress.ts": 3167, - "967-record-field-widening.ts": 2827, - "969-unions-arm-matrix.ts": 3297, - "970-unions-basics.ts": 3439, - "971-unions-switch.ts": 3593, - "972-unions-nested.ts": 2812, - "973-unions-rc-stress.ts": 2567, - "974-unions-modules/main.ts": 2485, - "975-unions-undefined.ts": 2505, - "976-unions-null.ts": 3528, - "977-unions-unit-rc-stress.ts": 2503, - "978-unions-nullish.ts": 2591, - "979-unions-optional-chaining.ts": 2499, - "980-exceptions-basics.ts": 2297, - "981-exceptions-values.ts": 3503, - "982-exceptions-rc-stress.ts": 3146, - "983-exceptions-control-flow.ts": 2518, - "984-exceptions-finally.ts": 2504, - "985-exceptions-call-chains.ts": 3540, - "986-exceptions-uncaught.ts": 3473, - "987-exceptions-result-unions.ts": 3527, - "990-process-basics.ts": 3510, - "991-process-exit.ts": 2297, - "992-fs-roundtrip.ts": 2694, - "993-fs-readdir.ts": 3781, - "994-fs-errors.ts": 2370, - "995-fs-uncaught.ts": 2239, - "996-fs-rc-stress.ts": 2822, - "997-fs-modules/main.ts": 2578, - "998-process-env.ts": 2181, - "abstract-property-dispatch.ts": 2739, - "arguments-arrow-capture.mjs": 3039, - "arguments-reexport/main.ts": 2635, - "array-argument-lifetimes-exits.ts": 3136, - "array-argument-lifetimes-mutation.ts": 3333, - "array-argument-lifetimes-strings.ts": 3015, - "array-argument-lifetimes-values.ts": 3223, - "array-buffer-conversions.js": 2594, - "array-buffer-storage.ts": 3699, - "array-checked-callback-results.mjs": 3402, - "array-checked-constructor.js": 3477, - "array-concat-widening.ts": 3858, + "603-closures-rc-stress.ts": 3096, + "604-closures-for-of.ts": 3045, + "605-closures-forward-capture-tdz.ts": 3323, + "700-classes-basic.ts": 2577, + "701-classes-composition.ts": 3154, + "702-classes-this-capture.ts": 2733, + "703-classes-rc-stress.ts": 3485, + "710-inheritance-basics.ts": 3238, + "711-inheritance-dispatch.ts": 3078, + "712-inheritance-instanceof.ts": 3534, + "713-inheritance-rc-stress.ts": 3301, + "720-accessors-basics.ts": 3158, + "721-accessors-eval-order.ts": 2971, + "722-accessors-inheritance.ts": 3316, + "723-accessors-rc-stress.ts": 3170, + "750-cycle-closure-box.ts": 2126, + "751-cycle-records-mutual.ts": 2363, + "752-cycle-classes.ts": 1960, + "753-cycle-owned-arrays.ts": 2692, + "754-cycle-external-ref.ts": 2903, + "755-cycle-async-promise.ts": 3043, + "756-cycle-inheritance.ts": 2972, + "757-cycle-cross-generation.ts": 2984, + "762-any-boundary.ts": 2786, + "764-any-async.ts": 3084, + "765-any-optional-chain.ts": 3008, + "766-any-union-boundary.ts": 3499, + "767-string-literal-keys.ts": 3514, + "768-any-uninitialized.ts": 3560, + "800-switch-basics.ts": 2767, + "801-switch-lazy-tests.ts": 2686, + "802-switch-loops.ts": 3125, + "803-switch-rc-stress.ts": 3547, + "804-switch-braced-blocks.ts": 2839, + "810-do-while.ts": 2218, + "820-multi-decl.ts": 3261, + "830-let-uninitialized.ts": 3097, + "900-records-basics.ts": 3422, + "901-records-eval-order.ts": 2695, + "902-records-functions-closures.ts": 3207, + "903-records-rc-stress.ts": 2631, + "904-records-optional-fields.ts": 2009, + "905-records-optional-rc-stress.ts": 2569, + "906-records-utility-types.ts": 3252, + "907-records-utility-generics.ts": 3311, + "908-records-index-signatures.ts": 3591, + "909-records-index-json.ts": 3947, + "910-records-index-rc-stress.ts": 3536, + "911-records-index-dot-access.ts": 3503, + "912-unknown-slots.ts": 3313, + "913-records-index-iteration.ts": 4350, + "914-records-from-entries.ts": 3768, + "915-unknown-tostring-eq.ts": 2630, + "916-unknown-bytes.ts": 3440, + "917-record-array-index-dot.ts": 3157, + "950-modules-basic/main.ts": 2848, + "951-modules-diamond/main.ts": 3198, + "952-modules-cross/main.ts": 3183, + "953-modules-default/main.ts": 3167, + "954-modules-reexport/main.ts": 2018, + "957-builtins-namespace.ts": 3430, + "960-generics-basics.ts": 3705, + "961-generics-recursion.ts": 2537, + "962-generics-closures.ts": 3548, + "963-generics-modules/main.ts": 2784, + "964-generics-rc-stress.ts": 3384, + "965-generics-async.ts": 2822, + "965-unions-retag.ts": 3386, + "966-unions-retag-rc-stress.ts": 2717, + "967-record-field-widening.ts": 2715, + "969-unions-arm-matrix.ts": 3012, + "970-unions-basics.ts": 2986, + "971-unions-switch.ts": 3685, + "972-unions-nested.ts": 3090, + "973-unions-rc-stress.ts": 3424, + "974-unions-modules/main.ts": 3121, + "975-unions-undefined.ts": 2840, + "976-unions-null.ts": 2783, + "977-unions-unit-rc-stress.ts": 3216, + "978-unions-nullish.ts": 3540, + "979-unions-optional-chaining.ts": 3197, + "980-exceptions-basics.ts": 3555, + "981-exceptions-values.ts": 3193, + "982-exceptions-rc-stress.ts": 2933, + "983-exceptions-control-flow.ts": 3085, + "984-exceptions-finally.ts": 3513, + "985-exceptions-call-chains.ts": 2381, + "986-exceptions-uncaught.ts": 2898, + "987-exceptions-result-unions.ts": 2879, + "990-process-basics.ts": 3199, + "991-process-exit.ts": 3081, + "992-fs-roundtrip.ts": 2369, + "993-fs-readdir.ts": 3082, + "994-fs-errors.ts": 3422, + "995-fs-uncaught.ts": 3294, + "996-fs-rc-stress.ts": 3471, + "997-fs-modules/main.ts": 2673, + "998-process-env.ts": 3051, + "abstract-property-dispatch.ts": 3176, + "arguments-arrow-capture.mjs": 3073, + "arguments-reexport/main.ts": 2672, + "array-argument-lifetimes-exits.ts": 3589, + "array-argument-lifetimes-mutation.ts": 3438, + "array-argument-lifetimes-strings.ts": 3059, + "array-argument-lifetimes-values.ts": 3883, + "array-buffer-conversions.js": 2989, + "array-buffer-storage.ts": 3822, + "array-checked-callback-results.mjs": 3408, + "array-checked-constructor.js": 3489, + "array-concat-widening.ts": 3866, "array-deque-unshift.ts": 2667, - "array-element-compound-updates.ts": 3591, - "array-fill-unit-values.ts": 2572, - "array-from-checked.js": 3097, - "array-from-value.mjs": 3428, - "array-isarray-value/main.js": 3143, - "array-numeric-own-keys.ts": 3632, - "array-optional-number-write-index.ts": 3380, - "array-primitive-ordering.ts": 3925, + "array-element-compound-updates.ts": 5084, + "array-fill-unit-values.ts": 3524, + "array-from-checked.js": 4344, + "array-from-value.mjs": 3171, + "array-isarray-value/main.js": 2914, + "array-numeric-own-keys.ts": 3622, + "array-optional-number-write-index.ts": 2652, + "array-primitive-ordering.ts": 4006, "array-queue-head-room.ts": 3597, - "array-read-helper-effects.ts": 3425, - "array-refined-storage.ts": 3909, - "array-sort-dense-effects.ts": 2917, - "array-sort-dense-values.ts": 5261, - "array-sort-holes-published.ts": 13040, - "array-sort-runs.ts": 10059, - "array-sort-runtime-comparator.ts": 5498, - "array-sort-unknown-comparator.ts": 2858, - "array-storage-transitions.ts": 2799, - "array-truncate-reuse.ts": 2407, - "async-backend-factory.mjs": 3609, - "async-local-typed-results.ts": 2487, - "atomics-integer-operations.ts": 3832, - "bigint-checked-casts.ts": 3603, - "bigint-checked-storage.js": 3992, - "bigint-union-conversion.ts": 3125, - "boxed-error-rethrows.mjs": 2646, - "buffer-codec-boundaries.ts": 3139, - "buffer-primitive-predicate.ts": 3495, - "builtin-prototype-method-values.mjs": 4297, - "byte-loop-bounds.ts": 3001, - "byte-number-pipeline.ts": 3966, - "byte-record-windows.ts": 3749, - "call-lifetimes-argument-order.ts": 2794, - "call-lifetimes-control-flow.ts": 3894, - "call-lifetimes-owned-boundaries.ts": 3881, - "call-lifetimes-projections.ts": 3082, - "call-lifetimes-union-values.ts": 3090, + "array-read-helper-effects.ts": 3562, + "array-refined-storage.ts": 4149, + "array-sort-dense-effects.ts": 4479, + "array-sort-dense-values.ts": 4819, + "array-sort-holes-published.ts": 7708, + "array-sort-runs.ts": 7566, + "array-sort-runtime-comparator.ts": 6150, + "array-sort-unknown-comparator.ts": 2544, + "array-storage-transitions.ts": 3926, + "array-truncate-reuse.ts": 3660, + "async-backend-factory.mjs": 3134, + "async-local-typed-results.ts": 3527, + "atomics-integer-operations.ts": 4356, + "bigint-checked-casts.ts": 2554, + "bigint-checked-storage.js": 3784, + "bigint-union-conversion.ts": 3322, + "boxed-error-rethrows.mjs": 2897, + "buffer-codec-boundaries.ts": 3387, + "buffer-primitive-predicate.ts": 3237, + "builtin-prototype-method-values.mjs": 3628, + "byte-loop-bounds.ts": 3700, + "byte-number-pipeline.ts": 3420, + "byte-record-windows.ts": 3513, + "call-lifetimes-argument-order.ts": 3157, + "call-lifetimes-control-flow.ts": 3596, + "call-lifetimes-owned-boundaries.ts": 3515, + "call-lifetimes-projections.ts": 2258, + "call-lifetimes-union-values.ts": 3157, "call-lifetimes-virtual-optionals.ts": 3774, - "callable-module-members.mjs": 2996, - "callable-properties.mjs": 3737, - "callable-property-cycles.js": 2394, - "callable-reexport/main.ts": 2995, - "captured-class-refinement.ts": 3815, - "catch-capture.ts": 2295, - "caught-class-identity.ts": 3893, - "caught-standalone-class.ts": 3591, - "caught-system-error-fields.ts": 3373, - "checked-addition.js": 3059, - "checked-any-addition.ts": 2638, - "checked-array-assignment.ts": 2861, - "checked-array-flat/main.ts": 2441, - "checked-bitwise/main.js": 3177, - "checked-builder-cycles.js": 3284, - "checked-byte-storage/main.ts": 3985, - "checked-callback-options.ts": 3034, - "checked-class-descriptors.mjs": 2786, - "checked-class-factory.mjs": 2348, - "checked-collection-iterators.ts": 3731, - "checked-collection-symbol-methods.ts": 3019, - "checked-dispatch-input-lifetimes.js": 3481, - "checked-increment/main.js": 2884, - "checked-inherited-fields.ts": 2756, - "checked-iterator-consumption.js": 4074, - "checked-numeric-arithmetic.js": 2874, - "checked-object-module-alias.js": 3204, - "checked-optional-calls.mjs": 2897, - "checked-promise-recovery.ts": 2819, - "checked-proxy-callback/main.ts": 3009, - "checked-record-constructor.ts": 3034, - "checked-renderer-defaults.js": 2935, - "checked-rest-function-adapters.js": 2965, - "checked-storage-transitions.js": 2510, - "checked-symbol-array.ts": 2504, - "checked-value-input-lifetimes.ts": 3033, - "class-accessor-returned-function.js": 2287, - "class-array-optional-return.ts": 3498, - "class-bracket-method-calls.js": 3071, - "class-brand-overload.js": 3526, - "class-callback-replacement.js": 3460, - "class-callback-storage.ts": 4585, - "class-checked-composites.ts": 3187, - "class-checked-upcast.ts": 3072, - "class-collection-insertion.ts": 4235, - "class-computed-presence.ts": 2974, - "class-computed-symbols.js": 3740, - "class-covariant-returns.ts": 3957, - "class-curried-factory.mjs": 4128, - "class-data-descriptors.js": 3270, - "class-factory-inherited-statics.mjs": 2538, - "class-factory-parameter-base.mjs": 2587, - "class-factory-record-base.mjs": 5836, - "class-factory-recursive-statics.mjs": 3651, - "class-factory-static-members.mjs": 3672, - "class-function-base/main.js": 2657, - "class-instance-constructor.js": 2942, - "class-interface-protocols.ts": 3713, - "class-interface-refinements.ts": 4567, - "class-json-checked.ts": 2571, - "class-local-function-base.mjs": 3643, - "class-method-spreads.ts": 3220, - "class-narrowed-views.ts": 3766, - "class-property-call-values.mjs": 3125, - "class-prototype-data.js": 4251, - "class-prototype-descriptor-copy.mjs": 3998, - "class-specialized-computed-base.mjs": 3397, - "class-static-data.js": 2157, - "class-subclass-assertions.ts": 3733, - "class-super-surplus-spread.mjs": 2301, - "class-symbol-accessors.ts": 2479, - "class-symbol-cache.mjs": 3721, - "class-value-constructor-exceptions.ts": 3210, + "callable-module-members.mjs": 3196, + "callable-properties.mjs": 3885, + "callable-property-cycles.js": 3532, + "callable-reexport/main.ts": 3427, + "captured-class-refinement.ts": 3597, + "catch-capture.ts": 2987, + "caught-class-identity.ts": 4072, + "caught-standalone-class.ts": 2672, + "caught-system-error-fields.ts": 3700, + "checked-addition.js": 3105, + "checked-any-addition.ts": 2239, + "checked-array-assignment.ts": 3049, + "checked-array-flat/main.ts": 3431, + "checked-bitwise/main.js": 3320, + "checked-builder-cycles.js": 2792, + "checked-byte-storage/main.ts": 3747, + "checked-callback-options.ts": 2687, + "checked-class-descriptors.mjs": 3712, + "checked-class-factory.mjs": 2771, + "checked-collection-iterators.ts": 3380, + "checked-collection-symbol-methods.ts": 2530, + "checked-dispatch-input-lifetimes.js": 3328, + "checked-increment/main.js": 3104, + "checked-inherited-fields.ts": 2621, + "checked-iterator-consumption.js": 4294, + "checked-numeric-arithmetic.js": 3111, + "checked-object-module-alias.js": 3420, + "checked-optional-calls.mjs": 3475, + "checked-promise-recovery.ts": 3214, + "checked-proxy-callback/main.ts": 2353, + "checked-record-constructor.ts": 3432, + "checked-renderer-defaults.js": 3283, + "checked-rest-function-adapters.js": 3083, + "checked-storage-transitions.js": 3622, + "checked-symbol-array.ts": 3310, + "checked-value-input-lifetimes.ts": 3545, + "class-accessor-returned-function.js": 3128, + "class-array-optional-return.ts": 2098, + "class-bracket-method-calls.js": 3772, + "class-brand-overload.js": 2492, + "class-callback-replacement.js": 4751, + "class-callback-storage.ts": 4435, + "class-checked-composites.ts": 2988, + "class-checked-upcast.ts": 3528, + "class-collection-insertion.ts": 3819, + "class-computed-presence.ts": 3069, + "class-computed-symbols.js": 4319, + "class-covariant-returns.ts": 2381, + "class-curried-factory.mjs": 4502, + "class-data-descriptors.js": 3422, + "class-factory-inherited-statics.mjs": 3137, + "class-factory-parameter-base.mjs": 3744, + "class-factory-record-base.mjs": 4712, + "class-factory-recursive-statics.mjs": 3419, + "class-factory-static-members.mjs": 3588, + "class-function-base/main.js": 3762, + "class-instance-constructor.js": 3074, + "class-interface-protocols.ts": 5102, + "class-interface-refinements.ts": 3720, + "class-json-checked.ts": 2934, + "class-local-function-base.mjs": 3255, + "class-method-spreads.ts": 4902, + "class-narrowed-views.ts": 3371, + "class-property-call-values.mjs": 4011, + "class-prototype-data.js": 3004, + "class-prototype-descriptor-copy.mjs": 3813, + "class-specialized-computed-base.mjs": 4267, + "class-static-data.js": 3151, + "class-subclass-assertions.ts": 3297, + "class-super-surplus-spread.mjs": 3182, + "class-symbol-accessors.ts": 3548, + "class-symbol-cache.mjs": 4032, + "class-value-constructor-exceptions.ts": 2673, "closed-virtual-dispatch-modules/main.ts": 2555, "closed-virtual-dispatch.ts": 3659, - "closure-nullable-union-return.ts": 2727, - "closure-union-locals.ts": 2878, - "collection-array-cycles.ts": 3240, - "collection-array-maps.ts": 4497, - "collection-array-missing.ts": 3865, - "collection-array-sets.ts": 3087, - "collection-copy-identities.ts": 2655, - "collection-data-unions.ts": 2993, - "collection-ingestion-mappers.ts": 3305, - "collection-ingestion-protocol/main.ts": 5059, - "collection-ingestion-references.ts": 4238, - "collection-ingestion.ts": 3626, - "collection-storage-copies.ts": 4163, - "collection-value-keys.ts": 4167, - "compound-field-receivers.ts": 2877, - "compound-presence-guards.ts": 3145, - "conditional-tuple-destructuring.ts": 3213, - "console-imports.cjs": 2893, - "console-native-value.js": 2516, - "const-enum-module-cycle/main.ts": 3456, - "constant-callback-dispatch.ts": 2916, - "constant-module-globals/main.ts": 2911, - "constant-number-remainders.ts": 2372, - "constructed-class-dispatch.ts": 3382, - "contextual-array-union-write.ts": 6417, - "contextual-return-layouts.ts": 3746, - "counted-loop-numbers.ts": 2724, - "counted-loop-storage.ts": 2302, - "crypto-hash-optional-input.ts": 3311, - "cycle-generations-long-lived.ts": 3514, - "cycle-growth-yield.ts": 3352, - "date-checked-native.js": 2676, - "declared-index-spread.ts": 2941, - "deep-reference-teardown.ts": 4427, - "default-undefined-parameters.ts": 3232, - "deferred-field-updates.ts": 3345, - "deferred-registry-many.ts": 3072, - "derived-numeric-updates.ts": 2702, - "destructure-call-assignment.js": 2978, - "destructure-inferred-row-defaults.js": 3175, - "destructure-union-arrays.ts": 3248, - "dynamic-function-descriptors.js": 2750, - "error-cause-writes.js": 3104, - "error-inherited-message.mjs": 3024, - "error-inherited-name.mjs": 2500, - "error-property-writes.mjs": 3373, - "error-prototype-tostring.js": 3874, - "error-stack-frames.ts": 2418, - "error-stack-limit.ts": 2675, - "error-tostring-overrides.ts": 3246, - "error-values-inspect.ts": 3043, - "exact-index-round-trip.ts": 3701, - "expression-runtime-values.ts": 2154, - "fiber-switch-stress.ts": 5012, - "fiberless-async-ordering.ts": 3413, - "fiberless-async-unhandled.ts": 2739, - "field-assignment-values.ts": 2662, - "file-handle-values.ts": 3133, - "file-read-storage.ts": 3685, - "file-url-percent-decoding.ts": 2659, - "final-field-borrows.ts": 3350, - "for-multiple-bindings.ts": 3223, - "for-multiple-lexical-bindings.ts": 3021, - "for-of-checked-iterator.js": 3541, - "for-of-subclass-elements.ts": 3037, - "forward-generic-signatures.ts": 2999, - "fresh-array-union-layout.js": 2679, - "frozen-checked-dictionaries.mjs": 3220, - "fs-native-realpath.ts": 2477, + "closure-nullable-union-return.ts": 3544, + "closure-union-locals.ts": 3476, + "collection-array-cycles.ts": 3864, + "collection-array-maps.ts": 4225, + "collection-array-missing.ts": 4159, + "collection-array-sets.ts": 4385, + "collection-copy-identities.ts": 2778, + "collection-data-unions.ts": 3634, + "collection-ingestion-mappers.ts": 3206, + "collection-ingestion-protocol/main.ts": 3833, + "collection-ingestion-references.ts": 3449, + "collection-ingestion.ts": 3258, + "collection-storage-copies.ts": 3108, + "collection-value-keys.ts": 4397, + "compound-field-receivers.ts": 3249, + "compound-presence-guards.ts": 2877, + "conditional-tuple-destructuring.ts": 2382, + "console-imports.cjs": 3167, + "console-native-value.js": 3394, + "const-enum-module-cycle/main.ts": 2006, + "constant-callback-dispatch.ts": 2991, + "constant-module-globals/main.ts": 2958, + "constant-number-remainders.ts": 3341, + "constructed-class-dispatch.ts": 2784, + "contextual-array-union-write.ts": 7276, + "contextual-return-layouts.ts": 3888, + "counted-loop-numbers.ts": 3637, + "counted-loop-storage.ts": 2691, + "crypto-hash-optional-input.ts": 3463, + "cycle-generations-long-lived.ts": 3441, + "cycle-growth-yield.ts": 3944, + "date-checked-native.js": 2845, + "declared-index-spread.ts": 4567, + "deep-reference-teardown.ts": 3926, + "default-undefined-parameters.ts": 3319, + "deferred-field-updates.ts": 3102, + "deferred-registry-many.ts": 3953, + "derived-numeric-updates.ts": 3389, + "destructure-call-assignment.js": 2983, + "destructure-inferred-row-defaults.js": 3512, + "destructure-union-arrays.ts": 2816, + "dynamic-function-descriptors.js": 3146, + "error-cause-writes.js": 3354, + "error-inherited-message.mjs": 3845, + "error-inherited-name.mjs": 2619, + "error-property-writes.mjs": 3158, + "error-prototype-tostring.js": 3672, + "error-stack-frames.ts": 3288, + "error-stack-limit.ts": 2624, + "error-tostring-overrides.ts": 3434, + "error-values-inspect.ts": 2196, + "exact-index-round-trip.ts": 3473, + "expression-runtime-values.ts": 3088, + "fiber-switch-stress.ts": 4040, + "fiberless-async-ordering.ts": 3692, + "fiberless-async-unhandled.ts": 2796, + "field-assignment-values.ts": 3175, + "file-handle-values.ts": 4245, + "file-read-storage.ts": 3850, + "file-url-percent-decoding.ts": 3346, + "final-field-borrows.ts": 4200, + "for-multiple-bindings.ts": 3350, + "for-multiple-lexical-bindings.ts": 2400, + "for-of-checked-iterator.js": 2766, + "for-of-subclass-elements.ts": 3269, + "forward-generic-signatures.ts": 3369, + "fresh-array-union-layout.js": 2566, + "frozen-checked-dictionaries.mjs": 3872, + "fs-native-realpath.ts": 3355, "fs-null-byte-paths-js.cjs": 2643, "fs-null-byte-paths.ts": 5975, - "fs-read-encodings.ts": 3111, + "fs-read-encodings.ts": 3730, "fs-read-utf8-edges.ts": 4190, "fs-read-utf8-handle-forms.ts": 3943, - "fs-remove-readonly.ts": 2708, - "fs-write-string-bytes-union.ts": 2772, - "function-apply-value.mjs": 2976, - "function-constructor-global.mjs": 2229, - "function-constructor-kinds/main.js": 3064, - "function-custom-prototype.js": 3165, - "function-custom-to-string.mjs": 3379, - "function-object-assign.js": 3235, - "function-own-prototype/main.js": 2539, - "generator-checked-protocol.ts": 3197, - "generator-checked-return.js": 3544, - "generator-custom-delegation/main.ts": 3611, - "generator-default-return-pattern.ts": 3352, - "generator-delegation-values.ts": 3047, - "generator-inferred-date.js": 3314, - "generator-mixed-checked-channels.ts": 3576, - "generator-untyped-consumer/main.ts": 3225, - "generic-base-specializations.ts": 2247, - "generic-binding-ownership.ts": 3517, - "generic-class-js-functions/main.ts": 2300, - "generic-class-recovery.ts": 2961, - "generic-namespace-factories/main.ts": 3104, - "generic-nullable-collections.ts": 2983, - "generic-pattern-bindings.ts": 3518, - "generic-record-index.ts": 3239, - "generic-visitor-void.ts": 3402, + "fs-remove-readonly.ts": 3417, + "fs-write-string-bytes-union.ts": 3274, + "function-apply-value.mjs": 3476, + "function-constructor-global.mjs": 3249, + "function-constructor-kinds/main.js": 3769, + "function-custom-prototype.js": 3876, + "function-custom-to-string.mjs": 3155, + "function-object-assign.js": 3527, + "function-own-prototype/main.js": 3460, + "generator-checked-protocol.ts": 2621, + "generator-checked-return.js": 3221, + "generator-custom-delegation/main.ts": 5126, + "generator-default-return-pattern.ts": 3182, + "generator-delegation-values.ts": 3197, + "generator-inferred-date.js": 3585, + "generator-mixed-checked-channels.ts": 3199, + "generator-untyped-consumer/main.ts": 3049, + "generic-base-specializations.ts": 3459, + "generic-binding-ownership.ts": 3288, + "generic-class-js-functions/main.ts": 2834, + "generic-class-recovery.ts": 3640, + "generic-namespace-factories/main.ts": 2618, + "generic-nullable-collections.ts": 3599, + "generic-pattern-bindings.ts": 3103, + "generic-record-index.ts": 3516, + "generic-visitor-void.ts": 3557, "global-accumulator-loops.ts": 3302, - "global-error-subclasses.ts": 2754, - "global-runtime-probes.js": 2804, - "global-stored-probes.js": 3113, - "global-string-cache/main.js": 2090, - "global-symbol-cache/main.js": 3628, - "guarded-native-iterables.ts": 3327, - "heap-input-aliases.ts": 3457, - "heap-input-collections.ts": 3653, - "in-array-runtime-index.ts": 3275, - "indexed-assignment-values.js": 3011, - "indexed-assignment-values.ts": 2182, - "indexed-element-field-reads.ts": 3247, - "inferred-array-assignment-values.mjs": 2906, - "inferred-class-default.mjs": 2977, - "inferred-compound-values.mjs": 2759, - "inferred-conditional-class.mjs": 3292, - "inferred-error-fields.js": 3405, - "inferred-map-patterns.mjs": 2764, - "inferred-method-override.js": 2696, - "inferred-partial-destructuring.mjs": 2539, - "inferred-primitive-properties.mjs": 2255, - "inferred-record-return.mjs": 2589, - "inferred-recursive-record.mjs": 2186, - "inferred-undefined-field.mjs": 2551, - "input-lifetime-intervals.ts": 3191, - "input-lifetimes-modules/main.ts": 3221, - "instanceof-class-record-union.ts": 3279, - "integer-flow-arithmetic.ts": 3347, - "integer-loop-forms.ts": 2940, - "integer-view-control.ts": 2093, - "integer-view-numbers.ts": 2680, - "integer-view-storage.ts": 3947, - "intl-grapheme-conformance/main.ts": 5064, - "intl-grapheme.ts": 2412, - "iterator-typed-returns.ts": 3466, - "js-abort-portable.js": 4587, - "js-array-constructor.js": 3296, - "js-array-default-buffer.js": 3604, - "js-array-iterators.js": 3215, - "js-arrow-bind.cjs": 3596, - "js-buffer-callback-brand.cjs": 3526, - "js-callable-proxy.js": 3865, - "js-chained-native-results.mjs": 3076, - "js-checked-array-iterator.js": 2790, - "js-checked-array-reference.js": 2884, - "js-checked-number-negation.mjs": 2418, - "js-checked-sort-result.js": 2906, - "js-child-error-listener.cjs": 2538, - "js-cjs-callable-snapshots/main.cjs": 2461, - "js-class-added-parameters.js": 2522, - "js-class-checked-overrides.js": 2542, - "js-class-computed-fields.js": 2281, - "js-class-enumeration.js": 3084, - "js-class-field-accessor-override.js": 3865, - "js-class-fluent-overrides.js": 3368, - "js-class-late-method-values.js": 2526, - "js-class-member-dispatch.js": 3846, - "js-class-return-shapes.js": 2639, - "js-class-shadowed-methods.js": 2891, - "js-class-stored-method-receiver.js": 2685, - "js-class-subclass-properties.js": 3775, - "js-class-symbol-spread.cjs": 3550, - "js-computed-prototype-additions.js": 3462, - "js-constructor-returned-callable.js": 3346, + "global-error-subclasses.ts": 2292, + "global-runtime-probes.js": 3435, + "global-stored-probes.js": 2946, + "global-string-cache/main.js": 2368, + "global-symbol-cache/main.js": 2737, + "guarded-native-iterables.ts": 3541, + "heap-input-aliases.ts": 3756, + "heap-input-collections.ts": 4265, + "in-array-runtime-index.ts": 3804, + "indexed-assignment-values.js": 3469, + "indexed-assignment-values.ts": 2742, + "indexed-element-field-reads.ts": 3016, + "inferred-array-assignment-values.mjs": 2506, + "inferred-class-default.mjs": 2376, + "inferred-compound-values.mjs": 2280, + "inferred-conditional-class.mjs": 3032, + "inferred-error-fields.js": 3161, + "inferred-map-patterns.mjs": 3075, + "inferred-method-override.js": 3123, + "inferred-partial-destructuring.mjs": 3133, + "inferred-primitive-properties.mjs": 2211, + "inferred-record-return.mjs": 3298, + "inferred-recursive-record.mjs": 3328, + "inferred-undefined-field.mjs": 2721, + "input-lifetime-intervals.ts": 3442, + "input-lifetimes-modules/main.ts": 3449, + "instanceof-class-record-union.ts": 3488, + "integer-flow-arithmetic.ts": 3827, + "integer-loop-forms.ts": 3201, + "integer-view-control.ts": 3231, + "integer-view-numbers.ts": 3409, + "integer-view-storage.ts": 3994, + "intl-grapheme-conformance/main.ts": 3445, + "intl-grapheme.ts": 2906, + "iterator-typed-returns.ts": 4729, + "js-abort-portable.js": 27919, + "js-array-constructor.js": 3813, + "js-array-default-buffer.js": 2697, + "js-array-iterators.js": 3607, + "js-arrow-bind.cjs": 4009, + "js-buffer-callback-brand.cjs": 3617, + "js-callable-proxy.js": 4304, + "js-chained-native-results.mjs": 2822, + "js-checked-array-iterator.js": 3340, + "js-checked-array-reference.js": 3923, + "js-checked-number-negation.mjs": 2222, + "js-checked-sort-result.js": 3358, + "js-child-error-listener.cjs": 3277, + "js-cjs-callable-snapshots/main.cjs": 2133, + "js-class-added-parameters.js": 4197, + "js-class-checked-overrides.js": 3307, + "js-class-computed-fields.js": 2995, + "js-class-enumeration.js": 4227, + "js-class-field-accessor-override.js": 3739, + "js-class-fluent-overrides.js": 3694, + "js-class-late-method-values.js": 3823, + "js-class-member-dispatch.js": 2888, + "js-class-return-shapes.js": 4179, + "js-class-shadowed-methods.js": 3019, + "js-class-stored-method-receiver.js": 3182, + "js-class-subclass-properties.js": 4548, + "js-class-symbol-spread.cjs": 3271, + "js-computed-prototype-additions.js": 3652, + "js-constructor-returned-callable.js": 3080, "js-constructor-spread.js": 3311, - "js-dataview-dispatch.js": 2423, - "js-declared-fields.cjs": 3098, - "js-default-listener-arguments.cjs": 2941, - "js-default-options/main.ts": 3442, - "js-deferred-field-initializers.js": 2409, - "js-deferred-registry-effects.js": 2980, - "js-derived-constructor-hoisting.js": 2695, - "js-dormant-array-write.js": 2014, - "js-dormant-overrides.js": 3783, - "js-expando-records.js": 2526, - "js-implicit-call-results.js": 2892, - "js-inferred-callback-exports/main.js": 3776, - "js-inferred-class-array-return.js": 3477, - "js-inferred-object-values.js": 3358, - "js-inherited-field-storage.js": 3527, - "js-inherited-parameter-abi.js": 3324, - "js-iterable-spread.js": 3504, - "js-loose-dynamic-primitives.js": 2079, - "js-map-object-seeds.js": 3322, - "js-member-increment.js": 4257, - "js-module-function-values.js": 3135, - "js-mutable-null-members.js": 2750, - "js-nested-native-descriptors.js": 2725, - "js-normalize-dispatch.js": 3264, - "js-nullish-inherited-fields.mjs": 3080, - "js-object-receiver-storage.js": 3515, - "js-object-returning-constructors.mjs": 3015, - "js-object-shared-arrays.js": 2539, - "js-omitted-typed-arguments.js": 2295, - "js-open-binding-writes.js": 1944, - "js-optional-class-fields.js": 3252, - "js-optional-member-call.js": 3095, - "js-primitive-union-addition.js": 2779, - "js-promise-all-values.js": 3443, - "js-promise-catch-handler.js": 2034, - "js-promise-finally-order.js": 2084, - "js-promise-pending-reactions.js": 3602, - "js-prototype-host-boundary.js": 4779, - "js-reflect-receivers.js": 3486, - "js-regex-record-captures.js": 2214, - "js-scalar-iterables.js": 3719, - "js-shared-method-dispatch.js": 2114, - "js-specialized-field-method.js": 3011, - "js-static-accessors.js": 3435, - "js-static-method-values.js": 3174, - "js-static-registries.cjs": 3047, - "js-super-accessor-initialization.js": 2998, - "js-uninitialized-native-fields.js": 2354, - "json-guarded-map-values.ts": 2502, - "json-output-bulk.ts": 3214, - "json-runtime-options.mjs": 2794, - "json-stringify-value.js": 2833, - "json-typed-parse-direct.ts": 3580, + "js-dataview-dispatch.js": 2584, + "js-declared-fields.cjs": 4858, + "js-default-listener-arguments.cjs": 2246, + "js-default-options/main.ts": 2763, + "js-deferred-field-initializers.js": 3209, + "js-deferred-registry-effects.js": 3112, + "js-derived-constructor-hoisting.js": 2435, + "js-dormant-array-write.js": 2504, + "js-dormant-overrides.js": 2426, + "js-expando-records.js": 2649, + "js-implicit-call-results.js": 2821, + "js-inferred-callback-exports/main.js": 4081, + "js-inferred-class-array-return.js": 3706, + "js-inferred-object-values.js": 2559, + "js-inherited-field-storage.js": 3955, + "js-inherited-parameter-abi.js": 2394, + "js-iterable-spread.js": 3349, + "js-loose-dynamic-primitives.js": 3110, + "js-map-object-seeds.js": 3942, + "js-member-increment.js": 4274, + "js-module-function-values.js": 3403, + "js-mutable-null-members.js": 2899, + "js-nested-native-descriptors.js": 3202, + "js-normalize-dispatch.js": 3282, + "js-nullish-inherited-fields.mjs": 2655, + "js-object-receiver-storage.js": 3904, + "js-object-returning-constructors.mjs": 2279, + "js-object-shared-arrays.js": 3613, + "js-omitted-typed-arguments.js": 2937, + "js-open-binding-writes.js": 2903, + "js-optional-class-fields.js": 3536, + "js-optional-member-call.js": 2325, + "js-primitive-union-addition.js": 3324, + "js-promise-all-values.js": 3699, + "js-promise-catch-handler.js": 3309, + "js-promise-finally-order.js": 3229, + "js-promise-pending-reactions.js": 3312, + "js-prototype-host-boundary.js": 3876, + "js-reflect-receivers.js": 2676, + "js-regex-record-captures.js": 3109, + "js-scalar-iterables.js": 3335, + "js-shared-method-dispatch.js": 3207, + "js-specialized-field-method.js": 3320, + "js-static-accessors.js": 3426, + "js-static-method-values.js": 3661, + "js-static-registries.cjs": 3718, + "js-super-accessor-initialization.js": 2555, + "js-uninitialized-native-fields.js": 3260, + "json-guarded-map-values.ts": 2760, + "json-output-bulk.ts": 3183, + "json-runtime-options.mjs": 3276, + "json-stringify-value.js": 3464, + "json-typed-parse-direct.ts": 4317, "json-typed-parse-index-signatures.ts": 4012, "json-typed-parse-optional-members.ts": 4377, "json-typed-parse-union-members.ts": 4357, - "literal-switch-dispatch.ts": 2951, - "live-reference-shared-converters.ts": 19276, - "llvm-read-receiver-lifetime.ts": 3803, - "local-class-call-spreads.js": 3495, - "local-class-declaration.ts": 2661, - "local-class-evaluation.ts": 3104, - "local-class-inheritance.ts": 2552, - "local-class-lifetimes.ts": 3344, - "local-class-namespace/main.js": 3630, - "local-class-prototype-data.js": 3990, - "local-class-specialization.js": 2812, - "local-class-unknown.ts": 3002, - "local-class-values.ts": 2009, - "local-union-storage.ts": 3026, - "locale-compare-root-order.ts": 3444, - "logical-assignment-dynamic.js": 3230, - "logical-assignment-values.ts": 3566, - "logical-runtime-optional-record.ts": 3322, - "loop-reference-lifetimes.ts": 3339, - "map-checked-boundary/main.ts": 2843, - "map-checked-seed.js": 2966, + "literal-switch-dispatch.ts": 2642, + "live-reference-shared-converters.ts": 5581, + "llvm-read-receiver-lifetime.ts": 3426, + "local-class-call-spreads.js": 3773, + "local-class-declaration.ts": 3293, + "local-class-evaluation.ts": 2921, + "local-class-inheritance.ts": 3273, + "local-class-lifetimes.ts": 3403, + "local-class-namespace/main.js": 4002, + "local-class-prototype-data.js": 3135, + "local-class-specialization.js": 3358, + "local-class-unknown.ts": 3386, + "local-class-values.ts": 3003, + "local-union-storage.ts": 3264, + "locale-compare-root-order.ts": 2579, + "logical-assignment-dynamic.js": 3596, + "logical-assignment-values.ts": 2685, + "logical-runtime-optional-record.ts": 3575, + "loop-reference-lifetimes.ts": 2726, + "map-checked-boundary/main.ts": 3371, + "map-checked-seed.js": 2974, "map-get-set-fusion.ts": 3516, - "map-number-keys-dense.ts": 2773, - "map-read-lifetimes-exits.ts": 2761, - "map-read-lifetimes.ts": 3024, - "map-seeds-and-spreads.ts": 3502, - "map-typed-array-values.ts": 3300, - "math-function-values.js": 2815, - "missing-read-lambda-results.ts": 3370, - "missing-read-narrowed-storage.ts": 2854, - "missing-read-number-conversions.ts": 2326, - "module-byte-loops.ts": 2961, - "module-fallback-functions/main.js": 2737, - "narrowed-nullish-values.ts": 3160, - "native-any-timer-callback.ts": 2388, - "native-array-borrowed-find-last.js": 2571, - "native-array-borrowed-slice.js": 3010, - "native-array-copying-methods.js": 3608, - "native-array-fill-copywithin.js": 2996, - "native-array-frozen-noops.js": 3132, - "native-array-index-boundaries.js": 2225, - "native-array-integrity.js": 3091, - "native-array-length.js": 2365, - "native-array-named-properties.js": 2772, - "native-array-prototype/main.js": 3257, - "native-array-read-lifetimes.ts": 3805, - "native-array-reduce-find-last.js": 2524, - "native-array-search-from-index.js": 2027, - "native-array-splice-coercion.js": 2902, - "native-array-splice-flat.js": 2702, - "native-buffer-coercion.js": 2533, - "native-callback-dispatch.ts": 3850, - "native-class-array-boundaries.ts": 3272, - "native-class-cache.js": 3290, - "native-class-properties.cjs": 4583, - "native-class-property-cycles.cjs": 2888, - "native-class-property-order.cjs": 2105, - "native-class-type-predicates.ts": 2960, - "native-factory-records.js": 3080, - "native-method-values.js": 3222, - "native-method-values.ts": 2808, - "native-npm-imports/main.ts": 2750, - "native-object-descriptors.js": 2979, - "native-object-for-in-minimal.js": 2411, - "native-object-property-attributes.js": 3057, - "native-object-prototype.js": 3409, - "native-property-names.ts": 2077, - "native-proxy-env.js": 4372, - "native-worker-arena-reuse.ts": 33854, - "native-worker-bounded-errors.ts": 2556, - "native-worker-buffer-consumers.ts": 38253, - "native-worker-cancel-hot.ts": 28908, - "native-worker-class-fields.ts": 3286, - "native-worker-clone-errors.ts": 3629, - "native-worker-commonjs.cjs": 3085, - "native-worker-delayed-messages.ts": 28752, - "native-worker-discarded-heaps.ts": 39440, - "native-worker-environment.ts": 27133, - "native-worker-error.ts": 2958, - "native-worker-exception-state.ts": 3945, - "native-worker-exit-listeners.ts": 4052, - "native-worker-io.ts": 3361, - "native-worker-loop-cancellation.ts": 2798, - "native-worker-message-graphs.ts": 2738, - "native-worker-messages.ts": 3079, - "native-worker-poll-exceptions.ts": 2575, - "native-worker-port-lifetime.ts": 3213, - "native-worker-process-exit.ts": 4104, - "native-worker-publish-classes.ts": 24713, - "native-worker-publish-refusals.ts": 2820, - "native-worker-published-graphs.ts": 3534, - "native-worker-references.ts": 3358, - "native-worker-roots/main.ts": 2808, - "native-worker-shared-views.ts": 3012, - "native-worker-stack-overflow.ts": 2597, - "native-worker-terminate-exception-state.ts": 3340, - "native-worker-terminate-loop.ts": 2222, - "native-worker-terminate-recursion.ts": 2829, - "native-worker-terminate-suspended.ts": 4348, - "native-worker-terminate-tested-loops.ts": 3576, - "native-worker-terminate-wait.ts": 3222, - "native-worker-typed-arrays.ts": 2653, - "nested-map-cycles.ts": 3041, - "nested-map-values.ts": 2382, - "never-returning-calls.ts": 2642, - "next-tick-commonjs-entry.cjs": 2624, - "node24-buffer-encoding-errors.ts": 2695, - "node24-buffer-encoding.ts": 3038, - "node24-crypto-kdf-errors.ts": 2745, - "node24-crypto-kdf-options.ts": 2029, - "node24-crypto-kdf.ts": 3632, - "node24-crypto-sha2.ts": 2849, - "node24-deep-equality-properties.js": 3355, - "node24-deep-equality.cjs": 2682, - "node24-deep-equality.ts": 4058, - "node24-env-files-errors.ts": 3202, - "node24-env-files.ts": 3044, - "node24-env-imports.cjs": 2529, - "node24-env-parse-errors.ts": 2062, - "node24-env-parse.ts": 3684, - "node24-esm-metadata/main.mjs": 2492, - "node24-file-url-buffer.ts": 2158, - "node24-file-url-errors.js": 3331, - "node24-file-url-options.ts": 2772, - "node24-fs-links-callbacks.cjs": 3549, - "node24-fs-links-errors.cjs": 2633, - "node24-fs-links-options.cjs": 3571, - "node24-fs-links-promise-errors.cjs": 2445, - "node24-fs-links-promises.ts": 2105, - "node24-fs-links.ts": 2967, - "node24-fs-statfs-callbacks.cjs": 3035, - "node24-fs-statfs-errors.cjs": 2969, - "node24-fs-statfs-options.cjs": 3557, - "node24-fs-statfs.ts": 3067, - "node24-fs-timestamps-callbacks.cjs": 3095, - "node24-fs-timestamps-errors.cjs": 3110, - "node24-fs-timestamps-promises.ts": 3573, - "node24-fs-timestamps-symlinks.ts": 3390, - "node24-fs-timestamps.ts": 3032, - "node24-no-error-assertions-coercion.js": 2850, - "node24-no-error-assertions.cjs": 2814, - "node24-no-error-assertions.ts": 4358, - "node24-parseargs.js": 5971, - "node24-string-decoder.ts": 3185, - "node24-style-text-environment.js": 4225, - "node24-style-text-validation.js": 3673, - "node24-style-text.cjs": 3476, - "node24-style-text.ts": 3037, - "node24-system-error-validation.js": 3005, - "node24-system-errors.cjs": 3631, - "node24-system-errors.ts": 2849, - "node24-text-codec-properties.ts": 30185, - "node24-text-encode-into.ts": 3601, - "node24-text-utilities-coercion.js": 3094, - "node24-text-utilities-validation.js": 2330, - "node24-text-utilities.cjs": 2768, - "node24-text-utilities.ts": 3312, - "node24-url-authority-coercion.js": 3307, - "node24-url-authority.ts": 2639, - "node24-url-factories.ts": 3240, - "node24-url-factory-errors.ts": 2819, - "node24-url-mutation-coercion.js": 2399, - "node24-url-mutation.ts": 3257, - "node24-util-types.cjs": 3263, - "node24-util-types.js": 2199, - "node24-util-types.ts": 3506, - "non-null-class-iteration.ts": 3295, - "nonnull-element-arguments.ts": 2857, - "nonnull-forwarded-class-values.ts": 3303, - "nullable-object-extension.mjs": 2652, - "nullish-asserted-class-arms.ts": 2669, - "nullish-assignment-values.ts": 2125, - "nullish-long-chain.ts": 2641, - "number-parse-statics.ts": 2471, - "number-predicates-unknown.ts": 2568, - "numeric-call-specialization.ts": 2498, - "object-enumeration-array-reads.ts": 2246, - "object-from-checked-entries.js": 3478, - "object-inherited-to-string.js": 2987, - "object-key-indexes.js": 3206, - "object-prototype-identity.mjs": 3083, - "object-reexport/main.js": 2466, - "object-spread-computed.ts": 2806, - "opentui-byte-queue.js": 3532, - "optional-callback-arity.ts": 2417, - "optional-class-flows.ts": 2497, - "optional-element-defaults.ts": 2632, - "optional-flag-comparisons.ts": 2536, - "optional-native-callables.js": 2751, - "optional-node-list-iteration.ts": 2564, - "optional-string-index/main.ts": 3419, - "path-to-file-url-options.ts": 2301, - "performance-presence.ts": 2913, - "primitive-and-function-descriptors.js": 3070, - "primitive-union-string.ts": 3434, - "process-builtin-values.js": 2781, - "process-constrained-memory.ts": 2857, - "process-env-computed-keys.js": 3185, - "process-hrtime.js": 2662, - "process-named-signals.cjs": 3171, - "process-uncaught-handler-throws.cjs": 2344, - "process-uncaught-loop.cjs": 3141, - "process-uncaught-module.mjs": 2646, - "process-uncaught-monitor.cjs": 2837, - "process-uncaught-rejection.cjs": 2664, - "process-uncaught-sync.cjs": 2858, - "process-version-pin.ts": 3005, - "process-versions-storage.ts": 2055, - "projected-collection-lifetimes.ts": 3232, - "promise-checked-rejections.ts": 2914, - "promise-resolve-void.ts": 2846, - "prototype-method-overrides.mjs": 4119, - "prototype-named-data-records.ts": 3179, + "map-number-keys-dense.ts": 3426, + "map-read-lifetimes-exits.ts": 2870, + "map-read-lifetimes.ts": 2755, + "map-seeds-and-spreads.ts": 3696, + "map-typed-array-values.ts": 3121, + "math-function-values.js": 3080, + "missing-read-lambda-results.ts": 2590, + "missing-read-narrowed-storage.ts": 3503, + "missing-read-number-conversions.ts": 3648, + "module-byte-loops.ts": 3462, + "module-fallback-functions/main.js": 3043, + "narrowed-nullish-values.ts": 2912, + "native-any-timer-callback.ts": 1952, + "native-array-borrowed-find-last.js": 2795, + "native-array-borrowed-slice.js": 3711, + "native-array-copying-methods.js": 3069, + "native-array-fill-copywithin.js": 3430, + "native-array-frozen-noops.js": 3638, + "native-array-index-boundaries.js": 2630, + "native-array-integrity.js": 3935, + "native-array-length.js": 3375, + "native-array-named-properties.js": 3404, + "native-array-prototype/main.js": 3369, + "native-array-read-lifetimes.ts": 3688, + "native-array-reduce-find-last.js": 3264, + "native-array-search-from-index.js": 3220, + "native-array-splice-coercion.js": 3281, + "native-array-splice-flat.js": 3336, + "native-buffer-coercion.js": 2766, + "native-callback-dispatch.ts": 3779, + "native-class-array-boundaries.ts": 3630, + "native-class-cache.js": 3925, + "native-class-properties.cjs": 3940, + "native-class-property-cycles.cjs": 2802, + "native-class-property-order.cjs": 3298, + "native-class-type-predicates.ts": 3174, + "native-factory-records.js": 3338, + "native-method-values.js": 4444, + "native-method-values.ts": 3470, + "native-npm-imports/main.ts": 4028, + "native-object-descriptors.js": 2892, + "native-object-for-in-minimal.js": 2799, + "native-object-property-attributes.js": 3744, + "native-object-prototype.js": 2121, + "native-property-names.ts": 2951, + "native-proxy-env.js": 4417, + "native-worker-arena-reuse.ts": 38589, + "native-worker-bounded-errors.ts": 3955, + "native-worker-buffer-consumers.ts": 3076, + "native-worker-cancel-hot.ts": 3811, + "native-worker-class-fields.ts": 3737, + "native-worker-clone-errors.ts": 3557, + "native-worker-commonjs.cjs": 3258, + "native-worker-delayed-messages.ts": 3234, + "native-worker-discarded-heaps.ts": 8633, + "native-worker-environment.ts": 2690, + "native-worker-error.ts": 2115, + "native-worker-exception-state.ts": 37223, + "native-worker-exit-listeners.ts": 4215, + "native-worker-io.ts": 4024, + "native-worker-loop-cancellation.ts": 3683, + "native-worker-message-graphs.ts": 4038, + "native-worker-messages.ts": 2850, + "native-worker-poll-exceptions.ts": 3386, + "native-worker-port-lifetime.ts": 3672, + "native-worker-process-exit.ts": 4483, + "native-worker-publish-classes.ts": 43586, + "native-worker-publish-refusals.ts": 3568, + "native-worker-published-graphs.ts": 4341, + "native-worker-references.ts": 3658, + "native-worker-roots/main.ts": 3661, + "native-worker-shared-views.ts": 3873, + "native-worker-stack-overflow.ts": 3498, + "native-worker-terminate-exception-state.ts": 4768, + "native-worker-terminate-loop.ts": 3671, + "native-worker-terminate-recursion.ts": 2944, + "native-worker-terminate-suspended.ts": 4867, + "native-worker-terminate-tested-loops.ts": 3737, + "native-worker-terminate-wait.ts": 3200, + "native-worker-typed-arrays.ts": 2972, + "nested-map-cycles.ts": 3092, + "nested-map-values.ts": 3902, + "never-returning-calls.ts": 3512, + "next-tick-commonjs-entry.cjs": 3497, + "node24-buffer-encoding-errors.ts": 2874, + "node24-buffer-encoding.ts": 2697, + "node24-crypto-kdf-errors.ts": 3771, + "node24-crypto-kdf-options.ts": 2897, + "node24-crypto-kdf.ts": 3236, + "node24-crypto-sha2.ts": 3082, + "node24-deep-equality-properties.js": 3692, + "node24-deep-equality.cjs": 4490, + "node24-deep-equality.ts": 2856, + "node24-env-files-errors.ts": 2870, + "node24-env-files.ts": 3392, + "node24-env-imports.cjs": 2365, + "node24-env-parse-errors.ts": 3439, + "node24-env-parse.ts": 3033, + "node24-esm-metadata/main.mjs": 3209, + "node24-file-url-buffer.ts": 3465, + "node24-file-url-errors.js": 3937, + "node24-file-url-options.ts": 3735, + "node24-fs-links-callbacks.cjs": 3621, + "node24-fs-links-errors.cjs": 3404, + "node24-fs-links-options.cjs": 6459, + "node24-fs-links-promise-errors.cjs": 3319, + "node24-fs-links-promises.ts": 2636, + "node24-fs-links.ts": 3567, + "node24-fs-statfs-callbacks.cjs": 2515, + "node24-fs-statfs-errors.cjs": 2787, + "node24-fs-statfs-options.cjs": 3945, + "node24-fs-statfs.ts": 3105, + "node24-fs-timestamps-callbacks.cjs": 3550, + "node24-fs-timestamps-errors.cjs": 2070, + "node24-fs-timestamps-promises.ts": 3342, + "node24-fs-timestamps-symlinks.ts": 3375, + "node24-fs-timestamps.ts": 3308, + "node24-no-error-assertions-coercion.js": 3613, + "node24-no-error-assertions.cjs": 2851, + "node24-no-error-assertions.ts": 4400, + "node24-parseargs.js": 5202, + "node24-string-decoder.ts": 3402, + "node24-style-text-environment.js": 3896, + "node24-style-text-validation.js": 3092, + "node24-style-text.cjs": 3244, + "node24-style-text.ts": 2726, + "node24-system-error-validation.js": 3065, + "node24-system-errors.cjs": 2955, + "node24-system-errors.ts": 3258, + "node24-text-codec-properties.ts": 31240, + "node24-text-encode-into.ts": 2827, + "node24-text-utilities-coercion.js": 3019, + "node24-text-utilities-validation.js": 3576, + "node24-text-utilities.cjs": 3204, + "node24-text-utilities.ts": 2533, + "node24-url-authority-coercion.js": 3364, + "node24-url-authority.ts": 3386, + "node24-url-factories.ts": 3341, + "node24-url-factory-errors.ts": 3442, + "node24-url-mutation-coercion.js": 3344, + "node24-url-mutation.ts": 3264, + "node24-util-types.cjs": 3872, + "node24-util-types.js": 3533, + "node24-util-types.ts": 2848, + "non-null-class-iteration.ts": 2837, + "nonnull-element-arguments.ts": 3131, + "nonnull-forwarded-class-values.ts": 2449, + "nullable-object-extension.mjs": 3515, + "nullish-asserted-class-arms.ts": 3564, + "nullish-assignment-values.ts": 3337, + "nullish-long-chain.ts": 4149, + "number-parse-statics.ts": 2899, + "number-predicates-unknown.ts": 2922, + "numeric-call-specialization.ts": 2677, + "object-enumeration-array-reads.ts": 3480, + "object-from-checked-entries.js": 4289, + "object-inherited-to-string.js": 3243, + "object-key-indexes.js": 3558, + "object-prototype-identity.mjs": 3385, + "object-reexport/main.js": 2771, + "object-spread-computed.ts": 3307, + "opentui-byte-queue.js": 3572, + "optional-callback-arity.ts": 3027, + "optional-class-flows.ts": 3557, + "optional-element-defaults.ts": 3575, + "optional-flag-comparisons.ts": 3414, + "optional-native-callables.js": 3002, + "optional-node-list-iteration.ts": 2230, + "optional-string-index/main.ts": 3788, + "path-to-file-url-options.ts": 2444, + "performance-presence.ts": 2497, + "primitive-and-function-descriptors.js": 3169, + "primitive-union-string.ts": 2622, + "process-builtin-values.js": 3706, + "process-constrained-memory.ts": 2749, + "process-env-computed-keys.js": 3550, + "process-hrtime.js": 2677, + "process-named-signals.cjs": 3293, + "process-uncaught-handler-throws.cjs": 2718, + "process-uncaught-loop.cjs": 2801, + "process-uncaught-module.mjs": 3158, + "process-uncaught-monitor.cjs": 3031, + "process-uncaught-rejection.cjs": 3327, + "process-uncaught-sync.cjs": 2443, + "process-version-pin.ts": 2957, + "process-versions-storage.ts": 3651, + "projected-collection-lifetimes.ts": 3241, + "promise-checked-rejections.ts": 3404, + "promise-resolve-void.ts": 3343, + "prototype-method-overrides.mjs": 4289, + "prototype-named-data-records.ts": 3466, "rc-last-use-moves.ts": 4113, "rc-private-array-writes.ts": 4261, - "record-field-presence.ts": 3698, - "record-key-order.ts": 2706, - "record-optional-json-presence.ts": 3216, - "record-presence-copies.ts": 3381, - "record-presence-delete-json.ts": 3160, - "record-unchecked-read-presence.ts": 2953, - "record-unknown-values.ts": 4095, - "reflect-own-keys.mjs": 2705, - "reflect-record-union-keys.mjs": 2815, - "reflect-typed-record-keys.ts": 2683, - "regex-callback-replacements.ts": 2631, - "regex-callback-values.js": 3741, - "regex-checked-casts.ts": 2405, - "regex-checked-storage.js": 3560, - "regex-exec-long-subject.ts": 5584, + "record-field-presence.ts": 4642, + "record-key-order.ts": 3034, + "record-optional-json-presence.ts": 3355, + "record-presence-copies.ts": 2764, + "record-presence-delete-json.ts": 2807, + "record-unchecked-read-presence.ts": 3073, + "record-unknown-values.ts": 4519, + "reflect-own-keys.mjs": 3709, + "reflect-record-union-keys.mjs": 2498, + "reflect-typed-record-keys.ts": 2697, + "regex-callback-replacements.ts": 3004, + "regex-callback-values.js": 2710, + "regex-checked-casts.ts": 3352, + "regex-checked-storage.js": 3330, + "regex-exec-long-subject.ts": 6176, "regex-exec-result-arrays.ts": 3812, "regex-fs-text-surfaces.ts": 4280, - "regex-input-lifetimes.ts": 3241, - "regex-native-matcher.ts": 3652, - "regex-optional-captures.ts": 2740, - "regex-optional-templates.ts": 2802, - "regex-split-captures.ts": 3590, - "regex-text-paths.ts": 2840, - "regexp-constructor-repeat.ts": 2602, - "regexp-optional-constructor.ts": 2950, - "regexp-string-coercion.js": 2621, - "renderer-export-dictionaries.js": 3415, - "renderer-null-state.js": 2259, - "renderer-specializations.js": 2837, - "repeat-and-typed-read-errors.ts": 3220, - "rest-optional-array-arguments.ts": 2860, - "rest-optional-elements.ts": 2445, - "return-void-through-finally.ts": 2861, - "runtime-optional-string-flows.ts": 2977, - "scalar-string-slices.ts": 2840, - "set-checked-methods.js": 3072, - "set-checked-storage.ts": 2667, - "set-iterator-seed-references.ts": 3159, - "set-iterator-seeds.ts": 3269, - "set-optional-seeds.ts": 2164, - "small-collection-transitions.ts": 3586, + "regex-input-lifetimes.ts": 3127, + "regex-native-matcher.ts": 5535, + "regex-optional-captures.ts": 3580, + "regex-optional-templates.ts": 3221, + "regex-split-captures.ts": 2939, + "regex-text-paths.ts": 3596, + "regexp-constructor-repeat.ts": 3069, + "regexp-optional-constructor.ts": 2996, + "regexp-string-coercion.js": 3263, + "renderer-export-dictionaries.js": 3616, + "renderer-null-state.js": 3037, + "renderer-specializations.js": 3634, + "repeat-and-typed-read-errors.ts": 2617, + "rest-optional-array-arguments.ts": 3777, + "rest-optional-elements.ts": 3195, + "return-void-through-finally.ts": 2410, + "runtime-optional-string-flows.ts": 3467, + "scalar-string-slices.ts": 3659, + "set-checked-methods.js": 2038, + "set-checked-storage.ts": 3153, + "set-iterator-seed-references.ts": 3637, + "set-iterator-seeds.ts": 3641, + "set-optional-seeds.ts": 3312, + "small-collection-transitions.ts": 3749, "speculative-integer-globals.ts": 3132, "speculative-integer-loops.ts": 3533, "speculative-integer-reads.ts": 3953, - "stack-depth-async-bodies.ts": 2727, - "stack-overflow-async.ts": 2942, - "stack-overflow-caught.ts": 3056, - "stack-overflow-finally.ts": 3694, - "stack-overflow-shapes.ts": 3565, - "stack-overflow-uncaught.ts": 2532, + "stack-depth-async-bodies.ts": 3272, + "stack-overflow-async.ts": 2638, + "stack-overflow-caught.ts": 2219, + "stack-overflow-finally.ts": 3033, + "stack-overflow-shapes.ts": 4491, + "stack-overflow-uncaught.ts": 2225, "stackless-async-concurrency.ts": 4361, "stackless-async-context.ts": 2699, "stackless-async-exceptions.ts": 3282, "stackless-async-ordering.ts": 3335, "stackless-async-unhandled.ts": 2784, - "static-field-updates/main.ts": 2914, - "static-method-receivers.ts": 2350, - "stdio-values.mjs": 2761, - "stdio-write-errors.mjs": 2672, - "stdio-write-overrides.mjs": 3205, - "stored-native-builtins.js": 3341, - "stored-object-helpers.js": 2959, + "static-field-updates/main.ts": 2292, + "static-method-receivers.ts": 3195, + "stdio-values.mjs": 3475, + "stdio-write-errors.mjs": 3473, + "stdio-write-overrides.mjs": 2782, + "stored-native-builtins.js": 3709, + "stored-object-helpers.js": 3602, "stream-dynamic-entry-kinds.cjs": 4557, "stream-dynamic-entry-kinds.ts": 4257, "stream-encoded-from-entries.cjs": 4266, "stream-encoded-from-entries.ts": 5622, - "string-char-code-integer-loops.ts": 2575, - "string-code-points.ts": 2460, - "string-concat-number-parts.ts": 2155, - "string-construction-order.ts": 3307, + "string-char-code-integer-loops.ts": 2285, + "string-code-points.ts": 3745, + "string-concat-number-parts.ts": 3405, + "string-construction-order.ts": 3532, "string-field-append.ts": 3568, - "string-lifetimes-boundaries.ts": 3304, - "string-lifetimes-evaluation.ts": 2835, - "string-lifetimes-iteration.ts": 2037, - "string-lifetimes-operations.ts": 2789, - "string-normalize.ts": 2348, - "string-pattern-replacement.ts": 3823, - "string-scan-fast-paths.ts": 3224, - "string-split-checked-separator.mjs": 2349, - "string-split-traversal.ts": 3258, - "structural-class-properties.ts": 2627, - "structured-text-boundaries.js": 3452, - "structured-text-storage.ts": 3201, - "switch-integer-dispatch.ts": 2387, - "symbol-checked-boundary/main.ts": 2796, - "symbol-class-fields.ts": 2814, - "symbol-class-fields/main.cjs": 2659, - "symbol-class-methods/main.ts": 1948, - "symbol-fields-deferred-factory.ts": 2721, - "symbol-fields-inferred.js": 2792, - "symbol-object-properties/main.js": 3376, - "synchronous-callback-lifetimes.ts": 2872, - "terminal-stream-properties.ts": 2946, - "text-codec-values/main.ts": 18964, - "text-codec-var.ts": 3480, - "text-encode-into-boundaries.ts": 2224, - "timers-clear-many.ts": 3073, - "tuple-and-string-search.ts": 2595, - "tuple-array-union.ts": 3305, - "tuple-callback-visitation.ts": 3801, - "tuple-forof-visitation.ts": 3276, - "typed-array-bulk-conversion.mjs": 5346, - "typed-array-byte-io.js": 41314, - "typed-array-checked-index.js": 2607, - "typed-array-constructor-alias.ts": 2778, - "typed-array-constructor-identity.js": 2769, - "typed-array-constructor-union.ts": 2366, - "typed-array-constructor-values.mjs": 3448, - "typed-array-dynamic-methods.js": 3373, - "typed-array-integer-widths.ts": 3014, - "typed-array-nan-coded-reads.ts": 4239, - "typed-array-numeric-import.ts": 3499, - "typed-array-present-reads.ts": 3561, - "typed-array-reversed-storage.ts": 2954, - "typed-array-unknown.ts": 3453, - "typed-collection-iterator-references.ts": 3531, - "typed-collection-iterators.ts": 3385, - "typed-collection-views/main.ts": 2577, - "typed-index-arguments.ts": 3036, - "typed-prototype-methods.ts": 2475, - "typed-rest-callables.ts": 2463, - "typed-rest-filtered-return.ts": 2800, - "typedarray-native-inputs.js": 3164, - "typeof-checked-comparison.js": 2913, - "uint8array-sort-domains.ts": 2505, - "unicode-case-paths.ts": 2924, - "unicode-process-argv.ts": 2793, - "union-discriminant-width.ts": 3726, - "union-literal-scalar-discriminants.ts": 3704, - "union-literal-slot-conversion.ts": 2972, - "union-nested-layout-discriminant.ts": 2841, - "union-optional-semantic-identity.ts": 3100, - "union-record-clone.ts": 3480, - "union-record-structural-copy.ts": 3563, - "union-reference-comparison.ts": 3338, - "unknown-array-holes.ts": 2088, - "unknown-collections.ts": 3765, - "unknown-object-enumeration.ts": 4219, - "unknown-record-views.ts": 3040, - "url-runtime-base.ts": 2778, - "utf8-span-decoding.ts": 2655, - "util-parseargs-wrapped/main.ts": 2482, - "virtual-runtime-optional-returns.ts": 3876, - "weak-map-array-buffer.ts": 2826, - "weak-map-fresh-array.js": 2495, - "weak-map-native.js": 3627, - "weak-native-class-identity.ts": 2943, - "weak-set-native.js": 3056, - "worker-class-instance-clone.ts": 35222 + "string-lifetimes-boundaries.ts": 2538, + "string-lifetimes-evaluation.ts": 3059, + "string-lifetimes-iteration.ts": 2631, + "string-lifetimes-operations.ts": 3387, + "string-normalize.ts": 2789, + "string-pattern-replacement.ts": 3618, + "string-scan-fast-paths.ts": 3272, + "string-split-checked-separator.mjs": 3453, + "string-split-traversal.ts": 4337, + "structural-class-properties.ts": 3247, + "structured-text-boundaries.js": 3686, + "structured-text-storage.ts": 3429, + "switch-integer-dispatch.ts": 3032, + "symbol-checked-boundary/main.ts": 3536, + "symbol-class-fields.ts": 2762, + "symbol-class-fields/main.cjs": 3297, + "symbol-class-methods/main.ts": 3256, + "symbol-fields-deferred-factory.ts": 2417, + "symbol-fields-inferred.js": 3396, + "symbol-object-properties/main.js": 3134, + "synchronous-callback-lifetimes.ts": 3731, + "terminal-stream-properties.ts": 3204, + "text-codec-values/main.ts": 34352, + "text-codec-var.ts": 32460, + "text-encode-into-boundaries.ts": 3355, + "timers-clear-many.ts": 3559, + "tuple-and-string-search.ts": 3678, + "tuple-array-union.ts": 3569, + "tuple-callback-visitation.ts": 4765, + "tuple-forof-visitation.ts": 3560, + "typed-array-bulk-conversion.mjs": 5651, + "typed-array-byte-io.js": 4933, + "typed-array-checked-index.js": 3214, + "typed-array-constructor-alias.ts": 3116, + "typed-array-constructor-identity.js": 2735, + "typed-array-constructor-union.ts": 2841, + "typed-array-constructor-values.mjs": 3638, + "typed-array-dynamic-methods.js": 3255, + "typed-array-integer-widths.ts": 3434, + "typed-array-nan-coded-reads.ts": 3804, + "typed-array-numeric-import.ts": 2396, + "typed-array-present-reads.ts": 4348, + "typed-array-reversed-storage.ts": 3192, + "typed-array-unknown.ts": 2874, + "typed-collection-iterator-references.ts": 4029, + "typed-collection-iterators.ts": 4109, + "typed-collection-views/main.ts": 3005, + "typed-index-arguments.ts": 2798, + "typed-prototype-methods.ts": 3814, + "typed-rest-callables.ts": 2881, + "typed-rest-filtered-return.ts": 3723, + "typedarray-native-inputs.js": 2740, + "typeof-checked-comparison.js": 2277, + "uint8array-sort-domains.ts": 3386, + "unicode-case-paths.ts": 3002, + "unicode-process-argv.ts": 3272, + "union-discriminant-width.ts": 3302, + "union-literal-scalar-discriminants.ts": 2833, + "union-literal-slot-conversion.ts": 4058, + "union-nested-layout-discriminant.ts": 3205, + "union-optional-semantic-identity.ts": 3833, + "union-record-clone.ts": 3862, + "union-record-structural-copy.ts": 3756, + "union-reference-comparison.ts": 2883, + "unknown-array-holes.ts": 2863, + "unknown-collections.ts": 4132, + "unknown-object-enumeration.ts": 4976, + "unknown-record-views.ts": 4014, + "url-runtime-base.ts": 3421, + "utf8-span-decoding.ts": 3446, + "util-parseargs-wrapped/main.ts": 3987, + "virtual-runtime-optional-returns.ts": 4683, + "weak-map-array-buffer.ts": 3291, + "weak-map-fresh-array.js": 2703, + "weak-map-native.js": 3899, + "weak-native-class-identity.ts": 2332, + "weak-set-native.js": 2464, + "worker-class-instance-clone.ts": 46305 } } From cd376c14f1d4f0c7da8ec70a0cef050a1ac92192 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 09:33:01 -0700 Subject: [PATCH 6/7] Refresh the corpus costs from main's newest green Linux shards Rerun scripts/ci-corpus-costs.mjs over the 120 green Linux corpus shard logs (plain and san, 20 shards each) of main CI runs 39142848734, 39142619508 and 39142079655 (307387c8e, 18c50b55d, b85dd44cd). Their Linux lanes were all green; only macOS jobs were still queued. This measures the programs added since the previous refresh, including 5770-5773, 5960-5962, 5973, 6041-6043, the CommonJS require programs 6140-6145 and 5023/5024. Coverage of current main's corpus goes from 2992/3012 (0.9934) to 3011/3012 (0.9997); the one unmeasured program, scratch-string-slices.ts, landed after those runs. Co-Authored-By: Claude Opus 5.5 --- tests/harness/corpus-costs.json | 11984 +++++++++++++++--------------- 1 file changed, 6011 insertions(+), 5973 deletions(-) diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index 622b64700..e4dd020cd 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -1,5991 +1,6029 @@ { "note": "Milliseconds per corpus program on a GitHub-hosted ubuntu-24.04 runner: its differential plus llvm-differential case, per flavor (medians of green main runs). scripts/ci-corpus-costs.mjs refreshes it from CI logs.", "plain": { - "001-hello.ts": 3065, - "002-log-args.ts": 4101, - "100-number-format.ts": 4051, - "1000-json-stringify-basics.ts": 5187, - "1001-json-escapes-unicode.ts": 4569, - "1002-json-parse-cast.ts": 3516, - "1003-json-parse-unions.ts": 3382, - "1004-json-parse-errors.ts": 4383, - "1005-json-nested.ts": 5206, - "1006-json-fs-config.ts": 3979, - "1007-json-rc-stress.ts": 3920, - "1008-json-null-arms.ts": 3823, - "1009-json-optional-fields.ts": 4367, - "101-arithmetic.ts": 3258, - "1010-json-stringify-space.ts": 3979, - "1011-json-unknown-typeof.ts": 4108, - "102-comparisons.ts": 4061, - "1020-async-basics.ts": 3165, - "1021-async-ordering.ts": 3062, - "1022-async-exceptions.ts": 3356, - "1023-async-rc-stress.ts": 3530, - "1024-async-pending-exit.ts": 2901, - "1025-async-promise-capture.ts": 3471, - "1026-throw-promise.ts": 3173, - "1027-async-return-promise.ts": 2405, - "1028-async-return-record-literals.ts": 3561, - "1029-async-eager-chains.ts": 3698, - "103-ternary.ts": 3292, - "104-ternary-empty-arrays.ts": 4072, - "1050-comptime-tables.ts": 3518, - "1051-comptime-strings.ts": 2082, - "1052-comptime-records.ts": 3252, - "1053-comptime-json.ts": 3388, - "1054-comptime-modules/main.ts": 3286, - "110-number-radix.ts": 3749, - "111-record-entries.ts": 4017, - "1110-math-members.ts": 2615, - "1111-math-random.ts": 2691, - "1113-string-methods.ts": 3490, - "1114-string-unicode-island.ts": 2532, - "1115-parse-globals.ts": 2850, - "1116-island-static-mix.ts": 3032, - "1117-typeof-static-union.ts": 3626, - "1118-object-spread-conditional.ts": 2554, - "1119-switch-union.ts": 2726, - "112-class-descriptor-key.js": 2549, - "1121-infinity-number-tostring.ts": 3208, - "1122-any-captures.ts": 3054, - "1124-union-narrowed-retag.ts": 3578, - "113-promise-checked-exits.ts": 3586, - "114-live-record-delete.ts": 3626, - "115-array-compound.js": 3341, - "116-text-decoder-runtime.js": 2988, - "117-weak-cache-cycle.js": 2923, - "118-fs-stored-callbacks.cjs": 4172, - "119-native-patterns.js": 3825, - "1200-regex-test-basics.ts": 3353, - "1201-regex-replace.ts": 3417, - "1202-regex-substitutions.ts": 2747, - "1203-regex-split.ts": 3543, - "1204-regex-empty-unicode.ts": 3255, - "1205-regex-rc-stress.ts": 3482, - "1300-errors-basics.ts": 4832, - "1301-errors-subclass.ts": 1974, - "1302-errors-typed-catch.ts": 3160, - "1303-errors-rc-stress.ts": 3496, - "1304-errors-uncaught.ts": 2419, - "1305-errors-async-rejections.ts": 3908, - "1306-errors-runtime-instances.ts": 3226, - "1350-path-normalize-join.ts": 3294, - "1351-path-parts.ts": 3299, - "1352-path-resolve-relative.ts": 3380, - "1353-os-basics.ts": 3216, - "1354-builtin-bare-specifiers.ts": 3413, - "1355-url-parse.ts": 3188, - "1356-url-file-bridge.ts": 3020, - "1357-fsp-roundtrip.ts": 3377, - "1358-crypto-random.ts": 3134, - "1359-json-module/main.ts": 3195, - "1360-spawn-sync.ts": 3446, - "1361-spawn-events.ts": 3606, - "1362-spawn-timers.ts": 9552, - "1363-spawn-unhandled-error.ts": 3308, - "1364-union-truthiness.ts": 2872, - "1365-union-logical.ts": 3452, - "1366-union-equality.ts": 2813, - "1367-destructuring.ts": 3209, - "1368-constructor-functions.ts": 1858, - "1369-promise-union.ts": 2635, - "1370-spread.ts": 2894, - "1371-union-template-tostring.ts": 3244, - "1372-loose-null-tests.ts": 3198, - "1373-union-array-arms.ts": 3455, - "140-bitwise-operators.ts": 3457, - "1400-typedarray-basics.ts": 2651, - "1401-typedarray-slice-set.ts": 4371, - "1402-buffer-encodings.ts": 3496, - "1403-buffer-fs.ts": 3517, - "1404-zlib-crypto-bytes.ts": 3174, - "1405-bytes-unions-arrays.ts": 4083, - "1406-dataview-mp4.ts": 3511, - "1407-dataview-bounds.ts": 2861, - "1408-string-indexing.ts": 3596, - "1409-typedarray-integer-loops.ts": 3161, - "1420-number-statics.ts": 1931, - "1421-number-parse-strings.ts": 2420, - "1422-date-iso.ts": 3107, - "1423-text-codec.ts": 4835, - "1424-fs-options.ts": 3321, - "1425-stdin-tty.ts": 2403, - "1426-stdin-read.ts": 3082, - "1427-fromcharcode-lastindexof.ts": 3173, - "1428-settled-await-order.ts": 1798, - "1429-promise-catch-finally.ts": 3573, - "1430-promise-race.ts": 3479, - "1431-caught-tostring.ts": 3384, - "1432-destructured-params.ts": 2875, - "1433-filter-narrow.ts": 3756, - "1434-async-never.ts": 3046, - "1435-math-spread.ts": 2761, - "1436-default-undef-param.ts": 2349, - "1437-pad-default.ts": 3147, - "1438-promise-all.ts": 6716, - "1440-interval-basics.ts": 2538, - "1441-interval-clear-cross.ts": 6428, - "1442-interval-throw.ts": 3155, - "1443-signal-handlers.ts": 5897, - "1444-exit-listeners.ts": 2050, - "1445-exit-process-exit.ts": 3031, - "1446-exit-uncaught.ts": 3104, - "1447-stdin-closed-events.ts": 2554, - "1448-stream-columns.ts": 2939, - "1450-incdec-expression.ts": 3366, - "1451-instanceof-uint8array-unknown.ts": 3581, - "1452-return-through-finally.ts": 2366, - "1453-pmap-settled.ts": 3689, - "1454-nonnull-narrow-and-fcc-bytes.ts": 3631, - "1455-lambda-union-return-adoption.ts": 3317, - "1460-console-error-warn.ts": 2928, - "1461-process-pid-getuid-kill.ts": 2613, - "1462-exec-sync.ts": 3611, - "1463-timeout-unref.ts": 2351, - "1464-env-writes.ts": 2366, - "1465-env-value.ts": 3573, - "1466-child-containers.ts": 3261, - "1467-string-match.ts": 2763, - "1468-exec-path.ts": 1874, - "1469-remove-listener.ts": 3366, - "1470-child-lifecycle.ts": 3503, - "1471-child-unref.ts": 7428, - "1472-errno-code.ts": 3503, - "1473-promisify-execfile.ts": 3923, - "1474-string-decoder.ts": 3543, - "1475-readline-closed-stdin.ts": 2561, - "1476-assign-expression.ts": 2094, - "1477-in-expressions.ts": 2351, - "1478-promise-reject.ts": 3535, - "1479-destructuring-assign.ts": 3422, - "1480-os-network-interfaces.ts": 3878, - "1481-string-case-static.ts": 1956, - "1482-spawnsync-error.ts": 3384, - "1483-array-slice.ts": 2259, - "1520-fs-wider-surface.ts": 2338, - "1520-string-split-static.ts": 2323, - "1521-fs-lstat-lock.ts": 2828, - "1521-string-trim-pad-static.ts": 3386, - "1522-parseint-static.ts": 3245, - "1522-spawnsync-options.ts": 5207, - "1523-isnan-floor-static.ts": 2460, - "1523-spawn-options.ts": 3155, - "1524-atomics-sleep-static.ts": 3514, - "1524-catch-narrowing.ts": 3000, - "1525-child-exit-signal.ts": 3280, - "1525-unknown-typeof-validation.ts": 3939, - "1526-set-spread.ts": 3125, - "1527-logical-mixed-operands.ts": 3109, - "1528-delete-records-env.ts": 3666, - "1529-class-with-statics.ts": 2773, - "1530-array-push-variadic.ts": 2981, - "1530-spread-override-completion.ts": 2727, - "1531-delete-optional-fields.ts": 3366, - "1531-process-arch-versions.ts": 3284, - "1532-array-splice-shift.ts": 3298, - "1532-union-shared-field-read.ts": 3134, - "1533-bool-equality.ts": 2685, - "1533-path-platform-namespaces.ts": 2976, - "1534-crypto-hash-chain.ts": 3181, - "1534-union-as-arm-cast.ts": 1932, - "1535-spawn-fd-stdio.ts": 2678, - "1535-union-param-defaults.ts": 3163, - "1536-destructuring-defaults.ts": 2281, - "1536-string-array-sweep.ts": 2437, - "1537-chalk-hybrid/main.ts": 2748, - "1537-os-release-spawnsync-stdio.ts": 1762, - "1538-await-promiselike-return.ts": 3032, - "1538-math-static-scalar.ts": 3194, - "1539-readonly-set-map.ts": 2459, - "1539-unknown-truthiness.ts": 3106, - "1540-os-userinfo.ts": 3344, - "1540-void-statement.ts": 2967, - "1541-fs-readdir-dirent.ts": 3638, - "1541-union-keyed-reads.ts": 3287, - "1542-map-promise-values.ts": 2441, - "1542-record-literal-into-union.ts": 3261, - "1543-rest-destructuring.ts": 2933, - "1543-set-server-handles.ts": 1958, - "1544-dyn-json-reads.ts": 2284, - "1544-string-matchall.ts": 2886, - "1545-spread-order-and-optional.ts": 3651, - "1546-union-element-reads.ts": 3172, - "1547-computed-key-fold.ts": 3047, - "1548-boolean-condition-forms.ts": 2170, + "001-hello.ts": 4256, + "002-log-args.ts": 4431, + "100-number-format.ts": 4288, + "1000-json-stringify-basics.ts": 5132, + "1001-json-escapes-unicode.ts": 3267, + "1002-json-parse-cast.ts": 5058, + "1003-json-parse-unions.ts": 4949, + "1004-json-parse-errors.ts": 3893, + "1005-json-nested.ts": 4163, + "1006-json-fs-config.ts": 3643, + "1007-json-rc-stress.ts": 4310, + "1008-json-null-arms.ts": 3701, + "1009-json-optional-fields.ts": 5156, + "101-arithmetic.ts": 3674, + "1010-json-stringify-space.ts": 4817, + "1011-json-unknown-typeof.ts": 3898, + "102-comparisons.ts": 4171, + "1020-async-basics.ts": 2636, + "1021-async-ordering.ts": 3263, + "1022-async-exceptions.ts": 3483, + "1023-async-rc-stress.ts": 4371, + "1024-async-pending-exit.ts": 3071, + "1025-async-promise-capture.ts": 3271, + "1026-throw-promise.ts": 3956, + "1027-async-return-promise.ts": 2933, + "1028-async-return-record-literals.ts": 3384, + "1029-async-eager-chains.ts": 2879, + "103-ternary.ts": 2774, + "104-ternary-empty-arrays.ts": 3724, + "1050-comptime-tables.ts": 3691, + "1051-comptime-strings.ts": 2389, + "1052-comptime-records.ts": 3840, + "1053-comptime-json.ts": 4536, + "1054-comptime-modules/main.ts": 3656, + "110-number-radix.ts": 2382, + "111-record-entries.ts": 4655, + "1110-math-members.ts": 4248, + "1111-math-random.ts": 3457, + "1113-string-methods.ts": 3364, + "1114-string-unicode-island.ts": 3366, + "1115-parse-globals.ts": 2591, + "1116-island-static-mix.ts": 3058, + "1117-typeof-static-union.ts": 3667, + "1118-object-spread-conditional.ts": 3693, + "1119-switch-union.ts": 3739, + "112-class-descriptor-key.js": 3492, + "1121-infinity-number-tostring.ts": 3539, + "1122-any-captures.ts": 3596, + "1124-union-narrowed-retag.ts": 3745, + "113-promise-checked-exits.ts": 2180, + "114-live-record-delete.ts": 3506, + "115-array-compound.js": 2722, + "116-text-decoder-runtime.js": 3978, + "117-weak-cache-cycle.js": 2417, + "118-fs-stored-callbacks.cjs": 4105, + "119-native-patterns.js": 4047, + "1200-regex-test-basics.ts": 2828, + "1201-regex-replace.ts": 3118, + "1202-regex-substitutions.ts": 2460, + "1203-regex-split.ts": 3529, + "1204-regex-empty-unicode.ts": 2746, + "1205-regex-rc-stress.ts": 3472, + "1300-errors-basics.ts": 3642, + "1301-errors-subclass.ts": 3871, + "1302-errors-typed-catch.ts": 3598, + "1303-errors-rc-stress.ts": 2806, + "1304-errors-uncaught.ts": 2053, + "1305-errors-async-rejections.ts": 3710, + "1306-errors-runtime-instances.ts": 2540, + "1350-path-normalize-join.ts": 2427, + "1351-path-parts.ts": 2680, + "1352-path-resolve-relative.ts": 3325, + "1353-os-basics.ts": 3345, + "1354-builtin-bare-specifiers.ts": 3282, + "1355-url-parse.ts": 2902, + "1356-url-file-bridge.ts": 2530, + "1357-fsp-roundtrip.ts": 2551, + "1358-crypto-random.ts": 3328, + "1359-json-module/main.ts": 3223, + "1360-spawn-sync.ts": 3535, + "1361-spawn-events.ts": 2778, + "1362-spawn-timers.ts": 8421, + "1363-spawn-unhandled-error.ts": 2559, + "1364-union-truthiness.ts": 2999, + "1365-union-logical.ts": 3464, + "1366-union-equality.ts": 3482, + "1367-destructuring.ts": 3491, + "1368-constructor-functions.ts": 3392, + "1369-promise-union.ts": 3326, + "1370-spread.ts": 2384, + "1371-union-template-tostring.ts": 3754, + "1372-loose-null-tests.ts": 3218, + "1373-union-array-arms.ts": 4066, + "140-bitwise-operators.ts": 2496, + "1400-typedarray-basics.ts": 3520, + "1401-typedarray-slice-set.ts": 3865, + "1402-buffer-encodings.ts": 2493, + "1403-buffer-fs.ts": 2658, + "1404-zlib-crypto-bytes.ts": 2380, + "1405-bytes-unions-arrays.ts": 2532, + "1406-dataview-mp4.ts": 3915, + "1407-dataview-bounds.ts": 3752, + "1408-string-indexing.ts": 3470, + "1409-typedarray-integer-loops.ts": 2071, + "1420-number-statics.ts": 3136, + "1421-number-parse-strings.ts": 2476, + "1422-date-iso.ts": 2600, + "1423-text-codec.ts": 4597, + "1424-fs-options.ts": 3300, + "1425-stdin-tty.ts": 3063, + "1426-stdin-read.ts": 2925, + "1427-fromcharcode-lastindexof.ts": 3413, + "1428-settled-await-order.ts": 2724, + "1429-promise-catch-finally.ts": 2634, + "1430-promise-race.ts": 4554, + "1431-caught-tostring.ts": 2091, + "1432-destructured-params.ts": 3338, + "1433-filter-narrow.ts": 3904, + "1434-async-never.ts": 3174, + "1435-math-spread.ts": 3092, + "1436-default-undef-param.ts": 3956, + "1437-pad-default.ts": 3383, + "1438-promise-all.ts": 6011, + "1440-interval-basics.ts": 4575, + "1441-interval-clear-cross.ts": 6244, + "1442-interval-throw.ts": 3389, + "1443-signal-handlers.ts": 6258, + "1444-exit-listeners.ts": 3211, + "1445-exit-process-exit.ts": 3320, + "1446-exit-uncaught.ts": 2360, + "1447-stdin-closed-events.ts": 2750, + "1448-stream-columns.ts": 2209, + "1450-incdec-expression.ts": 3228, + "1451-instanceof-uint8array-unknown.ts": 2957, + "1452-return-through-finally.ts": 3660, + "1453-pmap-settled.ts": 3618, + "1454-nonnull-narrow-and-fcc-bytes.ts": 3317, + "1455-lambda-union-return-adoption.ts": 2774, + "1460-console-error-warn.ts": 3320, + "1461-process-pid-getuid-kill.ts": 3247, + "1462-exec-sync.ts": 3282, + "1463-timeout-unref.ts": 3251, + "1464-env-writes.ts": 2987, + "1465-env-value.ts": 3024, + "1466-child-containers.ts": 3422, + "1467-string-match.ts": 3346, + "1468-exec-path.ts": 2301, + "1469-remove-listener.ts": 3606, + "1470-child-lifecycle.ts": 3256, + "1471-child-unref.ts": 7451, + "1472-errno-code.ts": 3295, + "1473-promisify-execfile.ts": 2595, + "1474-string-decoder.ts": 3611, + "1475-readline-closed-stdin.ts": 3112, + "1476-assign-expression.ts": 3030, + "1477-in-expressions.ts": 2996, + "1478-promise-reject.ts": 3812, + "1479-destructuring-assign.ts": 3356, + "1480-os-network-interfaces.ts": 4196, + "1481-string-case-static.ts": 3245, + "1482-spawnsync-error.ts": 3565, + "1483-array-slice.ts": 3674, + "1520-fs-wider-surface.ts": 3471, + "1520-string-split-static.ts": 2773, + "1521-fs-lstat-lock.ts": 3726, + "1521-string-trim-pad-static.ts": 3379, + "1522-parseint-static.ts": 3352, + "1522-spawnsync-options.ts": 5275, + "1523-isnan-floor-static.ts": 3491, + "1523-spawn-options.ts": 3565, + "1524-atomics-sleep-static.ts": 3559, + "1524-catch-narrowing.ts": 3222, + "1525-child-exit-signal.ts": 3428, + "1525-unknown-typeof-validation.ts": 3170, + "1526-set-spread.ts": 3383, + "1527-logical-mixed-operands.ts": 3407, + "1528-delete-records-env.ts": 3353, + "1529-class-with-statics.ts": 2988, + "1530-array-push-variadic.ts": 3122, + "1530-spread-override-completion.ts": 2849, + "1531-delete-optional-fields.ts": 3199, + "1531-process-arch-versions.ts": 3354, + "1532-array-splice-shift.ts": 2767, + "1532-union-shared-field-read.ts": 3248, + "1533-bool-equality.ts": 3299, + "1533-path-platform-namespaces.ts": 3213, + "1534-crypto-hash-chain.ts": 3265, + "1534-union-as-arm-cast.ts": 2201, + "1535-spawn-fd-stdio.ts": 3518, + "1535-union-param-defaults.ts": 2934, + "1536-destructuring-defaults.ts": 3325, + "1536-string-array-sweep.ts": 3492, + "1537-chalk-hybrid/main.ts": 2721, + "1537-os-release-spawnsync-stdio.ts": 3013, + "1538-await-promiselike-return.ts": 3514, + "1538-math-static-scalar.ts": 2646, + "1539-readonly-set-map.ts": 2440, + "1539-unknown-truthiness.ts": 3020, + "1540-os-userinfo.ts": 2759, + "1540-void-statement.ts": 3146, + "1541-fs-readdir-dirent.ts": 3308, + "1541-union-keyed-reads.ts": 2673, + "1542-map-promise-values.ts": 3263, + "1542-record-literal-into-union.ts": 3421, + "1543-rest-destructuring.ts": 2387, + "1543-set-server-handles.ts": 3383, + "1544-dyn-json-reads.ts": 4211, + "1544-string-matchall.ts": 3589, + "1545-spread-order-and-optional.ts": 3635, + "1546-union-element-reads.ts": 3551, + "1547-computed-key-fold.ts": 3124, + "1548-boolean-condition-forms.ts": 3319, "1549-array-isarray-unions.ts": 3931, - "1550-param-defaults-func-set.ts": 2398, - "1551-dyn-receiver-methods.ts": 3835, - "1552-exec-options-record.ts": 3202, - "1553-truthy-hof-predicates.ts": 3421, - "1554-caught-into-unknown.ts": 3543, - "1555-index-spread-into-declared.ts": 3633, - "1556-union-retag-width-arms.ts": 2627, - "1557-url-host.ts": 2357, - "1558-any-joins-and-dyn-validation.ts": 3196, - "1559-conditional-spread-index-merge.ts": 3131, - "1560-forof-homogeneous-tuples.ts": 3159, - "1561-forof-strings.ts": 2864, - "1561-promise-then.ts": 2385, - "1562-optional-chain-tails.ts": 3642, - "1562-spawn-conditional-spread.ts": 3319, - "1563-forof-iterator-projections.ts": 2786, - "1563-string-raw-fold.ts": 2587, - "1564-fs-watch.ts": 3261, - "1564-string-raw.ts": 2451, - "1565-spawn-pipe-streams.ts": 3391, - "1565-union-element-join.ts": 2486, - "1566-child-duck-interface.ts": 2840, - "1567-server-close-override.ts": 3237, - "1568-x509-fingerprint.ts": 3907, - "1569-fsp-mkdir-unlink-chmod.ts": 2903, - "1570-child-unref-kill-reffed.ts": 8636, - "1571-optional-call-tostring-tail.ts": 2889, - "1571-stdin-set-raw-mode-non-tty.ts": 2975, - "1572-promise-reject-all-tuple.ts": 3556, - "1572-x509-validity-date-gettime.ts": 3310, - "1573-promisify-execfile-env-spread.ts": 2814, - "1573-tdz-scalar-forward-capture.ts": 1712, - "1574-dyn-optional-method-number-keys.ts": 3878, - "1574-promise-all-tuple-literal.ts": 2253, - "1575-unknown-assert-into-record.ts": 1861, - "1576-width-coercions.ts": 2898, - "1577-url-hostname.ts": 2901, - "1578-exec-input-optional.ts": 3273, - "1579-matchall-index.ts": 3564, - "1580-exec-env-conditional-spread.ts": 2271, - "1581-declare-const-read.ts": 3037, - "1582-timer-sleep-resolve.ts": 3206, - "1583-loops-and-stream-captures.ts": 3193, - "1584-union-field-unassigned.ts": 3119, - "1585-union-field-conditional-ctor.ts": 3101, - "1586-derived-field-before-super-init.ts": 2618, - "1590-js-unannotated.js": 2053, - "1591-js-closures.js": 2387, - "1592-js-classes.js": 4973, - "1593-js-jsdoc-records.js": 3116, - "1594-js-async.js": 2589, - "1595-js-island-gap/main.js": 3108, - "1596-cjs-modules/main.js": 3096, - "1597-mjs-graph/main.mjs": 2863, - "1598-cjs-builtin-require/main.js": 2598, - "1599-js-uncaught-throw.js": 1785, - "1600-assert-passing.ts": 3203, - "1601-assert-fail-exit.ts": 2955, - "1602-assert-caught-error.ts": 2978, - "1603-assert-scalar-messages.ts": 3055, - "1604-assert-deep-structures.ts": 3591, - "1605-assert-import-forms.ts": 2429, - "1606-assert-strict-module.ts": 3039, - "1607-assert-throws-match.ts": 2826, - "1608-cjs-assert/main.js": 3263, - "1609-assert-async.ts": 3342, - "1610-path-win32-full.ts": 2405, - "1611-url-file-bridge-neutral.ts": 2476, - "1612-cjs-module-globals.cjs": 2856, - "1613-cjs-esm-proxy-named/main.mjs": 2613, - "1614-js-fence-dodges.cjs": 1967, - "1615-cjs-export-shapes/main.cjs": 2975, - "1616-cjs-esm-lexer-invisible/main.mjs": 2660, - "1617-cjs-esm-lexer-visible/main.mjs": 3090, - "1618-cjs-esm-poisoned-tail/main.mjs": 2780, - "1619-cjs-esm-reexport-invisible/main.mjs": 2185, - "1620-cjs-require-effects-order/main.js": 1410, - "1621-cjs-require-cache-hit/main.js": 2836, - "1622-cjs-require-conditional/main.js": 2564, - "1623-cjs-require-diamond/main.js": 2652, - "1624-cjs-require-dir-mid-file/main.js": 2573, - "1625-cjs-require-lazy-fn/main.js": 2246, - "1626-cjs-require-mjs/main.js": 2951, - "1627-mjs-import-cjs-requires/main.mjs": 2683, - "1628-checked-dynamic-builtin-args.cjs": 1896, - "1629-require-main-filename.cjs": 2867, - "1630-inspect-scalars.ts": 2361, - "1630-rmsync-retry-options.cjs": 2984, - "1631-inspect-arrays.ts": 3811, - "1632-inspect-records.ts": 4779, - "1633-inspect-map-set.ts": 3008, - "1634-inspect-classes.ts": 3344, - "1635-inspect-buffer.ts": 2898, - "1636-util-format.ts": 2261, - "1637-inspect-dyn.ts": 2934, - "1638-inspect-cjs.cjs": 3133, - "1639-versions-openssl-probe.ts": 2209, - "1640-fd-read-decode.ts": 3309, - "1641-string-search.ts": 2951, - "1642-object-fromentries-rows.ts": 3231, - "1643-metadata-dyn-return.cjs": 3375, - "1644-ee-basics.ts": 3158, - "1645-ee-extends.ts": 2448, - "1646-ee-once-remove.ts": 2581, - "1647-ee-meta-events.ts": 2563, - "1648-ee-error-event.ts": 2097, - "1649-ee-names-counts.ts": 2941, - "1650-ee-prepend.ts": 3190, - "1651-ee-max-listeners.ts": 2691, - "1652-ee-snapshot.ts": 2882, - "1653-ee-cjs.cjs": 2645, - "1654-ee-namespace.ts": 2314, - "1655-spawnsync-neutral.ts": 4787, - "1656-execsync-neutral.ts": 3015, - "1657-spawn-async-neutral.ts": 3128, - "1660-buffer-read-write-num.ts": 2511, - "1661-buffer-encodings-full.ts": 3466, - "1662-string-decoder-encodings.ts": 3207, - "1663-buffer-compare-search-fill.ts": 3063, - "1664-dyn-fn-boundary.cjs": 2280, - "1665-dyn-fn-mustcall/main.cjs": 2798, - "1666-dyn-fn-identity.ts": 3303, - "1667-dyn-fn-not-callable.cjs": 2431, - "1668-dyn-fn-throws.cjs": 3052, - "1669-symbol-identity.ts": 3194, - "1670-symbol-registry.ts": 2198, - "1671-symbol-typeof.ts": 2786, - "1672-symbol-containers.ts": 2209, - "1673-symbol-cjs.cjs": 2979, - "1674-symbol-inspect.ts": 2795, - "1676-func-array-surface.ts": 2945, - "1677-emitter-listeners.ts": 4548, - "1678-emitter-dyn-listeners.cjs": 3185, - "1679-console-dyn.js": 2910, - "1680-assert-bytes.ts": 3154, - "1681-assert-funcs.ts": 1828, - "1685-stream-readable-basics.ts": 2976, - "1686-stream-readable-paused.ts": 2831, - "1687-stream-readable-flow-control.ts": 2863, - "1688-stream-writable-basics.ts": 2245, - "1689-stream-writable-async-drain.ts": 1562, - "1690-stream-duplex.ts": 3124, - "1691-stream-transform.ts": 2070, - "1692-stream-pipe.ts": 2661, - "1693-stream-pipe-backpressure.ts": 2944, - "1694-stream-destroy.ts": 2243, - "1695-stream-props.ts": 2801, - "1696-stream-read-inside-read.ts": 2398, - "1697-stream-tick-vs-timer.ts": 2703, - "1698-stream-uncaught-error.ts": 2045, - "1699-stream-callback-shapes.ts": 2523, - "1700-mustcall-common/main.cjs": 3695, - "1701-mustcall-exit-report/main.cjs": 4202, - "1702-dyn-proto-dispatch.cjs": 3277, - "1703-arguments-rest-props.cjs": 2983, - "1710-cjs-export-class/main.js": 3030, - "1711-cjs-export-single-values/main.js": 2594, - "1712-field-incdec.ts": 1845, - "1713-js-dyn-fields.js": 2654, - "1720-assert-throws-shape.ts": 2898, - "1721-assert-throws-regex-class.ts": 3751, - "1722-assert-rejects.ts": 2848, - "1723-assert-does-not-reject.ts": 3358, - "1724-assert-iferror.ts": 1705, - "1725-assert-symbols.ts": 2141, - "1726-promise-with-resolvers.ts": 2575, - "1727-assert-throws-shape-exit.ts": 2905, - "1730-countdown-symbol-keys/main.js": 2273, - "1731-symbol-field-shapes.cjs": 2895, - "1732-symbol-field-cross-module/main.js": 2678, - "1740-stream-extends-readable.ts": 2983, - "1741-stream-extends-writable.ts": 2337, - "1742-stream-extends-duplex-transform.ts": 3417, - "1743-stream-extends-vt-dispatch.ts": 2520, - "1744-stream-set-encoding.ts": 3582, - "1745-stream-encoding-js.cjs": 2993, - "1746-stream-for-await.ts": 4666, - "1747-stream-for-await-js.cjs": 3552, - "1750-http-agent-options.ts": 2667, - "1751-options-record-stance.ts": 3044, - "1760-surplus-args-drop.cjs": 2775, - "1761-emitter-special-event-names.cjs": 2427, - "1770-assert-dyn-strict.ts": 3393, - "1771-assert-dyn-deep.ts": 3639, - "1772-assert-dyn-js.cjs": 2854, - "1773-assert-dyn-exit.ts": 2368, - "1780-http-res-surface.ts": 2318, - "1781-http-server-shapes.cjs": 3339, - "1790-computed-key-folds.ts": 2833, - "1791-searchparams-core.ts": 2212, - "1792-searchparams-encoding.ts": 2305, - "1793-searchparams-iteration.ts": 3412, - "1794-searchparams-url-live.ts": 2492, - "1795-dyn-handle-request.cjs": 3337, - "1796-dyn-handle-body.cjs": 3287, - "1797-dyn-handle-socket.cjs": 2497, - "1798-dyn-handle-typed-box.ts": 2870, - "1800-immediate-basics.ts": 2802, - "1801-immediate-handle.ts": 2655, - "1802-immediate-unref-exit.ts": 2450, - "1803-timeout-refresh.ts": 2797, - "1804-timers-module.ts": 2773, - "1805-timer-callback-args.ts": 2736, - "1806-timer-delay-trunc.ts": 2060, - "1810-stream-options-const-record.ts": 2542, - "1811-stream-option-value-callbacks.cjs": 2462, - "1812-stream-super-options-forwarding.cjs": 3383, - "1813-stream-finished.ts": 2720, - "1814-stream-pipeline.cjs": 3409, - "1815-stream-state-reads.cjs": 2880, - "1820-static-block-basics.ts": 1635, - "1821-static-block-order.ts": 2551, - "1822-static-block-js.js": 2387, - "1823-static-instance-method-names.ts": 1936, - "1824-for-of-destructuring-defaults.ts": 2145, - "1825-exhaustive-typeof-switch.ts": 2973, - "1826-settimeout-arguments-callback.js": 2489, - "1830-enum-numeric-basics.ts": 2207, - "1831-enum-string-const-reverse.ts": 1943, - "1832-enum-modules/main.ts": 2350, - "1835-var-basics.ts": 2804, - "1836-var-loop-capture.ts": 3197, - "1837-var-undefined-hoisting.ts": 2836, - "1838-var-modules/main.ts": 2550, - "1839-var-js/main.cjs": 2492, - "1840-jsdoc-import-type-only/main.js": 1919, - "1850-overload-basics.ts": 2640, - "1851-overload-return-narrowing.ts": 1736, - "1852-overload-class-members.ts": 2774, - "1853-overload-modules/main.ts": 2509, - "1854-ambient-declare-fn.ts": 2603, - "1855-ambient-declare-fn-uncaught.ts": 1999, - "1870-unit-type-values.ts": 2905, - "1871-empty-array-never.ts": 2516, - "1872-template-tostring-composite.ts": 1682, - "1880-json-declared-field-order.ts": 3529, - "1881-default-anon/main.ts": 2084, - "1882-default-cjs-interop/main.ts": 2606, - "1883-default-exports/main.ts": 2612, - "1890-ns-imports/main.ts": 2704, - "1891-ns-reexport/main.ts": 2129, - "1940-class-values-basics.ts": 2668, - "1941-class-values-registry.ts": 2870, - "1942-class-expressions.ts": 2682, - "1943-class-statics-expanded.ts": 2734, - "1944-class-values-modules/main.ts": 2146, - "1950-generic-fn-values.ts": 2755, - "1951-generic-classes-basics.ts": 3235, - "1952-generic-class-statics-values.ts": 2233, - "1953-generic-class-hierarchy.ts": 2990, - "1954-generic-modules/main.ts": 2377, - "1960-namespace-basics.ts": 2728, - "1961-namespace-nested.ts": 2156, - "1962-namespace-classes.ts": 2835, - "1963-namespace-aliases.ts": 2550, - "1964-namespace-type-only.ts": 2471, - "1965-namespace-ambient.ts": 2707, - "1966-namespace-modules/main.ts": 2766, - "1967-namespace-alias-typeonly.ts": 2273, - "1968-namespace-import-eq-snapshot.ts": 2594, - "1970-decorators-basics.ts": 2916, - "1971-decorators-rebinding.ts": 2369, - "1972-decorators-throwing.ts": 2667, - "1973-decorators-ambient.ts": 2709, - "1980-primitive-proto-statics.ts": 3013, - "1981-date-utc.ts": 2644, - "1982-freeze-resolve-passthrough.ts": 3023, - "1983-array-tuple-surfaces.ts": 3232, - "1990-labels-basics.ts": 2990, - "1991-for-in-loops.ts": 3611, - "1992-small-syntax.ts": 3054, - "200-strings.ts": 1903, - "2000-generic-methods-basic.ts": 2832, - "2001-generic-methods-generic-class.ts": 2741, - "2002-generic-methods-inheritance.ts": 2972, - "2003-generic-methods-object-literal.ts": 3023, - "2004-generic-methods-statics.ts": 2292, - "201-templates.ts": 2534, - "2010-generators-basics.ts": 1525, - "2011-generators-forof.ts": 2217, - "2012-generators-return-throw.ts": 3262, - "2013-generators-sent-values.ts": 2117, - "2014-generators-values.ts": 2991, - "2015-generators-yieldstar.ts": 2892, - "2016-generators-rc-stress.ts": 2942, - "2017-generators-async.ts": 1965, - "2018-generators-uncaught.ts": 2403, - "2019-generators-loops.ts": 2116, - "2020-generic-value-bindings.ts": 3355, - "2021-generic-value-binding-modules/main.ts": 2720, - "2022-width-index-capture.ts": 2258, - "2023-width-readonly.ts": 2519, - "2024-width-array-elems.ts": 2776, - "2025-width-union-compose.ts": 3243, - "2026-width-spread.ts": 1625, - "2030-width-nested.ts": 3160, - "2031-width-tuples.ts": 2019, - "2032-cjs-export-assigned-class-expression/main.cjs": 2230, - "2033-property-assigned-class-extends.cjs": 2058, - "2035-ternary-array-retag.cjs": 2602, - "2036-evolving-array-decl.cjs": 2125, - "2037-fn-decl-hoisting.cjs": 1595, - "2038-evolving-array-js.cjs": 2965, - "2040-any-bindings.ts": 3143, - "2040-mixin-heritage.ts": 3206, - "2041-any-params-returns.ts": 2996, - "2041-mixin-values.ts": 3090, - "2042-any-flow-loops.ts": 3104, - "2042-mixin-modules/main.ts": 2762, - "2043-any-dom-values.ts": 3345, - "2043-mixin-rc-stress.ts": 2605, - "2044-vtable-sibling-slots.ts": 3123, - "2045-objlit-accessors-basic.ts": 2774, - "2045-parameter-properties.ts": 3393, - "2046-abstract-classes.ts": 2184, - "2046-objlit-accessors-effects.ts": 2948, - "2047-objlit-accessors-shapes.ts": 1767, - "2047-optional-class-fields.ts": 2566, - "2050-dynamic-import-own-module/main.ts": 2384, - "2051-dynamic-import-then/main.ts": 2679, - "2052-dynamic-import-self.ts": 2722, - "2053-typeof-static-fold.ts": 2817, - "2054-destructuring-island-source.ts": 2995, - "2060-empty-tuple.ts": 2635, - "2070-computed-key-folds.ts": 2872, - "2071-integer-key-enumeration-order.ts": 3125, - "2072-expando-function-members.ts": 2341, - "2073-destructuring-assignment.ts": 2794, - "2074-island-destructuring.ts": 2364, - "2075-index-signature-runtime-keys.ts": 2866, - "2080-destructuring-defaults.ts": 1887, - "2081-destructuring-rest.ts": 3136, - "2082-destructuring-assignment.ts": 2594, - "2085-destructuring-heads-rest-params.ts": 2973, - "2087-destructuring-for-heads.ts": 2753, - "2090-index-signature-number-keys.ts": 2175, - "2091-index-signature-string-intersection.ts": 2763, - "2092-package-imports/main.ts": 2350, - "2093-timers-promises.ts": 2872, - "2094-diagnostics-channel.ts": 2689, - "2095-js-catch-unknown.js": 2633, - "2096-os-type.ts": 1968, - "2097-js-evolving-globals.js": 2880, - "210-string-methods.ts": 2798, - "2100-stream-default-hwm.ts": 2089, - "2101-dyn-param-defaults.ts": 2260, - "2102-empty-pattern-decls.ts": 1677, - "2105-computed-key-static-folds.ts": 2815, - "2106-comma-expressions.ts": 2657, - "211-string-unicode.ts": 2741, - "2110-top-object-types.ts": 2919, - "2111-json-stringify-unknown.ts": 2401, - "2112-array-at-findlast.ts": 1741, - "2113-string-index-methods.js": 1867, - "212-string-aliasing-append.ts": 2513, - "2120-package-self-import/main.ts": 2334, - "2121-esm-cycle-inert-backedge/main.ts": 2266, - "2123-ambient-import-crash/main.ts": 2890, - "2124-imports-field-wildcard/main.ts": 2153, - "2140-uri-component-codecs.ts": 2446, - "2160-dc-tracing-channel.cjs": 2881, - "2161-js-object-literal-identity.cjs": 2928, - "2162-js-dyn-destructure.cjs": 2896, - "2163-js-selfref-const.cjs": 2717, - "2164-js-then-dyn-handler.cjs": 2572, - "2165-js-throw-dyn.cjs": 2672, - "2166-cjs-getter-this/main.cjs": 2899, - "2170-island-array-exits.ts": 2722, - "2171-island-json-stringify.ts": 2071, - "2172-island-regexp-boundary.ts": 2828, - "2190-new-object-and-string-wrappers.ts": 2625, - "2191-uri-encoders.ts": 2849, - "2192-object-default-tostring.ts": 2537, - "2193-discarded-stdlib-reads.ts": 2594, - "2194-ambient-undef-chains.ts": 1718, - "2195-require-missing-package/main.mjs": 2757, - "2196-island-computed-key-chain.ts": 2575, - "2210-dyn-promise-crossing.cjs": 2319, - "2211-dc-trace-promise.cjs": 1935, - "2212-unhandled-rejection-listener.cjs": 2879, - "2213-async-local-storage.cjs": 2883, - "2214-dc-bind-store.cjs": 2240, - "2215-process-emit-warning-exit.cjs": 3330, - "2240-width-class-into-record.ts": 2571, - "2241-width-record-into-class.ts": 2500, - "2242-width-statics-into-record.ts": 1787, - "2243-width-assert-satisfies-shapes.ts": 2738, - "2250-tagged-templates.ts": 2408, - "2252-class-iterators.ts": 3611, - "2253-union-coercions.ts": 2810, - "2260-http2-constants.cjs": 2702, - "2280-builtin-namespace-destructure.cjs": 2594, - "2281-domexception-atob-btoa.cjs": 2615, - "2282-queue-microtask.cjs": 2780, - "2283-structured-clone.cjs": 3105, - "2284-regexp-constructor.cjs": 2648, - "2285-iferror-dyn.cjs": 2717, - "2286-dyn-object-walks.cjs": 3110, - "2300-dyn-record-spread-and-keyed-access.cjs": 2464, - "2301-cjs-export-table-dom-attach.cjs": 2425, - "2310-process-next-tick.ts": 2609, - "2311-next-tick-js-callbacks.js": 2450, - "2312-stream-underscore-assign.ts": 2473, - "2313-stream-underscore-assign-js.cjs": 3017, - "2314-process-introspection.ts": 3479, - "2320-await-unit.ts": 2334, - "2321-emitter-static-setmax.cjs": 2697, - "2322-dyn-array-sort.cjs": 3014, - "2323-timer-callback-returns.ts": 3852, - "2330-tls-server-runtime-options.cjs": 2565, - "2331-tls-server-options-typed.ts": 1980, - "2350-nan-global.ts": 3180, - "2351-async-methods.ts": 2138, - "2352-void-coercions.ts": 2843, - "2353-decorators-member-ambient.ts": 3089, - "2354-decorators-expression-ambient.ts": 1841, - "2360-tuple-to-array.ts": 2335, - "2361-assign-index-record.ts": 3492, - "2362-execsync-inherit.ts": 2484, - "2363-nullish-retag.ts": 2875, - "2364-in-runtime-key.ts": 2156, - "2365-dyn-into-island.ts": 2339, - "2366-string-well-formed.ts": 2760, - "2367-regexp-escape.ts": 2791, - "2368-set-methods.ts": 3237, - "2369-promise-try.ts": 2605, - "2370-group-by.ts": 3569, - "2371-iterator-helpers.ts": 3561, - "2380-buffer-module-named-import.ts": 2746, - "2381-builtin-default-imports.js": 2945, - "2382-cycle-two-decl/main.ts": 2560, - "2383-cycle-assertdoc/main.js": 3011, - "2384-cycle-mixed-bindings/main.ts": 2477, - "2385-builtin-reexport-facade/main.ts": 2948, - "2386-string-to-chars.ts": 2475, - "2387-tonumber-argv.ts": 3071, - "2388-tonumber-grammar-zoo.ts": 3157, - "2389-tonumber-unary-plus.ts": 2176, - "2390-dot-requires/main.cjs": 2329, - "2391-default-builtin-imports/main.ts": 2387, - "2392-block-guard-alias-scope.ts": 2363, - "2393-loop-exit-guard-narrow.ts": 2936, - "2394-loop-narrow-containment.ts": 2244, - "2395-while-cond-guard.ts": 2443, - "2396-born-narrowed-decl.ts": 2276, - "2397-branch-kill-merge.ts": 2681, - "2398-switch-arm-kill.ts": 3027, - "2399-reassign-kill-polarity.ts": 2662, - "240-stdout-write.ts": 1918, - "2400-kill-return-edge.ts": 2414, - "2401-kill-break-staging.ts": 2162, - "2402-labeled-break-kill.ts": 2493, - "2403-kill-continue-backedge.ts": 2457, - "2404-kill-throw-catch.ts": 1792, - "2405-sibling-arm-narrow.ts": 1781, - "2406-switch-clause-sibling-narrow.ts": 2641, - "2407-infinite-loop-seal.ts": 2308, - "2408-loop-terminality-reopen.ts": 2756, - "2409-loop-body-return-not-terminal.ts": 2759, - "2410-stacked-cases-terminality.ts": 2830, - "2411-exhaustive-switch-terminality.ts": 2112, - "2412-dowhile-guard-trailing-test.ts": 2230, - "2413-dowhile-kill-renarrow.ts": 2630, - "2414-dowhile-continue-kill.ts": 2624, - "2415-dowhile-break-trailing-test.ts": 2524, - "2416-spread-ternary-positions.ts": 2956, - "2417-ternary-local-inference.ts": 2300, - "2418-wrapped-ternary-arms.ts": 2768, - "2419-selector-ternary-union.ts": 2727, - "2420-nullish-null-identity.ts": 2533, - "2421-float-lane-inference.ts": 2620, - "2422-ieee-div-rem-corners.ts": 2629, - "2423-param-null-reassign.ts": 2622, - "2424-ternary-miss-first-narrowing.ts": 2228, - "2425-elseif-head-exit-narrow.ts": 2186, - "2426-default-snapshot-mutable/main.ts": 2520, - "2427-perf-hooks-now.ts": 2346, - "2428-field-redeclare-inherited.ts": 2882, - "2429-destructure-class-instance.ts": 2852, - "2430-empty-literal-unknown-field.js": 2190, - "2431-primitive-ctor-values.ts": 2149, - "2432-generic-member-fields-async.ts": 3225, - "2433-as-const-command-tables.ts": 3139, - "2434-deferred-init-fields.ts": 2789, - "2435-loose-same-kind-equality.ts": 2652, - "2440-console-inspect-args.ts": 3314, - "2441-console-process-argv.ts": 2095, - "2442-union-literal-arm-widening.ts": 2062, - "2443-union-literal-shadow-narrowing.ts": 2856, - "2444-union-literal-reducer-spread.ts": 2705, - "2445-math-minmax-nary.ts": 2093, - "2446-performance-global.ts": 2484, - "2447-island-boundary-slots/main.ts": 3456, - "2448-entries-null-arms-regex-arrays.ts": 2911, - "2450-private-instance-methods.ts": 2310, - "2451-private-fields.ts": 2058, - "2452-private-statics.ts": 2844, - "2453-private-accessors.ts": 2851, - "2454-private-generator-methods.ts": 2328, - "2455-private-brand-checks.ts": 2840, - "2456-private-async-methods.ts": 2932, - "2457-private-members.js": 2832, - "2460-qs-parse-grammar.ts": 2844, - "2461-qs-parse-options.ts": 2944, - "2462-qs-stringify.ts": 3219, - "2463-qs-escape-unescape.ts": 2133, - "2464-qs-require-forms.cjs": 2362, - "2470-mockable-module-shape.js": 3020, - "2471-record-keyed-write-hasown.js": 2921, - "2472-string-regexp-union.ts": 1528, - "2473-option-table-widths.js": 2792, - "2474-island-literal-forms.ts": 2730, - "2475-variadic-wrapper-island.js": 2962, - "2476-map-regex-values.ts": 1895, - "2480-recursive-record-tree.ts": 2781, - "2481-mutual-recursive-records.ts": 2829, - "2482-recursive-union-tree.ts": 2626, - "2483-recursive-record-cycles.ts": 2385, - "2484-json-stringify-circular.ts": 1936, - "2485-inspect-circular-refs.ts": 3139, - "2486-recursive-record-boundaries.ts": 3118, - "2487-recursive-deep-equal.ts": 2998, - "2488-ast-walker.ts": 3274, - "2490-find-miss-null-compare.ts": 2608, - "2491-strict-unit-compare-no-arm.ts": 2376, - "2492-loose-null-compare-unions.ts": 2805, - "2493-switch-unit-cases.ts": 2280, - "2494-no-arm-compare-effects.ts": 2159, - "2500-net-autosel-timeout.ts": 2195, - "2510-dyn-evolving-array-map.ts": 1961, - "2511-dyn-evolving-array-filter-foreach.ts": 2859, - "2512-dyn-evolving-array-mixed-push.ts": 1607, - "2520-private-statics-class-name-calls.ts": 2420, - "2521-private-statics-class-expression.ts": 1848, - "2522-private-statics-decorated.ts": 3008, - "2523-private-statics-aliased-class.ts": 2743, - "2530-object-destructuring-decl.ts": 2036, - "2531-array-tuple-destructuring-decl.ts": 2908, - "2532-param-destructuring-options.ts": 2917, - "2533-forof-destructuring.ts": 2821, - "2534-object-rest-decl.ts": 2914, - "2535-destructuring-assign-basics.ts": 2888, - "2536-destructuring-assign-nested.ts": 2697, - "2537-destructuring-assign-member-targets.ts": 1747, - "2538-destructuring-assign-class-source.ts": 2594, - "2539-class-instance-rest.ts": 2144, - "2540-accessor-destructuring-defaults.ts": 2790, - "2541-destructuring-eval-order.ts": 2901, - "2550-generics-keyof-pick.ts": 2724, - "2551-generics-value-aliases.ts": 2899, - "2552-generics-iface-methods.ts": 2924, - "2553-generics-signature-bindings.ts": 1690, - "2554-generics-frontier-mix.ts": 2607, - "2555-generics-keyof-writes.ts": 2074, - "2556-crypto-introspection.ts": 2165, - "2556-width-hybrid-shapes.ts": 1904, - "2557-tls-ca-store.ts": 3159, - "2557-width-field-lifts.ts": 3231, - "2558-index-signature-func-values.ts": 2869, - "2558-rejection-events.cjs": 1923, - "2559-index-signature-container-values.ts": 2319, - "2560-arraybuffer-dataview-set.ts": 3376, - "2561-object-is.ts": 3499, - "2562-intl-numberformat-en-us.ts": 2371, - "2563-stream-promises-pipeline.ts": 3059, - "2564-stream-promises-finished.ts": 1663, - "2565-stream-promises-js.cjs": 2464, - "2566-promise-reject-dyn-reason.js": 2041, - "2567-rest-spread-forward.js": 3238, - "2568-rest-spread-forward-dynamic.js": 2074, - "2569-upcast-identity.ts": 2471, - "2570-buffer-arg-validation.cjs": 4288, - "2571-searchparams-arg-validation.cjs": 2294, - "2572-readable-emitted-readable-flag.cjs": 2792, - "2573-fs-url-arg-ladders.cjs": 3144, - "2574-emitter-max-listeners-ladders.cjs": 2768, - "2575-string-destructuring-decl.ts": 3093, - "2576-string-destructuring-assign.ts": 1948, - "2577-builtin-global-destructuring.js": 1471, - "2578-jsval-into-unknown-rows.ts": 2895, - "2579-jsval-object-param-crossing.js": 2920, - "2580-jsval-routed-keyed-ops.js": 2793, - "2581-jsval-routed-calls.js": 2527, - "2582-jsval-object-statics.js": 3114, - "2582-jsval-routed-keyed-ops.js": 3012, - "2583-dyn-nullish-coalesce.js": 2872, - "2583-jsval-routed-calls.js": 3060, - "2584-jsval-object-statics.js": 3017, - "2584-union-dyn-collapse.ts": 3110, - "2585-dyn-nullish-coalesce.js": 3233, - "2585-unknown-array.ts": 3147, - "2586-object-assign-spread.js": 3063, - "2587-array-entries-forof.ts": 2868, - "2588-array-entries-chains.ts": 2948, - "2589-object-create-null.cjs": 2175, - "2590-object-create-dynamic.js": 2548, - "2591-ambient-generic-traps.ts": 2668, - "2592-ambient-trap-uncaught.ts": 2071, - "2593-generic-inert-bindings.ts": 2582, - "2594-nullish-generic-bindings.ts": 2649, - "2595-fs-arg-ladders.cjs": 3450, - "2596-net-arg-ladders.cjs": 3163, - "2597-dgram-send-ladders.cjs": 3471, - "2598-tls-arg-ladders.cjs": 2644, - "2599-stream-arg-ladders.cjs": 2952, - "2600-dyn-keyed-write-harness.js": 3162, - "2601-dyn-keyed-write-ops.js": 2780, - "2602-dyn-array-destructure.js": 2123, - "2603-island-keyed-write-dyn.js": 2776, - "2604-cycle-classes-mutual/main.ts": 2653, - "2605-cycle-three-module/main.ts": 2386, - "2606-dynamic-import-cycle/main.ts": 2580, - "2608-regex-named-groups.ts": 3189, - "2609-regex-named-replace.ts": 2460, - "2610-regex-named-matchall.ts": 1815, - "2611-regex-named-groups-js.cjs": 3151, - "2613-for-init-uninitialized-let.ts": 2759, - "2614-trap-binding-later-writes.ts": 1833, - "2615-nullish-field-record-binding.ts": 2522, - "2616-js-collect-probe-defers.js": 2932, - "2617-enum-static-field-import/main.ts": 2674, - "2618-ee-emit-override.ts": 2416, - "2619-ee-override-chain.ts": 2759, - "2620-ee-override-once-order.ts": 2863, - "2621-ee-override-error-throw.ts": 2669, - "2622-ee-override-filter.ts": 2972, - "2623-ee-job-queue.ts": 2457, - "2624-ee-override-js.cjs": 2851, - "2625-bytes-views.ts": 1866, - "2626-stream-event-names.ts": 3082, - "2627-stream-ticks-are-nextticks.ts": 2115, - "2628-stream-push-encodings.cjs": 2780, - "2629-stream-consumers.ts": 3333, - "2630-stream-consumers-errors.ts": 2597, - "2631-create-require/main.ts": 3215, - "2632-dyn-jsval-iterate.js": 3094, - "2633-island-promise-crossing.js": 2715, - "2634-stream-pipeline-arg-ladders.cjs": 2970, - "2635-trap-binding-unmappable-written.ts": 2644, - "2636-trap-binding-ambient-rooted-rewrite.ts": 2711, - "2637-create-require-bare/main.ts": 2926, - "2638-http-dyn-res-compat.cjs": 3551, - "2639-http-dyn-req-pause.cjs": 2114, - "2640-net-dyn-socket-compat.cjs": 3221, - "2641-http-agent-surface.cjs": 3393, - "2642-http-agent-maxsockets.cjs": 2445, - "2643-or-default-retag.ts": 2951, - "2644-http-client-url-argument.ts": 3003, - "2645-https-client-url-argument.ts": 1965, - "2646-top-level-await.ts": 1994, - "2647-top-level-await-modules/main.ts": 2883, - "2648-top-level-await-rejection.ts": 2548, - "2649-top-level-await-pending.ts": 2420, - "2650-top-level-await-self-import.ts": 2738, - "2651-top-level-await-pending-unhandled.ts": 1959, - "2652-top-level-await-dynamic/main.ts": 1976, - "2653-top-level-await-rejection-stops-loop.ts": 2530, - "2654-top-level-await-unrelated-rejection.ts": 2557, - "2655-top-level-await-cycle/main.ts": 2575, - "2656-top-level-await-cycle-order/main.ts": 2788, - "2657-top-level-await-cycle-dynamic/main.ts": 1945, - "2658-top-level-await-sync-completion/main.ts": 2486, - "2659-top-level-await-dynamic-cycle/main.ts": 2311, - "2660-top-level-await-cycle-rejection/main.ts": 1648, - "2661-top-level-await-dynamic-runtime-root/main.ts": 2615, - "2662-top-level-await-cycle-external-wait/main.ts": 2307, - "2663-top-level-await-dependency-errors/main.ts": 2145, - "2664-top-level-await-same-checkpoint-rejection.ts": 2652, - "2665-top-level-await-unhandled-listener-liveness.ts": 3003, - "2666-array-to-sorted.ts": 5347, - "2668-stored-number-array-iterator.ts": 2840, - "2669-array-copying-methods.ts": 2792, - "2670-uint8array-copy-iterate.ts": 2664, - "2671-array-copying-js.cjs": 2591, - "2672-http-request-response-callback.ts": 2953, - "2673-top-level-await-implicit-module.ts": 1743, - "2674-top-level-for-await-implicit-module.ts": 2697, - "2675-create-require-nested-esm.js": 2199, - "2675-process-self-reexec.ts": 2588, - "2676-indexed-read-strict-equality.ts": 2188, - "2676-record-clone-overrides.ts": 2426, - "2676-top-level-await-ambiguous/main.ts": 2482, - "2677-runtime-optional-closure.ts": 3477, - "2677-top-level-await-module-scope/main.ts": 2623, - "2678-date-instances.ts": 3208, - "2678-large-string-sparse-index.ts": 2981, - "2678-util-parseargs.ts": 5281, - "2679-util-parseargs-cjs.cjs": 3377, - "2680-util-parseargs-default.ts": 2722, - "2681-util-parseargs-dynamic.js": 1944, - "2682-fs-rename.ts": 3375, - "2683-filter-truthy-predicate.ts": 2838, - "2683-fs-rename-js.cjs": 1913, - "2684-filter-no-predicate-dyn.cjs": 2576, - "2684-fs-rename-abort.ts": 2742, - "2685-array-unshift-reverse.ts": 2654, - "2685-fs-write-sync.ts": 2517, - "2686-fs-file-handle.ts": 3648, - "2687-fsp-write-file-options.ts": 2384, - "2687-process-write-args.ts": 2846, - "2688-fs-stats-disk-fields.ts": 2938, - "2689-http-server-timeout-properties.ts": 3060, - "2690-https-server-timeout-option.ts": 2700, - "2691-retained-lowering-record-order.ts": 4234, - "2692-inline-record-assert-index.ts": 2826, - "2692-string-accumulation.ts": 2691, - "2693-math-constants.ts": 2761, - "2700-array-sort-complexity.ts": 2705, - "2700-http-static-trailers.ts": 2446, - "2700-wasi-core.ts": 2208, - "2701-array-sort-snapshot.ts": 2717, - "2701-http-static-trailer-wire.ts": 2689, - "2701-import-meta/main.mjs": 2846, - "2702-http-static-trailer-end.ts": 2522, - "2702-type-import-link-static/main.ts": 1984, - "2702-uint8array-to-sorted.ts": 2225, - "2703-array-sparse-sort.ts": 5044, - "2703-type-import-link-static-reexport/main.ts": 2359, - "2704-array-sparse-to-sorted.ts": 4461, - "2704-type-import-link-static-success/main.ts": 2324, - "2705-array-sparse-sort-append.ts": 5020, - "2705-type-import-link-dynamic/main.ts": 2074, - "2706-array-search-missing-needle.ts": 1941, - "2706-type-import-link-dynamic-success/main.ts": 2411, - "2707-array-search-huge-sparse.ts": 45551, - "2707-type-import-link-static-default-reexport/main.ts": 2522, - "2708-type-import-link-dynamic/main.ts": 2609, - "2720-array-read-parity.ts": 1979, - "2721-array-nested-missing-receiver.ts": 2483, - "2750-array-sparse-foundation.ts": 2217, - "2751-buffer-concat-sparse-list.ts": 2792, - "2752-array-optional-stores.ts": 2339, - "2753-array-optional-method-values.ts": 2060, - "2754-array-property-undefined.ts": 2275, - "2755-array-optional-literal-forwarding.ts": 2382, - "2780-array-parity-composition.ts": 6446, - "2781-array-missing-value-escape.ts": 1639, - "2782-array-sparse-callbacks.ts": 3365, - "2783-array-defaults-rest.ts": 2775, - "2784-array-reduce-missing-result.ts": 2916, - "2785-array-missing-destructuring.ts": 2952, - "2786-array-sparse-serialization.ts": 3296, - "2787-array-missing-string-arithmetic.ts": 2457, - "2788-array-missing-builtin-conversions.ts": 2610, - "2789-array-missing-optional-tostring.ts": 2734, - "2790-dynamic-import-self-name/main.ts": 2631, - "2791-record-optional-keys.ts": 1771, - "2792-record-optional-spread-entries.ts": 2836, - "2793-union-conversion-identity-capture.ts": 1991, - "2794-array-generic-callback-values.ts": 2454, - "2795-array-optional-typedarray-source.ts": 2778, - "2796-array-sparse-class-value-instanceof.ts": 1902, - "2800-array-expression-consumers.ts": 2537, - "2801-array-switch-consumers.ts": 2609, - "2820-array-missing-method-receivers.ts": 1866, - "2821-array-optional-numeric-comparisons.ts": 2322, - "2830-cjs-require-self-name/main.cjs": 1845, - "2840-finally-completions.ts": 2496, - "2841-using-sync.ts": 2927, - "2842-await-using.ts": 2618, - "2843-using-suppressed-error.ts": 2318, - "2844-node-disposable-resources.ts": 2824, - "2845-for-using-of.ts": 2486, - "2846-generator-using.ts": 2761, - "2850-async-generators-protocol.ts": 3258, - "2851-async-generators-values.ts": 2768, - "2852-timers-promises-interval.ts": 2398, - "2854-leading-bom-literals.ts": 1935, - "2855-searchparams-sort-complexity.ts": 2792, - "2856-dynamic-any-local-operators.ts": 2781, - "2857-branded-primitives.ts": 2351, - "2858-import-meta-resolve/main.mjs": 1967, - "2859-import-meta-resolve-dynamic/main.mjs": 1446, - "2860-require-resolve/main.cjs": 2029, - "2861-readable-iterator-close.ts": 3028, - "2862-web-readable-async-iteration.ts": 3505, - "2863-class-async-iterator.ts": 2866, - "2864-array-class-method-receivers.ts": 2760, - "2865-cjs-process-alias.cjs": 2491, - "2866-dyn-switch.ts": 1865, - "2867-array-shift-length.js": 1558, - "2868-empty-record-promise-presence.js": 2022, - "2869-nullish-mixed-lazy.ts": 2676, - "2870-and-dropped-truthy-arm.ts": 2329, - "2871-optional-promise-to-unknown.ts": 2191, - "2872-unobserved-dynamic-event.ts": 2513, - "2873-optional-receiver-loop-lifetime.js": 1923, - "2874-nullable-callback-field-cycle.js": 2614, - "2875-evolving-let-read-before-write.js": 2456, - "2876-class-unknown-roundtrip.ts": 2982, - "2877-child-unknown-roundtrip.ts": 2124, - "2878-class-private-unknown.cjs": 2900, - "2880-cjs-module-graph/main.cjs": 2229, - "2890-crypto-static-utility.ts": 3535, - "2891-json-record-key-escapes.ts": 3128, - "2892-windows-console-unicode.ts": 2483, - "2893-child-stdin-duplex.ts": 3150, - "2894-child-stdin-backpressure.ts": 2319, - "2895-child-stdin-write-after-end.ts": 3184, - "2896-child-stdin-write-after-finish.ts": 2909, - "2897-child-stdin-destroy.ts": 3007, - "2898-child-stdin-spawn-failure.ts": 2417, - "2899-nested-mutual-recursion.ts": 2782, - "2900-float64array-static.ts": 2797, - "2900-void-conditional-arrow.ts": 2455, - "2901-bigint-core.ts": 2012, - "2902-bigint-bytes.ts": 2175, - "2903-bigint-storage.ts": 2677, - "2904-bigint-errors.ts": 2992, - "2905-bigint-edges.ts": 2250, - "2906-bigint-wasi-width.ts": 2455, - "2910-overloaded-callable-alias.ts": 2480, - "2911-execfile-callback.ts": 2820, - "2912-execfile-callback-options.ts": 2673, - "2912-promisify-fs-readfile.ts": 1599, - "2913-builtin-callable-alias.ts": 2823, - "2914-fixed-tuple-call-spread.ts": 2909, - "2915-path-function-values.ts": 2957, - "2916-path-function-values-cjs.ts": 2512, - "2917-builtin-callable-widths.ts": 3024, - "2918-builtin-callable-widths-cjs.ts": 2656, - "2919-fs-function-values.ts": 3021, - "2920-fs-promises-function-values.ts": 2741, - "2921-zlib-callbacks.ts": 3153, - "2922-dyn-bitwise-not.cjs": 2708, - "2923-cjs-factory-export/main.cjs": 2093, - "2930-union-receiver-calls.ts": 2543, - "2931-union-dynamic-field-call.js": 2484, - "2932-create-require-program/main.ts": 2505, - "2933-static-dynamic-import/main.ts": 2593, - "2934-static-import-stored.ts": 2045, - "2935-module-namespace-values/main.ts": 2788, + "1550-param-defaults-func-set.ts": 3236, + "1551-dyn-receiver-methods.ts": 4427, + "1552-exec-options-record.ts": 3644, + "1553-truthy-hof-predicates.ts": 3271, + "1554-caught-into-unknown.ts": 3523, + "1555-index-spread-into-declared.ts": 4108, + "1556-union-retag-width-arms.ts": 2796, + "1557-url-host.ts": 3260, + "1558-any-joins-and-dyn-validation.ts": 2875, + "1559-conditional-spread-index-merge.ts": 2528, + "1560-forof-homogeneous-tuples.ts": 2537, + "1561-forof-strings.ts": 2246, + "1561-promise-then.ts": 3068, + "1562-optional-chain-tails.ts": 2705, + "1562-spawn-conditional-spread.ts": 3287, + "1563-forof-iterator-projections.ts": 2707, + "1563-string-raw-fold.ts": 2255, + "1564-fs-watch.ts": 3802, + "1564-string-raw.ts": 2918, + "1565-spawn-pipe-streams.ts": 3630, + "1565-union-element-join.ts": 3683, + "1566-child-duck-interface.ts": 3169, + "1567-server-close-override.ts": 2292, + "1568-x509-fingerprint.ts": 3260, + "1569-fsp-mkdir-unlink-chmod.ts": 2151, + "1570-child-unref-kill-reffed.ts": 8153, + "1571-optional-call-tostring-tail.ts": 2977, + "1571-stdin-set-raw-mode-non-tty.ts": 2223, + "1572-promise-reject-all-tuple.ts": 3566, + "1572-x509-validity-date-gettime.ts": 2517, + "1573-promisify-execfile-env-spread.ts": 3520, + "1573-tdz-scalar-forward-capture.ts": 2526, + "1574-dyn-optional-method-number-keys.ts": 3924, + "1574-promise-all-tuple-literal.ts": 2676, + "1575-unknown-assert-into-record.ts": 3519, + "1576-width-coercions.ts": 2683, + "1577-url-hostname.ts": 2337, + "1578-exec-input-optional.ts": 3059, + "1579-matchall-index.ts": 2856, + "1580-exec-env-conditional-spread.ts": 2426, + "1581-declare-const-read.ts": 3033, + "1582-timer-sleep-resolve.ts": 3454, + "1583-loops-and-stream-captures.ts": 2185, + "1584-union-field-unassigned.ts": 2354, + "1585-union-field-conditional-ctor.ts": 2702, + "1586-derived-field-before-super-init.ts": 2376, + "1590-js-unannotated.js": 2299, + "1591-js-closures.js": 3459, + "1592-js-classes.js": 3000, + "1593-js-jsdoc-records.js": 2837, + "1594-js-async.js": 3183, + "1595-js-island-gap/main.js": 3402, + "1596-cjs-modules/main.js": 2196, + "1597-mjs-graph/main.mjs": 3071, + "1598-cjs-builtin-require/main.js": 2199, + "1599-js-uncaught-throw.js": 2702, + "1600-assert-passing.ts": 3435, + "1601-assert-fail-exit.ts": 2059, + "1602-assert-caught-error.ts": 3377, + "1603-assert-scalar-messages.ts": 3468, + "1604-assert-deep-structures.ts": 3981, + "1605-assert-import-forms.ts": 3304, + "1606-assert-strict-module.ts": 3605, + "1607-assert-throws-match.ts": 2614, + "1608-cjs-assert/main.js": 3331, + "1609-assert-async.ts": 3158, + "1610-path-win32-full.ts": 3354, + "1611-url-file-bridge-neutral.ts": 2896, + "1612-cjs-module-globals.cjs": 1926, + "1613-cjs-esm-proxy-named/main.mjs": 2400, + "1614-js-fence-dodges.cjs": 2746, + "1615-cjs-export-shapes/main.cjs": 3057, + "1616-cjs-esm-lexer-invisible/main.mjs": 2969, + "1617-cjs-esm-lexer-visible/main.mjs": 3072, + "1618-cjs-esm-poisoned-tail/main.mjs": 2562, + "1619-cjs-esm-reexport-invisible/main.mjs": 2897, + "1620-cjs-require-effects-order/main.js": 3000, + "1621-cjs-require-cache-hit/main.js": 2851, + "1622-cjs-require-conditional/main.js": 3013, + "1623-cjs-require-diamond/main.js": 2407, + "1624-cjs-require-dir-mid-file/main.js": 2600, + "1625-cjs-require-lazy-fn/main.js": 2150, + "1626-cjs-require-mjs/main.js": 2871, + "1627-mjs-import-cjs-requires/main.mjs": 1644, + "1628-checked-dynamic-builtin-args.cjs": 3084, + "1629-require-main-filename.cjs": 2697, + "1630-inspect-scalars.ts": 2908, + "1630-rmsync-retry-options.cjs": 2250, + "1631-inspect-arrays.ts": 3807, + "1632-inspect-records.ts": 3072, + "1633-inspect-map-set.ts": 3749, + "1634-inspect-classes.ts": 3647, + "1635-inspect-buffer.ts": 2966, + "1636-util-format.ts": 2790, + "1637-inspect-dyn.ts": 3304, + "1638-inspect-cjs.cjs": 2542, + "1639-versions-openssl-probe.ts": 2867, + "1640-fd-read-decode.ts": 2932, + "1641-string-search.ts": 2902, + "1642-object-fromentries-rows.ts": 3493, + "1643-metadata-dyn-return.cjs": 3745, + "1644-ee-basics.ts": 2848, + "1645-ee-extends.ts": 2459, + "1646-ee-once-remove.ts": 3027, + "1647-ee-meta-events.ts": 2585, + "1648-ee-error-event.ts": 2283, + "1649-ee-names-counts.ts": 2675, + "1650-ee-prepend.ts": 2768, + "1651-ee-max-listeners.ts": 2226, + "1652-ee-snapshot.ts": 2979, + "1653-ee-cjs.cjs": 2570, + "1654-ee-namespace.ts": 2090, + "1655-spawnsync-neutral.ts": 4974, + "1656-execsync-neutral.ts": 2907, + "1657-spawn-async-neutral.ts": 3429, + "1660-buffer-read-write-num.ts": 3576, + "1661-buffer-encodings-full.ts": 3754, + "1662-string-decoder-encodings.ts": 3115, + "1663-buffer-compare-search-fill.ts": 3954, + "1664-dyn-fn-boundary.cjs": 3077, + "1665-dyn-fn-mustcall/main.cjs": 2296, + "1666-dyn-fn-identity.ts": 1815, + "1667-dyn-fn-not-callable.cjs": 3076, + "1668-dyn-fn-throws.cjs": 2849, + "1669-symbol-identity.ts": 2663, + "1670-symbol-registry.ts": 2947, + "1671-symbol-typeof.ts": 3427, + "1672-symbol-containers.ts": 2913, + "1673-symbol-cjs.cjs": 2504, + "1674-symbol-inspect.ts": 2841, + "1676-func-array-surface.ts": 3070, + "1677-emitter-listeners.ts": 3184, + "1678-emitter-dyn-listeners.cjs": 4068, + "1679-console-dyn.js": 3572, + "1680-assert-bytes.ts": 2927, + "1681-assert-funcs.ts": 3461, + "1685-stream-readable-basics.ts": 3135, + "1686-stream-readable-paused.ts": 2443, + "1687-stream-readable-flow-control.ts": 3237, + "1688-stream-writable-basics.ts": 2329, + "1689-stream-writable-async-drain.ts": 2789, + "1690-stream-duplex.ts": 2966, + "1691-stream-transform.ts": 2618, + "1692-stream-pipe.ts": 1917, + "1693-stream-pipe-backpressure.ts": 2276, + "1694-stream-destroy.ts": 3398, + "1695-stream-props.ts": 3260, + "1696-stream-read-inside-read.ts": 2732, + "1697-stream-tick-vs-timer.ts": 2767, + "1698-stream-uncaught-error.ts": 2710, + "1699-stream-callback-shapes.ts": 5108, + "1700-mustcall-common/main.cjs": 2603, + "1701-mustcall-exit-report/main.cjs": 3638, + "1702-dyn-proto-dispatch.cjs": 3719, + "1703-arguments-rest-props.cjs": 3420, + "1710-cjs-export-class/main.js": 3197, + "1711-cjs-export-single-values/main.js": 1720, + "1712-field-incdec.ts": 2250, + "1713-js-dyn-fields.js": 2301, + "1720-assert-throws-shape.ts": 3820, + "1721-assert-throws-regex-class.ts": 3123, + "1722-assert-rejects.ts": 3400, + "1723-assert-does-not-reject.ts": 2181, + "1724-assert-iferror.ts": 2290, + "1725-assert-symbols.ts": 2728, + "1726-promise-with-resolvers.ts": 3835, + "1727-assert-throws-shape-exit.ts": 2906, + "1730-countdown-symbol-keys/main.js": 3476, + "1731-symbol-field-shapes.cjs": 2330, + "1732-symbol-field-cross-module/main.js": 2189, + "1740-stream-extends-readable.ts": 2897, + "1741-stream-extends-writable.ts": 2368, + "1742-stream-extends-duplex-transform.ts": 2283, + "1743-stream-extends-vt-dispatch.ts": 3339, + "1744-stream-set-encoding.ts": 3916, + "1745-stream-encoding-js.cjs": 2742, + "1746-stream-for-await.ts": 3433, + "1747-stream-for-await-js.cjs": 2649, + "1750-http-agent-options.ts": 3028, + "1751-options-record-stance.ts": 3136, + "1760-surplus-args-drop.cjs": 2857, + "1761-emitter-special-event-names.cjs": 2907, + "1770-assert-dyn-strict.ts": 2622, + "1771-assert-dyn-deep.ts": 3046, + "1772-assert-dyn-js.cjs": 2864, + "1773-assert-dyn-exit.ts": 3097, + "1780-http-res-surface.ts": 3598, + "1781-http-server-shapes.cjs": 3736, + "1790-computed-key-folds.ts": 2845, + "1791-searchparams-core.ts": 3126, + "1792-searchparams-encoding.ts": 2170, + "1793-searchparams-iteration.ts": 2956, + "1794-searchparams-url-live.ts": 2603, + "1795-dyn-handle-request.cjs": 2396, + "1796-dyn-handle-body.cjs": 3535, + "1797-dyn-handle-socket.cjs": 3460, + "1798-dyn-handle-typed-box.ts": 2566, + "1800-immediate-basics.ts": 2566, + "1801-immediate-handle.ts": 2028, + "1802-immediate-unref-exit.ts": 3806, + "1803-timeout-refresh.ts": 2342, + "1804-timers-module.ts": 2401, + "1805-timer-callback-args.ts": 2781, + "1806-timer-delay-trunc.ts": 2824, + "1810-stream-options-const-record.ts": 2399, + "1811-stream-option-value-callbacks.cjs": 2961, + "1812-stream-super-options-forwarding.cjs": 3737, + "1813-stream-finished.ts": 3060, + "1814-stream-pipeline.cjs": 3701, + "1815-stream-state-reads.cjs": 2427, + "1820-static-block-basics.ts": 2518, + "1821-static-block-order.ts": 1976, + "1822-static-block-js.js": 3002, + "1823-static-instance-method-names.ts": 2691, + "1824-for-of-destructuring-defaults.ts": 2461, + "1825-exhaustive-typeof-switch.ts": 2514, + "1826-settimeout-arguments-callback.js": 2251, + "1830-enum-numeric-basics.ts": 2064, + "1831-enum-string-const-reverse.ts": 2264, + "1832-enum-modules/main.ts": 1833, + "1835-var-basics.ts": 2710, + "1836-var-loop-capture.ts": 3374, + "1837-var-undefined-hoisting.ts": 2917, + "1838-var-modules/main.ts": 2984, + "1839-var-js/main.cjs": 2891, + "1840-jsdoc-import-type-only/main.js": 1993, + "1850-overload-basics.ts": 2300, + "1851-overload-return-narrowing.ts": 2471, + "1852-overload-class-members.ts": 3006, + "1853-overload-modules/main.ts": 2503, + "1854-ambient-declare-fn.ts": 2630, + "1855-ambient-declare-fn-uncaught.ts": 3114, + "1870-unit-type-values.ts": 3109, + "1871-empty-array-never.ts": 2887, + "1872-template-tostring-composite.ts": 3584, + "1880-json-declared-field-order.ts": 3331, + "1881-default-anon/main.ts": 2353, + "1882-default-cjs-interop/main.ts": 2739, + "1883-default-exports/main.ts": 2650, + "1890-ns-imports/main.ts": 2779, + "1891-ns-reexport/main.ts": 2711, + "1940-class-values-basics.ts": 2460, + "1941-class-values-registry.ts": 3025, + "1942-class-expressions.ts": 2872, + "1943-class-statics-expanded.ts": 2580, + "1944-class-values-modules/main.ts": 2749, + "1950-generic-fn-values.ts": 2970, + "1951-generic-classes-basics.ts": 2980, + "1952-generic-class-statics-values.ts": 3062, + "1953-generic-class-hierarchy.ts": 2835, + "1954-generic-modules/main.ts": 1880, + "1960-namespace-basics.ts": 2265, + "1961-namespace-nested.ts": 2468, + "1962-namespace-classes.ts": 2516, + "1963-namespace-aliases.ts": 2375, + "1964-namespace-type-only.ts": 2816, + "1965-namespace-ambient.ts": 2803, + "1966-namespace-modules/main.ts": 3021, + "1967-namespace-alias-typeonly.ts": 2847, + "1968-namespace-import-eq-snapshot.ts": 2494, + "1970-decorators-basics.ts": 2822, + "1971-decorators-rebinding.ts": 2744, + "1972-decorators-throwing.ts": 2170, + "1973-decorators-ambient.ts": 2056, + "1980-primitive-proto-statics.ts": 2953, + "1981-date-utc.ts": 3276, + "1982-freeze-resolve-passthrough.ts": 2464, + "1983-array-tuple-surfaces.ts": 2644, + "1990-labels-basics.ts": 2635, + "1991-for-in-loops.ts": 3295, + "1992-small-syntax.ts": 3144, + "200-strings.ts": 2045, + "2000-generic-methods-basic.ts": 2851, + "2001-generic-methods-generic-class.ts": 2303, + "2002-generic-methods-inheritance.ts": 2257, + "2003-generic-methods-object-literal.ts": 3223, + "2004-generic-methods-statics.ts": 2748, + "201-templates.ts": 2400, + "2010-generators-basics.ts": 2273, + "2011-generators-forof.ts": 2704, + "2012-generators-return-throw.ts": 3247, + "2013-generators-sent-values.ts": 2662, + "2014-generators-values.ts": 3279, + "2015-generators-yieldstar.ts": 2320, + "2016-generators-rc-stress.ts": 2649, + "2017-generators-async.ts": 1806, + "2018-generators-uncaught.ts": 2418, + "2019-generators-loops.ts": 2694, + "2020-generic-value-bindings.ts": 3269, + "2021-generic-value-binding-modules/main.ts": 2143, + "2022-width-index-capture.ts": 3286, + "2023-width-readonly.ts": 2938, + "2024-width-array-elems.ts": 3159, + "2025-width-union-compose.ts": 3090, + "2026-width-spread.ts": 2628, + "2030-width-nested.ts": 3229, + "2031-width-tuples.ts": 2339, + "2032-cjs-export-assigned-class-expression/main.cjs": 2543, + "2033-property-assigned-class-extends.cjs": 1959, + "2035-ternary-array-retag.cjs": 2840, + "2036-evolving-array-decl.cjs": 2905, + "2037-fn-decl-hoisting.cjs": 2710, + "2038-evolving-array-js.cjs": 2879, + "2040-any-bindings.ts": 1964, + "2040-mixin-heritage.ts": 3294, + "2041-any-params-returns.ts": 2494, + "2041-mixin-values.ts": 3171, + "2042-any-flow-loops.ts": 2765, + "2042-mixin-modules/main.ts": 2821, + "2043-any-dom-values.ts": 1989, + "2043-mixin-rc-stress.ts": 2763, + "2044-vtable-sibling-slots.ts": 3156, + "2045-objlit-accessors-basic.ts": 2839, + "2045-parameter-properties.ts": 2262, + "2046-abstract-classes.ts": 2943, + "2046-objlit-accessors-effects.ts": 3238, + "2047-objlit-accessors-shapes.ts": 2962, + "2047-optional-class-fields.ts": 2352, + "2050-dynamic-import-own-module/main.ts": 2258, + "2051-dynamic-import-then/main.ts": 2628, + "2052-dynamic-import-self.ts": 2111, + "2053-typeof-static-fold.ts": 2331, + "2054-destructuring-island-source.ts": 2721, + "2060-empty-tuple.ts": 2638, + "2070-computed-key-folds.ts": 2482, + "2071-integer-key-enumeration-order.ts": 1999, + "2072-expando-function-members.ts": 2249, + "2073-destructuring-assignment.ts": 3060, + "2074-island-destructuring.ts": 3490, + "2075-index-signature-runtime-keys.ts": 3003, + "2080-destructuring-defaults.ts": 2782, + "2081-destructuring-rest.ts": 2626, + "2082-destructuring-assignment.ts": 2395, + "2085-destructuring-heads-rest-params.ts": 3137, + "2087-destructuring-for-heads.ts": 1934, + "2090-index-signature-number-keys.ts": 3257, + "2091-index-signature-string-intersection.ts": 2929, + "2092-package-imports/main.ts": 2114, + "2093-timers-promises.ts": 2678, + "2094-diagnostics-channel.ts": 3068, + "2095-js-catch-unknown.js": 2369, + "2096-os-type.ts": 2451, + "2097-js-evolving-globals.js": 2097, + "210-string-methods.ts": 2359, + "2100-stream-default-hwm.ts": 3022, + "2101-dyn-param-defaults.ts": 3172, + "2102-empty-pattern-decls.ts": 2881, + "2105-computed-key-static-folds.ts": 2838, + "2106-comma-expressions.ts": 1834, + "211-string-unicode.ts": 2972, + "2110-top-object-types.ts": 2238, + "2111-json-stringify-unknown.ts": 3135, + "2112-array-at-findlast.ts": 3283, + "2113-string-index-methods.js": 2879, + "212-string-aliasing-append.ts": 2677, + "2120-package-self-import/main.ts": 2837, + "2121-esm-cycle-inert-backedge/main.ts": 2507, + "2123-ambient-import-crash/main.ts": 2934, + "2124-imports-field-wildcard/main.ts": 2541, + "2140-uri-component-codecs.ts": 2133, + "2160-dc-tracing-channel.cjs": 2230, + "2161-js-object-literal-identity.cjs": 2537, + "2162-js-dyn-destructure.cjs": 2853, + "2163-js-selfref-const.cjs": 2693, + "2164-js-then-dyn-handler.cjs": 3004, + "2165-js-throw-dyn.cjs": 2225, + "2166-cjs-getter-this/main.cjs": 2804, + "2170-island-array-exits.ts": 2101, + "2171-island-json-stringify.ts": 2821, + "2172-island-regexp-boundary.ts": 2351, + "2190-new-object-and-string-wrappers.ts": 1908, + "2191-uri-encoders.ts": 3002, + "2192-object-default-tostring.ts": 2457, + "2193-discarded-stdlib-reads.ts": 2611, + "2194-ambient-undef-chains.ts": 1952, + "2195-require-missing-package/main.mjs": 3141, + "2196-island-computed-key-chain.ts": 2827, + "2210-dyn-promise-crossing.cjs": 3139, + "2211-dc-trace-promise.cjs": 2409, + "2212-unhandled-rejection-listener.cjs": 3057, + "2213-async-local-storage.cjs": 3299, + "2214-dc-bind-store.cjs": 3410, + "2215-process-emit-warning-exit.cjs": 3115, + "2240-width-class-into-record.ts": 2461, + "2241-width-record-into-class.ts": 2711, + "2242-width-statics-into-record.ts": 2854, + "2243-width-assert-satisfies-shapes.ts": 2928, + "2250-tagged-templates.ts": 2744, + "2252-class-iterators.ts": 3258, + "2253-union-coercions.ts": 3096, + "2260-http2-constants.cjs": 2383, + "2280-builtin-namespace-destructure.cjs": 2801, + "2281-domexception-atob-btoa.cjs": 2886, + "2282-queue-microtask.cjs": 2614, + "2283-structured-clone.cjs": 3700, + "2284-regexp-constructor.cjs": 2429, + "2285-iferror-dyn.cjs": 2807, + "2286-dyn-object-walks.cjs": 2926, + "2300-dyn-record-spread-and-keyed-access.cjs": 2890, + "2301-cjs-export-table-dom-attach.cjs": 2512, + "2310-process-next-tick.ts": 3216, + "2311-next-tick-js-callbacks.js": 2966, + "2312-stream-underscore-assign.ts": 3290, + "2313-stream-underscore-assign-js.cjs": 2122, + "2314-process-introspection.ts": 2917, + "2320-await-unit.ts": 2292, + "2321-emitter-static-setmax.cjs": 2256, + "2322-dyn-array-sort.cjs": 2432, + "2323-timer-callback-returns.ts": 2842, + "2330-tls-server-runtime-options.cjs": 2815, + "2331-tls-server-options-typed.ts": 3087, + "2350-nan-global.ts": 3034, + "2351-async-methods.ts": 2783, + "2352-void-coercions.ts": 3060, + "2353-decorators-member-ambient.ts": 2052, + "2354-decorators-expression-ambient.ts": 1987, + "2360-tuple-to-array.ts": 3001, + "2361-assign-index-record.ts": 2918, + "2362-execsync-inherit.ts": 2884, + "2363-nullish-retag.ts": 3048, + "2364-in-runtime-key.ts": 2311, + "2365-dyn-into-island.ts": 2070, + "2366-string-well-formed.ts": 2331, + "2367-regexp-escape.ts": 3110, + "2368-set-methods.ts": 2456, + "2369-promise-try.ts": 2986, + "2370-group-by.ts": 3578, + "2371-iterator-helpers.ts": 4030, + "2380-buffer-module-named-import.ts": 2871, + "2381-builtin-default-imports.js": 2605, + "2382-cycle-two-decl/main.ts": 2659, + "2383-cycle-assertdoc/main.js": 2644, + "2384-cycle-mixed-bindings/main.ts": 2274, + "2385-builtin-reexport-facade/main.ts": 2047, + "2386-string-to-chars.ts": 2950, + "2387-tonumber-argv.ts": 2189, + "2388-tonumber-grammar-zoo.ts": 2227, + "2389-tonumber-unary-plus.ts": 2546, + "2390-dot-requires/main.cjs": 2258, + "2391-default-builtin-imports/main.ts": 3224, + "2392-block-guard-alias-scope.ts": 2115, + "2393-loop-exit-guard-narrow.ts": 2686, + "2394-loop-narrow-containment.ts": 2464, + "2395-while-cond-guard.ts": 2793, + "2396-born-narrowed-decl.ts": 2989, + "2397-branch-kill-merge.ts": 2557, + "2398-switch-arm-kill.ts": 2776, + "2399-reassign-kill-polarity.ts": 2005, + "240-stdout-write.ts": 2170, + "2400-kill-return-edge.ts": 2417, + "2401-kill-break-staging.ts": 2710, + "2402-labeled-break-kill.ts": 2048, + "2403-kill-continue-backedge.ts": 2629, + "2404-kill-throw-catch.ts": 1738, + "2405-sibling-arm-narrow.ts": 2542, + "2406-switch-clause-sibling-narrow.ts": 1729, + "2407-infinite-loop-seal.ts": 2732, + "2408-loop-terminality-reopen.ts": 2758, + "2409-loop-body-return-not-terminal.ts": 2649, + "2410-stacked-cases-terminality.ts": 2587, + "2411-exhaustive-switch-terminality.ts": 2117, + "2412-dowhile-guard-trailing-test.ts": 2829, + "2413-dowhile-kill-renarrow.ts": 2634, + "2414-dowhile-continue-kill.ts": 2056, + "2415-dowhile-break-trailing-test.ts": 2838, + "2416-spread-ternary-positions.ts": 2794, + "2417-ternary-local-inference.ts": 1836, + "2418-wrapped-ternary-arms.ts": 2376, + "2419-selector-ternary-union.ts": 1886, + "2420-nullish-null-identity.ts": 2382, + "2421-float-lane-inference.ts": 2567, + "2422-ieee-div-rem-corners.ts": 2214, + "2423-param-null-reassign.ts": 2589, + "2424-ternary-miss-first-narrowing.ts": 2704, + "2425-elseif-head-exit-narrow.ts": 2085, + "2426-default-snapshot-mutable/main.ts": 2501, + "2427-perf-hooks-now.ts": 2322, + "2428-field-redeclare-inherited.ts": 2811, + "2429-destructure-class-instance.ts": 2113, + "2430-empty-literal-unknown-field.js": 2775, + "2431-primitive-ctor-values.ts": 2709, + "2432-generic-member-fields-async.ts": 3359, + "2433-as-const-command-tables.ts": 3152, + "2434-deferred-init-fields.ts": 2675, + "2435-loose-same-kind-equality.ts": 2929, + "2440-console-inspect-args.ts": 3616, + "2441-console-process-argv.ts": 2729, + "2442-union-literal-arm-widening.ts": 2394, + "2443-union-literal-shadow-narrowing.ts": 2878, + "2444-union-literal-reducer-spread.ts": 2611, + "2445-math-minmax-nary.ts": 2928, + "2446-performance-global.ts": 1959, + "2447-island-boundary-slots/main.ts": 3526, + "2448-entries-null-arms-regex-arrays.ts": 3606, + "2450-private-instance-methods.ts": 3040, + "2451-private-fields.ts": 2458, + "2452-private-statics.ts": 2875, + "2453-private-accessors.ts": 2477, + "2454-private-generator-methods.ts": 3086, + "2455-private-brand-checks.ts": 2830, + "2456-private-async-methods.ts": 3027, + "2457-private-members.js": 2823, + "2460-qs-parse-grammar.ts": 2369, + "2461-qs-parse-options.ts": 2633, + "2462-qs-stringify.ts": 2904, + "2463-qs-escape-unescape.ts": 2627, + "2464-qs-require-forms.cjs": 2308, + "2470-mockable-module-shape.js": 3113, + "2471-record-keyed-write-hasown.js": 3326, + "2472-string-regexp-union.ts": 2731, + "2473-option-table-widths.js": 3152, + "2474-island-literal-forms.ts": 2479, + "2475-variadic-wrapper-island.js": 3198, + "2476-map-regex-values.ts": 2520, + "2480-recursive-record-tree.ts": 2079, + "2481-mutual-recursive-records.ts": 2753, + "2482-recursive-union-tree.ts": 2627, + "2483-recursive-record-cycles.ts": 3056, + "2484-json-stringify-circular.ts": 3122, + "2485-inspect-circular-refs.ts": 2852, + "2486-recursive-record-boundaries.ts": 3348, + "2487-recursive-deep-equal.ts": 2661, + "2488-ast-walker.ts": 3060, + "2490-find-miss-null-compare.ts": 1733, + "2491-strict-unit-compare-no-arm.ts": 2221, + "2492-loose-null-compare-unions.ts": 2888, + "2493-switch-unit-cases.ts": 2663, + "2494-no-arm-compare-effects.ts": 2604, + "2500-net-autosel-timeout.ts": 2518, + "2510-dyn-evolving-array-map.ts": 2547, + "2511-dyn-evolving-array-filter-foreach.ts": 2095, + "2512-dyn-evolving-array-mixed-push.ts": 1858, + "2520-private-statics-class-name-calls.ts": 2236, + "2521-private-statics-class-expression.ts": 2886, + "2522-private-statics-decorated.ts": 2242, + "2523-private-statics-aliased-class.ts": 2547, + "2530-object-destructuring-decl.ts": 2810, + "2531-array-tuple-destructuring-decl.ts": 2637, + "2532-param-destructuring-options.ts": 1880, + "2533-forof-destructuring.ts": 2933, + "2534-object-rest-decl.ts": 2924, + "2535-destructuring-assign-basics.ts": 2850, + "2536-destructuring-assign-nested.ts": 3192, + "2537-destructuring-assign-member-targets.ts": 2938, + "2538-destructuring-assign-class-source.ts": 2800, + "2539-class-instance-rest.ts": 3105, + "2540-accessor-destructuring-defaults.ts": 2832, + "2541-destructuring-eval-order.ts": 2813, + "2550-generics-keyof-pick.ts": 2927, + "2551-generics-value-aliases.ts": 2674, + "2552-generics-iface-methods.ts": 2402, + "2553-generics-signature-bindings.ts": 3014, + "2554-generics-frontier-mix.ts": 2966, + "2555-generics-keyof-writes.ts": 2779, + "2556-crypto-introspection.ts": 3064, + "2556-width-hybrid-shapes.ts": 1985, + "2557-tls-ca-store.ts": 3012, + "2557-width-field-lifts.ts": 3351, + "2558-index-signature-func-values.ts": 3392, + "2558-rejection-events.cjs": 2929, + "2559-index-signature-container-values.ts": 3437, + "2560-arraybuffer-dataview-set.ts": 3189, + "2561-object-is.ts": 2016, + "2562-intl-numberformat-en-us.ts": 2324, + "2563-stream-promises-pipeline.ts": 2778, + "2564-stream-promises-finished.ts": 2282, + "2565-stream-promises-js.cjs": 2174, + "2566-promise-reject-dyn-reason.js": 2837, + "2567-rest-spread-forward.js": 3053, + "2568-rest-spread-forward-dynamic.js": 3336, + "2569-upcast-identity.ts": 2549, + "2570-buffer-arg-validation.cjs": 3495, + "2571-searchparams-arg-validation.cjs": 3289, + "2572-readable-emitted-readable-flag.cjs": 2702, + "2573-fs-url-arg-ladders.cjs": 2908, + "2574-emitter-max-listeners-ladders.cjs": 2125, + "2575-string-destructuring-decl.ts": 3056, + "2576-string-destructuring-assign.ts": 2769, + "2577-builtin-global-destructuring.js": 2592, + "2578-jsval-into-unknown-rows.ts": 3507, + "2579-jsval-object-param-crossing.js": 2689, + "2580-jsval-routed-keyed-ops.js": 3049, + "2581-jsval-routed-calls.js": 2613, + "2582-jsval-object-statics.js": 3028, + "2582-jsval-routed-keyed-ops.js": 2927, + "2583-dyn-nullish-coalesce.js": 2319, + "2583-jsval-routed-calls.js": 3227, + "2584-jsval-object-statics.js": 2921, + "2584-union-dyn-collapse.ts": 2532, + "2585-dyn-nullish-coalesce.js": 3154, + "2585-unknown-array.ts": 3043, + "2586-object-assign-spread.js": 3635, + "2587-array-entries-forof.ts": 2696, + "2588-array-entries-chains.ts": 2632, + "2589-object-create-null.cjs": 3471, + "2590-object-create-dynamic.js": 2856, + "2591-ambient-generic-traps.ts": 2325, + "2592-ambient-trap-uncaught.ts": 2711, + "2593-generic-inert-bindings.ts": 2516, + "2594-nullish-generic-bindings.ts": 2446, + "2595-fs-arg-ladders.cjs": 3442, + "2596-net-arg-ladders.cjs": 3131, + "2597-dgram-send-ladders.cjs": 3331, + "2598-tls-arg-ladders.cjs": 3733, + "2599-stream-arg-ladders.cjs": 2976, + "2600-dyn-keyed-write-harness.js": 3406, + "2601-dyn-keyed-write-ops.js": 2727, + "2602-dyn-array-destructure.js": 2959, + "2603-island-keyed-write-dyn.js": 2708, + "2604-cycle-classes-mutual/main.ts": 2723, + "2605-cycle-three-module/main.ts": 1625, + "2606-dynamic-import-cycle/main.ts": 2126, + "2608-regex-named-groups.ts": 2860, + "2609-regex-named-replace.ts": 2148, + "2610-regex-named-matchall.ts": 2297, + "2611-regex-named-groups-js.cjs": 2862, + "2613-for-init-uninitialized-let.ts": 2631, + "2614-trap-binding-later-writes.ts": 2032, + "2615-nullish-field-record-binding.ts": 2520, + "2616-js-collect-probe-defers.js": 2218, + "2617-enum-static-field-import/main.ts": 2916, + "2618-ee-emit-override.ts": 2896, + "2619-ee-override-chain.ts": 2889, + "2620-ee-override-once-order.ts": 2166, + "2621-ee-override-error-throw.ts": 2609, + "2622-ee-override-filter.ts": 3169, + "2623-ee-job-queue.ts": 3061, + "2624-ee-override-js.cjs": 2641, + "2625-bytes-views.ts": 2414, + "2626-stream-event-names.ts": 3336, + "2627-stream-ticks-are-nextticks.ts": 2921, + "2628-stream-push-encodings.cjs": 2936, + "2629-stream-consumers.ts": 2548, + "2630-stream-consumers-errors.ts": 2549, + "2631-create-require/main.ts": 3179, + "2632-dyn-jsval-iterate.js": 2810, + "2633-island-promise-crossing.js": 3789, + "2634-stream-pipeline-arg-ladders.cjs": 3204, + "2635-trap-binding-unmappable-written.ts": 2573, + "2636-trap-binding-ambient-rooted-rewrite.ts": 2836, + "2637-create-require-bare/main.ts": 3077, + "2638-http-dyn-res-compat.cjs": 3513, + "2639-http-dyn-req-pause.cjs": 3242, + "2640-net-dyn-socket-compat.cjs": 3276, + "2641-http-agent-surface.cjs": 2546, + "2642-http-agent-maxsockets.cjs": 2399, + "2643-or-default-retag.ts": 2038, + "2644-http-client-url-argument.ts": 3141, + "2645-https-client-url-argument.ts": 3327, + "2646-top-level-await.ts": 1674, + "2647-top-level-await-modules/main.ts": 2735, + "2648-top-level-await-rejection.ts": 2839, + "2649-top-level-await-pending.ts": 2632, + "2650-top-level-await-self-import.ts": 2130, + "2651-top-level-await-pending-unhandled.ts": 2661, + "2652-top-level-await-dynamic/main.ts": 2738, + "2653-top-level-await-rejection-stops-loop.ts": 2112, + "2654-top-level-await-unrelated-rejection.ts": 2041, + "2655-top-level-await-cycle/main.ts": 1850, + "2656-top-level-await-cycle-order/main.ts": 2731, + "2657-top-level-await-cycle-dynamic/main.ts": 2538, + "2658-top-level-await-sync-completion/main.ts": 2977, + "2659-top-level-await-dynamic-cycle/main.ts": 2760, + "2660-top-level-await-cycle-rejection/main.ts": 2805, + "2661-top-level-await-dynamic-runtime-root/main.ts": 2535, + "2662-top-level-await-cycle-external-wait/main.ts": 2399, + "2663-top-level-await-dependency-errors/main.ts": 2147, + "2664-top-level-await-same-checkpoint-rejection.ts": 2912, + "2665-top-level-await-unhandled-listener-liveness.ts": 2595, + "2666-array-to-sorted.ts": 5539, + "2668-stored-number-array-iterator.ts": 3042, + "2669-array-copying-methods.ts": 2580, + "2670-uint8array-copy-iterate.ts": 3366, + "2671-array-copying-js.cjs": 2250, + "2672-http-request-response-callback.ts": 2816, + "2673-top-level-await-implicit-module.ts": 2785, + "2674-top-level-for-await-implicit-module.ts": 1961, + "2675-create-require-nested-esm.js": 2652, + "2675-process-self-reexec.ts": 2948, + "2676-indexed-read-strict-equality.ts": 2688, + "2676-record-clone-overrides.ts": 2029, + "2676-top-level-await-ambiguous/main.ts": 2537, + "2677-runtime-optional-closure.ts": 3484, + "2677-top-level-await-module-scope/main.ts": 2041, + "2678-date-instances.ts": 2275, + "2678-large-string-sparse-index.ts": 2301, + "2678-util-parseargs.ts": 5332, + "2679-util-parseargs-cjs.cjs": 2235, + "2680-util-parseargs-default.ts": 2688, + "2681-util-parseargs-dynamic.js": 3031, + "2682-fs-rename.ts": 3590, + "2683-filter-truthy-predicate.ts": 3261, + "2683-fs-rename-js.cjs": 2894, + "2684-filter-no-predicate-dyn.cjs": 2218, + "2684-fs-rename-abort.ts": 2755, + "2685-array-unshift-reverse.ts": 2996, + "2685-fs-write-sync.ts": 3069, + "2686-fs-file-handle.ts": 4210, + "2687-fsp-write-file-options.ts": 2069, + "2687-process-write-args.ts": 2527, + "2688-fs-stats-disk-fields.ts": 2259, + "2689-http-server-timeout-properties.ts": 2541, + "2690-https-server-timeout-option.ts": 1835, + "2691-retained-lowering-record-order.ts": 3261, + "2692-inline-record-assert-index.ts": 2994, + "2692-string-accumulation.ts": 2802, + "2693-math-constants.ts": 2159, + "2700-array-sort-complexity.ts": 3020, + "2700-http-static-trailers.ts": 2315, + "2700-wasi-core.ts": 2595, + "2701-array-sort-snapshot.ts": 2502, + "2701-http-static-trailer-wire.ts": 2176, + "2701-import-meta/main.mjs": 3392, + "2702-http-static-trailer-end.ts": 2071, + "2702-type-import-link-static/main.ts": 2443, + "2702-uint8array-to-sorted.ts": 2965, + "2703-array-sparse-sort.ts": 3909, + "2703-type-import-link-static-reexport/main.ts": 2704, + "2704-array-sparse-to-sorted.ts": 3697, + "2704-type-import-link-static-success/main.ts": 2487, + "2705-array-sparse-sort-append.ts": 4843, + "2705-type-import-link-dynamic/main.ts": 2701, + "2706-array-search-missing-needle.ts": 2539, + "2706-type-import-link-dynamic-success/main.ts": 2462, + "2707-array-search-huge-sparse.ts": 45317, + "2707-type-import-link-static-default-reexport/main.ts": 2670, + "2708-type-import-link-dynamic/main.ts": 2350, + "2720-array-read-parity.ts": 1959, + "2721-array-nested-missing-receiver.ts": 2561, + "2750-array-sparse-foundation.ts": 2117, + "2751-buffer-concat-sparse-list.ts": 1676, + "2752-array-optional-stores.ts": 2649, + "2753-array-optional-method-values.ts": 2199, + "2754-array-property-undefined.ts": 2439, + "2755-array-optional-literal-forwarding.ts": 2745, + "2780-array-parity-composition.ts": 7200, + "2781-array-missing-value-escape.ts": 2902, + "2782-array-sparse-callbacks.ts": 3115, + "2783-array-defaults-rest.ts": 2837, + "2784-array-reduce-missing-result.ts": 2800, + "2785-array-missing-destructuring.ts": 3065, + "2786-array-sparse-serialization.ts": 2409, + "2787-array-missing-string-arithmetic.ts": 2854, + "2788-array-missing-builtin-conversions.ts": 2132, + "2789-array-missing-optional-tostring.ts": 1804, + "2790-dynamic-import-self-name/main.ts": 2534, + "2791-record-optional-keys.ts": 2401, + "2792-record-optional-spread-entries.ts": 2956, + "2793-union-conversion-identity-capture.ts": 3189, + "2794-array-generic-callback-values.ts": 2738, + "2795-array-optional-typedarray-source.ts": 3311, + "2796-array-sparse-class-value-instanceof.ts": 2925, + "2800-array-expression-consumers.ts": 2649, + "2801-array-switch-consumers.ts": 2865, + "2820-array-missing-method-receivers.ts": 1887, + "2821-array-optional-numeric-comparisons.ts": 2197, + "2830-cjs-require-self-name/main.cjs": 2632, + "2840-finally-completions.ts": 3271, + "2841-using-sync.ts": 2134, + "2842-await-using.ts": 1855, + "2843-using-suppressed-error.ts": 1631, + "2844-node-disposable-resources.ts": 2377, + "2845-for-using-of.ts": 2775, + "2846-generator-using.ts": 2854, + "2850-async-generators-protocol.ts": 2671, + "2851-async-generators-values.ts": 2378, + "2852-timers-promises-interval.ts": 2688, + "2854-leading-bom-literals.ts": 2637, + "2855-searchparams-sort-complexity.ts": 1784, + "2856-dynamic-any-local-operators.ts": 2953, + "2857-branded-primitives.ts": 2640, + "2858-import-meta-resolve/main.mjs": 2725, + "2859-import-meta-resolve-dynamic/main.mjs": 1820, + "2860-require-resolve/main.cjs": 2780, + "2861-readable-iterator-close.ts": 3397, + "2862-web-readable-async-iteration.ts": 3414, + "2863-class-async-iterator.ts": 2684, + "2864-array-class-method-receivers.ts": 2886, + "2865-cjs-process-alias.cjs": 2940, + "2866-dyn-switch.ts": 2042, + "2867-array-shift-length.js": 1841, + "2868-empty-record-promise-presence.js": 1948, + "2869-nullish-mixed-lazy.ts": 2998, + "2870-and-dropped-truthy-arm.ts": 1701, + "2871-optional-promise-to-unknown.ts": 2708, + "2872-unobserved-dynamic-event.ts": 1982, + "2873-optional-receiver-loop-lifetime.js": 2129, + "2874-nullable-callback-field-cycle.js": 2941, + "2875-evolving-let-read-before-write.js": 2038, + "2876-class-unknown-roundtrip.ts": 3117, + "2877-child-unknown-roundtrip.ts": 2838, + "2878-class-private-unknown.cjs": 2816, + "2880-cjs-module-graph/main.cjs": 2623, + "2890-crypto-static-utility.ts": 3216, + "2891-json-record-key-escapes.ts": 3136, + "2892-windows-console-unicode.ts": 2711, + "2893-child-stdin-duplex.ts": 2652, + "2894-child-stdin-backpressure.ts": 3049, + "2895-child-stdin-write-after-end.ts": 2813, + "2896-child-stdin-write-after-finish.ts": 1947, + "2897-child-stdin-destroy.ts": 3101, + "2898-child-stdin-spawn-failure.ts": 3024, + "2899-nested-mutual-recursion.ts": 2834, + "2900-float64array-static.ts": 2695, + "2900-void-conditional-arrow.ts": 2641, + "2901-bigint-core.ts": 2912, + "2902-bigint-bytes.ts": 2182, + "2903-bigint-storage.ts": 2897, + "2904-bigint-errors.ts": 2971, + "2905-bigint-edges.ts": 2917, + "2906-bigint-wasi-width.ts": 2941, + "2910-overloaded-callable-alias.ts": 2710, + "2911-execfile-callback.ts": 3076, + "2912-execfile-callback-options.ts": 1918, + "2912-promisify-fs-readfile.ts": 2767, + "2913-builtin-callable-alias.ts": 2872, + "2914-fixed-tuple-call-spread.ts": 2555, + "2915-path-function-values.ts": 2085, + "2916-path-function-values-cjs.ts": 2881, + "2917-builtin-callable-widths.ts": 2912, + "2918-builtin-callable-widths-cjs.ts": 1902, + "2919-fs-function-values.ts": 2935, + "2920-fs-promises-function-values.ts": 2882, + "2921-zlib-callbacks.ts": 2124, + "2922-dyn-bitwise-not.cjs": 2707, + "2923-cjs-factory-export/main.cjs": 2830, + "2930-union-receiver-calls.ts": 2484, + "2931-union-dynamic-field-call.js": 2846, + "2932-create-require-program/main.ts": 3067, + "2933-static-dynamic-import/main.ts": 2168, + "2934-static-import-stored.ts": 3004, + "2935-module-namespace-values/main.ts": 2141, "2936-static-loose-equality.ts": 3392, - "2937-bitwise-hot-loop.ts": 2487, - "2938-fs-sync-overloads.cjs": 1878, - "2939-child-shell-text.ts": 3433, - "2940-date-parse.ts": 2705, - "2940-fsp-realpath.ts": 2908, - "2941-fsp-lstat-identity.ts": 3091, - "2941-process-exit-code.ts": 2544, - "2942-fsp-readdir-dirent.ts": 3069, - "2942-process-exit-code-override.ts": 2534, - "2943-process-exit-code-invalid.ts": 2277, - "2944-process-exit-code-wrap.ts": 1815, - "2945-url-origin-username.ts": 2639, - "2946-child-fork-ipc/main.ts": 3716, - "2946-url-port-hash.ts": 1906, - "2947-set-readonly-seeds.ts": 2763, - "2948-child-fork-eof-callback/main.ts": 2163, - "2948-stdio-callback-record.ts": 2566, - "2949-child-fork-default/main.mjs": 3027, - "2949-url-password.ts": 1993, - "2950-fs-descriptor-publication.ts": 2687, - "2951-math-static-analytic.ts": 3185, - "2952-math-static-remaining.ts": 2865, - "2953-http-header-validation.ts": 2969, - "2954-http-outgoing-headers.ts": 3565, - "2955-http-static-state.ts": 2954, - "2956-http-static-informational.ts": 2194, - "2957-http-static-response-controls.ts": 3186, - "2961-emitter-computed-names.cjs": 1565, - "2962-emitter-computed-optional.ts": 2714, - "2963-child-fork-dispatch/main.ts": 3146, - "2964-indexed-compound.ts": 3331, - "2966-numeric-array-read-fusion.ts": 3033, - "2967-numeric-array-read-lifetime.ts": 2835, - "2968-numeric-array-borrow.ts": 2871, - "2969-scalar-record-results.ts": 2889, - "2970-constant-numeric-tables.ts": 3083, - "2971-constant-table-modules/main.ts": 2199, - "2972-http-static-distinct-snapshots.ts": 3234, - "2972-math-receiver-borrow.ts": 3625, - "2973-http-static-agent.ts": 2730, - "2973-integer-bitwise-arithmetic.ts": 2687, - "2974-array-search-from-index.ts": 104135, - "2974-http-static-module-values.ts": 2450, - "2974-numeric-remainder.ts": 3031, - "2975-bigint-default-radix.ts": 2379, - "2975-http-static-client-controls.ts": 2663, - "2976-http-static-incoming-state.ts": 2293, - "2976-json-stringify-no-arguments.js": 2688, - "2977-http-static-incoming-timeout.ts": 2143, - "2977-nested-array-binding-defaults.js": 2455, - "2978-http-static-client-timeout.ts": 2987, - "2978-regexp-optional-subject.js": 2083, - "2979-array-search-mixed-needles.js": 2924, - "2979-http-static-server-timeout.ts": 2502, - "2980-http-static-server-timeout-default.ts": 2655, - "2980-string-position-arguments.js": 2015, - "2981-http-static-events.ts": 2563, - "2981-string-optional-positions.ts": 2841, - "2982-http-static-close-all.ts": 1931, - "2982-string-position-coercion-order.js": 2986, - "2983-http-static-close-idle.ts": 2485, - "2984-http-static-close-upgrade.ts": 2815, - "2985-http-static-message-destroy.ts": 2511, - "2986-http-static-client-socket-finish.ts": 2889, - "2987-http-static-timeout-errors.ts": 2695, - "2988-http-static-client-abort.ts": 2770, - "2989-http-static-response-timeout-handled.ts": 2973, - "2990-http-static-request-timeout-handled.ts": 3045, - "2991-array-indexed-equality.ts": 3039, - "2992-stream-rows.ts": 1990, - "2993-fiber-stack-lifetimes.ts": 3353, - "2994-fromcharcode-scalar.ts": 2251, - "2995-math-hyperbolic.ts": 3028, - "2996-math-near-one.ts": 2750, - "2997-math-integer-float.ts": 2792, - "300-if-else.ts": 2615, - "3001-caught-typeof-object.js": 2565, - "3002-promise-then-two.ts": 3076, - "301-while.ts": 2690, - "302-for.ts": 2617, - "3020-string-last-index-position.ts": 2669, - "3021-buffer-union-narrow-callback.ts": 3133, - "3022-string-affix-positions.ts": 2471, - "3023-string-affix-position-coercion.js": 2793, - "3024-string-number-narrow-for-in.ts": 2773, - "3025-string-search-position-coercion.js": 2152, - "3026-array-last-index-of.js": 2967, - "3027-array-last-index-of-records.ts": 1994, - "3028-string-search-dynamic-needle.js": 2238, - "3029-string-search-union-needle.js": 2519, - "303-break-continue.ts": 2536, - "3030-array-search-no-arg.js": 2653, - "3031-array-relative-index-coercion.js": 3093, - "3031-string-last-index-search-value.js": 1619, - "3032-string-search-value.js": 2450, - "3033-string-search-needle-coercion.js": 2494, - "3034-arguments-with-parameters.js": 3025, - "3035-string-positioned-search-value.js": 3075, - "3036-string-object-search-value.js": 2233, - "3037-number-nullish-conversion.js": 2181, - "3038-number-scalar-unions.ts": 2410, - "3039-string-repeat-count.js": 2478, - "304-compound-incdec.ts": 2719, - "3040-string-prototype-call.js": 3243, - "3041-string-prototype-object-call.js": 2455, - "3042-string-padding-coercion.js": 3099, - "3043-string-split-arguments.js": 2355, - "3044-array-slice-splice-positions.js": 2214, - "3045-array-indexed-mutation.js": 3434, - "3046-array-indexed-ref-identity.ts": 2361, - "3047-object-prototype-tag.js": 3196, - "3048-object-own-prototype.ts": 3472, - "3049-array-flat-depth.ts": 1949, - "305-truthiness.ts": 2568, - "3050-array-splice-insert.ts": 3099, - "3051-array-join-default.ts": 1846, - "3052-array-construction.ts": 3399, - "3053-array-construction-js.js": 1676, - "3054-dynamic-abort-record.ts": 1731, - "3055-default-builtin-nodenext/main.ts": 2687, - "3056-default-builtin-bundler/main.ts": 2789, - "3057-default-builtin-nodenext-dynamic/main.ts": 2579, - "3058-optional-array-chain-join.ts": 2967, - "3059-arguments-property-names.ts": 2947, - "3061-concurrent-fiber-stacks.ts": 2717, - "3062-runtime-optional-record-guards.ts": 3531, - "3063-runtime-optional-class-guards.ts": 3234, - "3064-installed-entry-imports/main.ts": 2104, - "3065-installed-entry-js/main.js": 2454, - "3066-source-debugging/main.ts": 2680, - "3067-cjs-function-export-require/main.cjs": 2781, - "3068-debug-variables/main.ts": 2201, - "3068-url-checked-identity.ts": 3005, - "3069-set-checked-seed.js": 3167, - "3069-tuple-spread.ts": 3057, - "3070-checked-object-accessors.js": 3314, - "3070-collection-views.ts": 2586, - "3071-checked-specialization-narrowing.js": 2429, - "3071-map-contextual-record-seeds.ts": 2886, - "3072-optional-union-receivers.ts": 3001, - "3072-weak-process-streams.js": 2971, - "3073-optional-callable-module.js": 2030, - "3073-union-keyed-reads.ts": 3228, - "3074-discriminated-intersections.ts": 3008, - "3075-recursive-contextual-literals.ts": 3333, - "3076-nullish-record-defaults.ts": 3030, - "3077-optional-union-array-reads.ts": 2968, - "3078-forward-mutable-captures.ts": 1926, - "3079-forward-mutable-tdz.ts": 2889, - "3080-exhaustive-never-bindings.ts": 2787, - "3081-recursive-array-destinations.ts": 2576, - "3082-forward-write-unwind.ts": 2875, + "2937-bitwise-hot-loop.ts": 2114, + "2938-fs-sync-overloads.cjs": 1863, + "2939-child-shell-text.ts": 3119, + "2940-date-parse.ts": 2606, + "2940-fsp-realpath.ts": 2319, + "2941-fsp-lstat-identity.ts": 3102, + "2941-process-exit-code.ts": 2025, + "2942-fsp-readdir-dirent.ts": 2835, + "2942-process-exit-code-override.ts": 2255, + "2943-process-exit-code-invalid.ts": 2733, + "2944-process-exit-code-wrap.ts": 1969, + "2945-url-origin-username.ts": 1974, + "2946-child-fork-ipc/main.ts": 3772, + "2946-url-port-hash.ts": 2074, + "2947-set-readonly-seeds.ts": 3071, + "2948-child-fork-eof-callback/main.ts": 3013, + "2948-stdio-callback-record.ts": 2065, + "2949-child-fork-default/main.mjs": 2829, + "2949-url-password.ts": 2408, + "2950-fs-descriptor-publication.ts": 2677, + "2951-math-static-analytic.ts": 2349, + "2952-math-static-remaining.ts": 2335, + "2953-http-header-validation.ts": 2772, + "2954-http-outgoing-headers.ts": 3428, + "2955-http-static-state.ts": 2945, + "2956-http-static-informational.ts": 2218, + "2957-http-static-response-controls.ts": 2590, + "2961-emitter-computed-names.cjs": 2830, + "2962-emitter-computed-optional.ts": 2777, + "2963-child-fork-dispatch/main.ts": 3250, + "2964-indexed-compound.ts": 3270, + "2966-numeric-array-read-fusion.ts": 2442, + "2967-numeric-array-read-lifetime.ts": 2772, + "2968-numeric-array-borrow.ts": 3227, + "2969-scalar-record-results.ts": 3038, + "2970-constant-numeric-tables.ts": 2771, + "2971-constant-table-modules/main.ts": 1871, + "2972-http-static-distinct-snapshots.ts": 3053, + "2972-math-receiver-borrow.ts": 2947, + "2973-http-static-agent.ts": 3397, + "2973-integer-bitwise-arithmetic.ts": 2920, + "2974-array-search-from-index.ts": 124091, + "2974-http-static-module-values.ts": 2984, + "2974-numeric-remainder.ts": 3296, + "2975-bigint-default-radix.ts": 2470, + "2975-http-static-client-controls.ts": 2919, + "2976-http-static-incoming-state.ts": 2589, + "2976-json-stringify-no-arguments.js": 2303, + "2977-http-static-incoming-timeout.ts": 2944, + "2977-nested-array-binding-defaults.js": 2175, + "2978-http-static-client-timeout.ts": 2391, + "2978-regexp-optional-subject.js": 2308, + "2979-array-search-mixed-needles.js": 2358, + "2979-http-static-server-timeout.ts": 1739, + "2980-http-static-server-timeout-default.ts": 2883, + "2980-string-position-arguments.js": 2832, + "2981-http-static-events.ts": 2774, + "2981-string-optional-positions.ts": 2352, + "2982-http-static-close-all.ts": 2171, + "2982-string-position-coercion-order.js": 2155, + "2983-http-static-close-idle.ts": 3021, + "2984-http-static-close-upgrade.ts": 2125, + "2985-http-static-message-destroy.ts": 2402, + "2986-http-static-client-socket-finish.ts": 2843, + "2987-http-static-timeout-errors.ts": 3151, + "2988-http-static-client-abort.ts": 2768, + "2989-http-static-response-timeout-handled.ts": 2766, + "2990-http-static-request-timeout-handled.ts": 3159, + "2991-array-indexed-equality.ts": 2285, + "2992-stream-rows.ts": 2873, + "2993-fiber-stack-lifetimes.ts": 3425, + "2994-fromcharcode-scalar.ts": 3028, + "2995-math-hyperbolic.ts": 2938, + "2996-math-near-one.ts": 3222, + "2997-math-integer-float.ts": 2299, + "300-if-else.ts": 2867, + "3001-caught-typeof-object.js": 2563, + "3002-promise-then-two.ts": 3204, + "301-while.ts": 2926, + "302-for.ts": 2606, + "3020-string-last-index-position.ts": 2319, + "3021-buffer-union-narrow-callback.ts": 2195, + "3022-string-affix-positions.ts": 2341, + "3023-string-affix-position-coercion.js": 2752, + "3024-string-number-narrow-for-in.ts": 1609, + "3025-string-search-position-coercion.js": 2728, + "3026-array-last-index-of.js": 2413, + "3027-array-last-index-of-records.ts": 2116, + "3028-string-search-dynamic-needle.js": 1998, + "3029-string-search-union-needle.js": 2405, + "303-break-continue.ts": 2031, + "3030-array-search-no-arg.js": 3128, + "3031-array-relative-index-coercion.js": 2454, + "3031-string-last-index-search-value.js": 2375, + "3032-string-search-value.js": 2888, + "3033-string-search-needle-coercion.js": 2002, + "3034-arguments-with-parameters.js": 3443, + "3035-string-positioned-search-value.js": 2991, + "3036-string-object-search-value.js": 2678, + "3037-number-nullish-conversion.js": 2958, + "3038-number-scalar-unions.ts": 2263, + "3039-string-repeat-count.js": 2105, + "304-compound-incdec.ts": 2747, + "3040-string-prototype-call.js": 3083, + "3041-string-prototype-object-call.js": 2578, + "3042-string-padding-coercion.js": 2198, + "3043-string-split-arguments.js": 2450, + "3044-array-slice-splice-positions.js": 3038, + "3045-array-indexed-mutation.js": 3285, + "3046-array-indexed-ref-identity.ts": 1964, + "3047-object-prototype-tag.js": 2750, + "3048-object-own-prototype.ts": 3516, + "3049-array-flat-depth.ts": 2507, + "305-truthiness.ts": 3022, + "3050-array-splice-insert.ts": 3679, + "3051-array-join-default.ts": 2848, + "3052-array-construction.ts": 2982, + "3053-array-construction-js.js": 3024, + "3054-dynamic-abort-record.ts": 2146, + "3055-default-builtin-nodenext/main.ts": 2904, + "3056-default-builtin-bundler/main.ts": 2933, + "3057-default-builtin-nodenext-dynamic/main.ts": 2973, + "3058-optional-array-chain-join.ts": 2285, + "3059-arguments-property-names.ts": 2296, + "3061-concurrent-fiber-stacks.ts": 1843, + "3062-runtime-optional-record-guards.ts": 3177, + "3063-runtime-optional-class-guards.ts": 2891, + "3064-installed-entry-imports/main.ts": 2942, + "3065-installed-entry-js/main.js": 2574, + "3066-source-debugging/main.ts": 2037, + "3067-cjs-function-export-require/main.cjs": 2917, + "3068-debug-variables/main.ts": 2538, + "3068-url-checked-identity.ts": 2749, + "3069-set-checked-seed.js": 2271, + "3069-tuple-spread.ts": 2404, + "3070-checked-object-accessors.js": 3199, + "3070-collection-views.ts": 3106, + "3071-checked-specialization-narrowing.js": 2927, + "3071-map-contextual-record-seeds.ts": 3315, + "3072-optional-union-receivers.ts": 3294, + "3072-weak-process-streams.js": 2924, + "3073-optional-callable-module.js": 2944, + "3073-union-keyed-reads.ts": 2310, + "3074-discriminated-intersections.ts": 2137, + "3075-recursive-contextual-literals.ts": 3075, + "3076-nullish-record-defaults.ts": 2013, + "3077-optional-union-array-reads.ts": 3340, + "3078-forward-mutable-captures.ts": 3407, + "3079-forward-mutable-tdz.ts": 3267, + "3080-exhaustive-never-bindings.ts": 2952, + "3081-recursive-array-destinations.ts": 2842, + "3082-forward-write-unwind.ts": 2956, "3083-set-string-seed.ts": 2684, - "3084-record-own-membership.ts": 3102, - "3085-conditional-record-construction.ts": 1925, - "3086-error-constructor-options.ts": 3227, - "3087-error-options-lifetime.ts": 2113, - "3088-array-wide-callbacks.ts": 2993, - "3089-array-find-narrowing.ts": 3128, - "3090-json-discriminated-records.ts": 3480, - "3091-json-recursive-discriminants.ts": 2300, - "3092-number-union-predicates.ts": 2639, - "3093-error-option-data.ts": 2191, - "3094-json-replacer-traversal.ts": 2898, - "3095-json-reviver-traversal.ts": 2824, - "3096-json-callback-nonfinite.ts": 1927, - "3097-json-callback-reentrancy.ts": 3321, - "3098-json-callback-space.ts": 2551, - "3099-json-callback-functions.ts": 3507, - "3100-json-callback-holder.js": 3048, - "3101-json-callback-bytes.ts": 2658, - "3102-json-unknown-fields.ts": 2725, - "3103-scalar-record-nested-control-flow.ts": 3195, - "3104-native-analysis-tables-loops.ts": 1557, - "3105-nullable-collections.ts": 1888, - "3106-mixed-insertion-spreads.ts": 3368, - "3107-nullable-collection-lifetimes.ts": 3149, - "3108-for-await-sync-arrays.js": 4447, - "3108-identity-map-keys.ts": 3401, - "3109-destructuring-unknown-defaults.js": 2735, - "3109-identity-union-collections.ts": 3270, - "3110-builtin-error-families.ts": 2441, - "3110-identity-collection-mutation.ts": 2906, - "3111-identity-collection-cycles.ts": 3069, - "3112-union-switch-control-flow.ts": 2641, - "3113-union-array-removal.ts": 3416, - "3114-union-record-field-write.ts": 3033, - "3115-zlib-static-compression-levels.ts": 2443, - "3116-sequence-expression-lifetimes.ts": 3044, - "3117-unknown-switch-control-flow.ts": 2684, - "3118-recursive-union-spread.ts": 2422, - "3119-runtime-optional-spread.ts": 2447, - "3120-dynamic-property-descriptors.js": 3293, - "3120-generator-method-loop-bindings.ts": 3248, - "3120-ir-nonfinite-numbers.ts": 3000, - "3121-compound-assignment-values.js": 2549, - "3121-dynamic-accessor-descriptors.js": 3250, - "3122-dynamic-delete-descriptors.cjs": 2600, - "3122-dynamic-delete-descriptors.js": 2091, - "3122-js-async-class-methods.js": 2297, - "3123-destructured-global-tdz.js": 2836, - "3124-array-prototype-borrow.js": 3537, - "3125-regex-global-match.ts": 2402, - "3126-js-number-radix/main.ts": 3052, - "3127-spawn-runtime-options.ts": 3285, - "3128-regex-last-index.ts": 3076, - "3129-js-token-union/main.ts": 2700, - "3130-child-generic-streams.ts": 3044, - "3131-child-rest-listeners.js": 2943, - "3132-child-generic-stream-completion.ts": 6235, - "3133-text-decoder-streaming.ts": 2265, - "3134-fs-vectors.ts": 2815, - "3135-fs-file-handle-controls.ts": 2278, - "3136-fs-file-handle-options.ts": 3814, - "3137-fs-vector-callbacks.cjs": 3509, - "3138-array-large-storage.ts": 4245, - "3139-regex-native-deep-alternatives.ts": 27587, - "3140-array-dense-access.ts": 3800, - "3141-map-string-key-hash.ts": 2566, - "3150-integer-remainder.ts": 3289, - "3151-array-push-writes.ts": 3227, - "3170-number-conversion-fast-paths.ts": 2553, - "3171-method-census-data-writes.ts": 3442, - "400-fib.ts": 2589, - "401-mutual-recursion.ts": 2527, - "402-string-functions.ts": 2176, - "403-void-and-params.ts": 2350, - "4030-runtime-object-truthiness.ts": 2749, - "4031-event-emitter-long-tuples.ts": 2083, - "4032-inline-rc-fast-paths.ts": 4192, - "404-rc-stress.ts": 2456, - "4040-adapted-function-identity.ts": 2867, - "4041-adapted-function-properties.ts": 2991, - "4042-object-is-union-subclass.ts": 2310, - "4043-nonnull-missing-element.ts": 2433, - "4044-adapted-callback-modules/main.ts": 2886, - "4045-optional-element-projections.ts": 3138, - "4046-captured-parameter-values.ts": 3423, - "4047-captured-parameter-rebinding.ts": 2500, - "405-params-optional.ts": 2755, - "406-params-defaults.ts": 2105, - "4060-cycle-shared-instance/main.ts": 2837, - "4060-stack-union-reads.ts": 3299, - "4061-cycle-evaluation-order/main.ts": 2712, - "4061-nullable-ref-fields.ts": 4653, - "4062-cycle-tdz-read/main.ts": 1857, - "4063-cycle-hoisted-calls/main.ts": 2616, - "4064-cycle-classes-after-init/main.ts": 2926, - "4065-cycle-init-throws/main.ts": 2592, - "4066-cycle-top-level-tdz/main.ts": 1456, - "4067-dynamic-import-cycle-tdz/main.ts": 2785, - "407-params-rest.ts": 2693, - "408-params-ctors-inheritance.ts": 2837, - "4080-optional-read-presence-tests.ts": 2357, - "4080-string-index-bounds.ts": 2174, - "4081-hoisted-function-tdz.ts": 3131, - "4081-string-index-unproven.ts": 2850, - "4082-hoisted-function-tdz-uncaught.ts": 2634, - "4083-dynamic-import-failure/main.ts": 2355, - "4084-record-optional-field-copies.ts": 2952, - "4085-generator-loop-close.ts": 3078, - "4086-optional-capture-defaults.ts": 2684, - "4088-class-static-tdz.ts": 2183, - "4089-class-wrapper-tdz.js": 2911, - "409-params-async-generics.ts": 1894, - "4090-computed-key-tdz.js": 2483, - "4091-class-evaluation-deferred.ts": 3134, - "410-params-rc-stress.ts": 1591, - "4140-array-callback-split-visit.ts": 4467, - "4141-array-callback-ambient-receiver/main.ts": 2178, - "4142-array-callback-factories.ts": 3521, - "4143-union-refinement-intersection-arms.ts": 3254, - "420-dead-strip-modules/main.ts": 2523, - "4290-acyclic-immutable-trees.ts": 3062, - "4291-acyclic-constructor-escapes.ts": 2390, - "4292-acyclic-readonly-bypass.ts": 1956, - "4293-acyclic-dynamic-writes.ts": 3149, - "4294-console-line-sizes.ts": 5491, - "4295-console-template-parts.ts": 3025, - "4296-console-glued-long-parts.ts": 4102, - "4410-inline-object-allocation.ts": 3371, - "4411-nullable-ref-values.ts": 3446, - "4412-nullable-record-values.ts": 3505, - "4413-cycle-old-late-death.ts": 3210, - "4413-nullable-null-and-undefined.ts": 3960, - "4414-cycle-old-weak-keys.ts": 2210, - "4414-nullable-string-values.ts": 3960, - "4415-identity-borrowed-operands.ts": 2923, - "4415-nullable-container-values.ts": 4078, - "4431-exception-pending-contexts.ts": 3547, - "4432-checked-downcast-failures.ts": 3362, - "4451-int32-field-storage.ts": 3587, - "4452-int32-field-dynamic-writes.ts": 2629, - "4453-int32-closed-locals.ts": 2708, - "4454-int32-field-reflection-reads.ts": 3626, - "4455-live-view-reads-without-stores.ts": 3673, - "4471-unassigned-field-reads.ts": 3063, - "4476-string-ascii-header-fact.ts": 3053, - "4477-buffer-write-ascii-runs.ts": 1845, - "4478-string-large-index-reads.ts": 2385, - "4481-array-optional-push.ts": 2921, - "4482-instanceof-static-class-optional.ts": 2110, - "4483-array-splice-statement.ts": 3260, - "4484-array-length-reset.ts": 2963, - "4485-array-splice-optional-item.ts": 3033, - "4486-array-field-element-borrows.ts": 2099, - "4487-array-literal-optional-values.ts": 2387, - "4520-optional-guard-narrowing.ts": 3290, - "4521-array-callback-element-presence.ts": 4205, - "4522-captured-parameter-lifetimes.ts": 3072, - "4523-array-pop-removal.ts": 2939, - "4524-array-callback-supertype-params.ts": 4250, - "4541-nullable-wrap-borrows.ts": 2850, - "4542-preserving-call-borrows.ts": 3298, - "4543-walk-borrowed-locals.ts": 3324, - "4544-checked-cast-aliases.ts": 2878, - "4545-borrowed-returns.ts": 3935, - "4546-rebound-borrowed-params.ts": 2128, - "4560-field-store-borrowed-receivers.ts": 3268, - "4561-virtual-borrowed-parameters.ts": 2119, - "4562-string-self-concat-move.ts": 2875, - "4563-array-read-projection-receivers.ts": 2961, - "4564-literal-choice-strings.ts": 3091, - "4568-for-of-hole-elements.ts": 3194, - "4569-shorthand-missing-elements.ts": 2799, - "4570-map-lookup-default-record.ts": 2885, - "4591-weak-keys-union-records.ts": 3283, - "4592-cycle-const-from-import/main.ts": 2283, - "4593-weak-keys-empty-objects.ts": 1759, - "4594-union-class-field-mixed-types.ts": 3165, - "4595-union-class-field-optional-receiver.ts": 2742, - "4596-error-subclass-int-fields.ts": 2574, - "4596-tdz-nullable-forward-capture.ts": 3762, - "4597-callback-field-method-name.ts": 3397, - "4598-live-array-ref-element-access.ts": 4852, - "4598-map-set-clear-reuse.ts": 4729, - "4598-os-available-parallelism.ts": 2510, - "4598-publish-constructor-stores.ts": 1852, - "4599-construction-only-field-borrows.ts": 3236, - "4600-construction-only-fields-dynamic-writes.ts": 3072, - "4601-cycle-holders.ts": 2734, - "4602-constructor-escape-order.ts": 2610, - "4610-array-ext-dyn-refresh.ts": 2862, - "4620-optional-chain-borrowed-receivers.ts": 3224, - "4621-edge-preserving-callees/main.ts": 3365, - "4630-contract-int32.ts": 2754, - "4630-reference-write-call-arguments.ts": 3053, - "4631-contract-nothrow.ts": 2070, - "4631-reference-write-aliases.ts": 2695, - "4632-contract-immutable.ts": 2863, - "4632-reference-write-loops-and-walks.ts": 3098, - "4633-contract-program-lifetime.ts": 3689, - "4633-reference-write-callbacks-returns.ts": 3144, - "4634-contract-program-lifetime-publish.ts": 4904, - "4634-optional-element-borrowed-returns.ts": 2709, - "4640-bitwise-identity-ranges.ts": 2778, - "4641-nothrow-try-catch.ts": 2708, - "4642-acyclic-contract.ts": 3288, - "4650-stale-property-narrowing.ts": 3851, - "4651-map-string-get-entry.ts": 3371, - "4652-stale-closure-binding-narrowing.ts": 3495, - "4660-typed-rest-spread-forwarding.ts": 2766, - "4671-scoped-array-read-borrows.ts": 3085, - "4690-cycle-bypass-long-lived.ts": 2735, - "4691-publish-constructor-self-alias.ts": 3219, - "4692-borrowed-result-mutating-callees.ts": 2601, - "4720-cold-throw-paths.ts": 3390, - "4721-integer-induction-numbers.ts": 2467, - "4730-touint32-large-magnitudes.ts": 3097, - "4731-string-mixed-ascii-slices.ts": 2704, - "4732-buffer-write-utf16le-runs.ts": 1998, - "4733-typed-array-read-compares.ts": 3234, - "4750-map-string-absent-filter.ts": 3594, - "4751-string-search-multibyte-needles.ts": 2725, - "4795-published-untyped-member-reads.ts": 3268, - "4806-uint32-loop-accumulators.ts": 3231, - "4810-union-identity-retags.ts": 4620, - "4811-union-retag-checked-cast.ts": 3091, - "4812-int32-wrapping-sums.ts": 3463, - "4813-typed-array-read-equality-bindings.ts": 4674, - "4820-sort-comparator-lent-arguments.ts": 4000, - "4821-callback-lent-arguments.ts": 2333, - "4822-stable-capture-reads.ts": 2409, - "4823-array-store-receivers.ts": 2969, - "4830-typed-teardown-chains.ts": 2905, - "4831-cycle-bypass-probe-windows.ts": 2840, - "4840-array-hole-free-prefix.ts": 2459, - "4860-int32-local-storage.ts": 4170, - "4870-array-pipeline-fusion.ts": 7346, - "4871-array-pipeline-analytics.ts": 4533, - "4872-array-pipeline-temporaries.ts": 7994, - "4875-stream-consumers-array-buffer.ts": 3281, - "4876-array-buffer-inspect.ts": 2814, - "4880-await-call-turn-order.ts": 1921, - "4881-await-call-exceptions.ts": 3225, - "4882-await-call-request-chain.ts": 3022, - "4883-await-values-and-hops.ts": 2825, - "4884-await-call-unhandled-sibling.ts": 2163, - "4885-await-call-checkpoints.ts": 2954, - "4890-regex-literal-sites.ts": 3163, - "4891-regex-plain-text-patterns.ts": 2001, - "4892-regex-exec-read-captures.ts": 3652, - "4900-bigint-division-cross-check.ts": 3357, - "4900-console-instances.ts": 3637, - "4901-bigint-radix-text.ts": 2779, - "4901-console-instance-errors.ts": 3196, - "4902-bigint-compound-assign.ts": 1706, - "4903-bigint-fixed-width.ts": 3128, - "4904-bigint-large-products.ts": 3340, - "4905-bigint-fixed-width-fusion.ts": 3031, - "4906-bigint-small-value-trees.ts": 3759, - "4907-bigint-random-trees.ts": 5188, - "4910-hole-free-prefix-upkeep.ts": 3084, - "4920-string-literal-switch.ts": 3310, - "4930-typed-record-reflection.ts": 4737, - "4931-typed-data-generic-walks.ts": 4118, - "4932-typed-json-unknown.ts": 3475, - "4940-async-return-adoption.ts": 3491, - "4941-async-return-adoption-try.ts": 3096, - "4942-async-return-adoption-values.ts": 2964, - "4943-async-return-adoption-interleaved.ts": 2876, - "4950-regex-compiled-captures.ts": 4852, - "4951-regex-compiled-last-index.ts": 2706, - "4952-regex-compiled-anchors-classes.ts": 2724, - "4953-regex-compiled-backtracking.ts": 4297, - "4954-regex-log-report.ts": 3687, - "4955-regex-compiled-differential.ts": 13757, - "4970-int32-call-abi.ts": 3580, - "4980-generator-early-exit-finally.ts": 3050, - "4981-generator-delegation-iterables.ts": 4127, - "4982-generator-sent-values.ts": 2957, - "4983-generator-reuse-iterables.ts": 3475, - "4984-generator-exceptions.ts": 3390, - "4985-generator-lazy-pipeline.ts": 3419, - "4986-generator-default-channels.ts": 3152, - "4987-generator-closures-methods.ts": 3151, - "4988-generator-async-interplay.ts": 2316, - "4989-generator-step-drives.ts": 3427, - "4990-lone-surrogates.ts": 3491, - "4991-lone-surrogate-halves.ts": 3293, - "4992-lone-surrogate-search.ts": 2456, - "4993-lone-surrogate-json.ts": 3728, - "4994-lone-surrogate-uri.ts": 1777, - "4995-lone-surrogate-regex.ts": 2799, - "4996-lone-surrogate-stdio.ts": 3100, - "4997-lone-surrogate-stdout-patch.js": 1716, - "4998-lone-surrogate-buffers.ts": 3414, - "4999-lone-surrogate-io.ts": 2886, - "500-array-basics.ts": 2955, - "501-array-push-pop.ts": 1902, - "5010-lifetime-region-generations.ts": 3477, - "5011-lifetime-region-outside-references.ts": 2843, - "5012-lifetime-region-shapes.ts": 4150, - "5013-lifetime-region-async.ts": 3814, - "5014-lifetime-region-nesting.ts": 2997, - "5015-lifetime-region-publish.ts": 2741, - "5016-lifetime-region-weak-keys.ts": 3235, - "5017-lifetime-region-cycles.ts": 3057, - "5018-lifetime-region-hierarchies.ts": 4043, - "5019-lifetime-region-values.ts": 2895, - "502-array-for-of.ts": 2808, - "5020-lifetime-region-large.ts": 3808, - "5021-lifetime-region-opaque-holders.ts": 3422, - "5022-lifetime-region-workers.ts": 2531, - "503-array-functions.ts": 2837, - "504-array-rc-stress.ts": 2722, - "5040-promise-all-race-turns.ts": 3860, - "5041-promise-all-turns.js": 3644, - "5042-async-generator-return-promise.ts": 3304, - "5043-async-generator-return-forms.ts": 3190, - "5045-generator-delegation-typed-next.ts": 3751, - "5046-generator-delegation-return-throw.ts": 2749, - "5047-generator-delegation-iterables-typed.ts": 4798, - "5048-generator-delegation-async.ts": 3315, - "5049-generator-delegation-edges.ts": 3539, - "5050-inherited-in-membership.ts": 3427, - "5051-typed-record-prototypes.ts": 2418, - "5052-class-for-in-unknown.ts": 3692, - "5053-json-replacer-arrays.ts": 3781, - "5054-required-field-delete.ts": 2108, - "5055-object-create-record-literal.ts": 2773, - "5056-generator-in-unknown.ts": 2634, - "5060-child-fork-exit-after-messages/main.ts": 2129, - "5061-child-fork-local-disconnect/main.ts": 3136, - "5062-child-fork-message-before-eof/main.ts": 3024, - "5065-global-increment-initializers.ts": 2900, - "5066-global-compound-updates.ts": 3224, - "5067-global-updates-in-functions.ts": 2208, - "5068-global-var-let-const-updates.ts": 2542, - "5069-global-update-modules/main.ts": 1962, - "5070-optional-read-bindings.ts": 2623, - "5071-optional-chain-scalars.ts": 2743, - "5072-optional-nullish-ternary.ts": 2840, - "5073-optional-results.ts": 3242, - "5074-optional-pop-shift.ts": 2144, - "5075-optional-reads-unchecked/main.ts": 3167, - "5076-optional-escapes.ts": 2155, - "5080-boolean-array-storage.ts": 4783, - "5081-boolean-array-dynamic-views.ts": 2550, - "5085-promise-allsettled-turns.ts": 4142, - "5086-promise-any-turns.ts": 3722, - "5087-promise-allsettled-any-dyn.js": 5509, - "5088-promise-combinator-thenables.js": 4706, - "5089-promise-settled-records.ts": 3855, - "5090-generator-finished-result-value.ts": 2787, - "5091-generator-delegation-arrays-strings.ts": 4059, - "5092-generator-delegation-sets-maps.ts": 3822, - "5095-console-count-group.ts": 3219, - "5096-console-assert-dir.ts": 3665, - "5097-console-table.ts": 2407, - "5098-console-time-warnings.ts": 5609, - "5099-console-methods-dynamic.cjs": 3155, - "510-array-map-filter-foreach.ts": 2313, - "511-array-indexof-includes.ts": 2884, - "5110-var-hoisting-early-reads.ts": 2759, - "5111-var-hoisting-closures-classes.ts": 2869, - "5112-var-hoisting-function-scope.ts": 2697, - "5113-tdz-let-const-class.ts": 2402, - "5114-var-hoisting-js.js": 2192, - "5115-regex-replace-compiled.ts": 2826, - "5116-regex-capture-reads.ts": 3329, - "5117-regex-log-report-spans.ts": 3686, - "5118-regex-replace-char-chains.ts": 2917, - "512-array-join-chains.ts": 1729, - "5120-frame-records.ts": 2763, - "5121-frame-objects.ts": 2346, - "5122-frame-result-slots.ts": 3086, - "5123-frame-reassigned.ts": 2807, - "5124-frame-objects-control.ts": 2789, - "5125-frame-mutating-methods.ts": 2122, - "5126-frame-returned-params.ts": 2597, - "5127-frame-loop-bindings.ts": 2498, - "513-array-methods-rc-stress.ts": 3202, - "5130-event-target-dispatch.js": 4435, - "5131-event-target-listener-errors.js": 1856, - "5132-event-target-typed.ts": 2296, - "5133-abort-signal-event-target.ts": 3474, - "5134-events-error-monitor.ts": 2972, - "5135-event-target-warnings.js": 2909, - "5136-events-error-monitor-string-name.ts": 2529, - "5137-events-error-monitor-computed-name.js": 3132, - "5138-events-error-monitor-shared-listener.ts": 2744, - "5139-event-target-listener-throw.ts": 2800, - "514-array-find-some-every.ts": 3281, - "5140-os-host-facts.ts": 3044, - "5141-os-constants.ts": 3300, - "5142-path-parse-format.ts": 2224, - "5145-path-matches-glob-basics.ts": 2906, - "5146-path-matches-glob-braces.ts": 5151, - "5147-path-matches-glob-extglob.ts": 2798, - "5148-path-matches-glob-classes.ts": 2450, - "5149-path-matches-glob-win32.ts": 3351, - "515-array-flatmap.ts": 3014, - "5150-small-array-inline-slots.ts": 3873, - "5155-cycle-header-types.ts": 3715, - "516-array-reduce.ts": 3532, - "5160-field-callback-receiver.ts": 3321, - "5161-field-callback-receiver-escape.ts": 2766, - "5162-field-method-reference-receiver.ts": 2634, - "5163-field-callback-receiver.cjs": 3329, - "5164-worker-field-callback-receiver.ts": 3447, - "5165-interface-method-dispatch.ts": 3406, - "5166-interface-method-values.ts": 4300, - "5167-interface-method-order.ts": 3903, - "5168-interface-method-hierarchy.ts": 5186, - "5169-interface-method-chains.ts": 2434, - "517-array-hof-index-args.ts": 3100, - "5170-string-scan-eviction.ts": 1929, - "5171-lone-surrogate-replace-seams.ts": 2824, - "5175-forin-typed-as-unknown.ts": 2364, - "5176-object-keys-typed-as-unknown.ts": 1967, - "5177-forin-dynamic-objects.ts": 2917, - "5178-forin-keys-js.js": 3039, - "5179-forin-typed-shapes.ts": 3389, - "518-array-sort.ts": 3117, - "518-promise-void-union-callbacks.ts": 2562, - "5180-interface-arrays.ts": 3202, - "5181-interface-array-methods.ts": 6982, - "5182-interface-array-boundaries.ts": 3287, - "5183-interface-property-reads.ts": 3238, - "5184-interface-property-objects.ts": 3177, - "5185-util-inherits.cjs": 3654, - "5186-util-inherits.ts": 3139, - "5187-util-deprecate.cjs": 2383, - "5188-util-deprecate-flags.cjs": 2907, - "5189-util-deprecate.ts": 2180, - "519-array-from-length.ts": 2896, - "519-promise-union-await-values.ts": 2702, - "5190-util-callbackify.cjs": 3059, - "5191-util-callbackify.ts": 3126, - "5192-util-debuglog.cjs": 3809, - "5193-util-debuglog.ts": 2614, - "5194-process-emit-warning-tick.cjs": 2394, - "5195-object-entries-typed-as-unknown.ts": 3883, - "5196-object-values-typed-as-unknown.ts": 3399, - "5197-object-entries-dynamic-objects.ts": 3397, - "5198-object-entries-values-js.js": 2635, - "5199-object-entries-identity.ts": 3121, - "520-map-basics.ts": 2823, - "5200-array-sort-keyed-numbers.ts": 4287, - "5201-array-sort-keyed-records.ts": 4564, - "5202-array-sort-keyed-lookalikes.ts": 3516, - "5203-typed-array-sort-default.ts": 6009, - "5204-typed-array-sort-comparators.ts": 4333, - "521-map-number-keys.ts": 2785, - "5210-process-memory-usage.ts": 2299, - "5211-process-identity.ts": 3103, - "5212-perf-marks-measures.ts": 3829, - "5213-perf-timing-errors.ts": 3477, - "5214-perf-entry-inspect.ts": 4088, - "5215-perf-timing-validation.js": 3386, - "5216-perf-spread-arguments.js": 4128, - "5217-perf-spread-typed.ts": 3454, - "522-map-foreach.ts": 2702, - "5220-url-parse-warnings.ts": 2881, - "5221-url-parse-shapes.ts": 1930, - "5222-url-parse-hosts.ts": 3064, - "5223-url-parse-query.ts": 3104, - "5224-url-format-objects.ts": 3496, - "5225-url-format-whatwg.ts": 2608, - "5226-url-resolve.ts": 2695, - "5227-url-legacy-dependency/main.ts": 2825, - "5228-url-domain-conversion.ts": 2843, - "5229-url-legacy-errors.cjs": 3833, - "523-map-ref-values.ts": 3192, - "5230-inline-union-fields.ts": 2629, - "5231-inline-union-field-kinds.ts": 2513, - "5232-inline-union-fields-dynamic.ts": 3917, - "5233-inline-union-fields-shapes.ts": 3689, - "5234-inline-union-class-fields.ts": 3417, - "5235-inline-union-fields-publish.ts": 2910, - "5236-inline-union-unchecked-reads.ts": 2919, - "5237-inline-union-frame-objects.ts": 2775, - "524-map-cycles.ts": 2820, - "5240-event-target-subclass.ts": 4712, - "5241-event-subclass.ts": 3442, - "5242-event-target-subclass-hierarchy.ts": 3429, - "5243-event-target-subclass-dynamic.ts": 3827, - "5244-event-target-subclass.js": 3772, - "5245-event-target-subclass-signals.ts": 3197, - "5246-event-target-subclass-listener-throw.ts": 1982, - "5247-event-target-subclass-lifetimes.ts": 4315, - "5248-event-target-subclass-warnings.ts": 2798, - "5249-event-target-subclass-unconstructed.ts": 2600, - "525-map-rc-stress.ts": 2751, - "5250-cipher-aes-gcm.ts": 6095, - "5251-cipher-aes-cbc.ts": 3544, - "5252-cipher-aes-ctr.ts": 2536, - "5253-cipher-chacha20-poly1305.ts": 3577, - "5254-cipher-errors.js": 3835, - "5255-cipher-encodings.cjs": 3839, - "5256-cipher-deprecation.cjs": 3149, - "5257-cipher-vectors.ts": 3374, - "5258-cipher-handles.js": 2798, - "5259-cipher-chunked.ts": 3781, - "526-set-basics.ts": 2514, - "5260-record-unknown-identity.ts": 3342, - "5261-optional-field-identity.ts": 2813, - "5262-record-unknown-many.ts": 2768, - "527-set-foreach.ts": 2947, - "5270-url-parse-no-deprecation.cjs": 3204, - "5271-url-parse-throw-deprecation.cjs": 3229, - "5275-http-end-callback-order.ts": 3224, - "5276-style-text-hex-colors.cjs": 2193, - "5277-fs-read-file-buffer-option.cjs": 1864, - "5278-host-null-bytes.cjs": 2972, - "5279-search-params-null-init.cjs": 1662, - "528-set-seeded.ts": 1937, - "5285-blob-construct.ts": 3802, - "5286-blob-readers.ts": 2609, - "5287-blob-inspect.ts": 2930, - "5288-blob-validation.js": 4282, - "5289-blob-read-order.ts": 3276, - "529-map-seeded.ts": 2575, - "5290-blob-dynamic.js": 3409, - "5295-readline-promises-question.ts": 2860, - "5296-readline-lines.ts": 3085, - "5297-readline-callback-events.cjs": 2092, - "5298-readline-abort.cjs": 3384, - "5299-readline-stdin.ts": 2909, - "530-record-arrays.ts": 3090, - "5300-stream-add-abort-signal.ts": 2505, - "5301-stream-add-abort-signal-errors.cjs": 3168, - "5302-stream-promises-options.ts": 2812, - "5303-stream-finished-callback-opts.cjs": 2840, - "5305-json-stringify-typed-arrays.ts": 4425, - "531-record-array-hofs.ts": 3107, - "5315-map-iterate-after-front-deletes.ts": 3372, - "5316-map-lru-eviction.ts": 2980, - "5317-map-iterate-while-mutating.ts": 3025, - "5318-set-iterate-after-deletes.ts": 2325, - "5319-map-iteration-values.ts": 2767, - "532-record-arrays-rc-stress.ts": 2605, - "5320-map-iterate-across-compaction.ts": 3341, - "5321-integer-closed-arithmetic-loops.ts": 2935, - "5321-json-parse-cycles.ts": 2739, - "5322-integer-variable-step-loops.ts": 2732, - "5322-json-stringify-parsed-trees.ts": 3539, - "5323-dyn-numeric-index-reads.ts": 1771, - "5323-int32-nonnegative-slot-facts.ts": 2925, - "5324-int32-initializer-locals.ts": 2126, - "5324-structured-clone-documents.ts": 3093, - "5325-record-boundary-returns.ts": 2952, - "5326-record-boundary-params.ts": 3045, - "5327-record-boundary-identity.ts": 2913, - "5328-record-boundary-open.ts": 2787, - "5329-record-boundary-recursion.ts": 2543, - "533-array-element-cycles.ts": 2595, - "5330-record-boundary-fields.ts": 2690, - "5331-record-boundary-methods.ts": 2941, - "5332-int32-narrowed-slot-facts.ts": 3036, - "5333-integer-guarded-while-counters.ts": 2907, - "5333-record-boundary-nullable-argument.ts": 3066, - "5334-fetch-mentions-without-calls.ts": 2537, - "5335-stream-operators-values.ts": 3463, - "5335-top-level-await-pending-exit-code.ts": 2626, - "5336-stream-operators-promise-timing.ts": 3056, - "5336-top-level-await-pending-exit-listener.ts": 2547, - "5337-dc-subscriber-throw-next-tick.cjs": 2655, - "5337-stream-operators-concurrency.ts": 2539, - "5338-js-tdz-function-element.js": 2247, - "5338-stream-operators-checks.cjs": 3619, - "5339-array-buffer-constructor.js": 3106, - "5339-stream-for-await-hops.ts": 2525, - "534-record-width-subtyping.ts": 2764, - "5340-readable-from-options.ts": 3427, - "5341-compound-any-operand.ts": 3571, - "5341-generator-callback-params.ts": 3696, - "5341-integer-recursion-boundaries.ts": 2410, - "5341-readable-from-dynamic.cjs": 3652, - "5342-compound-any-operand.cjs": 2807, - "5342-generator-scalar-channels.ts": 2386, - "5342-integer-recursion-stack-and-mutual.ts": 2999, - "5342-stream-compose.ts": 3332, - "5343-any-flow-compound.ts": 1598, - "5343-integer-recursion-array-index.ts": 3219, - "5343-iterator-result-records.ts": 2018, - "5343-stream-compose-edges.ts": 3167, - "5344-json-parse-undeclared-keys.ts": 4016, - "5344-stream-pipeline-timing.ts": 3216, - "5345-object-values-for-of-unknown.ts": 2662, - "5346-object-values-length-dynamic.ts": 3253, - "5347-object-values-loop-control.ts": 3534, - "5348-object-values-for-of-js.js": 3133, - "5349-object-entries-values-optional.ts": 3434, - "535-object-statics.ts": 3684, - "5350-object-values-wide-record.ts": 3383, - "5351-object-values-methods-index.ts": 4044, - "5352-final-field-loop-reads.ts": 2982, - "5353-captured-const-values.ts": 3255, - "5354-captured-const-tdz.ts": 1913, - "5355-captured-function-declarations.ts": 2960, - "5356-captured-tdz-ordering.ts": 2164, - "5357-init-only-module-bindings.ts": 3203, - "536-map-seed-array.ts": 2803, - "5360-array-sort-comparator-calls.ts": 2961, - "5361-array-sort-inconsistent-comparators.ts": 2659, - "5362-array-sort-comparator-throws.ts": 2991, - "5363-array-sort-comparator-writes.ts": 5900, - "5364-array-sort-union-and-boolean-elements.ts": 10497, - "5365-array-sort-dynamic-values.js": 3189, - "537-map-iter-drains.ts": 2987, - "5370-zlib-stream-roundtrip.ts": 3454, - "5371-zlib-stream-chunking.cjs": 3925, - "5372-zlib-stream-errors.cjs": 2700, - "5373-zlib-stream-options.cjs": 3872, - "5374-zlib-stream-flush-params.ts": 3102, - "5375-zlib-stream-promises.ts": 2399, - "5376-zlib-constants.cjs": 2483, - "5377-zlib-stream-backpressure.cjs": 3427, - "5378-zlib-sync-options.cjs": 2176, - "5379-zlib-callback-options.ts": 3566, - "538-map-set-for-of.ts": 2976, - "5390-interface-loop-element-lifetimes.ts": 3153, - "5391-interface-dispatch-hierarchies.ts": 3899, - "5392-interface-receiver-bindings.ts": 3131, - "5393-interface-array-holes.ts": 3093, - "5394-interface-implementers.ts": 3579, - "5395-locale-compare-ascii.ts": 2963, - "5396-locale-compare-latin.ts": 1885, - "5397-locale-compare-sorting.ts": 3156, - "540-tuples-basics.ts": 2555, - "5400-json-parse-typed-keys.ts": 3448, - "5405-buffer-arraybuffer-window.ts": 3039, - "5406-util-types-keys.ts": 2823, - "5407-http-header-field-limit.ts": 3316, - "5408-http-unread-request-end.ts": 3667, - "5409-http-held-request-body.ts": 2506, - "541-ref-array-json.ts": 2521, - "5410-inspect-class-values.ts": 2528, - "5411-inspect-class-hierarchies.ts": 3094, - "5412-inspect-dynamic-collections.ts": 3071, - "5413-inspect-class-values.cjs": 3263, - "5415-zlib-dynamic-inputs.cjs": 2520, - "542-union-element-arrays.ts": 2223, - "5420-readable-from-generators.ts": 3661, - "5421-readable-from-generators.cjs": 3036, - "5422-stream-async-push-wakeup.ts": 3138, - "5423-stream-end-and-eos-timing.ts": 3247, - "5424-stream-write-buffer-encoding.ts": 2663, - "5425-pipeline-generator-stage.ts": 2060, - "5426-pipeline-generator-errors.ts": 3490, - "5427-pipeline-generator-backpressure.ts": 2729, - "5428-pipeline-generator-stages.cjs": 3499, - "5429-pipeline-generator-buffers.ts": 3223, - "5430-dyn-number-string-boxes.ts": 3048, - "5435-crypto-hash-algorithms.ts": 2461, - "5436-crypto-hash-names.js": 3064, - "5437-crypto-hmac-algorithms.ts": 3107, - "5438-crypto-kdf-digests.ts": 3109, - "5439-crypto-kdf-callbacks.js": 2368, - "5440-crypto-hash-encodings.js": 4093, - "5441-crypto-hash-output-length.ts": 3652, - "5442-crypto-random-values.ts": 4190, - "5443-crypto-random-arguments.js": 3529, - "5444-crypto-timing-safe-equal.js": 3508, - "5445-crypto-secret-key-objects.ts": 3186, - "5445-stream-buffer-chunks.ts": 3012, - "5446-crypto-secret-key-errors.js": 3785, - "5446-stream-buffer-chunks-dynamic.js": 3127, - "5447-fs-readdir-order.ts": 2143, - "5448-fs-glob-patterns.ts": 3113, - "5449-fs-glob-options.ts": 3649, - "5450-fs-glob-validation.js": 2855, - "5451-fs-promises-glob.ts": 3569, - "5452-fs-glob-callback.ts": 2885, - "5455-power-of-two-remainder.ts": 3093, - "5456-remainder-large-integer-dividends.ts": 2991, - "5457-lcg-modulus.ts": 2871, - "5458-fractional-remainder.ts": 2988, - "5460-locale-compare-contractions.ts": 2881, - "5461-locale-compare-equivalents.ts": 2942, - "5462-locale-compare-probe-sweep.ts": 2752, - "5463-locale-compare-combining-letters.ts": 3006, - "5464-locale-compare-fractions.ts": 2946, - "5465-dyn-index-read-arrays.ts": 3424, - "5466-dyn-index-read-special.ts": 2632, - "5470-strip-vt-osc.cjs": 2376, - "5471-strip-vt-csi.cjs": 2167, - "5472-strip-vt-random.cjs": 3001, - "5473-strip-vt-unterminated.cjs": 3560, - "5474-strip-vt-surrogates.ts": 3301, - "5510-assert-error-properties.js": 3653, - "5511-assert-error-class.ts": 3637, - "5512-assert-error-options.js": 3115, - "5513-assert-deep-equal-loose.js": 3866, - "5514-assert-deep-equal-typed.ts": 3778, - "5515-assert-deep-strict-typed-messages.ts": 1850, - "5516-assert-deep-equal-edges.js": 3662, - "5517-assert-partial-deep-equal.js": 2640, - "5518-assert-partial-deep-typed.ts": 3542, - "5519-assert-partial-deep-typed-edges.ts": 3280, - "5520-assert-record-literal-failures.ts": 3499, - "5520-dyn-property-read-receivers.ts": 3367, - "5521-assert-empty-message.js": 3321, - "5521-dyn-property-read-keys.ts": 2391, - "5522-assert-throws-failure-properties.ts": 3436, - "5523-assert-class-options.js": 3102, - "5524-assert-class-skip-prototype.ts": 3823, - "5530-buffer-pool.ts": 3971, - "5531-buffer-pool-first-slab.ts": 5569, - "5532-buffer-pool-first-slab-untyped.mjs": 40038, - "5540-fs-callback-forms.cjs": 3631, - "5541-fs-stats-fields.cjs": 3800, - "5542-fs-promises-parity.cjs": 3962, - "5543-fs-promises-typed.ts": 2212, - "5544-fs-opendir.cjs": 3332, - "5545-fs-options-encoding.cjs": 4482, - "5546-fs-read-stream.cjs": 4502, - "5547-fs-write-stream.cjs": 5101, - "5548-fs-callback-arguments.cjs": 4306, - "5549-fs-callback-option-checks.cjs": 4187, - "5550-locale-compare-ascii-words.ts": 2669, - "5551-array-search-references.ts": 3663, - "5552-string-appends.ts": 3195, - "5553-string-append-char-code.ts": 2446, - "5554-fs-streams-typed.ts": 3785, - "5555-fs-callback-turns.cjs": 3093, - "5555-http-server-close-keep-alive.ts": 7242, - "5556-http-client-agent-connection.ts": 2788, - "5557-http-outgoing-header-values.ts": 3401, - "5558-http-incoming-duplicate-headers.ts": 2354, - "5559-http-expect-header.ts": 3766, - "5560-http-response-framing.ts": 4849, - "5561-http-max-header-size.ts": 3443, - "5562-https-verify-errors.ts": 3494, - "5563-http-keep-alive-timeout.ts": 11607, - "5564-http-request-signal.ts": 3916, - "5565-fs-dirent-untyped.mjs": 3810, - "5566-fs-dirent-dyn-boundaries/main.mjs": 3533, - "5567-fs-cpsync.ts": 3626, - "5568-fs-cp-errors.js": 3163, - "5569-fs-cp-symlinks.ts": 3704, - "5570-fs-cp-async.ts": 3480, - "5571-fs-cp-deep.ts": 4934, - "5585-record-results-inlined.ts": 3154, - "5595-net-ref-unref.ts": 2641, - "5600-dyn-cycle-self.ts": 2124, - "5601-dyn-cycle-mutual.ts": 3279, - "5602-dyn-cycle-arrays.ts": 2568, - "5603-dyn-cycle-identity.ts": 2702, - "5604-dyn-cycle-checks.ts": 3057, - "5605-dyn-cycle-containers.ts": 3526, - "5606-dyn-cycle-capsules.ts": 1609, - "5610-readable-from-sets-and-views.ts": 3539, - "5611-readable-from-class-iterables.ts": 2637, - "5612-readable-from-iterables.cjs": 4089, - "5613-readable-from-iterable-timing.cjs": 4101, - "5614-readable-from-iterable-errors.cjs": 4082, - "5615-next-tick-callback-phases.ts": 3272, - "5616-next-tick-callback-phases.cjs": 2953, - "5617-pipeline-function-ends.ts": 2551, - "5618-pipeline-function-ends-errors.ts": 3775, - "5619-pipeline-function-ends.cjs": 2549, - "5620-timers-promises-values.ts": 3225, - "5621-util-format-float.ts": 2907, - "5622-events-once.mjs": 3347, - "5623-events-once.ts": 2334, - "5624-timers-promises-unawaited.ts": 3127, - "5625-promisify-exec.ts": 7142, - "5626-promisify-forms.ts": 2175, - "5627-exec-callback.ts": 1900, - "5628-promisify-timers.ts": 3185, - "5629-promisify-stream.ts": 3048, - "5630-promisify-zlib.ts": 1934, - "5631-promisify-crypto.ts": 2200, - "5632-promisify-dns.ts": 1700, - "5644-net-socket-addresses.ts": 3275, - "5645-net-socket-callbacks.ts": 3377, - "5646-net-server-connections.ts": 2448, - "5647-net-is-ip.ts": 2731, - "5648-dns-lookup-forms.ts": 3763, - "5649-dns-service-servers.ts": 2892, - "5650-dns-lookup-errors-untyped.cjs": 2811, - "5651-tls-socket-protocol.ts": 3198, - "5652-http-client-trailer-overflow.ts": 2916, - "5653-net-socket-read-ahead.ts": 4816, - "5654-https-empty-servername.ts": 3117, - "5655-dgram-socket-options.ts": 3309, - "5656-dgram-option-states.ts": 3364, - "5657-net-reset-and-address.ts": 2680, - "5658-net-reset-dynamic.cjs": 2474, - "5659-net-blocklist-socketaddress.ts": 4089, - "5664-tls-client-identity.ts": 2704, - "5674-union-instanceof-array-arms.ts": 3663, - "5680-array-growth-after-copy.ts": 3726, - "5681-array-pop-and-length.ts": 4270, - "5682-publish-wide-objects.ts": 3077, - "5700-cycle-release-retained.ts": 2148, - "5701-cycle-release-old-edges.ts": 2696, - "5702-publish-candidate-buffers.ts": 2775, - "5703-lifetime-region-debug.ts": 2224, - "5704-publish-refused-restores-counts.ts": 3329, - "5710-map-number-keys-hashed.ts": 3647, - "5711-map-number-write-after-read.ts": 2210, - "5712-map-number-overwrite-at-growth.ts": 3023, - "5714-cycle-large-candidate-buffers.ts": 2468, - "5715-json-parse-fitted-tables.ts": 3870, - "5717-set-prototype-of-primitives.ts": 2889, - "5719-int32-fields-dynamic-operators.ts": 3112, - "5720-intern-table-basics.ts": 3730, - "5721-intern-table-values.ts": 3508, - "5722-intern-table-workers.ts": 2907, - "5723-intern-table-shared-types.ts": 4686, - "5724-intern-table-array-keys.ts": 3089, - "5725-intern-table-callbacks.ts": 3280, - "5726-intern-table-key-limits.ts": 2828, - "5740-atomics-operation-semantics.ts": 4575, - "5741-atomics-contended-counters.ts": 2574, - "5742-atomics-lock-ordering.ts": 3308, - "5743-atomics-wait-notify.ts": 3213, - "5744-atomics-ring-buffer.ts": 2799, - "5745-atomics-semaphore-stress.ts": 3529, - "5746-shared-bulk-operations.ts": 3548, - "5747-fs-stat-throw-if-no-entry.ts": 2061, - "5748-fs-stat-throw-if-no-entry-js.cjs": 3369, - "5752-string-number-concat.ts": 1990, - "5760-crypto-hash-stream.ts": 3142, - "5761-crypto-hash-stream-states.ts": 3329, - "5762-crypto-hash-stream.cjs": 3414, - "5763-crypto-sha-blocks.ts": 3741, - "5764-class-structural-view-writes.ts": 3376, - "5764-crypto-hmac-edges.cjs": 2142, - "5765-class-structural-view-identity.ts": 3439, - "5766-class-structural-view-callbacks.ts": 2597, - "5767-class-opaque-accessor-view.ts": 3393, - "5776-power-of-two-remainder-integer-path.ts": 2953, - "5780-readline-history-options.ts": 2935, - "5781-readline-history-options.cjs": 2270, - "5782-readline-terminal-editing.ts": 3076, - "5783-readline-terminal-completion.cjs": 5270, - "5784-readline-terminal-promises.ts": 2520, - "5785-readline-terminal-keys.ts": 3009, - "5786-readline-terminal-history.cjs": 2912, - "5787-readline-cursor-helpers.cjs": 1948, - "5788-readline-promises-readline.ts": 3069, - "5789-readline-cursor-pos.cjs": 2494, - "5790-readline-keypress-events.ts": 3064, - "5791-dyn-constant-key-read-sites.ts": 3916, - "5791-readline-keypress-interfaces.cjs": 3122, - "5792-json-parse-repeated-layouts.ts": 3794, - "5792-readline-keypress-listeners.ts": 2820, - "5793-worker-message-channel.ts": 2538, - "5794-worker-message-port-close-order.ts": 2834, - "5795-worker-message-port-batches.ts": 2254, - "5796-worker-message-channel.cjs": 3566, - "5797-worker-message-port-transfer.ts": 3180, - "5800-broadcast-channel.ts": 3206, - "5801-broadcast-channel.cjs": 3035, - "5802-broadcast-channel-workers.ts": 3120, - "5803-worker-environment-data.ts": 3113, - "5804-worker-environment-data.cjs": 3000, - "5805-worker-receive-message-parent-port.ts": 3259, - "5806-worker-resource-limits.ts": 3191, - "5807-worker-error-values.ts": 3239, - "5808-worker-unhandled-rejections.ts": 3439, - "5809-process-exit-and-rejections.cjs": 3393, - "5810-mock-method-records.ts": 3670, - "5811-mock-tracker-restore.ts": 3216, - "5812-dyn-box-async-fields.ts": 2941, - "5813-mock-timers-module.ts": 3052, - "5814-mock-timers-date.ts": 3365, - "5830-timers-promises-signal.ts": 3771, - "5831-util-types-brands.ts": 3300, - "5832-util-types-brands-dynamic.js": 3811, - "5833-url-search-params-iterators.ts": 3578, - "5834-url-search-params-iterators-dynamic.mjs": 3566, - "5835-util-format-integer-specifiers.ts": 2544, - "5836-url-search-params-tuple-pairs.ts": 2830, - "5837-util-format-json-circular.ts": 2387, - "5838-qs-stringify-bigint.ts": 3072, - "5839-timers-promises-scheduler.ts": 2609, - "5840-promise-with-resolvers-js.js": 2922, - "5841-json-typed-dyn-members.ts": 3536, - "5842-qs-parse-null-prototype.ts": 3138, - "5843-qs-parse-null-prototype-js.mjs": 2658, - "5844-date-unknown-values.ts": 3255, - "5845-groupby-null-prototype.ts": 3675, - "5846-events-esm-default-max.ts": 2633, - "5847-events-cjs-default-max.cjs": 2823, - "5849-class-view-observations.ts": 2583, - "5850-using-disposable-values.ts": 3206, - "5851-using-suppressed-error-values.ts": 3035, - "5852-using-disposable-values-js.js": 1792, - "5853-set-methods-map-arguments.ts": 2849, - "5854-array-from-async.ts": 3165, - "5855-array-from-async-js.js": 3186, - "5856-error-is-error.ts": 3631, - "5857-regexp-unicode-sets.ts": 2021, - "5858-disposable-stack.ts": 4753, - "5859-disposable-stack-js.js": 3636, - "5860-url-ipv4-hosts.ts": 3030, - "5870-worker-thread-names.ts": 3457, - "5871-worker-untransferable.cjs": 2368, - "5872-readline-positional-create-interface.mjs": 2993, - "5873-readline-promises-namespace.cjs": 2951, - "5874-worker-stdio-streams.ts": 2974, - "5875-worker-stdout-pipe.cjs": 3115, - "5879-worker-stdin.ts": 3644, - "5880-emitter-leak-warning-delivery.ts": 2660, - "5881-inspect-weak-collections.ts": 2621, - "5882-string-decoder-runtime-encoding.ts": 2742, - "5883-os-set-priority.ts": 2927, - "5884-inspect-layout-options.ts": 3552, - "5885-events-max-listener-helpers.ts": 3645, - "5886-inspect-dates.ts": 2931, - "5887-inspect-typed-arrays.ts": 2476, - "5888-inspect-sorted.ts": 3227, - "5889-timers-scheduler-signal.ts": 2549, - "5890-while-string-length-counters.ts": 3080, - "5892-buffer-write-utf16le-runs.ts": 3098, - "5900-float16-array.ts": 3586, - "5901-float16-array-js.js": 3449, - "5904-async-generator-completion.ts": 5816, - "5905-array-from-async-generator.ts": 2793, - "5906-array-from-async-generator-js.js": 3377, - "5907-regex-groups-match-rows.ts": 3150, - "5910-set-prototype-of-primitive-object-kinds.ts": 2148, - "5911-dyn-class-to-primitive.ts": 6231, - "5912-dyn-class-conversion-methods.ts": 4317, - "5913-prototype-type-error-messages.ts": 2831, - "5914-dyn-in-class-prototype-members.ts": 2811, - "5915-dyn-error-string-conversions.ts": 3158, - "5920-promise-try-args.ts": 3150, - "5921-promise-try-args-js.js": 2112, - "5922-matchall-groups-callbacks.ts": 4259, - "5923-matchall-groups-js.js": 4523, - "5924-js-literal-identity.js": 3064, - "5925-class-view-identity-observers.ts": 2653, - "5926-class-view-switch-js.js": 1690, - "5927-switch-object-identity.ts": 2783, - "5928-groupby-iterables.ts": 3526, - "5929-groupby-js.js": 1756, - "5930-contract-int32-arrays.ts": 3803, - "5930-method-census-asserted-number-keys.ts": 2348, - "5931-asserted-reads-keep-number-parameters.ts": 2715, - "5932-generic-class-observed-methods.ts": 4825, - "5933-class-fields-unknown-object.ts": 3920, - "5934-js-class-fields-property-order.js": 4713, - "5935-js-subclass-fields-and-element-calls.js": 3523, - "5936-checked-js-class-types.js": 2384, - "5937-override-narrowed-union-returns.ts": 3039, - "5938-object-literal-computed-keys-keep-methods.ts": 3195, - "5939-js-let-object-reassigned-wider.js": 2362, - "5940-callback-helper-specialization.ts": 3130, - "5941-callback-specialization-recursion.ts": 3996, - "5942-callback-specialization-throws.ts": 2908, - "5943-fields-read-before-assignment.ts": 6856, - "5944-js-fields-read-before-assignment.js": 4247, - "5945-local-class-observed-methods.ts": 5063, - "5946-nested-record-field-optional-writes.ts": 6045, - "5950-tuple-predicate-methods.ts": 3865, - "5951-result-never-widening.ts": 3022, - "5952-record-missing-keys.ts": 6090, - "5953-nan-coded-method-returns.ts": 4100, - "5955-any-promise-methods.js": 3111, - "5956-erased-generic-members.ts": 5669, - "5958-asserted-union-receiver.ts": 1929, - "5959-date-to-json.ts": 2922, - "5960-generic-mapped-types.ts": 3167, - "5970-net-connect-host-name.ts": 1992, - "5971-buffer-chunks-to-string.ts": 3183, - "5972-net-set-encoding-listeners.ts": 2129, - "5974-typeof-module-exports.cjs": 2008, - "5975-zlib-class-values.ts": 2800, - "5990-worker-uncloneable.mjs": 3202, - "5991-worker-async-dispose.mjs": 5853, - "5992-worker-thread-name-lifetime.mjs": 2058, + "3084-record-own-membership.ts": 3434, + "3085-conditional-record-construction.ts": 2128, + "3086-error-constructor-options.ts": 2138, + "3087-error-options-lifetime.ts": 2004, + "3088-array-wide-callbacks.ts": 2257, + "3089-array-find-narrowing.ts": 2620, + "3090-json-discriminated-records.ts": 2285, + "3091-json-recursive-discriminants.ts": 2190, + "3092-number-union-predicates.ts": 2281, + "3093-error-option-data.ts": 2642, + "3094-json-replacer-traversal.ts": 3187, + "3095-json-reviver-traversal.ts": 2938, + "3096-json-callback-nonfinite.ts": 2858, + "3097-json-callback-reentrancy.ts": 2787, + "3098-json-callback-space.ts": 3229, + "3099-json-callback-functions.ts": 3214, + "3100-json-callback-holder.js": 2206, + "3101-json-callback-bytes.ts": 2646, + "3102-json-unknown-fields.ts": 3086, + "3103-scalar-record-nested-control-flow.ts": 2112, + "3104-native-analysis-tables-loops.ts": 2780, + "3105-nullable-collections.ts": 3028, + "3106-mixed-insertion-spreads.ts": 2007, + "3107-nullable-collection-lifetimes.ts": 3338, + "3108-for-await-sync-arrays.js": 2682, + "3108-identity-map-keys.ts": 2227, + "3109-destructuring-unknown-defaults.js": 2915, + "3109-identity-union-collections.ts": 3423, + "3110-builtin-error-families.ts": 2570, + "3110-identity-collection-mutation.ts": 2678, + "3111-identity-collection-cycles.ts": 2997, + "3112-union-switch-control-flow.ts": 2901, + "3113-union-array-removal.ts": 3399, + "3114-union-record-field-write.ts": 2336, + "3115-zlib-static-compression-levels.ts": 2528, + "3116-sequence-expression-lifetimes.ts": 3297, + "3117-unknown-switch-control-flow.ts": 2618, + "3118-recursive-union-spread.ts": 3545, + "3119-runtime-optional-spread.ts": 2406, + "3120-dynamic-property-descriptors.js": 3089, + "3120-generator-method-loop-bindings.ts": 3317, + "3120-ir-nonfinite-numbers.ts": 1849, + "3121-compound-assignment-values.js": 2286, + "3121-dynamic-accessor-descriptors.js": 4553, + "3122-dynamic-delete-descriptors.cjs": 1796, + "3122-dynamic-delete-descriptors.js": 2168, + "3122-js-async-class-methods.js": 2287, + "3123-destructured-global-tdz.js": 2851, + "3124-array-prototype-borrow.js": 3706, + "3125-regex-global-match.ts": 3004, + "3126-js-number-radix/main.ts": 3034, + "3127-spawn-runtime-options.ts": 2691, + "3128-regex-last-index.ts": 2151, + "3129-js-token-union/main.ts": 2990, + "3130-child-generic-streams.ts": 3199, + "3131-child-rest-listeners.js": 1690, + "3132-child-generic-stream-completion.ts": 5607, + "3133-text-decoder-streaming.ts": 3055, + "3134-fs-vectors.ts": 3055, + "3135-fs-file-handle-controls.ts": 3371, + "3136-fs-file-handle-options.ts": 2897, + "3137-fs-vector-callbacks.cjs": 3277, + "3138-array-large-storage.ts": 3756, + "3139-regex-native-deep-alternatives.ts": 28435, + "3140-array-dense-access.ts": 3894, + "3141-map-string-key-hash.ts": 3167, + "3150-integer-remainder.ts": 3353, + "3151-array-push-writes.ts": 3497, + "3170-number-conversion-fast-paths.ts": 3302, + "3171-method-census-data-writes.ts": 2848, + "400-fib.ts": 2397, + "401-mutual-recursion.ts": 2469, + "402-string-functions.ts": 2915, + "403-void-and-params.ts": 1930, + "4030-runtime-object-truthiness.ts": 2360, + "4031-event-emitter-long-tuples.ts": 1978, + "4032-inline-rc-fast-paths.ts": 4391, + "404-rc-stress.ts": 2580, + "4040-adapted-function-identity.ts": 3640, + "4041-adapted-function-properties.ts": 3228, + "4042-object-is-union-subclass.ts": 1738, + "4043-nonnull-missing-element.ts": 3185, + "4044-adapted-callback-modules/main.ts": 2445, + "4045-optional-element-projections.ts": 2663, + "4046-captured-parameter-values.ts": 3523, + "4047-captured-parameter-rebinding.ts": 2990, + "405-params-optional.ts": 2128, + "406-params-defaults.ts": 2785, + "4060-cycle-shared-instance/main.ts": 2724, + "4060-stack-union-reads.ts": 3544, + "4061-cycle-evaluation-order/main.ts": 2941, + "4061-nullable-ref-fields.ts": 4633, + "4062-cycle-tdz-read/main.ts": 2132, + "4063-cycle-hoisted-calls/main.ts": 2837, + "4064-cycle-classes-after-init/main.ts": 2919, + "4065-cycle-init-throws/main.ts": 2003, + "4066-cycle-top-level-tdz/main.ts": 2633, + "4067-dynamic-import-cycle-tdz/main.ts": 2814, + "407-params-rest.ts": 3063, + "408-params-ctors-inheritance.ts": 2314, + "4080-optional-read-presence-tests.ts": 2434, + "4080-string-index-bounds.ts": 2754, + "4081-hoisted-function-tdz.ts": 3289, + "4081-string-index-unproven.ts": 2424, + "4082-hoisted-function-tdz-uncaught.ts": 2711, + "4083-dynamic-import-failure/main.ts": 3307, + "4084-record-optional-field-copies.ts": 3992, + "4085-generator-loop-close.ts": 2360, + "4086-optional-capture-defaults.ts": 2000, + "4088-class-static-tdz.ts": 2016, + "4089-class-wrapper-tdz.js": 2230, + "409-params-async-generics.ts": 2900, + "4090-computed-key-tdz.js": 2345, + "4091-class-evaluation-deferred.ts": 2676, + "410-params-rc-stress.ts": 2904, + "4140-array-callback-split-visit.ts": 4145, + "4141-array-callback-ambient-receiver/main.ts": 3151, + "4142-array-callback-factories.ts": 3774, + "4143-union-refinement-intersection-arms.ts": 1858, + "420-dead-strip-modules/main.ts": 2735, + "4290-acyclic-immutable-trees.ts": 3335, + "4291-acyclic-constructor-escapes.ts": 2796, + "4292-acyclic-readonly-bypass.ts": 2522, + "4293-acyclic-dynamic-writes.ts": 2365, + "4294-console-line-sizes.ts": 6187, + "4295-console-template-parts.ts": 2942, + "4296-console-glued-long-parts.ts": 4142, + "4410-inline-object-allocation.ts": 2124, + "4411-nullable-ref-values.ts": 4400, + "4412-nullable-record-values.ts": 4209, + "4413-cycle-old-late-death.ts": 2986, + "4413-nullable-null-and-undefined.ts": 2888, + "4414-cycle-old-weak-keys.ts": 3194, + "4414-nullable-string-values.ts": 4815, + "4415-identity-borrowed-operands.ts": 2337, + "4415-nullable-container-values.ts": 4436, + "4431-exception-pending-contexts.ts": 2184, + "4432-checked-downcast-failures.ts": 3797, + "4451-int32-field-storage.ts": 3817, + "4452-int32-field-dynamic-writes.ts": 3773, + "4453-int32-closed-locals.ts": 2395, + "4454-int32-field-reflection-reads.ts": 3951, + "4455-live-view-reads-without-stores.ts": 3598, + "4471-unassigned-field-reads.ts": 2666, + "4476-string-ascii-header-fact.ts": 2214, + "4477-buffer-write-ascii-runs.ts": 3271, + "4478-string-large-index-reads.ts": 2510, + "4481-array-optional-push.ts": 3023, + "4482-instanceof-static-class-optional.ts": 2810, + "4483-array-splice-statement.ts": 3482, + "4484-array-length-reset.ts": 2127, + "4485-array-splice-optional-item.ts": 2800, + "4486-array-field-element-borrows.ts": 3650, + "4487-array-literal-optional-values.ts": 3286, + "4520-optional-guard-narrowing.ts": 2046, + "4521-array-callback-element-presence.ts": 4687, + "4522-captured-parameter-lifetimes.ts": 2497, + "4523-array-pop-removal.ts": 3081, + "4524-array-callback-supertype-params.ts": 3932, + "4541-nullable-wrap-borrows.ts": 2389, + "4542-preserving-call-borrows.ts": 3360, + "4543-walk-borrowed-locals.ts": 3391, + "4544-checked-cast-aliases.ts": 3252, + "4545-borrowed-returns.ts": 3896, + "4546-rebound-borrowed-params.ts": 1833, + "4560-field-store-borrowed-receivers.ts": 2735, + "4561-virtual-borrowed-parameters.ts": 3750, + "4562-string-self-concat-move.ts": 2152, + "4563-array-read-projection-receivers.ts": 2323, + "4564-literal-choice-strings.ts": 2445, + "4568-for-of-hole-elements.ts": 3409, + "4569-shorthand-missing-elements.ts": 2920, + "4570-map-lookup-default-record.ts": 3442, + "4591-weak-keys-union-records.ts": 3061, + "4592-cycle-const-from-import/main.ts": 2838, + "4593-weak-keys-empty-objects.ts": 3425, + "4594-union-class-field-mixed-types.ts": 3724, + "4595-union-class-field-optional-receiver.ts": 3074, + "4596-error-subclass-int-fields.ts": 2744, + "4596-tdz-nullable-forward-capture.ts": 3971, + "4597-callback-field-method-name.ts": 2791, + "4598-live-array-ref-element-access.ts": 5033, + "4598-map-set-clear-reuse.ts": 4347, + "4598-os-available-parallelism.ts": 2628, + "4598-publish-constructor-stores.ts": 3091, + "4599-construction-only-field-borrows.ts": 3355, + "4600-construction-only-fields-dynamic-writes.ts": 2213, + "4601-cycle-holders.ts": 2024, + "4602-constructor-escape-order.ts": 2992, + "4610-array-ext-dyn-refresh.ts": 3195, + "4620-optional-chain-borrowed-receivers.ts": 3095, + "4621-edge-preserving-callees/main.ts": 3779, + "4630-contract-int32.ts": 2865, + "4630-reference-write-call-arguments.ts": 2202, + "4631-contract-nothrow.ts": 2128, + "4631-reference-write-aliases.ts": 3078, + "4632-contract-immutable.ts": 2740, + "4632-reference-write-loops-and-walks.ts": 3256, + "4633-contract-program-lifetime.ts": 2525, + "4633-reference-write-callbacks-returns.ts": 3120, + "4634-contract-program-lifetime-publish.ts": 5678, + "4634-optional-element-borrowed-returns.ts": 2332, + "4640-bitwise-identity-ranges.ts": 3148, + "4641-nothrow-try-catch.ts": 3252, + "4642-acyclic-contract.ts": 2463, + "4650-stale-property-narrowing.ts": 3973, + "4651-map-string-get-entry.ts": 2471, + "4652-stale-closure-binding-narrowing.ts": 3516, + "4660-typed-rest-spread-forwarding.ts": 3181, + "4671-scoped-array-read-borrows.ts": 2667, + "4690-cycle-bypass-long-lived.ts": 4305, + "4691-publish-constructor-self-alias.ts": 2372, + "4692-borrowed-result-mutating-callees.ts": 1719, + "4720-cold-throw-paths.ts": 3494, + "4721-integer-induction-numbers.ts": 2519, + "4730-touint32-large-magnitudes.ts": 3115, + "4731-string-mixed-ascii-slices.ts": 3544, + "4732-buffer-write-utf16le-runs.ts": 3493, + "4733-typed-array-read-compares.ts": 3222, + "4750-map-string-absent-filter.ts": 2733, + "4751-string-search-multibyte-needles.ts": 2428, + "4795-published-untyped-member-reads.ts": 3850, + "4806-uint32-loop-accumulators.ts": 3676, + "4810-union-identity-retags.ts": 4908, + "4811-union-retag-checked-cast.ts": 2426, + "4812-int32-wrapping-sums.ts": 3340, + "4813-typed-array-read-equality-bindings.ts": 4912, + "4820-sort-comparator-lent-arguments.ts": 4229, + "4821-callback-lent-arguments.ts": 4442, + "4822-stable-capture-reads.ts": 3053, + "4823-array-store-receivers.ts": 3132, + "4830-typed-teardown-chains.ts": 2523, + "4831-cycle-bypass-probe-windows.ts": 2952, + "4840-array-hole-free-prefix.ts": 3114, + "4860-int32-local-storage.ts": 4294, + "4870-array-pipeline-fusion.ts": 4815, + "4871-array-pipeline-analytics.ts": 3642, + "4872-array-pipeline-temporaries.ts": 8318, + "4875-stream-consumers-array-buffer.ts": 2209, + "4876-array-buffer-inspect.ts": 3069, + "4880-await-call-turn-order.ts": 2111, + "4881-await-call-exceptions.ts": 3319, + "4882-await-call-request-chain.ts": 2496, + "4883-await-values-and-hops.ts": 2868, + "4884-await-call-unhandled-sibling.ts": 2184, + "4885-await-call-checkpoints.ts": 3054, + "4890-regex-literal-sites.ts": 2434, + "4891-regex-plain-text-patterns.ts": 2078, + "4892-regex-exec-read-captures.ts": 2821, + "4900-bigint-division-cross-check.ts": 3490, + "4900-console-instances.ts": 3829, + "4901-bigint-radix-text.ts": 2425, + "4901-console-instance-errors.ts": 2457, + "4902-bigint-compound-assign.ts": 2147, + "4903-bigint-fixed-width.ts": 2614, + "4904-bigint-large-products.ts": 3572, + "4905-bigint-fixed-width-fusion.ts": 3509, + "4906-bigint-small-value-trees.ts": 3794, + "4907-bigint-random-trees.ts": 4702, + "4910-hole-free-prefix-upkeep.ts": 2383, + "4920-string-literal-switch.ts": 2483, + "4930-typed-record-reflection.ts": 5024, + "4931-typed-data-generic-walks.ts": 4893, + "4932-typed-json-unknown.ts": 3278, + "4940-async-return-adoption.ts": 3536, + "4941-async-return-adoption-try.ts": 2995, + "4942-async-return-adoption-values.ts": 4513, + "4943-async-return-adoption-interleaved.ts": 2479, + "4950-regex-compiled-captures.ts": 4860, + "4951-regex-compiled-last-index.ts": 3606, + "4952-regex-compiled-anchors-classes.ts": 3738, + "4953-regex-compiled-backtracking.ts": 2856, + "4954-regex-log-report.ts": 4801, + "4955-regex-compiled-differential.ts": 24475, + "4970-int32-call-abi.ts": 3417, + "4980-generator-early-exit-finally.ts": 3144, + "4981-generator-delegation-iterables.ts": 4656, + "4982-generator-sent-values.ts": 2721, + "4983-generator-reuse-iterables.ts": 3420, + "4984-generator-exceptions.ts": 3409, + "4985-generator-lazy-pipeline.ts": 3627, + "4986-generator-default-channels.ts": 3616, + "4987-generator-closures-methods.ts": 2884, + "4988-generator-async-interplay.ts": 2217, + "4989-generator-step-drives.ts": 3530, + "4990-lone-surrogates.ts": 2833, + "4991-lone-surrogate-halves.ts": 2382, + "4992-lone-surrogate-search.ts": 2602, + "4993-lone-surrogate-json.ts": 2479, + "4994-lone-surrogate-uri.ts": 3069, + "4995-lone-surrogate-regex.ts": 3486, + "4996-lone-surrogate-stdio.ts": 3232, + "4997-lone-surrogate-stdout-patch.js": 2640, + "4998-lone-surrogate-buffers.ts": 2452, + "4999-lone-surrogate-io.ts": 2454, + "500-array-basics.ts": 2089, + "501-array-push-pop.ts": 2391, + "5010-lifetime-region-generations.ts": 2818, + "5011-lifetime-region-outside-references.ts": 3377, + "5012-lifetime-region-shapes.ts": 3312, + "5013-lifetime-region-async.ts": 3967, + "5014-lifetime-region-nesting.ts": 3224, + "5015-lifetime-region-publish.ts": 3866, + "5016-lifetime-region-weak-keys.ts": 2328, + "5017-lifetime-region-cycles.ts": 2417, + "5018-lifetime-region-hierarchies.ts": 4028, + "5019-lifetime-region-values.ts": 3115, + "502-array-for-of.ts": 2081, + "5020-lifetime-region-large.ts": 4189, + "5021-lifetime-region-opaque-holders.ts": 2035, + "5022-lifetime-region-workers.ts": 3716, + "5023-lifetime-region-await.ts": 3656, + "5024-lifetime-region-await-forms.ts": 3342, + "503-array-functions.ts": 2924, + "504-array-rc-stress.ts": 3242, + "5040-promise-all-race-turns.ts": 4173, + "5041-promise-all-turns.js": 2741, + "5042-async-generator-return-promise.ts": 3826, + "5043-async-generator-return-forms.ts": 2473, + "5045-generator-delegation-typed-next.ts": 4238, + "5046-generator-delegation-return-throw.ts": 3793, + "5047-generator-delegation-iterables-typed.ts": 4942, + "5048-generator-delegation-async.ts": 3582, + "5049-generator-delegation-edges.ts": 2876, + "5050-inherited-in-membership.ts": 3767, + "5051-typed-record-prototypes.ts": 3580, + "5052-class-for-in-unknown.ts": 3587, + "5053-json-replacer-arrays.ts": 2213, + "5054-required-field-delete.ts": 2545, + "5055-object-create-record-literal.ts": 2467, + "5056-generator-in-unknown.ts": 2333, + "5060-child-fork-exit-after-messages/main.ts": 2415, + "5061-child-fork-local-disconnect/main.ts": 3036, + "5062-child-fork-message-before-eof/main.ts": 2882, + "5065-global-increment-initializers.ts": 2801, + "5066-global-compound-updates.ts": 3218, + "5067-global-updates-in-functions.ts": 3110, + "5068-global-var-let-const-updates.ts": 2271, + "5069-global-update-modules/main.ts": 2850, + "5070-optional-read-bindings.ts": 2832, + "5071-optional-chain-scalars.ts": 2863, + "5072-optional-nullish-ternary.ts": 2578, + "5073-optional-results.ts": 3429, + "5074-optional-pop-shift.ts": 2389, + "5075-optional-reads-unchecked/main.ts": 2697, + "5076-optional-escapes.ts": 2437, + "5080-boolean-array-storage.ts": 6485, + "5081-boolean-array-dynamic-views.ts": 2359, + "5085-promise-allsettled-turns.ts": 3904, + "5086-promise-any-turns.ts": 3934, + "5087-promise-allsettled-any-dyn.js": 5476, + "5088-promise-combinator-thenables.js": 3403, + "5089-promise-settled-records.ts": 3102, + "5090-generator-finished-result-value.ts": 3342, + "5091-generator-delegation-arrays-strings.ts": 4412, + "5092-generator-delegation-sets-maps.ts": 3102, + "5095-console-count-group.ts": 3177, + "5096-console-assert-dir.ts": 3849, + "5097-console-table.ts": 3057, + "5098-console-time-warnings.ts": 6642, + "5099-console-methods-dynamic.cjs": 3356, + "510-array-map-filter-foreach.ts": 3363, + "511-array-indexof-includes.ts": 3037, + "5110-var-hoisting-early-reads.ts": 2475, + "5111-var-hoisting-closures-classes.ts": 3177, + "5112-var-hoisting-function-scope.ts": 2961, + "5113-tdz-let-const-class.ts": 3714, + "5114-var-hoisting-js.js": 2962, + "5115-regex-replace-compiled.ts": 3348, + "5116-regex-capture-reads.ts": 3537, + "5117-regex-log-report-spans.ts": 2918, + "5118-regex-replace-char-chains.ts": 2863, + "512-array-join-chains.ts": 2158, + "5120-frame-records.ts": 2742, + "5121-frame-objects.ts": 2716, + "5122-frame-result-slots.ts": 2032, + "5123-frame-reassigned.ts": 2738, + "5124-frame-objects-control.ts": 2735, + "5125-frame-mutating-methods.ts": 2979, + "5126-frame-returned-params.ts": 2879, + "5127-frame-loop-bindings.ts": 3193, + "513-array-methods-rc-stress.ts": 2584, + "5130-event-target-dispatch.js": 3996, + "5131-event-target-listener-errors.js": 2992, + "5132-event-target-typed.ts": 2663, + "5133-abort-signal-event-target.ts": 3726, + "5134-events-error-monitor.ts": 3026, + "5135-event-target-warnings.js": 3015, + "5136-events-error-monitor-string-name.ts": 1974, + "5137-events-error-monitor-computed-name.js": 2881, + "5138-events-error-monitor-shared-listener.ts": 1863, + "5139-event-target-listener-throw.ts": 2263, + "514-array-find-some-every.ts": 3260, + "5140-os-host-facts.ts": 3684, + "5141-os-constants.ts": 3492, + "5142-path-parse-format.ts": 2821, + "5145-path-matches-glob-basics.ts": 2871, + "5146-path-matches-glob-braces.ts": 4793, + "5147-path-matches-glob-extglob.ts": 3097, + "5148-path-matches-glob-classes.ts": 3036, + "5149-path-matches-glob-win32.ts": 3100, + "515-array-flatmap.ts": 3003, + "5150-small-array-inline-slots.ts": 3147, + "5155-cycle-header-types.ts": 3920, + "516-array-reduce.ts": 3545, + "5160-field-callback-receiver.ts": 2905, + "5161-field-callback-receiver-escape.ts": 2883, + "5162-field-method-reference-receiver.ts": 2527, + "5163-field-callback-receiver.cjs": 3464, + "5164-worker-field-callback-receiver.ts": 3434, + "5165-interface-method-dispatch.ts": 3679, + "5166-interface-method-values.ts": 3253, + "5167-interface-method-order.ts": 3399, + "5168-interface-method-hierarchy.ts": 3873, + "5169-interface-method-chains.ts": 4165, + "517-array-hof-index-args.ts": 2228, + "5170-string-scan-eviction.ts": 2996, + "5171-lone-surrogate-replace-seams.ts": 3136, + "5175-forin-typed-as-unknown.ts": 2043, + "5176-object-keys-typed-as-unknown.ts": 3098, + "5177-forin-dynamic-objects.ts": 3236, + "5178-forin-keys-js.js": 3163, + "5179-forin-typed-shapes.ts": 3384, + "518-array-sort.ts": 2963, + "518-promise-void-union-callbacks.ts": 3093, + "5180-interface-arrays.ts": 3147, + "5181-interface-array-methods.ts": 8906, + "5182-interface-array-boundaries.ts": 2573, + "5183-interface-property-reads.ts": 3303, + "5184-interface-property-objects.ts": 2438, + "5185-util-inherits.cjs": 3986, + "5186-util-inherits.ts": 3513, + "5187-util-deprecate.cjs": 3994, + "5188-util-deprecate-flags.cjs": 2993, + "5189-util-deprecate.ts": 3292, + "519-array-from-length.ts": 2634, + "519-promise-union-await-values.ts": 2998, + "5190-util-callbackify.cjs": 2477, + "5191-util-callbackify.ts": 3362, + "5192-util-debuglog.cjs": 3445, + "5193-util-debuglog.ts": 3383, + "5194-process-emit-warning-tick.cjs": 2282, + "5195-object-entries-typed-as-unknown.ts": 3460, + "5196-object-values-typed-as-unknown.ts": 3267, + "5197-object-entries-dynamic-objects.ts": 3904, + "5198-object-entries-values-js.js": 2966, + "5199-object-entries-identity.ts": 3380, + "520-map-basics.ts": 2986, + "5200-array-sort-keyed-numbers.ts": 3421, + "5201-array-sort-keyed-records.ts": 5202, + "5202-array-sort-keyed-lookalikes.ts": 3629, + "5203-typed-array-sort-default.ts": 5027, + "5204-typed-array-sort-comparators.ts": 3154, + "521-map-number-keys.ts": 2975, + "5210-process-memory-usage.ts": 2993, + "5211-process-identity.ts": 2460, + "5212-perf-marks-measures.ts": 3807, + "5213-perf-timing-errors.ts": 2266, + "5214-perf-entry-inspect.ts": 4135, + "5215-perf-timing-validation.js": 3297, + "5216-perf-spread-arguments.js": 2533, + "5217-perf-spread-typed.ts": 2686, + "522-map-foreach.ts": 3042, + "5220-url-parse-warnings.ts": 2728, + "5221-url-parse-shapes.ts": 3405, + "5222-url-parse-hosts.ts": 3159, + "5223-url-parse-query.ts": 3506, + "5224-url-format-objects.ts": 3987, + "5225-url-format-whatwg.ts": 3370, + "5226-url-resolve.ts": 3030, + "5227-url-legacy-dependency/main.ts": 2891, + "5228-url-domain-conversion.ts": 2727, + "5229-url-legacy-errors.cjs": 3507, + "523-map-ref-values.ts": 2648, + "5230-inline-union-fields.ts": 3279, + "5231-inline-union-field-kinds.ts": 2225, + "5232-inline-union-fields-dynamic.ts": 4075, + "5233-inline-union-fields-shapes.ts": 3388, + "5234-inline-union-class-fields.ts": 3532, + "5235-inline-union-fields-publish.ts": 2491, + "5236-inline-union-unchecked-reads.ts": 3193, + "5237-inline-union-frame-objects.ts": 3058, + "524-map-cycles.ts": 2269, + "5240-event-target-subclass.ts": 4204, + "5241-event-subclass.ts": 2870, + "5242-event-target-subclass-hierarchy.ts": 2589, + "5243-event-target-subclass-dynamic.ts": 3729, + "5244-event-target-subclass.js": 3769, + "5245-event-target-subclass-signals.ts": 3471, + "5246-event-target-subclass-listener-throw.ts": 3466, + "5247-event-target-subclass-lifetimes.ts": 4294, + "5248-event-target-subclass-warnings.ts": 3036, + "5249-event-target-subclass-unconstructed.ts": 2612, + "525-map-rc-stress.ts": 2418, + "5250-cipher-aes-gcm.ts": 5771, + "5251-cipher-aes-cbc.ts": 3823, + "5252-cipher-aes-ctr.ts": 2580, + "5253-cipher-chacha20-poly1305.ts": 3418, + "5254-cipher-errors.js": 4743, + "5255-cipher-encodings.cjs": 2250, + "5256-cipher-deprecation.cjs": 3088, + "5257-cipher-vectors.ts": 3572, + "5258-cipher-handles.js": 2980, + "5259-cipher-chunked.ts": 2586, + "526-set-basics.ts": 2254, + "5260-record-unknown-identity.ts": 2475, + "5261-optional-field-identity.ts": 3183, + "5262-record-unknown-many.ts": 2600, + "527-set-foreach.ts": 2444, + "5270-url-parse-no-deprecation.cjs": 3324, + "5271-url-parse-throw-deprecation.cjs": 3222, + "5275-http-end-callback-order.ts": 3388, + "5276-style-text-hex-colors.cjs": 2986, + "5277-fs-read-file-buffer-option.cjs": 2730, + "5278-host-null-bytes.cjs": 2802, + "5279-search-params-null-init.cjs": 2749, + "528-set-seeded.ts": 3056, + "5285-blob-construct.ts": 2884, + "5286-blob-readers.ts": 2550, + "5287-blob-inspect.ts": 3329, + "5288-blob-validation.js": 3838, + "5289-blob-read-order.ts": 3430, + "529-map-seeded.ts": 2821, + "5290-blob-dynamic.js": 3167, + "5295-readline-promises-question.ts": 3310, + "5296-readline-lines.ts": 2423, + "5297-readline-callback-events.cjs": 2594, + "5298-readline-abort.cjs": 3296, + "5299-readline-stdin.ts": 3344, + "530-record-arrays.ts": 2381, + "5300-stream-add-abort-signal.ts": 3578, + "5301-stream-add-abort-signal-errors.cjs": 3164, + "5302-stream-promises-options.ts": 2875, + "5303-stream-finished-callback-opts.cjs": 3111, + "5305-json-stringify-typed-arrays.ts": 3510, + "531-record-array-hofs.ts": 3334, + "5315-map-iterate-after-front-deletes.ts": 2670, + "5316-map-lru-eviction.ts": 3171, + "5317-map-iterate-while-mutating.ts": 3109, + "5318-set-iterate-after-deletes.ts": 3338, + "5319-map-iteration-values.ts": 2901, + "532-record-arrays-rc-stress.ts": 2965, + "5320-map-iterate-across-compaction.ts": 2712, + "5321-integer-closed-arithmetic-loops.ts": 3349, + "5321-json-parse-cycles.ts": 3308, + "5322-integer-variable-step-loops.ts": 2801, + "5322-json-stringify-parsed-trees.ts": 3139, + "5323-dyn-numeric-index-reads.ts": 2266, + "5323-int32-nonnegative-slot-facts.ts": 2381, + "5324-int32-initializer-locals.ts": 3123, + "5324-structured-clone-documents.ts": 3223, + "5325-record-boundary-returns.ts": 1813, + "5326-record-boundary-params.ts": 2295, + "5327-record-boundary-identity.ts": 3016, + "5328-record-boundary-open.ts": 2956, + "5329-record-boundary-recursion.ts": 3001, + "533-array-element-cycles.ts": 2575, + "5330-record-boundary-fields.ts": 2897, + "5331-record-boundary-methods.ts": 2874, + "5332-int32-narrowed-slot-facts.ts": 2932, + "5333-integer-guarded-while-counters.ts": 2773, + "5333-record-boundary-nullable-argument.ts": 2389, + "5334-fetch-mentions-without-calls.ts": 2822, + "5335-stream-operators-values.ts": 3448, + "5335-top-level-await-pending-exit-code.ts": 2359, + "5336-stream-operators-promise-timing.ts": 3509, + "5336-top-level-await-pending-exit-listener.ts": 2649, + "5337-dc-subscriber-throw-next-tick.cjs": 2705, + "5337-stream-operators-concurrency.ts": 2478, + "5338-js-tdz-function-element.js": 2787, + "5338-stream-operators-checks.cjs": 3991, + "5339-array-buffer-constructor.js": 3134, + "5339-stream-for-await-hops.ts": 2919, + "534-record-width-subtyping.ts": 3068, + "5340-readable-from-options.ts": 1980, + "5341-compound-any-operand.ts": 3314, + "5341-generator-callback-params.ts": 3955, + "5341-integer-recursion-boundaries.ts": 2534, + "5341-readable-from-dynamic.cjs": 3057, + "5342-compound-any-operand.cjs": 3386, + "5342-generator-scalar-channels.ts": 3184, + "5342-integer-recursion-stack-and-mutual.ts": 3097, + "5342-stream-compose.ts": 2940, + "5343-any-flow-compound.ts": 2063, + "5343-integer-recursion-array-index.ts": 2905, + "5343-iterator-result-records.ts": 3426, + "5343-stream-compose-edges.ts": 3078, + "5344-json-parse-undeclared-keys.ts": 4193, + "5344-stream-pipeline-timing.ts": 3177, + "5345-object-values-for-of-unknown.ts": 3435, + "5346-object-values-length-dynamic.ts": 3274, + "5347-object-values-loop-control.ts": 3443, + "5348-object-values-for-of-js.js": 2832, + "5349-object-entries-values-optional.ts": 3325, + "535-object-statics.ts": 3232, + "5350-object-values-wide-record.ts": 2628, + "5351-object-values-methods-index.ts": 4093, + "5352-final-field-loop-reads.ts": 2894, + "5353-captured-const-values.ts": 3727, + "5354-captured-const-tdz.ts": 2243, + "5355-captured-function-declarations.ts": 2917, + "5356-captured-tdz-ordering.ts": 2726, + "5357-init-only-module-bindings.ts": 1956, + "536-map-seed-array.ts": 1912, + "5360-array-sort-comparator-calls.ts": 3363, + "5361-array-sort-inconsistent-comparators.ts": 3560, + "5362-array-sort-comparator-throws.ts": 3410, + "5363-array-sort-comparator-writes.ts": 7945, + "5364-array-sort-union-and-boolean-elements.ts": 10573, + "5365-array-sort-dynamic-values.js": 2528, + "537-map-iter-drains.ts": 3127, + "5370-zlib-stream-roundtrip.ts": 3486, + "5371-zlib-stream-chunking.cjs": 4025, + "5372-zlib-stream-errors.cjs": 2794, + "5373-zlib-stream-options.cjs": 3210, + "5374-zlib-stream-flush-params.ts": 3572, + "5375-zlib-stream-promises.ts": 3156, + "5376-zlib-constants.cjs": 2490, + "5377-zlib-stream-backpressure.cjs": 2917, + "5378-zlib-sync-options.cjs": 2777, + "5379-zlib-callback-options.ts": 2861, + "538-map-set-for-of.ts": 2968, + "5390-interface-loop-element-lifetimes.ts": 3450, + "5391-interface-dispatch-hierarchies.ts": 2856, + "5392-interface-receiver-bindings.ts": 2639, + "5393-interface-array-holes.ts": 3216, + "5394-interface-implementers.ts": 3420, + "5395-locale-compare-ascii.ts": 2643, + "5396-locale-compare-latin.ts": 3373, + "5397-locale-compare-sorting.ts": 2181, + "540-tuples-basics.ts": 3148, + "5400-json-parse-typed-keys.ts": 3311, + "5405-buffer-arraybuffer-window.ts": 2743, + "5406-util-types-keys.ts": 3041, + "5407-http-header-field-limit.ts": 3155, + "5408-http-unread-request-end.ts": 3012, + "5409-http-held-request-body.ts": 3019, + "541-ref-array-json.ts": 2632, + "5410-inspect-class-values.ts": 3232, + "5411-inspect-class-hierarchies.ts": 3027, + "5412-inspect-dynamic-collections.ts": 2914, + "5413-inspect-class-values.cjs": 3313, + "5415-zlib-dynamic-inputs.cjs": 3606, + "542-union-element-arrays.ts": 3131, + "5420-readable-from-generators.ts": 3459, + "5421-readable-from-generators.cjs": 3156, + "5422-stream-async-push-wakeup.ts": 3051, + "5423-stream-end-and-eos-timing.ts": 3065, + "5424-stream-write-buffer-encoding.ts": 2687, + "5425-pipeline-generator-stage.ts": 2503, + "5426-pipeline-generator-errors.ts": 3640, + "5427-pipeline-generator-backpressure.ts": 3096, + "5428-pipeline-generator-stages.cjs": 2057, + "5429-pipeline-generator-buffers.ts": 2918, + "5430-dyn-number-string-boxes.ts": 3282, + "5435-crypto-hash-algorithms.ts": 2301, + "5436-crypto-hash-names.js": 2084, + "5437-crypto-hmac-algorithms.ts": 3303, + "5438-crypto-kdf-digests.ts": 2137, + "5439-crypto-kdf-callbacks.js": 3353, + "5440-crypto-hash-encodings.js": 4466, + "5441-crypto-hash-output-length.ts": 3422, + "5442-crypto-random-values.ts": 3350, + "5443-crypto-random-arguments.js": 3269, + "5444-crypto-timing-safe-equal.js": 2816, + "5445-crypto-secret-key-objects.ts": 3209, + "5445-stream-buffer-chunks.ts": 3329, + "5446-crypto-secret-key-errors.js": 2813, + "5446-stream-buffer-chunks-dynamic.js": 2503, + "5447-fs-readdir-order.ts": 2263, + "5448-fs-glob-patterns.ts": 2912, + "5449-fs-glob-options.ts": 3879, + "5450-fs-glob-validation.js": 4118, + "5451-fs-promises-glob.ts": 3698, + "5452-fs-glob-callback.ts": 2619, + "5455-power-of-two-remainder.ts": 2806, + "5456-remainder-large-integer-dividends.ts": 3156, + "5457-lcg-modulus.ts": 2975, + "5458-fractional-remainder.ts": 2938, + "5460-locale-compare-contractions.ts": 2684, + "5461-locale-compare-equivalents.ts": 3166, + "5462-locale-compare-probe-sweep.ts": 4453, + "5463-locale-compare-combining-letters.ts": 2871, + "5464-locale-compare-fractions.ts": 3156, + "5465-dyn-index-read-arrays.ts": 3603, + "5466-dyn-index-read-special.ts": 2823, + "5470-strip-vt-osc.cjs": 2872, + "5471-strip-vt-csi.cjs": 2359, + "5472-strip-vt-random.cjs": 3265, + "5473-strip-vt-unterminated.cjs": 3751, + "5474-strip-vt-surrogates.ts": 2805, + "5510-assert-error-properties.js": 2744, + "5511-assert-error-class.ts": 3998, + "5512-assert-error-options.js": 3572, + "5513-assert-deep-equal-loose.js": 3537, + "5514-assert-deep-equal-typed.ts": 2922, + "5515-assert-deep-strict-typed-messages.ts": 2776, + "5516-assert-deep-equal-edges.js": 3465, + "5517-assert-partial-deep-equal.js": 4023, + "5518-assert-partial-deep-typed.ts": 3538, + "5519-assert-partial-deep-typed-edges.ts": 3741, + "5520-assert-record-literal-failures.ts": 3435, + "5520-dyn-property-read-receivers.ts": 3114, + "5521-assert-empty-message.js": 3945, + "5521-dyn-property-read-keys.ts": 2472, + "5522-assert-throws-failure-properties.ts": 3505, + "5523-assert-class-options.js": 3797, + "5524-assert-class-skip-prototype.ts": 2105, + "5530-buffer-pool.ts": 3788, + "5531-buffer-pool-first-slab.ts": 5451, + "5532-buffer-pool-first-slab-untyped.mjs": 37592, + "5540-fs-callback-forms.cjs": 3863, + "5541-fs-stats-fields.cjs": 4344, + "5542-fs-promises-parity.cjs": 2640, + "5543-fs-promises-typed.ts": 3538, + "5544-fs-opendir.cjs": 3175, + "5545-fs-options-encoding.cjs": 3831, + "5546-fs-read-stream.cjs": 3808, + "5547-fs-write-stream.cjs": 5798, + "5548-fs-callback-arguments.cjs": 4728, + "5549-fs-callback-option-checks.cjs": 4270, + "5550-locale-compare-ascii-words.ts": 2457, + "5551-array-search-references.ts": 2240, + "5552-string-appends.ts": 3367, + "5553-string-append-char-code.ts": 2628, + "5554-fs-streams-typed.ts": 4016, + "5555-fs-callback-turns.cjs": 3136, + "5555-http-server-close-keep-alive.ts": 6777, + "5556-http-client-agent-connection.ts": 3427, + "5557-http-outgoing-header-values.ts": 2893, + "5558-http-incoming-duplicate-headers.ts": 3230, + "5559-http-expect-header.ts": 3517, + "5560-http-response-framing.ts": 5004, + "5561-http-max-header-size.ts": 3610, + "5562-https-verify-errors.ts": 3646, + "5563-http-keep-alive-timeout.ts": 11895, + "5564-http-request-signal.ts": 4124, + "5565-fs-dirent-untyped.mjs": 2565, + "5566-fs-dirent-dyn-boundaries/main.mjs": 3508, + "5567-fs-cpsync.ts": 3736, + "5568-fs-cp-errors.js": 4246, + "5569-fs-cp-symlinks.ts": 2136, + "5570-fs-cp-async.ts": 3348, + "5571-fs-cp-deep.ts": 4817, + "5585-record-results-inlined.ts": 3419, + "5595-net-ref-unref.ts": 3245, + "5600-dyn-cycle-self.ts": 2318, + "5601-dyn-cycle-mutual.ts": 2455, + "5602-dyn-cycle-arrays.ts": 3115, + "5603-dyn-cycle-identity.ts": 3197, + "5604-dyn-cycle-checks.ts": 3210, + "5605-dyn-cycle-containers.ts": 2935, + "5606-dyn-cycle-capsules.ts": 2308, + "5610-readable-from-sets-and-views.ts": 3154, + "5611-readable-from-class-iterables.ts": 3984, + "5612-readable-from-iterables.cjs": 3740, + "5613-readable-from-iterable-timing.cjs": 4549, + "5614-readable-from-iterable-errors.cjs": 4240, + "5615-next-tick-callback-phases.ts": 3053, + "5616-next-tick-callback-phases.cjs": 3322, + "5617-pipeline-function-ends.ts": 2710, + "5618-pipeline-function-ends-errors.ts": 3693, + "5619-pipeline-function-ends.cjs": 3677, + "5620-timers-promises-values.ts": 2181, + "5621-util-format-float.ts": 2886, + "5622-events-once.mjs": 3520, + "5623-events-once.ts": 2509, + "5624-timers-promises-unawaited.ts": 2304, + "5625-promisify-exec.ts": 7463, + "5626-promisify-forms.ts": 2936, + "5627-exec-callback.ts": 2909, + "5628-promisify-timers.ts": 3194, + "5629-promisify-stream.ts": 2517, + "5630-promisify-zlib.ts": 2503, + "5631-promisify-crypto.ts": 4296, + "5632-promisify-dns.ts": 2784, + "5644-net-socket-addresses.ts": 2435, + "5645-net-socket-callbacks.ts": 2678, + "5646-net-server-connections.ts": 3279, + "5647-net-is-ip.ts": 2496, + "5648-dns-lookup-forms.ts": 2735, + "5649-dns-service-servers.ts": 3175, + "5650-dns-lookup-errors-untyped.cjs": 1968, + "5651-tls-socket-protocol.ts": 2771, + "5652-http-client-trailer-overflow.ts": 3884, + "5653-net-socket-read-ahead.ts": 4524, + "5654-https-empty-servername.ts": 3451, + "5655-dgram-socket-options.ts": 3481, + "5656-dgram-option-states.ts": 3002, + "5657-net-reset-and-address.ts": 3415, + "5658-net-reset-dynamic.cjs": 2564, + "5659-net-blocklist-socketaddress.ts": 4443, + "5664-tls-client-identity.ts": 3727, + "5674-union-instanceof-array-arms.ts": 2159, + "5680-array-growth-after-copy.ts": 3791, + "5681-array-pop-and-length.ts": 2915, + "5682-publish-wide-objects.ts": 3326, + "5700-cycle-release-retained.ts": 2156, + "5701-cycle-release-old-edges.ts": 2601, + "5702-publish-candidate-buffers.ts": 3469, + "5703-lifetime-region-debug.ts": 3115, + "5704-publish-refused-restores-counts.ts": 2979, + "5710-map-number-keys-hashed.ts": 3019, + "5711-map-number-write-after-read.ts": 2613, + "5712-map-number-overwrite-at-growth.ts": 2614, + "5714-cycle-large-candidate-buffers.ts": 3979, + "5715-json-parse-fitted-tables.ts": 3940, + "5717-set-prototype-of-primitives.ts": 3887, + "5719-int32-fields-dynamic-operators.ts": 3207, + "5720-intern-table-basics.ts": 3625, + "5721-intern-table-values.ts": 4014, + "5722-intern-table-workers.ts": 3210, + "5723-intern-table-shared-types.ts": 4601, + "5724-intern-table-array-keys.ts": 4072, + "5725-intern-table-callbacks.ts": 1996, + "5726-intern-table-key-limits.ts": 2644, + "5740-atomics-operation-semantics.ts": 4810, + "5741-atomics-contended-counters.ts": 2504, + "5742-atomics-lock-ordering.ts": 3000, + "5743-atomics-wait-notify.ts": 3638, + "5744-atomics-ring-buffer.ts": 3352, + "5745-atomics-semaphore-stress.ts": 3671, + "5746-shared-bulk-operations.ts": 2732, + "5747-fs-stat-throw-if-no-entry.ts": 2662, + "5748-fs-stat-throw-if-no-entry-js.cjs": 3085, + "5752-string-number-concat.ts": 3186, + "5760-crypto-hash-stream.ts": 3011, + "5761-crypto-hash-stream-states.ts": 3241, + "5762-crypto-hash-stream.cjs": 3286, + "5763-crypto-sha-blocks.ts": 3264, + "5764-class-structural-view-writes.ts": 4118, + "5764-crypto-hmac-edges.cjs": 2105, + "5765-class-structural-view-identity.ts": 3529, + "5766-class-structural-view-callbacks.ts": 3162, + "5767-class-opaque-accessor-view.ts": 2108, + "5770-guarded-union-narrows.ts": 2881, + "5771-guarded-downcasts.ts": 3555, + "5772-guarded-catch-narrows.ts": 2601, + "5773-stale-narrowing-inherited.ts": 2486, + "5776-power-of-two-remainder-integer-path.ts": 3263, + "5780-readline-history-options.ts": 2909, + "5781-readline-history-options.cjs": 3288, + "5782-readline-terminal-editing.ts": 2661, + "5783-readline-terminal-completion.cjs": 4948, + "5784-readline-terminal-promises.ts": 3042, + "5785-readline-terminal-keys.ts": 3376, + "5786-readline-terminal-history.cjs": 2745, + "5787-readline-cursor-helpers.cjs": 3241, + "5788-readline-promises-readline.ts": 3322, + "5789-readline-cursor-pos.cjs": 3206, + "5790-readline-keypress-events.ts": 3280, + "5791-dyn-constant-key-read-sites.ts": 2813, + "5791-readline-keypress-interfaces.cjs": 3397, + "5792-json-parse-repeated-layouts.ts": 3939, + "5792-readline-keypress-listeners.ts": 2151, + "5793-worker-message-channel.ts": 3274, + "5794-worker-message-port-close-order.ts": 3161, + "5795-worker-message-port-batches.ts": 1925, + "5796-worker-message-channel.cjs": 2678, + "5797-worker-message-port-transfer.ts": 3445, + "5800-broadcast-channel.ts": 3609, + "5801-broadcast-channel.cjs": 3080, + "5802-broadcast-channel-workers.ts": 2610, + "5803-worker-environment-data.ts": 3416, + "5804-worker-environment-data.cjs": 2230, + "5805-worker-receive-message-parent-port.ts": 3538, + "5806-worker-resource-limits.ts": 2813, + "5807-worker-error-values.ts": 4237, + "5808-worker-unhandled-rejections.ts": 4239, + "5809-process-exit-and-rejections.cjs": 3639, + "5810-mock-method-records.ts": 3521, + "5811-mock-tracker-restore.ts": 2838, + "5812-dyn-box-async-fields.ts": 3501, + "5813-mock-timers-module.ts": 3107, + "5814-mock-timers-date.ts": 2412, + "5830-timers-promises-signal.ts": 3875, + "5831-util-types-brands.ts": 4018, + "5832-util-types-brands-dynamic.js": 3859, + "5833-url-search-params-iterators.ts": 2320, + "5834-url-search-params-iterators-dynamic.mjs": 3863, + "5835-util-format-integer-specifiers.ts": 2838, + "5836-url-search-params-tuple-pairs.ts": 3097, + "5837-util-format-json-circular.ts": 2711, + "5838-qs-stringify-bigint.ts": 3073, + "5839-timers-promises-scheduler.ts": 3195, + "5840-promise-with-resolvers-js.js": 2842, + "5841-json-typed-dyn-members.ts": 3759, + "5842-qs-parse-null-prototype.ts": 3419, + "5843-qs-parse-null-prototype-js.mjs": 2453, + "5844-date-unknown-values.ts": 3400, + "5845-groupby-null-prototype.ts": 2868, + "5846-events-esm-default-max.ts": 2670, + "5847-events-cjs-default-max.cjs": 2274, + "5849-class-view-observations.ts": 3073, + "5850-using-disposable-values.ts": 3391, + "5851-using-suppressed-error-values.ts": 2932, + "5852-using-disposable-values-js.js": 3132, + "5853-set-methods-map-arguments.ts": 3034, + "5854-array-from-async.ts": 4140, + "5855-array-from-async-js.js": 3324, + "5856-error-is-error.ts": 2937, + "5857-regexp-unicode-sets.ts": 2520, + "5858-disposable-stack.ts": 4398, + "5859-disposable-stack-js.js": 3669, + "5860-url-ipv4-hosts.ts": 3101, + "5870-worker-thread-names.ts": 3899, + "5871-worker-untransferable.cjs": 3409, + "5872-readline-positional-create-interface.mjs": 3151, + "5873-readline-promises-namespace.cjs": 2023, + "5874-worker-stdio-streams.ts": 3395, + "5875-worker-stdout-pipe.cjs": 3257, + "5879-worker-stdin.ts": 3922, + "5880-emitter-leak-warning-delivery.ts": 3418, + "5881-inspect-weak-collections.ts": 2457, + "5882-string-decoder-runtime-encoding.ts": 2823, + "5883-os-set-priority.ts": 2720, + "5884-inspect-layout-options.ts": 3781, + "5885-events-max-listener-helpers.ts": 2992, + "5886-inspect-dates.ts": 3072, + "5887-inspect-typed-arrays.ts": 2960, + "5888-inspect-sorted.ts": 3397, + "5889-timers-scheduler-signal.ts": 2284, + "5890-while-string-length-counters.ts": 2516, + "5892-buffer-write-utf16le-runs.ts": 3107, + "5900-float16-array.ts": 3631, + "5901-float16-array-js.js": 3789, + "5904-async-generator-completion.ts": 5745, + "5905-array-from-async-generator.ts": 3532, + "5906-array-from-async-generator-js.js": 3910, + "5907-regex-groups-match-rows.ts": 4071, + "5910-set-prototype-of-primitive-object-kinds.ts": 3248, + "5911-dyn-class-to-primitive.ts": 6701, + "5912-dyn-class-conversion-methods.ts": 4374, + "5913-prototype-type-error-messages.ts": 3102, + "5914-dyn-in-class-prototype-members.ts": 2530, + "5915-dyn-error-string-conversions.ts": 3023, + "5920-promise-try-args.ts": 3028, + "5921-promise-try-args-js.js": 3179, + "5922-matchall-groups-callbacks.ts": 4418, + "5923-matchall-groups-js.js": 3161, + "5924-js-literal-identity.js": 2577, + "5925-class-view-identity-observers.ts": 2297, + "5926-class-view-switch-js.js": 2243, + "5927-switch-object-identity.ts": 2986, + "5928-groupby-iterables.ts": 3444, + "5929-groupby-js.js": 2997, + "5930-contract-int32-arrays.ts": 3715, + "5930-method-census-asserted-number-keys.ts": 3330, + "5931-asserted-reads-keep-number-parameters.ts": 2990, + "5932-generic-class-observed-methods.ts": 4272, + "5933-class-fields-unknown-object.ts": 4189, + "5934-js-class-fields-property-order.js": 4613, + "5935-js-subclass-fields-and-element-calls.js": 2484, + "5936-checked-js-class-types.js": 3412, + "5937-override-narrowed-union-returns.ts": 3036, + "5938-object-literal-computed-keys-keep-methods.ts": 3273, + "5939-js-let-object-reassigned-wider.js": 1819, + "5940-callback-helper-specialization.ts": 3109, + "5941-callback-specialization-recursion.ts": 3112, + "5942-callback-specialization-throws.ts": 3221, + "5943-fields-read-before-assignment.ts": 3902, + "5944-js-fields-read-before-assignment.js": 2868, + "5945-local-class-observed-methods.ts": 2284, + "5946-nested-record-field-optional-writes.ts": 2987, + "5950-tuple-predicate-methods.ts": 4611, + "5951-result-never-widening.ts": 2943, + "5952-record-missing-keys.ts": 2332, + "5953-nan-coded-method-returns.ts": 2799, + "5955-any-promise-methods.js": 3148, + "5956-erased-generic-members.ts": 4927, + "5958-asserted-union-receiver.ts": 2198, + "5959-date-to-json.ts": 3051, + "5960-frame-records-own-references.ts": 3563, + "5960-generic-mapped-types.ts": 2996, + "5961-frame-spread-updates.ts": 3260, + "5962-frame-tuples.ts": 3208, + "5970-net-connect-host-name.ts": 1747, + "5971-buffer-chunks-to-string.ts": 3079, + "5972-net-set-encoding-listeners.ts": 3253, + "5973-large-closure-environment.ts": 4499, + "5974-typeof-module-exports.cjs": 2558, + "5975-zlib-class-values.ts": 2531, + "5990-worker-uncloneable.mjs": 3772, + "5991-worker-async-dispose.mjs": 4075, + "5992-worker-thread-name-lifetime.mjs": 3241, "5993-array-length-loop-resizing.ts": 3187, "5994-array-length-sparse-loops.ts": 3292, "5995-array-dense-loop-boundaries.ts": 2596, - "600-closures-basic.ts": 2637, - "601-closures-loops.ts": 2250, - "602-closures-identity-recursion.ts": 2821, - "6020-class-extends-function-constructor.js": 3026, - "6021-asserted-literal-union-arm.ts": 3400, - "603-closures-rc-stress.ts": 2800, - "604-closures-for-of.ts": 1980, - "605-closures-forward-capture-tdz.ts": 2765, - "700-classes-basic.ts": 1650, - "701-classes-composition.ts": 2262, - "702-classes-this-capture.ts": 1945, - "703-classes-rc-stress.ts": 2498, - "710-inheritance-basics.ts": 1936, - "711-inheritance-dispatch.ts": 2643, - "712-inheritance-instanceof.ts": 2608, - "713-inheritance-rc-stress.ts": 2855, - "720-accessors-basics.ts": 2703, - "721-accessors-eval-order.ts": 2000, - "722-accessors-inheritance.ts": 2558, - "723-accessors-rc-stress.ts": 2721, - "750-cycle-closure-box.ts": 2521, - "751-cycle-records-mutual.ts": 2024, - "752-cycle-classes.ts": 2646, - "753-cycle-owned-arrays.ts": 2810, - "754-cycle-external-ref.ts": 2655, - "755-cycle-async-promise.ts": 2228, - "756-cycle-inheritance.ts": 2657, - "757-cycle-cross-generation.ts": 2901, - "762-any-boundary.ts": 2854, - "764-any-async.ts": 2890, - "765-any-optional-chain.ts": 2394, - "766-any-union-boundary.ts": 2672, - "767-string-literal-keys.ts": 2479, - "768-any-uninitialized.ts": 2844, - "800-switch-basics.ts": 2758, - "801-switch-lazy-tests.ts": 2588, - "802-switch-loops.ts": 1780, - "803-switch-rc-stress.ts": 2015, - "804-switch-braced-blocks.ts": 2537, - "810-do-while.ts": 1969, - "820-multi-decl.ts": 1629, - "830-let-uninitialized.ts": 2899, - "900-records-basics.ts": 2778, - "901-records-eval-order.ts": 2686, - "902-records-functions-closures.ts": 2628, - "903-records-rc-stress.ts": 2550, - "904-records-optional-fields.ts": 3083, - "905-records-optional-rc-stress.ts": 2791, - "906-records-utility-types.ts": 1783, - "907-records-utility-generics.ts": 2604, - "908-records-index-signatures.ts": 2041, - "909-records-index-json.ts": 3081, - "910-records-index-rc-stress.ts": 2746, - "911-records-index-dot-access.ts": 3174, - "912-unknown-slots.ts": 2915, - "913-records-index-iteration.ts": 3669, - "914-records-from-entries.ts": 3427, - "915-unknown-tostring-eq.ts": 3373, - "916-unknown-bytes.ts": 2791, - "917-record-array-index-dot.ts": 2745, - "950-modules-basic/main.ts": 2721, - "951-modules-diamond/main.ts": 1492, - "952-modules-cross/main.ts": 1431, - "953-modules-default/main.ts": 2552, - "954-modules-reexport/main.ts": 2362, - "957-builtins-namespace.ts": 2216, - "960-generics-basics.ts": 2982, - "961-generics-recursion.ts": 2893, - "962-generics-closures.ts": 2684, - "963-generics-modules/main.ts": 2595, - "964-generics-rc-stress.ts": 3029, - "965-generics-async.ts": 3085, - "965-unions-retag.ts": 2457, - "966-unions-retag-rc-stress.ts": 2098, - "967-record-field-widening.ts": 2939, - "969-unions-arm-matrix.ts": 2998, - "970-unions-basics.ts": 2779, - "971-unions-switch.ts": 2261, - "972-unions-nested.ts": 2825, - "973-unions-rc-stress.ts": 2576, - "974-unions-modules/main.ts": 2186, - "975-unions-undefined.ts": 2396, - "976-unions-null.ts": 2274, - "977-unions-unit-rc-stress.ts": 2486, - "978-unions-nullish.ts": 2487, - "979-unions-optional-chaining.ts": 2987, - "980-exceptions-basics.ts": 2385, - "981-exceptions-values.ts": 2867, - "982-exceptions-rc-stress.ts": 1550, - "983-exceptions-control-flow.ts": 2778, - "984-exceptions-finally.ts": 2144, - "985-exceptions-call-chains.ts": 3115, - "986-exceptions-uncaught.ts": 2615, - "987-exceptions-result-unions.ts": 1576, - "990-process-basics.ts": 2148, - "991-process-exit.ts": 2021, - "992-fs-roundtrip.ts": 2662, - "993-fs-readdir.ts": 2790, - "994-fs-errors.ts": 2954, - "995-fs-uncaught.ts": 2485, - "996-fs-rc-stress.ts": 2801, - "997-fs-modules/main.ts": 1791, - "998-process-env.ts": 2322, - "abstract-property-dispatch.ts": 3676, - "arguments-arrow-capture.mjs": 2969, - "arguments-reexport/main.ts": 2670, - "array-argument-lifetimes-exits.ts": 3229, - "array-argument-lifetimes-mutation.ts": 2355, - "array-argument-lifetimes-strings.ts": 2875, - "array-argument-lifetimes-values.ts": 3135, - "array-buffer-conversions.js": 2768, - "array-buffer-storage.ts": 2184, - "array-checked-callback-results.mjs": 3207, - "array-checked-constructor.js": 2168, - "array-concat-widening.ts": 3084, - "array-deque-unshift.ts": 3209, - "array-element-compound-updates.ts": 4339, - "array-fill-unit-values.ts": 2510, - "array-from-checked.js": 4274, - "array-from-value.mjs": 3224, - "array-isarray-value/main.js": 2742, - "array-numeric-own-keys.ts": 1884, - "array-optional-number-write-index.ts": 2617, - "array-primitive-ordering.ts": 2544, - "array-queue-head-room.ts": 3344, - "array-read-helper-effects.ts": 2217, - "array-refined-storage.ts": 2827, - "array-sort-dense-effects.ts": 3621, - "array-sort-dense-values.ts": 3004, - "array-sort-holes-published.ts": 7729, - "array-sort-runs.ts": 4117, - "array-sort-runtime-comparator.ts": 4714, - "array-sort-unknown-comparator.ts": 2824, - "array-storage-transitions.ts": 3984, - "array-truncate-reuse.ts": 2234, - "async-backend-factory.mjs": 1807, - "async-local-typed-results.ts": 2185, - "atomics-integer-operations.ts": 2603, - "bigint-checked-casts.ts": 2636, - "bigint-checked-storage.js": 3528, - "bigint-union-conversion.ts": 2763, - "boxed-error-rethrows.mjs": 2627, - "buffer-codec-boundaries.ts": 2453, - "buffer-primitive-predicate.ts": 2183, - "builtin-prototype-method-values.mjs": 3361, - "byte-loop-bounds.ts": 3029, - "byte-number-pipeline.ts": 3197, - "byte-record-windows.ts": 2142, - "call-lifetimes-argument-order.ts": 2451, - "call-lifetimes-control-flow.ts": 2879, - "call-lifetimes-owned-boundaries.ts": 3007, - "call-lifetimes-projections.ts": 1722, - "call-lifetimes-union-values.ts": 2751, - "call-lifetimes-virtual-optionals.ts": 3153, - "callable-module-members.mjs": 2485, - "callable-properties.mjs": 3432, - "callable-property-cycles.js": 3096, - "callable-reexport/main.ts": 3039, - "captured-class-refinement.ts": 3032, - "catch-capture.ts": 2928, - "caught-class-identity.ts": 2572, - "caught-standalone-class.ts": 3034, - "caught-system-error-fields.ts": 2540, - "checked-addition.js": 2460, - "checked-any-addition.ts": 2597, - "checked-array-assignment.ts": 1938, - "checked-array-flat/main.ts": 2376, - "checked-bitwise/main.js": 2931, - "checked-builder-cycles.js": 2124, - "checked-byte-storage/main.ts": 2136, - "checked-callback-options.ts": 2655, - "checked-class-descriptors.mjs": 3730, - "checked-class-factory.mjs": 2259, - "checked-collection-iterators.ts": 3189, - "checked-collection-symbol-methods.ts": 2758, - "checked-dispatch-input-lifetimes.js": 3290, - "checked-increment/main.js": 2209, - "checked-inherited-fields.ts": 1885, - "checked-iterator-consumption.js": 3562, - "checked-numeric-arithmetic.js": 2775, - "checked-object-module-alias.js": 2993, - "checked-optional-calls.mjs": 2857, - "checked-promise-recovery.ts": 2965, - "checked-proxy-callback/main.ts": 2460, - "checked-record-constructor.ts": 2536, - "checked-renderer-defaults.js": 2974, - "checked-rest-function-adapters.js": 2402, - "checked-storage-transitions.js": 3227, - "checked-symbol-array.ts": 2138, - "checked-value-input-lifetimes.ts": 2968, - "class-accessor-returned-function.js": 2548, - "class-array-optional-return.ts": 2505, - "class-bracket-method-calls.js": 3232, - "class-brand-overload.js": 2772, - "class-callback-replacement.js": 4256, - "class-callback-storage.ts": 3103, - "class-checked-composites.ts": 2644, - "class-checked-upcast.ts": 2728, - "class-collection-insertion.ts": 4030, - "class-computed-presence.ts": 3380, - "class-computed-symbols.js": 2436, - "class-covariant-returns.ts": 3091, - "class-curried-factory.mjs": 3427, - "class-data-descriptors.js": 3815, - "class-factory-inherited-statics.mjs": 3016, - "class-factory-parameter-base.mjs": 3162, - "class-factory-record-base.mjs": 5127, - "class-factory-recursive-statics.mjs": 2561, - "class-factory-static-members.mjs": 3200, - "class-function-base/main.js": 3392, - "class-instance-constructor.js": 3735, - "class-interface-protocols.ts": 5264, - "class-interface-refinements.ts": 2054, - "class-json-checked.ts": 2470, - "class-local-function-base.mjs": 3094, - "class-method-spreads.ts": 4098, - "class-narrowed-views.ts": 1811, - "class-property-call-values.mjs": 3042, - "class-prototype-data.js": 2959, - "class-prototype-descriptor-copy.mjs": 3884, - "class-specialized-computed-base.mjs": 3695, - "class-static-data.js": 2083, - "class-subclass-assertions.ts": 2716, - "class-super-surplus-spread.mjs": 3129, - "class-symbol-accessors.ts": 2288, - "class-symbol-cache.mjs": 3599, - "class-value-constructor-exceptions.ts": 2725, - "closed-virtual-dispatch-modules/main.ts": 2752, - "closed-virtual-dispatch.ts": 3200, - "closure-nullable-union-return.ts": 2492, - "closure-union-locals.ts": 2959, - "collection-array-cycles.ts": 3095, - "collection-array-maps.ts": 3559, - "collection-array-missing.ts": 3686, - "collection-array-sets.ts": 3501, - "collection-copy-identities.ts": 2360, - "collection-data-unions.ts": 3003, - "collection-ingestion-mappers.ts": 2535, - "collection-ingestion-protocol/main.ts": 3823, - "collection-ingestion-references.ts": 2342, - "collection-ingestion.ts": 3093, - "collection-storage-copies.ts": 2080, - "collection-value-keys.ts": 2956, - "compound-field-receivers.ts": 1671, - "compound-presence-guards.ts": 3200, - "conditional-tuple-destructuring.ts": 2750, - "console-imports.cjs": 1673, - "console-native-value.js": 2807, - "const-enum-module-cycle/main.ts": 2704, - "constant-callback-dispatch.ts": 1960, - "constant-module-globals/main.ts": 1705, - "constant-number-remainders.ts": 2349, - "constructed-class-dispatch.ts": 3130, - "contextual-array-union-write.ts": 6681, - "contextual-return-layouts.ts": 3422, - "counted-loop-numbers.ts": 2709, - "counted-loop-storage.ts": 2965, - "crypto-hash-optional-input.ts": 2865, - "cycle-generations-long-lived.ts": 2572, - "cycle-growth-yield.ts": 3019, - "date-checked-native.js": 2742, - "declared-index-spread.ts": 3806, - "deep-reference-teardown.ts": 3156, - "default-undefined-parameters.ts": 2963, - "deferred-field-updates.ts": 1865, - "deferred-registry-many.ts": 3051, - "derived-numeric-updates.ts": 1958, - "destructure-call-assignment.js": 2640, - "destructure-inferred-row-defaults.js": 2122, - "destructure-union-arrays.ts": 2784, - "dynamic-function-descriptors.js": 2749, - "error-cause-writes.js": 2022, - "error-inherited-message.mjs": 2684, - "error-inherited-name.mjs": 2378, - "error-property-writes.mjs": 2676, - "error-prototype-tostring.js": 3103, - "error-stack-frames.ts": 2531, - "error-stack-limit.ts": 2338, - "error-tostring-overrides.ts": 2421, - "error-values-inspect.ts": 2394, - "exact-index-round-trip.ts": 2708, - "expression-runtime-values.ts": 2672, - "fiber-switch-stress.ts": 2404, - "fiberless-async-ordering.ts": 2698, - "fiberless-async-unhandled.ts": 2605, - "field-assignment-values.ts": 2753, - "file-handle-values.ts": 2888, - "file-read-storage.ts": 3335, - "file-url-percent-decoding.ts": 1678, - "final-field-borrows.ts": 2810, - "for-multiple-bindings.ts": 2621, - "for-multiple-lexical-bindings.ts": 2696, - "for-of-checked-iterator.js": 2735, - "for-of-subclass-elements.ts": 2538, - "forward-generic-signatures.ts": 1734, - "fresh-array-union-layout.js": 2661, - "frozen-checked-dictionaries.mjs": 2513, - "fs-native-realpath.ts": 2900, - "fs-null-byte-paths-js.cjs": 2166, - "fs-null-byte-paths.ts": 3560, - "fs-read-encodings.ts": 2192, - "fs-read-utf8-edges.ts": 3494, - "fs-read-utf8-handle-forms.ts": 1894, - "fs-remove-readonly.ts": 2005, - "fs-write-string-bytes-union.ts": 2781, - "function-apply-value.mjs": 2795, - "function-constructor-global.mjs": 2338, - "function-constructor-kinds/main.js": 3030, - "function-custom-prototype.js": 2801, - "function-custom-to-string.mjs": 1937, - "function-object-assign.js": 1754, - "function-own-prototype/main.js": 2470, - "generator-checked-protocol.ts": 2909, - "generator-checked-return.js": 3084, - "generator-custom-delegation/main.ts": 5038, - "generator-default-return-pattern.ts": 2685, - "generator-delegation-values.ts": 1962, - "generator-inferred-date.js": 3181, - "generator-mixed-checked-channels.ts": 2887, - "generator-untyped-consumer/main.ts": 2216, - "generic-base-specializations.ts": 2930, - "generic-binding-ownership.ts": 2565, - "generic-class-js-functions/main.ts": 2055, - "generic-class-recovery.ts": 2723, - "generic-namespace-factories/main.ts": 2103, - "generic-nullable-collections.ts": 2282, - "generic-pattern-bindings.ts": 2536, - "generic-record-index.ts": 2488, - "generic-visitor-void.ts": 2848, - "global-accumulator-loops.ts": 2271, - "global-error-subclasses.ts": 1850, - "global-runtime-probes.js": 3085, - "global-stored-probes.js": 3029, - "global-string-cache/main.js": 2487, - "global-symbol-cache/main.js": 2631, - "guarded-native-iterables.ts": 2969, - "heap-input-aliases.ts": 2864, - "heap-input-collections.ts": 2900, - "in-array-runtime-index.ts": 3065, - "indexed-assignment-values.js": 2826, - "indexed-assignment-values.ts": 1639, - "indexed-element-field-reads.ts": 1506, - "inferred-array-assignment-values.mjs": 2520, - "inferred-class-default.mjs": 2339, - "inferred-compound-values.mjs": 2708, - "inferred-conditional-class.mjs": 2429, - "inferred-error-fields.js": 2383, - "inferred-map-patterns.mjs": 2476, - "inferred-method-override.js": 2284, - "inferred-partial-destructuring.mjs": 1972, - "inferred-primitive-properties.mjs": 2268, - "inferred-record-return.mjs": 2543, - "inferred-recursive-record.mjs": 2822, - "inferred-undefined-field.mjs": 2615, - "input-lifetime-intervals.ts": 2188, - "input-lifetimes-modules/main.ts": 2672, - "instanceof-class-record-union.ts": 2441, - "integer-flow-arithmetic.ts": 1990, - "integer-loop-forms.ts": 2426, - "integer-view-control.ts": 2085, - "integer-view-numbers.ts": 2088, - "integer-view-storage.ts": 2560, - "intl-grapheme-conformance/main.ts": 4354, - "intl-grapheme.ts": 1787, - "iterator-typed-returns.ts": 2556, - "js-abort-portable.js": 3289, - "js-array-constructor.js": 3326, - "js-array-default-buffer.js": 2785, - "js-array-iterators.js": 2367, - "js-arrow-bind.cjs": 3832, - "js-buffer-callback-brand.cjs": 2996, - "js-callable-proxy.js": 3619, - "js-chained-native-results.mjs": 2794, - "js-checked-array-iterator.js": 2235, - "js-checked-array-reference.js": 3562, - "js-checked-number-negation.mjs": 2819, - "js-checked-sort-result.js": 2743, - "js-child-error-listener.cjs": 2228, - "js-cjs-callable-snapshots/main.cjs": 2256, - "js-class-added-parameters.js": 2567, - "js-class-checked-overrides.js": 2547, - "js-class-computed-fields.js": 2943, - "js-class-enumeration.js": 3714, - "js-class-field-accessor-override.js": 3000, - "js-class-fluent-overrides.js": 2749, - "js-class-late-method-values.js": 2358, - "js-class-member-dispatch.js": 3594, - "js-class-return-shapes.js": 3435, - "js-class-shadowed-methods.js": 3639, - "js-class-stored-method-receiver.js": 2943, - "js-class-subclass-properties.js": 3662, - "js-class-symbol-spread.cjs": 2503, - "js-computed-prototype-additions.js": 2456, - "js-constructor-returned-callable.js": 2517, - "js-constructor-spread.js": 3593, - "js-dataview-dispatch.js": 2188, - "js-declared-fields.cjs": 4540, - "js-default-listener-arguments.cjs": 2448, - "js-default-options/main.ts": 3104, - "js-deferred-field-initializers.js": 2710, - "js-deferred-registry-effects.js": 2361, - "js-derived-constructor-hoisting.js": 2306, - "js-dormant-array-write.js": 2104, - "js-dormant-overrides.js": 1741, - "js-expando-records.js": 2473, - "js-implicit-call-results.js": 2893, - "js-inferred-callback-exports/main.js": 4125, - "js-inferred-class-array-return.js": 2816, - "js-inferred-object-values.js": 2369, - "js-inherited-field-storage.js": 3308, - "js-inherited-parameter-abi.js": 2238, - "js-iterable-spread.js": 2086, - "js-loose-dynamic-primitives.js": 2810, - "js-map-object-seeds.js": 2592, - "js-member-increment.js": 3352, - "js-module-function-values.js": 2994, - "js-mutable-null-members.js": 2723, - "js-nested-native-descriptors.js": 2548, - "js-normalize-dispatch.js": 2929, - "js-nullish-inherited-fields.mjs": 2189, - "js-object-receiver-storage.js": 2175, - "js-object-returning-constructors.mjs": 2945, - "js-object-shared-arrays.js": 2935, - "js-omitted-typed-arguments.js": 2736, - "js-open-binding-writes.js": 2167, - "js-optional-class-fields.js": 3219, - "js-optional-member-call.js": 3110, - "js-primitive-union-addition.js": 2549, - "js-promise-all-values.js": 3527, - "js-promise-catch-handler.js": 2649, - "js-promise-finally-order.js": 2445, - "js-promise-pending-reactions.js": 2595, - "js-prototype-host-boundary.js": 2723, - "js-reflect-receivers.js": 3391, - "js-regex-record-captures.js": 3115, - "js-scalar-iterables.js": 2746, - "js-shared-method-dispatch.js": 2796, - "js-specialized-field-method.js": 2049, - "js-static-accessors.js": 3053, - "js-static-method-values.js": 2375, - "js-static-registries.cjs": 2790, - "js-super-accessor-initialization.js": 2104, - "js-uninitialized-native-fields.js": 1764, - "json-guarded-map-values.ts": 3144, - "json-output-bulk.ts": 2572, - "json-runtime-options.mjs": 2583, - "json-stringify-value.js": 2182, - "json-typed-parse-direct.ts": 3644, - "json-typed-parse-index-signatures.ts": 4122, - "json-typed-parse-optional-members.ts": 3273, - "json-typed-parse-union-members.ts": 3078, - "literal-switch-dispatch.ts": 2252, - "live-reference-shared-converters.ts": 3470, - "llvm-read-receiver-lifetime.ts": 3118, - "local-class-call-spreads.js": 2490, - "local-class-declaration.ts": 2302, - "local-class-evaluation.ts": 2915, - "local-class-inheritance.ts": 2396, - "local-class-lifetimes.ts": 2780, - "local-class-namespace/main.js": 3248, - "local-class-prototype-data.js": 3273, - "local-class-specialization.js": 2054, - "local-class-unknown.ts": 1964, - "local-class-values.ts": 2059, - "local-union-storage.ts": 2500, - "locale-compare-root-order.ts": 2609, - "logical-assignment-dynamic.js": 2892, - "logical-assignment-values.ts": 2287, - "logical-runtime-optional-record.ts": 2390, - "loop-reference-lifetimes.ts": 2959, - "map-checked-boundary/main.ts": 2651, - "map-checked-seed.js": 1821, - "map-get-set-fusion.ts": 3131, - "map-number-keys-dense.ts": 2480, - "map-read-lifetimes-exits.ts": 2004, - "map-read-lifetimes.ts": 2956, - "map-seeds-and-spreads.ts": 2807, - "map-typed-array-values.ts": 2864, - "math-function-values.js": 2704, - "missing-read-lambda-results.ts": 2964, - "missing-read-narrowed-storage.ts": 2975, - "missing-read-number-conversions.ts": 2247, - "module-byte-loops.ts": 2710, - "module-fallback-functions/main.js": 2953, - "narrowed-nullish-values.ts": 2689, - "native-any-timer-callback.ts": 2256, - "native-array-borrowed-find-last.js": 2331, - "native-array-borrowed-slice.js": 2738, - "native-array-copying-methods.js": 2547, - "native-array-fill-copywithin.js": 2422, - "native-array-frozen-noops.js": 1940, - "native-array-index-boundaries.js": 1855, - "native-array-integrity.js": 3078, - "native-array-length.js": 2779, - "native-array-named-properties.js": 2991, - "native-array-prototype/main.js": 1536, - "native-array-read-lifetimes.ts": 3338, - "native-array-reduce-find-last.js": 2328, - "native-array-search-from-index.js": 2430, - "native-array-splice-coercion.js": 2633, - "native-array-splice-flat.js": 2555, - "native-buffer-coercion.js": 2993, - "native-callback-dispatch.ts": 3551, - "native-class-array-boundaries.ts": 2938, - "native-class-cache.js": 4207, - "native-class-properties.cjs": 3301, - "native-class-property-cycles.cjs": 2085, - "native-class-property-order.cjs": 2417, - "native-class-type-predicates.ts": 2597, - "native-factory-records.js": 2167, - "native-method-values.js": 3675, - "native-method-values.ts": 2504, - "native-npm-imports/main.ts": 3572, - "native-object-descriptors.js": 2795, - "native-object-for-in-minimal.js": 2689, - "native-object-property-attributes.js": 2700, - "native-object-prototype.js": 2600, - "native-property-names.ts": 2409, - "native-proxy-env.js": 3746, - "native-worker-arena-reuse.ts": 4764, - "native-worker-bounded-errors.ts": 3072, - "native-worker-buffer-consumers.ts": 2989, - "native-worker-cancel-hot.ts": 2633, - "native-worker-class-fields.ts": 3458, - "native-worker-clone-errors.ts": 2734, - "native-worker-commonjs.cjs": 2159, - "native-worker-delayed-messages.ts": 2169, - "native-worker-discarded-heaps.ts": 5523, - "native-worker-environment.ts": 3190, - "native-worker-error.ts": 2740, - "native-worker-exception-state.ts": 4140, - "native-worker-exit-listeners.ts": 2056, - "native-worker-io.ts": 2596, - "native-worker-loop-cancellation.ts": 2554, - "native-worker-message-graphs.ts": 3182, - "native-worker-messages.ts": 2651, - "native-worker-poll-exceptions.ts": 3212, - "native-worker-port-lifetime.ts": 3033, - "native-worker-process-exit.ts": 2692, - "native-worker-publish-classes.ts": 4065, - "native-worker-publish-refusals.ts": 3039, - "native-worker-published-graphs.ts": 3663, - "native-worker-references.ts": 2640, - "native-worker-roots/main.ts": 3080, - "native-worker-shared-views.ts": 3041, - "native-worker-stack-overflow.ts": 2862, - "native-worker-terminate-exception-state.ts": 3985, - "native-worker-terminate-loop.ts": 2725, - "native-worker-terminate-recursion.ts": 3128, - "native-worker-terminate-suspended.ts": 2867, - "native-worker-terminate-tested-loops.ts": 3161, - "native-worker-terminate-wait.ts": 1905, - "native-worker-typed-arrays.ts": 2971, - "nested-map-cycles.ts": 2802, - "nested-map-values.ts": 3022, - "never-returning-calls.ts": 2411, - "next-tick-commonjs-entry.cjs": 2251, - "node24-buffer-encoding-errors.ts": 2393, - "node24-buffer-encoding.ts": 2789, - "node24-crypto-kdf-errors.ts": 2833, - "node24-crypto-kdf-options.ts": 2131, - "node24-crypto-kdf.ts": 4066, - "node24-crypto-sha2.ts": 1593, - "node24-deep-equality-properties.js": 2924, - "node24-deep-equality.cjs": 2596, - "node24-deep-equality.ts": 3235, - "node24-env-files-errors.ts": 2781, - "node24-env-files.ts": 2586, - "node24-env-imports.cjs": 1729, - "node24-env-parse-errors.ts": 2642, - "node24-env-parse.ts": 2636, - "node24-esm-metadata/main.mjs": 2627, - "node24-file-url-buffer.ts": 2669, - "node24-file-url-errors.js": 2467, - "node24-file-url-options.ts": 3030, - "node24-fs-links-callbacks.cjs": 3015, - "node24-fs-links-errors.cjs": 2843, - "node24-fs-links-options.cjs": 3229, - "node24-fs-links-promise-errors.cjs": 2844, - "node24-fs-links-promises.ts": 2107, - "node24-fs-links.ts": 1958, - "node24-fs-statfs-callbacks.cjs": 2203, - "node24-fs-statfs-errors.cjs": 2705, - "node24-fs-statfs-options.cjs": 2846, - "node24-fs-statfs.ts": 2174, - "node24-fs-timestamps-callbacks.cjs": 2972, - "node24-fs-timestamps-errors.cjs": 1969, - "node24-fs-timestamps-promises.ts": 2959, - "node24-fs-timestamps-symlinks.ts": 2931, - "node24-fs-timestamps.ts": 1989, - "node24-no-error-assertions-coercion.js": 3207, - "node24-no-error-assertions.cjs": 1972, - "node24-no-error-assertions.ts": 2214, - "node24-parseargs.js": 4158, - "node24-string-decoder.ts": 2635, - "node24-style-text-environment.js": 2062, - "node24-style-text-validation.js": 3237, - "node24-style-text.cjs": 2491, - "node24-style-text.ts": 2829, - "node24-system-error-validation.js": 2660, - "node24-system-errors.cjs": 2361, - "node24-system-errors.ts": 2897, - "node24-text-codec-properties.ts": 2383, - "node24-text-encode-into.ts": 2992, - "node24-text-utilities-coercion.js": 2902, - "node24-text-utilities-validation.js": 2997, - "node24-text-utilities.cjs": 2432, - "node24-text-utilities.ts": 1910, - "node24-url-authority-coercion.js": 2861, - "node24-url-authority.ts": 2689, - "node24-url-factories.ts": 1863, - "node24-url-factory-errors.ts": 1955, - "node24-url-mutation-coercion.js": 2400, - "node24-url-mutation.ts": 2663, - "node24-util-types.cjs": 3712, - "node24-util-types.js": 2869, - "node24-util-types.ts": 3395, - "non-null-class-iteration.ts": 2220, - "nonnull-element-arguments.ts": 2568, - "nonnull-forwarded-class-values.ts": 2603, - "nullable-object-extension.mjs": 2408, - "nullish-asserted-class-arms.ts": 2116, - "nullish-assignment-values.ts": 2517, - "nullish-long-chain.ts": 2430, - "number-parse-statics.ts": 1887, - "number-predicates-unknown.ts": 1974, - "numeric-call-specialization.ts": 2627, - "object-enumeration-array-reads.ts": 2586, - "object-from-checked-entries.js": 2775, - "object-inherited-to-string.js": 2674, - "object-key-indexes.js": 2909, - "object-prototype-identity.mjs": 2317, - "object-reexport/main.js": 2625, - "object-spread-computed.ts": 2429, - "opentui-byte-queue.js": 3139, - "optional-callback-arity.ts": 2294, - "optional-class-flows.ts": 2613, - "optional-element-defaults.ts": 2793, - "optional-flag-comparisons.ts": 2714, - "optional-native-callables.js": 2344, - "optional-node-list-iteration.ts": 2344, - "optional-string-index/main.ts": 2788, - "path-to-file-url-options.ts": 2568, - "performance-presence.ts": 2450, - "primitive-and-function-descriptors.js": 2677, - "primitive-union-string.ts": 1777, - "process-builtin-values.js": 3974, - "process-constrained-memory.ts": 1850, - "process-env-computed-keys.js": 2019, - "process-hrtime.js": 2975, - "process-named-signals.cjs": 2191, - "process-uncaught-handler-throws.cjs": 2460, - "process-uncaught-loop.cjs": 2411, - "process-uncaught-module.mjs": 1942, - "process-uncaught-monitor.cjs": 1718, - "process-uncaught-rejection.cjs": 2645, - "process-uncaught-sync.cjs": 2436, - "process-version-pin.ts": 1717, - "process-versions-storage.ts": 2502, - "projected-collection-lifetimes.ts": 2791, - "promise-checked-rejections.ts": 2434, - "promise-resolve-void.ts": 2330, - "prototype-method-overrides.mjs": 4995, - "prototype-named-data-records.ts": 2858, - "rc-last-use-moves.ts": 2819, - "rc-private-array-writes.ts": 2121, - "record-field-presence.ts": 3356, - "record-key-order.ts": 2943, - "record-optional-json-presence.ts": 2861, - "record-presence-copies.ts": 2372, - "record-presence-delete-json.ts": 3243, - "record-unchecked-read-presence.ts": 2717, - "record-unknown-values.ts": 3976, - "reflect-own-keys.mjs": 2238, - "reflect-record-union-keys.mjs": 2626, - "reflect-typed-record-keys.ts": 2852, - "regex-callback-replacements.ts": 2111, - "regex-callback-values.js": 2464, - "regex-checked-casts.ts": 2160, - "regex-checked-storage.js": 2310, - "regex-exec-long-subject.ts": 4567, - "regex-exec-result-arrays.ts": 3123, - "regex-fs-text-surfaces.ts": 2847, - "regex-input-lifetimes.ts": 2221, - "regex-native-matcher.ts": 4414, - "regex-optional-captures.ts": 3043, - "regex-optional-templates.ts": 2695, - "regex-split-captures.ts": 2413, - "regex-text-paths.ts": 3078, - "regexp-constructor-repeat.ts": 2829, - "regexp-optional-constructor.ts": 2162, - "regexp-string-coercion.js": 2219, - "renderer-export-dictionaries.js": 2331, - "renderer-null-state.js": 1751, - "renderer-specializations.js": 2860, - "repeat-and-typed-read-errors.ts": 2689, - "rest-optional-array-arguments.ts": 2219, - "rest-optional-elements.ts": 2503, - "return-void-through-finally.ts": 2582, - "runtime-optional-string-flows.ts": 2381, - "scalar-string-slices.ts": 2256, - "set-checked-methods.js": 2598, - "set-checked-storage.ts": 2088, - "set-iterator-seed-references.ts": 2454, - "set-iterator-seeds.ts": 3016, - "set-optional-seeds.ts": 2563, - "small-collection-transitions.ts": 2967, - "speculative-integer-globals.ts": 2480, - "speculative-integer-loops.ts": 3219, - "speculative-integer-reads.ts": 2852, - "stack-depth-async-bodies.ts": 2421, - "stack-overflow-async.ts": 1922, - "stack-overflow-caught.ts": 2542, - "stack-overflow-finally.ts": 2607, - "stack-overflow-shapes.ts": 3083, - "stack-overflow-uncaught.ts": 2465, - "stackless-async-concurrency.ts": 2441, - "stackless-async-context.ts": 2934, - "stackless-async-exceptions.ts": 2936, - "stackless-async-ordering.ts": 2618, - "stackless-async-unhandled.ts": 2477, - "static-field-updates/main.ts": 2461, - "static-method-receivers.ts": 1849, - "stdio-values.mjs": 2236, - "stdio-write-errors.mjs": 2342, - "stdio-write-overrides.mjs": 2002, - "stored-native-builtins.js": 2708, - "stored-object-helpers.js": 2808, - "stream-dynamic-entry-kinds.cjs": 3015, - "stream-dynamic-entry-kinds.ts": 1582, - "stream-encoded-from-entries.cjs": 3058, - "stream-encoded-from-entries.ts": 2590, - "string-char-code-integer-loops.ts": 2802, - "string-code-points.ts": 2658, - "string-concat-number-parts.ts": 2339, - "string-construction-order.ts": 2902, - "string-field-append.ts": 3251, - "string-lifetimes-boundaries.ts": 2858, - "string-lifetimes-evaluation.ts": 1805, - "string-lifetimes-iteration.ts": 2235, - "string-lifetimes-operations.ts": 2468, - "string-normalize.ts": 2348, - "string-pattern-replacement.ts": 1662, - "string-scan-fast-paths.ts": 2133, - "string-split-checked-separator.mjs": 2285, - "string-split-traversal.ts": 1939, - "structural-class-properties.ts": 3139, - "structured-text-boundaries.js": 3111, - "structured-text-storage.ts": 2912, - "switch-integer-dispatch.ts": 2264, - "symbol-checked-boundary/main.ts": 2800, - "symbol-class-fields.ts": 2364, - "symbol-class-fields/main.cjs": 2507, - "symbol-class-methods/main.ts": 2255, - "symbol-fields-deferred-factory.ts": 2386, - "symbol-fields-inferred.js": 2386, - "symbol-object-properties/main.js": 3085, - "synchronous-callback-lifetimes.ts": 2296, - "terminal-stream-properties.ts": 2094, - "text-codec-values/main.ts": 2338, - "text-codec-var.ts": 2708, - "text-encode-into-boundaries.ts": 2679, - "timers-clear-many.ts": 2665, - "tuple-and-string-search.ts": 2567, - "tuple-array-union.ts": 2150, - "tuple-callback-visitation.ts": 3321, - "tuple-forof-visitation.ts": 2818, - "typed-array-bulk-conversion.mjs": 4061, - "typed-array-byte-io.js": 3073, - "typed-array-checked-index.js": 2572, - "typed-array-constructor-alias.ts": 2243, - "typed-array-constructor-identity.js": 2693, - "typed-array-constructor-union.ts": 2646, - "typed-array-constructor-values.mjs": 2380, - "typed-array-dynamic-methods.js": 2112, - "typed-array-integer-widths.ts": 2661, - "typed-array-nan-coded-reads.ts": 3761, - "typed-array-numeric-import.ts": 2783, - "typed-array-present-reads.ts": 3074, - "typed-array-reversed-storage.ts": 2650, - "typed-array-unknown.ts": 2830, - "typed-collection-iterator-references.ts": 3315, - "typed-collection-iterators.ts": 3098, - "typed-collection-views/main.ts": 1720, - "typed-index-arguments.ts": 2531, - "typed-prototype-methods.ts": 3386, - "typed-rest-callables.ts": 2393, - "typed-rest-filtered-return.ts": 2745, - "typedarray-native-inputs.js": 3102, - "typeof-checked-comparison.js": 2558, - "uint8array-sort-domains.ts": 2057, - "unicode-case-paths.ts": 2222, - "unicode-process-argv.ts": 2491, - "union-discriminant-width.ts": 2970, - "union-literal-scalar-discriminants.ts": 3053, - "union-literal-slot-conversion.ts": 2820, - "union-nested-layout-discriminant.ts": 1976, - "union-optional-semantic-identity.ts": 3464, - "union-record-clone.ts": 2368, - "union-record-structural-copy.ts": 3130, - "union-reference-comparison.ts": 2882, - "unknown-array-holes.ts": 1889, - "unknown-collections.ts": 3133, - "unknown-object-enumeration.ts": 4341, - "unknown-record-views.ts": 3288, - "url-runtime-base.ts": 2471, - "utf8-span-decoding.ts": 2821, - "util-parseargs-wrapped/main.ts": 2971, - "virtual-runtime-optional-returns.ts": 3001, - "weak-map-array-buffer.ts": 1951, - "weak-map-fresh-array.js": 2498, - "weak-map-native.js": 3238, - "weak-native-class-identity.ts": 2197, - "weak-set-native.js": 2814, - "worker-class-instance-clone.ts": 3421 + "600-closures-basic.ts": 2093, + "601-closures-loops.ts": 2964, + "602-closures-identity-recursion.ts": 2859, + "6020-class-extends-function-constructor.js": 3170, + "6021-asserted-literal-union-arm.ts": 3166, + "603-closures-rc-stress.ts": 2756, + "604-closures-for-of.ts": 2963, + "6041-error-cause-redeclared.ts": 2988, + "6042-regex-match-object-destructuring.ts": 3393, + "6043-string-index-narrowed-union.ts": 2983, + "605-closures-forward-capture-tdz.ts": 2902, + "6140-cjs-require-tdz-throws/main.js": 2731, + "6141-cjs-require-tdz-checked/main.js": 2856, + "6142-cjs-require-published-early/main.js": 3400, + "6143-cjs-require-json/main.js": 3245, + "6144-cjs-require-builtin-nested/main.js": 2181, + "6145-cjs-require-cycle/main.js": 3507, + "700-classes-basic.ts": 2476, + "701-classes-composition.ts": 2819, + "702-classes-this-capture.ts": 2834, + "703-classes-rc-stress.ts": 2484, + "710-inheritance-basics.ts": 2629, + "711-inheritance-dispatch.ts": 2199, + "712-inheritance-instanceof.ts": 2914, + "713-inheritance-rc-stress.ts": 2307, + "720-accessors-basics.ts": 2496, + "721-accessors-eval-order.ts": 3007, + "722-accessors-inheritance.ts": 2266, + "723-accessors-rc-stress.ts": 2951, + "750-cycle-closure-box.ts": 2797, + "751-cycle-records-mutual.ts": 2867, + "752-cycle-classes.ts": 2668, + "753-cycle-owned-arrays.ts": 2613, + "754-cycle-external-ref.ts": 2566, + "755-cycle-async-promise.ts": 2707, + "756-cycle-inheritance.ts": 2258, + "757-cycle-cross-generation.ts": 3080, + "762-any-boundary.ts": 3283, + "764-any-async.ts": 2876, + "765-any-optional-chain.ts": 3213, + "766-any-union-boundary.ts": 3515, + "767-string-literal-keys.ts": 2750, + "768-any-uninitialized.ts": 2902, + "800-switch-basics.ts": 2776, + "801-switch-lazy-tests.ts": 2159, + "802-switch-loops.ts": 2543, + "803-switch-rc-stress.ts": 3003, + "804-switch-braced-blocks.ts": 2593, + "810-do-while.ts": 2089, + "820-multi-decl.ts": 2503, + "830-let-uninitialized.ts": 2817, + "900-records-basics.ts": 2340, + "901-records-eval-order.ts": 2257, + "902-records-functions-closures.ts": 2757, + "903-records-rc-stress.ts": 2938, + "904-records-optional-fields.ts": 2935, + "905-records-optional-rc-stress.ts": 2626, + "906-records-utility-types.ts": 2717, + "907-records-utility-generics.ts": 2997, + "908-records-index-signatures.ts": 3162, + "909-records-index-json.ts": 3408, + "910-records-index-rc-stress.ts": 2486, + "911-records-index-dot-access.ts": 3533, + "912-unknown-slots.ts": 2761, + "913-records-index-iteration.ts": 3662, + "914-records-from-entries.ts": 3551, + "915-unknown-tostring-eq.ts": 3814, + "916-unknown-bytes.ts": 2926, + "917-record-array-index-dot.ts": 2493, + "950-modules-basic/main.ts": 2549, + "951-modules-diamond/main.ts": 2015, + "952-modules-cross/main.ts": 2203, + "953-modules-default/main.ts": 2058, + "954-modules-reexport/main.ts": 2223, + "957-builtins-namespace.ts": 2583, + "960-generics-basics.ts": 2371, + "961-generics-recursion.ts": 2698, + "962-generics-closures.ts": 2945, + "963-generics-modules/main.ts": 1815, + "964-generics-rc-stress.ts": 3183, + "965-generics-async.ts": 3138, + "965-unions-retag.ts": 2552, + "966-unions-retag-rc-stress.ts": 2838, + "967-record-field-widening.ts": 3366, + "969-unions-arm-matrix.ts": 2362, + "970-unions-basics.ts": 2298, + "971-unions-switch.ts": 2850, + "972-unions-nested.ts": 2374, + "973-unions-rc-stress.ts": 1915, + "974-unions-modules/main.ts": 2639, + "975-unions-undefined.ts": 2297, + "976-unions-null.ts": 1941, + "977-unions-unit-rc-stress.ts": 2513, + "978-unions-nullish.ts": 3070, + "979-unions-optional-chaining.ts": 3263, + "980-exceptions-basics.ts": 2631, + "981-exceptions-values.ts": 2273, + "982-exceptions-rc-stress.ts": 2398, + "983-exceptions-control-flow.ts": 2350, + "984-exceptions-finally.ts": 2928, + "985-exceptions-call-chains.ts": 2642, + "986-exceptions-uncaught.ts": 2072, + "987-exceptions-result-unions.ts": 2255, + "990-process-basics.ts": 2565, + "991-process-exit.ts": 1649, + "992-fs-roundtrip.ts": 2134, + "993-fs-readdir.ts": 2805, + "994-fs-errors.ts": 1790, + "995-fs-uncaught.ts": 2295, + "996-fs-rc-stress.ts": 3230, + "997-fs-modules/main.ts": 2893, + "998-process-env.ts": 1803, + "abstract-property-dispatch.ts": 3619, + "arguments-arrow-capture.mjs": 2943, + "arguments-reexport/main.ts": 2123, + "array-argument-lifetimes-exits.ts": 3367, + "array-argument-lifetimes-mutation.ts": 2372, + "array-argument-lifetimes-strings.ts": 2429, + "array-argument-lifetimes-values.ts": 3148, + "array-buffer-conversions.js": 2274, + "array-buffer-storage.ts": 2433, + "array-checked-callback-results.mjs": 2526, + "array-checked-constructor.js": 3336, + "array-concat-widening.ts": 1977, + "array-deque-unshift.ts": 3233, + "array-element-compound-updates.ts": 3547, + "array-fill-unit-values.ts": 2929, + "array-from-checked.js": 3397, + "array-from-value.mjs": 3059, + "array-isarray-value/main.js": 2918, + "array-numeric-own-keys.ts": 2790, + "array-optional-number-write-index.ts": 2704, + "array-primitive-ordering.ts": 4576, + "array-queue-head-room.ts": 2847, + "array-read-helper-effects.ts": 3311, + "array-refined-storage.ts": 2961, + "array-sort-dense-effects.ts": 4064, + "array-sort-dense-values.ts": 4011, + "array-sort-holes-published.ts": 7513, + "array-sort-runs.ts": 5700, + "array-sort-runtime-comparator.ts": 4830, + "array-sort-unknown-comparator.ts": 3102, + "array-storage-transitions.ts": 3965, + "array-truncate-reuse.ts": 3475, + "async-backend-factory.mjs": 2766, + "async-local-typed-results.ts": 3471, + "atomics-integer-operations.ts": 3518, + "bigint-checked-casts.ts": 3182, + "bigint-checked-storage.js": 3679, + "bigint-union-conversion.ts": 2403, + "boxed-error-rethrows.mjs": 2704, + "buffer-codec-boundaries.ts": 3023, + "buffer-primitive-predicate.ts": 2153, + "builtin-prototype-method-values.mjs": 2713, + "byte-loop-bounds.ts": 3126, + "byte-number-pipeline.ts": 3555, + "byte-record-windows.ts": 3164, + "call-lifetimes-argument-order.ts": 3386, + "call-lifetimes-control-flow.ts": 2774, + "call-lifetimes-owned-boundaries.ts": 2902, + "call-lifetimes-projections.ts": 2603, + "call-lifetimes-union-values.ts": 3045, + "call-lifetimes-virtual-optionals.ts": 2344, + "callable-module-members.mjs": 2928, + "callable-properties.mjs": 2765, + "callable-property-cycles.js": 1847, + "callable-reexport/main.ts": 2222, + "captured-class-refinement.ts": 3000, + "catch-capture.ts": 3112, + "caught-class-identity.ts": 3640, + "caught-standalone-class.ts": 3171, + "caught-system-error-fields.ts": 3152, + "checked-addition.js": 2684, + "checked-any-addition.ts": 2642, + "checked-array-assignment.ts": 2697, + "checked-array-flat/main.ts": 2840, + "checked-bitwise/main.js": 2581, + "checked-builder-cycles.js": 2948, + "checked-byte-storage/main.ts": 2611, + "checked-callback-options.ts": 1643, + "checked-class-descriptors.mjs": 3640, + "checked-class-factory.mjs": 2778, + "checked-collection-iterators.ts": 3241, + "checked-collection-symbol-methods.ts": 2293, + "checked-dispatch-input-lifetimes.js": 2742, + "checked-increment/main.js": 2072, + "checked-inherited-fields.ts": 3028, + "checked-iterator-consumption.js": 3107, + "checked-numeric-arithmetic.js": 2378, + "checked-object-module-alias.js": 2947, + "checked-optional-calls.mjs": 3142, + "checked-promise-recovery.ts": 2855, + "checked-proxy-callback/main.ts": 1847, + "checked-record-constructor.ts": 2481, + "checked-renderer-defaults.js": 2013, + "checked-rest-function-adapters.js": 3046, + "checked-storage-transitions.js": 2689, + "checked-symbol-array.ts": 2459, + "checked-value-input-lifetimes.ts": 3335, + "class-accessor-returned-function.js": 2629, + "class-array-optional-return.ts": 2795, + "class-bracket-method-calls.js": 3486, + "class-brand-overload.js": 2784, + "class-callback-replacement.js": 2660, + "class-callback-storage.ts": 3042, + "class-checked-composites.ts": 3335, + "class-checked-upcast.ts": 3076, + "class-collection-insertion.ts": 2281, + "class-computed-presence.ts": 3266, + "class-computed-symbols.js": 2803, + "class-covariant-returns.ts": 3398, + "class-curried-factory.mjs": 3626, + "class-data-descriptors.js": 3529, + "class-factory-inherited-statics.mjs": 3667, + "class-factory-parameter-base.mjs": 2767, + "class-factory-record-base.mjs": 3407, + "class-factory-recursive-statics.mjs": 3184, + "class-factory-static-members.mjs": 3515, + "class-function-base/main.js": 3746, + "class-instance-constructor.js": 3651, + "class-interface-protocols.ts": 5020, + "class-interface-refinements.ts": 2194, + "class-json-checked.ts": 1821, + "class-local-function-base.mjs": 3398, + "class-method-spreads.ts": 3880, + "class-narrowed-views.ts": 3116, + "class-property-call-values.mjs": 3490, + "class-prototype-data.js": 3512, + "class-prototype-descriptor-copy.mjs": 4571, + "class-specialized-computed-base.mjs": 3883, + "class-static-data.js": 2886, + "class-subclass-assertions.ts": 3020, + "class-super-surplus-spread.mjs": 2209, + "class-symbol-accessors.ts": 2490, + "class-symbol-cache.mjs": 2911, + "class-value-constructor-exceptions.ts": 2697, + "closed-virtual-dispatch-modules/main.ts": 2682, + "closed-virtual-dispatch.ts": 3944, + "closure-nullable-union-return.ts": 3308, + "closure-union-locals.ts": 3570, + "collection-array-cycles.ts": 2714, + "collection-array-maps.ts": 3451, + "collection-array-missing.ts": 3109, + "collection-array-sets.ts": 2862, + "collection-copy-identities.ts": 3119, + "collection-data-unions.ts": 3087, + "collection-ingestion-mappers.ts": 3823, + "collection-ingestion-protocol/main.ts": 2461, + "collection-ingestion-references.ts": 3913, + "collection-ingestion.ts": 3524, + "collection-storage-copies.ts": 3595, + "collection-value-keys.ts": 2425, + "compound-field-receivers.ts": 2962, + "compound-presence-guards.ts": 3337, + "conditional-tuple-destructuring.ts": 2631, + "console-imports.cjs": 2257, + "console-native-value.js": 2531, + "const-enum-module-cycle/main.ts": 2437, + "constant-callback-dispatch.ts": 2800, + "constant-module-globals/main.ts": 3036, + "constant-number-remainders.ts": 2724, + "constructed-class-dispatch.ts": 3005, + "contextual-array-union-write.ts": 6554, + "contextual-return-layouts.ts": 2859, + "counted-loop-numbers.ts": 2703, + "counted-loop-storage.ts": 2473, + "crypto-hash-optional-input.ts": 3036, + "cycle-generations-long-lived.ts": 2902, + "cycle-growth-yield.ts": 3252, + "date-checked-native.js": 2177, + "declared-index-spread.ts": 3543, + "deep-reference-teardown.ts": 2409, + "default-undefined-parameters.ts": 3171, + "deferred-field-updates.ts": 2290, + "deferred-registry-many.ts": 3267, + "derived-numeric-updates.ts": 2762, + "destructure-call-assignment.js": 2259, + "destructure-inferred-row-defaults.js": 2953, + "destructure-union-arrays.ts": 3202, + "dynamic-function-descriptors.js": 2214, + "error-cause-writes.js": 3441, + "error-inherited-message.mjs": 3449, + "error-inherited-name.mjs": 2955, + "error-property-writes.mjs": 2326, + "error-prototype-tostring.js": 2596, + "error-stack-frames.ts": 2880, + "error-stack-limit.ts": 2871, + "error-tostring-overrides.ts": 2481, + "error-values-inspect.ts": 2856, + "exact-index-round-trip.ts": 3660, + "expression-runtime-values.ts": 2159, + "fiber-switch-stress.ts": 2800, + "fiberless-async-ordering.ts": 3075, + "fiberless-async-unhandled.ts": 2437, + "field-assignment-values.ts": 2878, + "file-handle-values.ts": 2035, + "file-read-storage.ts": 2737, + "file-url-percent-decoding.ts": 2029, + "final-field-borrows.ts": 3105, + "for-multiple-bindings.ts": 2994, + "for-multiple-lexical-bindings.ts": 2863, + "for-of-checked-iterator.js": 3515, + "for-of-subclass-elements.ts": 2469, + "forward-generic-signatures.ts": 3287, + "fresh-array-union-layout.js": 2961, + "frozen-checked-dictionaries.mjs": 3021, + "fs-native-realpath.ts": 3263, + "fs-null-byte-paths-js.cjs": 2762, + "fs-null-byte-paths.ts": 3411, + "fs-read-encodings.ts": 3220, + "fs-read-utf8-edges.ts": 3246, + "fs-read-utf8-handle-forms.ts": 3163, + "fs-remove-readonly.ts": 2468, + "fs-write-string-bytes-union.ts": 2571, + "function-apply-value.mjs": 2118, + "function-constructor-global.mjs": 2459, + "function-constructor-kinds/main.js": 2510, + "function-custom-prototype.js": 3445, + "function-custom-to-string.mjs": 3088, + "function-object-assign.js": 2894, + "function-own-prototype/main.js": 2937, + "generator-checked-protocol.ts": 3202, + "generator-checked-return.js": 2917, + "generator-custom-delegation/main.ts": 5180, + "generator-default-return-pattern.ts": 2163, + "generator-delegation-values.ts": 2121, + "generator-inferred-date.js": 1700, + "generator-mixed-checked-channels.ts": 3203, + "generator-untyped-consumer/main.ts": 3571, + "generic-base-specializations.ts": 2610, + "generic-binding-ownership.ts": 3653, + "generic-class-js-functions/main.ts": 2631, + "generic-class-recovery.ts": 3190, + "generic-namespace-factories/main.ts": 2712, + "generic-nullable-collections.ts": 2692, + "generic-pattern-bindings.ts": 2004, + "generic-record-index.ts": 2705, + "generic-visitor-void.ts": 2865, + "global-accumulator-loops.ts": 3053, + "global-error-subclasses.ts": 2690, + "global-runtime-probes.js": 1976, + "global-stored-probes.js": 2924, + "global-string-cache/main.js": 2572, + "global-symbol-cache/main.js": 2380, + "guarded-native-iterables.ts": 2466, + "heap-input-aliases.ts": 2784, + "heap-input-collections.ts": 3100, + "in-array-runtime-index.ts": 3210, + "indexed-assignment-values.js": 3521, + "indexed-assignment-values.ts": 2224, + "indexed-element-field-reads.ts": 2611, + "inferred-array-assignment-values.mjs": 2976, + "inferred-class-default.mjs": 2564, + "inferred-compound-values.mjs": 2110, + "inferred-conditional-class.mjs": 2584, + "inferred-error-fields.js": 2163, + "inferred-map-patterns.mjs": 2233, + "inferred-method-override.js": 2516, + "inferred-partial-destructuring.mjs": 2158, + "inferred-primitive-properties.mjs": 2508, + "inferred-record-return.mjs": 2099, + "inferred-recursive-record.mjs": 2183, + "inferred-undefined-field.mjs": 3012, + "input-lifetime-intervals.ts": 3244, + "input-lifetimes-modules/main.ts": 2793, + "instanceof-class-record-union.ts": 2242, + "integer-flow-arithmetic.ts": 3060, + "integer-loop-forms.ts": 2872, + "integer-view-control.ts": 2400, + "integer-view-numbers.ts": 2753, + "integer-view-storage.ts": 2545, + "intl-grapheme-conformance/main.ts": 4747, + "intl-grapheme.ts": 2345, + "iterator-typed-returns.ts": 3833, + "js-abort-portable.js": 2996, + "js-array-constructor.js": 3177, + "js-array-default-buffer.js": 2796, + "js-array-iterators.js": 3414, + "js-arrow-bind.cjs": 4772, + "js-buffer-callback-brand.cjs": 2001, + "js-callable-proxy.js": 3739, + "js-chained-native-results.mjs": 2683, + "js-checked-array-iterator.js": 2865, + "js-checked-array-reference.js": 3607, + "js-checked-number-negation.mjs": 2731, + "js-checked-sort-result.js": 2328, + "js-child-error-listener.cjs": 2751, + "js-cjs-callable-snapshots/main.cjs": 2946, + "js-class-added-parameters.js": 2228, + "js-class-checked-overrides.js": 2130, + "js-class-computed-fields.js": 2657, + "js-class-enumeration.js": 2642, + "js-class-field-accessor-override.js": 2687, + "js-class-fluent-overrides.js": 2370, + "js-class-late-method-values.js": 3690, + "js-class-member-dispatch.js": 3108, + "js-class-return-shapes.js": 3149, + "js-class-shadowed-methods.js": 3491, + "js-class-stored-method-receiver.js": 2218, + "js-class-subclass-properties.js": 4610, + "js-class-symbol-spread.cjs": 2295, + "js-computed-prototype-additions.js": 3232, + "js-constructor-returned-callable.js": 2404, + "js-constructor-spread.js": 3538, + "js-dataview-dispatch.js": 3187, + "js-declared-fields.cjs": 4825, + "js-default-listener-arguments.cjs": 1767, + "js-default-options/main.ts": 3097, + "js-deferred-field-initializers.js": 1977, + "js-deferred-registry-effects.js": 2772, + "js-derived-constructor-hoisting.js": 2288, + "js-dormant-array-write.js": 2420, + "js-dormant-overrides.js": 2890, + "js-expando-records.js": 2867, + "js-implicit-call-results.js": 2946, + "js-inferred-callback-exports/main.js": 4147, + "js-inferred-class-array-return.js": 3209, + "js-inferred-object-values.js": 2234, + "js-inherited-field-storage.js": 2161, + "js-inherited-parameter-abi.js": 2457, + "js-iterable-spread.js": 3088, + "js-loose-dynamic-primitives.js": 2797, + "js-map-object-seeds.js": 3253, + "js-member-increment.js": 3027, + "js-module-function-values.js": 3358, + "js-mutable-null-members.js": 2588, + "js-nested-native-descriptors.js": 2862, + "js-normalize-dispatch.js": 3006, + "js-nullish-inherited-fields.mjs": 2812, + "js-object-receiver-storage.js": 2500, + "js-object-returning-constructors.mjs": 2542, + "js-object-shared-arrays.js": 2369, + "js-omitted-typed-arguments.js": 2596, + "js-open-binding-writes.js": 2909, + "js-optional-class-fields.js": 3469, + "js-optional-member-call.js": 3126, + "js-primitive-union-addition.js": 2730, + "js-promise-all-values.js": 3561, + "js-promise-catch-handler.js": 2902, + "js-promise-finally-order.js": 2511, + "js-promise-pending-reactions.js": 2712, + "js-prototype-host-boundary.js": 2617, + "js-reflect-receivers.js": 3341, + "js-regex-record-captures.js": 3157, + "js-scalar-iterables.js": 3299, + "js-shared-method-dispatch.js": 3057, + "js-specialized-field-method.js": 2254, + "js-static-accessors.js": 3374, + "js-static-method-values.js": 3629, + "js-static-registries.cjs": 3164, + "js-super-accessor-initialization.js": 2332, + "js-uninitialized-native-fields.js": 2069, + "json-guarded-map-values.ts": 3048, + "json-output-bulk.ts": 1978, + "json-runtime-options.mjs": 3034, + "json-stringify-value.js": 2308, + "json-typed-parse-direct.ts": 2696, + "json-typed-parse-index-signatures.ts": 3686, + "json-typed-parse-optional-members.ts": 3044, + "json-typed-parse-union-members.ts": 3090, + "literal-switch-dispatch.ts": 2612, + "live-reference-shared-converters.ts": 3144, + "llvm-read-receiver-lifetime.ts": 1978, + "local-class-call-spreads.js": 1989, + "local-class-declaration.ts": 1927, + "local-class-evaluation.ts": 2816, + "local-class-inheritance.ts": 2647, + "local-class-lifetimes.ts": 3188, + "local-class-namespace/main.js": 3542, + "local-class-prototype-data.js": 2714, + "local-class-specialization.js": 2650, + "local-class-unknown.ts": 2915, + "local-class-values.ts": 2331, + "local-union-storage.ts": 2638, + "locale-compare-root-order.ts": 3001, + "logical-assignment-dynamic.js": 3172, + "logical-assignment-values.ts": 2043, + "logical-runtime-optional-record.ts": 2200, + "loop-reference-lifetimes.ts": 2559, + "map-checked-boundary/main.ts": 2442, + "map-checked-seed.js": 2756, + "map-get-set-fusion.ts": 3284, + "map-number-keys-dense.ts": 2972, + "map-read-lifetimes-exits.ts": 2860, + "map-read-lifetimes.ts": 2905, + "map-seeds-and-spreads.ts": 2984, + "map-typed-array-values.ts": 2649, + "math-function-values.js": 2638, + "missing-read-lambda-results.ts": 2850, + "missing-read-narrowed-storage.ts": 3077, + "missing-read-number-conversions.ts": 3015, + "module-byte-loops.ts": 2315, + "module-fallback-functions/main.js": 2716, + "narrowed-nullish-values.ts": 2405, + "native-any-timer-callback.ts": 2380, + "native-array-borrowed-find-last.js": 2591, + "native-array-borrowed-slice.js": 2966, + "native-array-copying-methods.js": 2605, + "native-array-fill-copywithin.js": 2662, + "native-array-frozen-noops.js": 2568, + "native-array-index-boundaries.js": 2581, + "native-array-integrity.js": 3066, + "native-array-length.js": 3005, + "native-array-named-properties.js": 2812, + "native-array-prototype/main.js": 3103, + "native-array-read-lifetimes.ts": 2912, + "native-array-reduce-find-last.js": 2732, + "native-array-search-from-index.js": 2720, + "native-array-splice-coercion.js": 1769, + "native-array-splice-flat.js": 2701, + "native-buffer-coercion.js": 2837, + "native-callback-dispatch.ts": 3750, + "native-class-array-boundaries.ts": 3033, + "native-class-cache.js": 3922, + "native-class-properties.cjs": 5335, + "native-class-property-cycles.cjs": 2421, + "native-class-property-order.cjs": 2798, + "native-class-type-predicates.ts": 2523, + "native-factory-records.js": 2515, + "native-method-values.js": 4031, + "native-method-values.ts": 2347, + "native-npm-imports/main.ts": 3454, + "native-object-descriptors.js": 1755, + "native-object-for-in-minimal.js": 2603, + "native-object-property-attributes.js": 3035, + "native-object-prototype.js": 2445, + "native-property-names.ts": 2425, + "native-proxy-env.js": 3704, + "native-worker-arena-reuse.ts": 6858, + "native-worker-bounded-errors.ts": 2058, + "native-worker-buffer-consumers.ts": 3068, + "native-worker-cancel-hot.ts": 2722, + "native-worker-class-fields.ts": 2782, + "native-worker-clone-errors.ts": 2690, + "native-worker-commonjs.cjs": 3412, + "native-worker-delayed-messages.ts": 2375, + "native-worker-discarded-heaps.ts": 5717, + "native-worker-environment.ts": 2804, + "native-worker-error.ts": 2211, + "native-worker-exception-state.ts": 4167, + "native-worker-exit-listeners.ts": 2523, + "native-worker-io.ts": 3345, + "native-worker-loop-cancellation.ts": 2510, + "native-worker-message-graphs.ts": 2419, + "native-worker-messages.ts": 2757, + "native-worker-poll-exceptions.ts": 3061, + "native-worker-port-lifetime.ts": 2699, + "native-worker-process-exit.ts": 2130, + "native-worker-publish-classes.ts": 3636, + "native-worker-publish-refusals.ts": 2020, + "native-worker-published-graphs.ts": 2461, + "native-worker-references.ts": 2598, + "native-worker-roots/main.ts": 3212, + "native-worker-shared-views.ts": 2802, + "native-worker-stack-overflow.ts": 2946, + "native-worker-terminate-exception-state.ts": 3847, + "native-worker-terminate-loop.ts": 2735, + "native-worker-terminate-recursion.ts": 4636, + "native-worker-terminate-suspended.ts": 2692, + "native-worker-terminate-tested-loops.ts": 3271, + "native-worker-terminate-wait.ts": 2775, + "native-worker-typed-arrays.ts": 3254, + "nested-map-cycles.ts": 2753, + "nested-map-values.ts": 4785, + "never-returning-calls.ts": 2228, + "next-tick-commonjs-entry.cjs": 1929, + "node24-buffer-encoding-errors.ts": 2283, + "node24-buffer-encoding.ts": 2691, + "node24-crypto-kdf-errors.ts": 3129, + "node24-crypto-kdf-options.ts": 3852, + "node24-crypto-kdf.ts": 3936, + "node24-crypto-sha2.ts": 1860, + "node24-deep-equality-properties.js": 2441, + "node24-deep-equality.cjs": 2912, + "node24-deep-equality.ts": 3378, + "node24-env-files-errors.ts": 2760, + "node24-env-files.ts": 2643, + "node24-env-imports.cjs": 1749, + "node24-env-parse-errors.ts": 2987, + "node24-env-parse.ts": 1797, + "node24-esm-metadata/main.mjs": 2385, + "node24-file-url-buffer.ts": 2665, + "node24-file-url-errors.js": 3394, + "node24-file-url-options.ts": 3117, + "node24-fs-links-callbacks.cjs": 2182, + "node24-fs-links-errors.cjs": 2221, + "node24-fs-links-options.cjs": 3438, + "node24-fs-links-promise-errors.cjs": 1752, + "node24-fs-links-promises.ts": 2960, + "node24-fs-links.ts": 3132, + "node24-fs-statfs-callbacks.cjs": 2404, + "node24-fs-statfs-errors.cjs": 3053, + "node24-fs-statfs-options.cjs": 3275, + "node24-fs-statfs.ts": 2771, + "node24-fs-timestamps-callbacks.cjs": 3442, + "node24-fs-timestamps-errors.cjs": 2214, + "node24-fs-timestamps-promises.ts": 2905, + "node24-fs-timestamps-symlinks.ts": 2911, + "node24-fs-timestamps.ts": 2652, + "node24-no-error-assertions-coercion.js": 3450, + "node24-no-error-assertions.cjs": 2131, + "node24-no-error-assertions.ts": 3704, + "node24-parseargs.js": 3975, + "node24-string-decoder.ts": 1840, + "node24-style-text-environment.js": 1777, + "node24-style-text-validation.js": 2850, + "node24-style-text.cjs": 2428, + "node24-style-text.ts": 2934, + "node24-system-error-validation.js": 2301, + "node24-system-errors.cjs": 2559, + "node24-system-errors.ts": 2989, + "node24-text-codec-properties.ts": 3210, + "node24-text-encode-into.ts": 2657, + "node24-text-utilities-coercion.js": 2506, + "node24-text-utilities-validation.js": 3129, + "node24-text-utilities.cjs": 2550, + "node24-text-utilities.ts": 2610, + "node24-url-authority-coercion.js": 3075, + "node24-url-authority.ts": 2397, + "node24-url-factories.ts": 3132, + "node24-url-factory-errors.ts": 2346, + "node24-url-mutation-coercion.js": 2926, + "node24-url-mutation.ts": 2845, + "node24-util-types.cjs": 2459, + "node24-util-types.js": 2601, + "node24-util-types.ts": 3126, + "non-null-class-iteration.ts": 1674, + "nonnull-element-arguments.ts": 2593, + "nonnull-forwarded-class-values.ts": 1775, + "nullable-object-extension.mjs": 1502, + "nullish-asserted-class-arms.ts": 2652, + "nullish-assignment-values.ts": 2755, + "nullish-long-chain.ts": 3588, + "number-parse-statics.ts": 2229, + "number-predicates-unknown.ts": 2605, + "numeric-call-specialization.ts": 1690, + "object-enumeration-array-reads.ts": 3043, + "object-from-checked-entries.js": 3900, + "object-inherited-to-string.js": 1733, + "object-key-indexes.js": 3227, + "object-prototype-identity.mjs": 2689, + "object-reexport/main.js": 2801, + "object-spread-computed.ts": 2239, + "opentui-byte-queue.js": 3379, + "optional-callback-arity.ts": 1977, + "optional-class-flows.ts": 2120, + "optional-element-defaults.ts": 2378, + "optional-flag-comparisons.ts": 2194, + "optional-native-callables.js": 2420, + "optional-node-list-iteration.ts": 2425, + "optional-string-index/main.ts": 2629, + "path-to-file-url-options.ts": 1964, + "performance-presence.ts": 2369, + "primitive-and-function-descriptors.js": 2715, + "primitive-union-string.ts": 2231, + "process-builtin-values.js": 3831, + "process-constrained-memory.ts": 2154, + "process-env-computed-keys.js": 2619, + "process-hrtime.js": 2376, + "process-named-signals.cjs": 2024, + "process-uncaught-handler-throws.cjs": 2023, + "process-uncaught-loop.cjs": 1789, + "process-uncaught-module.mjs": 1660, + "process-uncaught-monitor.cjs": 2359, + "process-uncaught-rejection.cjs": 2287, + "process-uncaught-sync.cjs": 2104, + "process-version-pin.ts": 2000, + "process-versions-storage.ts": 2763, + "projected-collection-lifetimes.ts": 2478, + "promise-checked-rejections.ts": 2584, + "promise-resolve-void.ts": 1939, + "prototype-method-overrides.mjs": 5633, + "prototype-named-data-records.ts": 2571, + "rc-last-use-moves.ts": 2854, + "rc-private-array-writes.ts": 3076, + "record-field-presence.ts": 3566, + "record-key-order.ts": 2682, + "record-optional-json-presence.ts": 2822, + "record-presence-copies.ts": 3201, + "record-presence-delete-json.ts": 3074, + "record-unchecked-read-presence.ts": 2374, + "record-unknown-values.ts": 3234, + "reflect-own-keys.mjs": 1796, + "reflect-record-union-keys.mjs": 2278, + "reflect-typed-record-keys.ts": 2418, + "regex-callback-replacements.ts": 2839, + "regex-callback-values.js": 2887, + "regex-checked-casts.ts": 1808, + "regex-checked-storage.js": 2999, + "regex-exec-long-subject.ts": 2794, + "regex-exec-result-arrays.ts": 3204, + "regex-fs-text-surfaces.ts": 3720, + "regex-input-lifetimes.ts": 2060, + "regex-native-matcher.ts": 4292, + "regex-optional-captures.ts": 2856, + "regex-optional-templates.ts": 2387, + "regex-split-captures.ts": 2496, + "regex-text-paths.ts": 3201, + "regexp-constructor-repeat.ts": 2842, + "regexp-optional-constructor.ts": 2495, + "regexp-string-coercion.js": 1920, + "renderer-export-dictionaries.js": 2828, + "renderer-null-state.js": 2692, + "renderer-specializations.js": 2881, + "repeat-and-typed-read-errors.ts": 2395, + "rest-optional-array-arguments.ts": 2478, + "rest-optional-elements.ts": 2534, + "return-void-through-finally.ts": 2913, + "runtime-optional-string-flows.ts": 2188, + "scalar-string-slices.ts": 2172, + "set-checked-methods.js": 3226, + "set-checked-storage.ts": 1974, + "set-iterator-seed-references.ts": 2018, + "set-iterator-seeds.ts": 3264, + "set-optional-seeds.ts": 2769, + "small-collection-transitions.ts": 3115, + "speculative-integer-globals.ts": 2544, + "speculative-integer-loops.ts": 2308, + "speculative-integer-reads.ts": 3059, + "stack-depth-async-bodies.ts": 2625, + "stack-overflow-async.ts": 1714, + "stack-overflow-caught.ts": 2878, + "stack-overflow-finally.ts": 2668, + "stack-overflow-shapes.ts": 3524, + "stack-overflow-uncaught.ts": 2587, + "stackless-async-concurrency.ts": 3322, + "stackless-async-context.ts": 1853, + "stackless-async-exceptions.ts": 3251, + "stackless-async-ordering.ts": 3551, + "stackless-async-unhandled.ts": 1779, + "static-field-updates/main.ts": 2473, + "static-method-receivers.ts": 2567, + "stdio-values.mjs": 2963, + "stdio-write-errors.mjs": 2760, + "stdio-write-overrides.mjs": 2090, + "stored-native-builtins.js": 2900, + "stored-object-helpers.js": 2328, + "stream-dynamic-entry-kinds.cjs": 2778, + "stream-dynamic-entry-kinds.ts": 2624, + "stream-encoded-from-entries.cjs": 2924, + "stream-encoded-from-entries.ts": 3274, + "string-char-code-integer-loops.ts": 1819, + "string-code-points.ts": 1858, + "string-concat-number-parts.ts": 1705, + "string-construction-order.ts": 2928, + "string-field-append.ts": 2926, + "string-lifetimes-boundaries.ts": 1843, + "string-lifetimes-evaluation.ts": 2718, + "string-lifetimes-iteration.ts": 2668, + "string-lifetimes-operations.ts": 2866, + "string-normalize.ts": 2507, + "string-pattern-replacement.ts": 3053, + "string-scan-fast-paths.ts": 2942, + "string-split-checked-separator.mjs": 2465, + "string-split-traversal.ts": 3686, + "structural-class-properties.ts": 2071, + "structured-text-boundaries.js": 2038, + "structured-text-storage.ts": 2083, + "switch-integer-dispatch.ts": 2561, + "symbol-checked-boundary/main.ts": 3073, + "symbol-class-fields.ts": 1839, + "symbol-class-fields/main.cjs": 2716, + "symbol-class-methods/main.ts": 1920, + "symbol-fields-deferred-factory.ts": 2270, + "symbol-fields-inferred.js": 1610, + "symbol-object-properties/main.js": 2842, + "synchronous-callback-lifetimes.ts": 3460, + "terminal-stream-properties.ts": 2151, + "text-codec-values/main.ts": 2261, + "text-codec-var.ts": 2601, + "text-encode-into-boundaries.ts": 2554, + "timers-clear-many.ts": 2390, + "tuple-and-string-search.ts": 2238, + "tuple-array-union.ts": 2290, + "tuple-callback-visitation.ts": 3777, + "tuple-forof-visitation.ts": 2917, + "typed-array-bulk-conversion.mjs": 4510, + "typed-array-byte-io.js": 2794, + "typed-array-checked-index.js": 1963, + "typed-array-constructor-alias.ts": 2203, + "typed-array-constructor-identity.js": 2030, + "typed-array-constructor-union.ts": 2632, + "typed-array-constructor-values.mjs": 3162, + "typed-array-dynamic-methods.js": 2468, + "typed-array-integer-widths.ts": 2823, + "typed-array-nan-coded-reads.ts": 3658, + "typed-array-numeric-import.ts": 2758, + "typed-array-present-reads.ts": 2812, + "typed-array-reversed-storage.ts": 2702, + "typed-array-unknown.ts": 2767, + "typed-collection-iterator-references.ts": 3694, + "typed-collection-iterators.ts": 3044, + "typed-collection-views/main.ts": 3027, + "typed-index-arguments.ts": 2801, + "typed-prototype-methods.ts": 2702, + "typed-rest-callables.ts": 2066, + "typed-rest-filtered-return.ts": 1741, + "typedarray-native-inputs.js": 3278, + "typeof-checked-comparison.js": 2471, + "uint8array-sort-domains.ts": 2675, + "unicode-case-paths.ts": 2617, + "unicode-process-argv.ts": 2688, + "union-discriminant-width.ts": 3120, + "union-literal-scalar-discriminants.ts": 3160, + "union-literal-slot-conversion.ts": 2002, + "union-nested-layout-discriminant.ts": 2160, + "union-optional-semantic-identity.ts": 3319, + "union-record-clone.ts": 3245, + "union-record-structural-copy.ts": 3278, + "union-reference-comparison.ts": 2689, + "unknown-array-holes.ts": 1863, + "unknown-collections.ts": 2098, + "unknown-object-enumeration.ts": 4264, + "unknown-record-views.ts": 2126, + "url-runtime-base.ts": 2747, + "utf8-span-decoding.ts": 2143, + "util-parseargs-wrapped/main.ts": 3020, + "virtual-runtime-optional-returns.ts": 3408, + "weak-map-array-buffer.ts": 2113, + "weak-map-fresh-array.js": 2822, + "weak-map-native.js": 2623, + "weak-native-class-identity.ts": 1967, + "weak-set-native.js": 2320, + "worker-class-instance-clone.ts": 3408 }, "san": { - "001-hello.ts": 47467, - "002-log-args.ts": 4723, - "100-number-format.ts": 49913, - "1000-json-stringify-basics.ts": 49071, - "1001-json-escapes-unicode.ts": 5167, - "1002-json-parse-cast.ts": 48226, - "1003-json-parse-unions.ts": 5247, - "1004-json-parse-errors.ts": 4196, - "1005-json-nested.ts": 8262, - "1006-json-fs-config.ts": 36095, - "1007-json-rc-stress.ts": 30487, - "1008-json-null-arms.ts": 48758, - "1009-json-optional-fields.ts": 3469, - "101-arithmetic.ts": 49638, - "1010-json-stringify-space.ts": 48585, - "1011-json-unknown-typeof.ts": 52058, - "102-comparisons.ts": 47851, - "1020-async-basics.ts": 4722, - "1021-async-ordering.ts": 4973, - "1022-async-exceptions.ts": 49732, - "1023-async-rc-stress.ts": 6131, - "1024-async-pending-exit.ts": 48202, - "1025-async-promise-capture.ts": 3959, - "1026-throw-promise.ts": 4948, - "1027-async-return-promise.ts": 4908, - "1028-async-return-record-literals.ts": 4271, - "1029-async-eager-chains.ts": 3619, - "103-ternary.ts": 5182, - "104-ternary-empty-arrays.ts": 7669, - "1050-comptime-tables.ts": 4897, - "1051-comptime-strings.ts": 47107, - "1052-comptime-records.ts": 39735, - "1053-comptime-json.ts": 5104, - "1054-comptime-modules/main.ts": 48253, - "110-number-radix.ts": 3792, - "111-record-entries.ts": 7069, - "1110-math-members.ts": 5365, - "1111-math-random.ts": 4260, - "1113-string-methods.ts": 54370, - "1114-string-unicode-island.ts": 52372, - "1115-parse-globals.ts": 3948, - "1116-island-static-mix.ts": 42223, - "1117-typeof-static-union.ts": 4732, - "1118-object-spread-conditional.ts": 39126, - "1119-switch-union.ts": 28754, - "112-class-descriptor-key.js": 39424, - "1121-infinity-number-tostring.ts": 4725, - "1122-any-captures.ts": 7404, - "1124-union-narrowed-retag.ts": 6000, - "113-promise-checked-exits.ts": 3453, - "114-live-record-delete.ts": 4924, - "115-array-compound.js": 5191, - "116-text-decoder-runtime.js": 46050, - "117-weak-cache-cycle.js": 5083, - "118-fs-stored-callbacks.cjs": 56960, - "119-native-patterns.js": 8396, - "1200-regex-test-basics.ts": 52932, - "1201-regex-replace.ts": 57037, - "1202-regex-substitutions.ts": 57467, - "1203-regex-split.ts": 3335, - "1204-regex-empty-unicode.ts": 42721, - "1205-regex-rc-stress.ts": 4531, - "1300-errors-basics.ts": 4518, - "1301-errors-subclass.ts": 4955, - "1302-errors-typed-catch.ts": 4560, - "1303-errors-rc-stress.ts": 3938, - "1304-errors-uncaught.ts": 4101, - "1305-errors-async-rejections.ts": 3614, - "1306-errors-runtime-instances.ts": 4054, - "1350-path-normalize-join.ts": 3568, - "1351-path-parts.ts": 4963, - "1352-path-resolve-relative.ts": 4503, - "1353-os-basics.ts": 4704, - "1354-builtin-bare-specifiers.ts": 4189, - "1355-url-parse.ts": 3863, - "1356-url-file-bridge.ts": 4207, - "1357-fsp-roundtrip.ts": 4886, - "1358-crypto-random.ts": 4050, - "1359-json-module/main.ts": 3853, - "1360-spawn-sync.ts": 4896, - "1361-spawn-events.ts": 3844, - "1362-spawn-timers.ts": 9749, - "1363-spawn-unhandled-error.ts": 5302, - "1364-union-truthiness.ts": 4307, - "1365-union-logical.ts": 4482, - "1366-union-equality.ts": 4253, - "1367-destructuring.ts": 5033, - "1368-constructor-functions.ts": 4831, - "1369-promise-union.ts": 3513, - "1370-spread.ts": 3969, - "1371-union-template-tostring.ts": 4126, - "1372-loose-null-tests.ts": 4513, - "1373-union-array-arms.ts": 3764, - "140-bitwise-operators.ts": 5173, - "1400-typedarray-basics.ts": 5411, - "1401-typedarray-slice-set.ts": 6335, - "1402-buffer-encodings.ts": 3500, - "1403-buffer-fs.ts": 7777, - "1404-zlib-crypto-bytes.ts": 6742, - "1405-bytes-unions-arrays.ts": 3762, - "1406-dataview-mp4.ts": 4549, - "1407-dataview-bounds.ts": 3820, - "1408-string-indexing.ts": 4530, - "1409-typedarray-integer-loops.ts": 4694, - "1420-number-statics.ts": 2928, - "1421-number-parse-strings.ts": 4454, - "1422-date-iso.ts": 3607, - "1423-text-codec.ts": 45738, - "1424-fs-options.ts": 3565, - "1425-stdin-tty.ts": 3853, - "1426-stdin-read.ts": 4250, - "1427-fromcharcode-lastindexof.ts": 3449, - "1428-settled-await-order.ts": 3904, - "1429-promise-catch-finally.ts": 6712, - "1430-promise-race.ts": 5576, - "1431-caught-tostring.ts": 4594, - "1432-destructured-params.ts": 5133, - "1433-filter-narrow.ts": 5015, - "1434-async-never.ts": 4402, - "1435-math-spread.ts": 4605, - "1436-default-undef-param.ts": 3807, - "1437-pad-default.ts": 3436, - "1438-promise-all.ts": 7568, - "1440-interval-basics.ts": 4290, - "1441-interval-clear-cross.ts": 7227, - "1442-interval-throw.ts": 4291, - "1443-signal-handlers.ts": 9442, - "1444-exit-listeners.ts": 5858, - "1445-exit-process-exit.ts": 5492, - "1446-exit-uncaught.ts": 4521, - "1447-stdin-closed-events.ts": 5005, - "1448-stream-columns.ts": 4280, - "1450-incdec-expression.ts": 3444, - "1451-instanceof-uint8array-unknown.ts": 4098, - "1452-return-through-finally.ts": 4660, - "1453-pmap-settled.ts": 7068, - "1454-nonnull-narrow-and-fcc-bytes.ts": 4716, - "1455-lambda-union-return-adoption.ts": 4826, - "1460-console-error-warn.ts": 4457, - "1461-process-pid-getuid-kill.ts": 4447, - "1462-exec-sync.ts": 4723, - "1463-timeout-unref.ts": 3720, - "1464-env-writes.ts": 4414, - "1465-env-value.ts": 4722, - "1466-child-containers.ts": 3465, - "1467-string-match.ts": 3798, - "1468-exec-path.ts": 4492, - "1469-remove-listener.ts": 6954, - "1470-child-lifecycle.ts": 4162, - "1471-child-unref.ts": 8772, - "1472-errno-code.ts": 5205, - "1473-promisify-execfile.ts": 5324, - "1474-string-decoder.ts": 4470, - "1475-readline-closed-stdin.ts": 55374, - "1476-assign-expression.ts": 4697, - "1477-in-expressions.ts": 3393, - "1478-promise-reject.ts": 4340, - "1479-destructuring-assign.ts": 4907, - "1480-os-network-interfaces.ts": 5202, - "1481-string-case-static.ts": 5232, - "1482-spawnsync-error.ts": 4518, - "1483-array-slice.ts": 47847, - "1520-fs-wider-surface.ts": 4261, - "1520-string-split-static.ts": 3932, - "1521-fs-lstat-lock.ts": 4472, - "1521-string-trim-pad-static.ts": 3262, - "1522-parseint-static.ts": 4734, - "1522-spawnsync-options.ts": 5888, - "1523-isnan-floor-static.ts": 4375, - "1523-spawn-options.ts": 4320, - "1524-atomics-sleep-static.ts": 4175, - "1524-catch-narrowing.ts": 4322, - "1525-child-exit-signal.ts": 4107, - "1525-unknown-typeof-validation.ts": 4804, - "1526-set-spread.ts": 5272, - "1527-logical-mixed-operands.ts": 3380, - "1528-delete-records-env.ts": 26816, - "1529-class-with-statics.ts": 3554, - "1530-array-push-variadic.ts": 4410, - "1530-spread-override-completion.ts": 4642, - "1531-delete-optional-fields.ts": 4468, - "1531-process-arch-versions.ts": 4294, - "1532-array-splice-shift.ts": 4135, - "1532-union-shared-field-read.ts": 3539, - "1533-bool-equality.ts": 3797, - "1533-path-platform-namespaces.ts": 4105, - "1534-crypto-hash-chain.ts": 4243, - "1534-union-as-arm-cast.ts": 3852, - "1535-spawn-fd-stdio.ts": 3827, - "1535-union-param-defaults.ts": 3756, - "1536-destructuring-defaults.ts": 4441, - "1536-string-array-sweep.ts": 4773, - "1537-chalk-hybrid/main.ts": 4555, - "1537-os-release-spawnsync-stdio.ts": 3030, - "1538-await-promiselike-return.ts": 4081, - "1538-math-static-scalar.ts": 2688, - "1539-readonly-set-map.ts": 4386, - "1539-unknown-truthiness.ts": 4573, - "1540-os-userinfo.ts": 4277, - "1540-void-statement.ts": 3770, - "1541-fs-readdir-dirent.ts": 5970, - "1541-union-keyed-reads.ts": 5137, - "1542-map-promise-values.ts": 3680, - "1542-record-literal-into-union.ts": 4161, - "1543-rest-destructuring.ts": 5386, - "1543-set-server-handles.ts": 8749, - "1544-dyn-json-reads.ts": 5370, - "1544-string-matchall.ts": 4375, - "1545-spread-order-and-optional.ts": 4546, - "1546-union-element-reads.ts": 50679, - "1547-computed-key-fold.ts": 5436, - "1548-boolean-condition-forms.ts": 3960, - "1549-array-isarray-unions.ts": 3329, - "1550-param-defaults-func-set.ts": 3161, - "1551-dyn-receiver-methods.ts": 6009, - "1552-exec-options-record.ts": 3255, - "1553-truthy-hof-predicates.ts": 4287, - "1554-caught-into-unknown.ts": 3533, - "1555-index-spread-into-declared.ts": 4772, - "1556-union-retag-width-arms.ts": 4319, - "1557-url-host.ts": 4070, - "1558-any-joins-and-dyn-validation.ts": 54305, - "1559-conditional-spread-index-merge.ts": 2926, - "1560-forof-homogeneous-tuples.ts": 32566, - "1561-forof-strings.ts": 3862, - "1561-promise-then.ts": 4850, - "1562-optional-chain-tails.ts": 4960, - "1562-spawn-conditional-spread.ts": 3616, - "1563-forof-iterator-projections.ts": 4225, - "1563-string-raw-fold.ts": 4244, - "1564-fs-watch.ts": 5142, - "1564-string-raw.ts": 4078, - "1565-spawn-pipe-streams.ts": 4189, - "1565-union-element-join.ts": 3622, - "1566-child-duck-interface.ts": 4142, - "1567-server-close-override.ts": 8728, - "1568-x509-fingerprint.ts": 3542, - "1569-fsp-mkdir-unlink-chmod.ts": 4083, - "1570-child-unref-kill-reffed.ts": 9583, - "1571-optional-call-tostring-tail.ts": 28217, - "1571-stdin-set-raw-mode-non-tty.ts": 3839, - "1572-promise-reject-all-tuple.ts": 4539, - "1572-x509-validity-date-gettime.ts": 4354, - "1573-promisify-execfile-env-spread.ts": 5359, - "1573-tdz-scalar-forward-capture.ts": 4394, - "1574-dyn-optional-method-number-keys.ts": 4461, - "1574-promise-all-tuple-literal.ts": 5082, - "1575-unknown-assert-into-record.ts": 4680, - "1576-width-coercions.ts": 4595, - "1577-url-hostname.ts": 3199, - "1578-exec-input-optional.ts": 3688, - "1579-matchall-index.ts": 4163, - "1580-exec-env-conditional-spread.ts": 3992, - "1581-declare-const-read.ts": 3904, - "1582-timer-sleep-resolve.ts": 5122, - "1583-loops-and-stream-captures.ts": 2955, - "1584-union-field-unassigned.ts": 4202, - "1585-union-field-conditional-ctor.ts": 4837, - "1586-derived-field-before-super-init.ts": 3740, - "1590-js-unannotated.js": 5105, - "1591-js-closures.js": 4745, - "1592-js-classes.js": 5879, - "1593-js-jsdoc-records.js": 4650, - "1594-js-async.js": 4426, - "1595-js-island-gap/main.js": 26477, - "1596-cjs-modules/main.js": 3160, - "1597-mjs-graph/main.mjs": 4960, - "1598-cjs-builtin-require/main.js": 3030, - "1599-js-uncaught-throw.js": 4259, - "1600-assert-passing.ts": 4325, - "1601-assert-fail-exit.ts": 4804, - "1602-assert-caught-error.ts": 5361, - "1603-assert-scalar-messages.ts": 4806, - "1604-assert-deep-structures.ts": 6023, - "1605-assert-import-forms.ts": 5339, - "1606-assert-strict-module.ts": 4600, - "1607-assert-throws-match.ts": 4414, - "1608-cjs-assert/main.js": 5188, - "1609-assert-async.ts": 4729, - "1610-path-win32-full.ts": 2755, - "1611-url-file-bridge-neutral.ts": 3733, - "1612-cjs-module-globals.cjs": 4516, - "1613-cjs-esm-proxy-named/main.mjs": 4105, - "1614-js-fence-dodges.cjs": 5207, - "1615-cjs-export-shapes/main.cjs": 5553, - "1616-cjs-esm-lexer-invisible/main.mjs": 3099, - "1617-cjs-esm-lexer-visible/main.mjs": 4087, - "1618-cjs-esm-poisoned-tail/main.mjs": 2476, - "1619-cjs-esm-reexport-invisible/main.mjs": 3415, - "1620-cjs-require-effects-order/main.js": 2713, - "1621-cjs-require-cache-hit/main.js": 3783, - "1622-cjs-require-conditional/main.js": 3828, - "1623-cjs-require-diamond/main.js": 3626, - "1624-cjs-require-dir-mid-file/main.js": 2336, - "1625-cjs-require-lazy-fn/main.js": 3015, - "1626-cjs-require-mjs/main.js": 2250, - "1627-mjs-import-cjs-requires/main.mjs": 2873, - "1628-checked-dynamic-builtin-args.cjs": 3077, - "1629-require-main-filename.cjs": 3479, - "1630-inspect-scalars.ts": 3977, - "1630-rmsync-retry-options.cjs": 3932, - "1631-inspect-arrays.ts": 5457, - "1632-inspect-records.ts": 4882, - "1633-inspect-map-set.ts": 4086, - "1634-inspect-classes.ts": 5725, - "1635-inspect-buffer.ts": 5155, - "1636-util-format.ts": 5015, - "1637-inspect-dyn.ts": 4071, - "1638-inspect-cjs.cjs": 3892, - "1639-versions-openssl-probe.ts": 4020, - "1640-fd-read-decode.ts": 4014, - "1641-string-search.ts": 21121, - "1642-object-fromentries-rows.ts": 4097, - "1643-metadata-dyn-return.cjs": 56433, - "1644-ee-basics.ts": 3623, - "1645-ee-extends.ts": 5009, - "1646-ee-once-remove.ts": 3768, - "1647-ee-meta-events.ts": 3840, - "1648-ee-error-event.ts": 2892, - "1649-ee-names-counts.ts": 4454, - "1650-ee-prepend.ts": 2707, - "1651-ee-max-listeners.ts": 4174, - "1652-ee-snapshot.ts": 5505, - "1653-ee-cjs.cjs": 4390, - "1654-ee-namespace.ts": 4636, - "1655-spawnsync-neutral.ts": 6342, - "1656-execsync-neutral.ts": 4702, - "1657-spawn-async-neutral.ts": 4011, - "1660-buffer-read-write-num.ts": 4936, - "1661-buffer-encodings-full.ts": 4916, - "1662-string-decoder-encodings.ts": 4639, - "1663-buffer-compare-search-fill.ts": 4818, - "1664-dyn-fn-boundary.cjs": 3636, - "1665-dyn-fn-mustcall/main.cjs": 4145, - "1666-dyn-fn-identity.ts": 3840, - "1667-dyn-fn-not-callable.cjs": 2882, - "1668-dyn-fn-throws.cjs": 3462, - "1669-symbol-identity.ts": 4719, - "1670-symbol-registry.ts": 4117, - "1671-symbol-typeof.ts": 5887, - "1672-symbol-containers.ts": 4625, - "1673-symbol-cjs.cjs": 6028, - "1674-symbol-inspect.ts": 4649, - "1676-func-array-surface.ts": 3616, - "1677-emitter-listeners.ts": 5664, - "1678-emitter-dyn-listeners.cjs": 6093, - "1679-console-dyn.js": 4398, - "1680-assert-bytes.ts": 3589, - "1681-assert-funcs.ts": 4450, - "1685-stream-readable-basics.ts": 8176, - "1686-stream-readable-paused.ts": 8142, - "1687-stream-readable-flow-control.ts": 6069, - "1688-stream-writable-basics.ts": 9377, - "1689-stream-writable-async-drain.ts": 7873, - "1690-stream-duplex.ts": 8422, - "1691-stream-transform.ts": 6383, - "1692-stream-pipe.ts": 5114, - "1693-stream-pipe-backpressure.ts": 3801, - "1694-stream-destroy.ts": 3612, - "1695-stream-props.ts": 8560, - "1696-stream-read-inside-read.ts": 4132, - "1697-stream-tick-vs-timer.ts": 7129, - "1698-stream-uncaught-error.ts": 4025, - "1699-stream-callback-shapes.ts": 4137, - "1700-mustcall-common/main.cjs": 4739, - "1701-mustcall-exit-report/main.cjs": 4788, - "1702-dyn-proto-dispatch.cjs": 4406, - "1703-arguments-rest-props.cjs": 3234, - "1710-cjs-export-class/main.js": 4152, - "1711-cjs-export-single-values/main.js": 3547, - "1712-field-incdec.ts": 3906, - "1713-js-dyn-fields.js": 5278, - "1720-assert-throws-shape.ts": 4205, - "1721-assert-throws-regex-class.ts": 3161, - "1722-assert-rejects.ts": 4021, - "1723-assert-does-not-reject.ts": 4049, - "1724-assert-iferror.ts": 3854, - "1725-assert-symbols.ts": 3165, - "1726-promise-with-resolvers.ts": 2792, - "1727-assert-throws-shape-exit.ts": 4670, - "1730-countdown-symbol-keys/main.js": 3893, - "1731-symbol-field-shapes.cjs": 4357, - "1732-symbol-field-cross-module/main.js": 4117, - "1740-stream-extends-readable.ts": 5412, - "1741-stream-extends-writable.ts": 7703, - "1742-stream-extends-duplex-transform.ts": 8664, - "1743-stream-extends-vt-dispatch.ts": 7746, - "1744-stream-set-encoding.ts": 3694, - "1745-stream-encoding-js.cjs": 3919, - "1746-stream-for-await.ts": 6732, - "1747-stream-for-await-js.cjs": 11913, - "1750-http-agent-options.ts": 7010, - "1751-options-record-stance.ts": 4331, - "1760-surplus-args-drop.cjs": 3419, - "1761-emitter-special-event-names.cjs": 3326, - "1770-assert-dyn-strict.ts": 4129, - "1771-assert-dyn-deep.ts": 4621, - "1772-assert-dyn-js.cjs": 3690, - "1773-assert-dyn-exit.ts": 3870, - "1780-http-res-surface.ts": 7391, - "1781-http-server-shapes.cjs": 11204, - "1790-computed-key-folds.ts": 3769, - "1791-searchparams-core.ts": 2566, - "1792-searchparams-encoding.ts": 3926, - "1793-searchparams-iteration.ts": 3839, - "1794-searchparams-url-live.ts": 3667, - "1795-dyn-handle-request.cjs": 7469, - "1796-dyn-handle-body.cjs": 4708, - "1797-dyn-handle-socket.cjs": 6317, - "1798-dyn-handle-typed-box.ts": 12433, - "1800-immediate-basics.ts": 3461, - "1801-immediate-handle.ts": 2828, - "1802-immediate-unref-exit.ts": 3773, - "1803-timeout-refresh.ts": 2890, - "1804-timers-module.ts": 4324, - "1805-timer-callback-args.ts": 4084, - "1806-timer-delay-trunc.ts": 3166, - "1810-stream-options-const-record.ts": 3962, - "1811-stream-option-value-callbacks.cjs": 3964, - "1812-stream-super-options-forwarding.cjs": 8384, - "1813-stream-finished.ts": 5772, - "1814-stream-pipeline.cjs": 8091, - "1815-stream-state-reads.cjs": 7977, - "1820-static-block-basics.ts": 3028, - "1821-static-block-order.ts": 2726, - "1822-static-block-js.js": 4178, - "1823-static-instance-method-names.ts": 2438, - "1824-for-of-destructuring-defaults.ts": 3053, - "1825-exhaustive-typeof-switch.ts": 3216, - "1826-settimeout-arguments-callback.js": 2649, - "1830-enum-numeric-basics.ts": 3631, - "1831-enum-string-const-reverse.ts": 3353, - "1832-enum-modules/main.ts": 3697, - "1835-var-basics.ts": 3553, - "1836-var-loop-capture.ts": 3991, - "1837-var-undefined-hoisting.ts": 3692, - "1838-var-modules/main.ts": 2987, - "1839-var-js/main.cjs": 3074, - "1840-jsdoc-import-type-only/main.js": 3723, - "1850-overload-basics.ts": 3730, - "1851-overload-return-narrowing.ts": 3097, - "1852-overload-class-members.ts": 4001, - "1853-overload-modules/main.ts": 4277, - "1854-ambient-declare-fn.ts": 2860, - "1855-ambient-declare-fn-uncaught.ts": 4252, - "1870-unit-type-values.ts": 3913, - "1871-empty-array-never.ts": 2656, - "1872-template-tostring-composite.ts": 3669, - "1880-json-declared-field-order.ts": 5166, - "1881-default-anon/main.ts": 3155, - "1882-default-cjs-interop/main.ts": 4152, - "1883-default-exports/main.ts": 4005, - "1890-ns-imports/main.ts": 4423, - "1891-ns-reexport/main.ts": 2975, - "1940-class-values-basics.ts": 2991, - "1941-class-values-registry.ts": 4395, - "1942-class-expressions.ts": 4086, - "1943-class-statics-expanded.ts": 3500, - "1944-class-values-modules/main.ts": 3932, - "1950-generic-fn-values.ts": 4360, - "1951-generic-classes-basics.ts": 4948, - "1952-generic-class-statics-values.ts": 4310, - "1953-generic-class-hierarchy.ts": 3171, - "1954-generic-modules/main.ts": 3610, - "1960-namespace-basics.ts": 3656, - "1961-namespace-nested.ts": 4076, - "1962-namespace-classes.ts": 3740, - "1963-namespace-aliases.ts": 3282, - "1964-namespace-type-only.ts": 3064, - "1965-namespace-ambient.ts": 3659, - "1966-namespace-modules/main.ts": 4077, - "1967-namespace-alias-typeonly.ts": 2697, - "1968-namespace-import-eq-snapshot.ts": 2527, - "1970-decorators-basics.ts": 4151, - "1971-decorators-rebinding.ts": 2897, - "1972-decorators-throwing.ts": 2556, - "1973-decorators-ambient.ts": 3932, - "1980-primitive-proto-statics.ts": 4096, - "1981-date-utc.ts": 3463, - "1982-freeze-resolve-passthrough.ts": 4042, - "1983-array-tuple-surfaces.ts": 4356, - "1990-labels-basics.ts": 3887, - "1991-for-in-loops.ts": 5008, - "1992-small-syntax.ts": 3829, - "200-strings.ts": 3521, - "2000-generic-methods-basic.ts": 4027, - "2001-generic-methods-generic-class.ts": 3431, - "2002-generic-methods-inheritance.ts": 3737, - "2003-generic-methods-object-literal.ts": 4544, - "2004-generic-methods-statics.ts": 3642, - "201-templates.ts": 2558, - "2010-generators-basics.ts": 3652, - "2011-generators-forof.ts": 3852, - "2012-generators-return-throw.ts": 3950, - "2013-generators-sent-values.ts": 4017, - "2014-generators-values.ts": 4246, - "2015-generators-yieldstar.ts": 3908, - "2016-generators-rc-stress.ts": 4275, - "2017-generators-async.ts": 2845, - "2018-generators-uncaught.ts": 3328, - "2019-generators-loops.ts": 3191, - "2020-generic-value-bindings.ts": 5274, - "2021-generic-value-binding-modules/main.ts": 3546, - "2022-width-index-capture.ts": 4336, - "2023-width-readonly.ts": 3104, - "2024-width-array-elems.ts": 3482, - "2025-width-union-compose.ts": 4076, - "2026-width-spread.ts": 3943, - "2030-width-nested.ts": 4567, - "2031-width-tuples.ts": 2753, - "2032-cjs-export-assigned-class-expression/main.cjs": 4056, - "2033-property-assigned-class-extends.cjs": 3174, - "2035-ternary-array-retag.cjs": 4091, - "2036-evolving-array-decl.cjs": 3778, - "2037-fn-decl-hoisting.cjs": 2776, - "2038-evolving-array-js.cjs": 4351, - "2040-any-bindings.ts": 3377, - "2040-mixin-heritage.ts": 3511, - "2041-any-params-returns.ts": 3626, - "2041-mixin-values.ts": 4380, - "2042-any-flow-loops.ts": 3135, - "2042-mixin-modules/main.ts": 4398, - "2043-any-dom-values.ts": 3973, - "2043-mixin-rc-stress.ts": 3648, - "2044-vtable-sibling-slots.ts": 3788, - "2045-objlit-accessors-basic.ts": 3867, - "2045-parameter-properties.ts": 4798, - "2046-abstract-classes.ts": 5738, - "2046-objlit-accessors-effects.ts": 3922, - "2047-objlit-accessors-shapes.ts": 3974, - "2047-optional-class-fields.ts": 5957, - "2050-dynamic-import-own-module/main.ts": 4276, - "2051-dynamic-import-then/main.ts": 3569, - "2052-dynamic-import-self.ts": 2505, - "2053-typeof-static-fold.ts": 3591, - "2054-destructuring-island-source.ts": 4039, - "2060-empty-tuple.ts": 3547, - "2070-computed-key-folds.ts": 5392, - "2071-integer-key-enumeration-order.ts": 4114, - "2072-expando-function-members.ts": 3911, - "2073-destructuring-assignment.ts": 3331, - "2074-island-destructuring.ts": 2722, - "2075-index-signature-runtime-keys.ts": 2808, - "2080-destructuring-defaults.ts": 4723, - "2081-destructuring-rest.ts": 3815, - "2082-destructuring-assignment.ts": 4463, - "2085-destructuring-heads-rest-params.ts": 3370, - "2087-destructuring-for-heads.ts": 3817, - "2090-index-signature-number-keys.ts": 3307, - "2091-index-signature-string-intersection.ts": 4503, - "2092-package-imports/main.ts": 3209, - "2093-timers-promises.ts": 4576, - "2094-diagnostics-channel.ts": 5184, - "2095-js-catch-unknown.js": 3505, - "2096-os-type.ts": 3468, - "2097-js-evolving-globals.js": 3426, - "210-string-methods.ts": 3239, - "2100-stream-default-hwm.ts": 4068, - "2101-dyn-param-defaults.ts": 4169, - "2102-empty-pattern-decls.ts": 3916, - "2105-computed-key-static-folds.ts": 3626, - "2106-comma-expressions.ts": 4728, + "001-hello.ts": 48584, + "002-log-args.ts": 53231, + "100-number-format.ts": 36832, + "1000-json-stringify-basics.ts": 52367, + "1001-json-escapes-unicode.ts": 4807, + "1002-json-parse-cast.ts": 5113, + "1003-json-parse-unions.ts": 7293, + "1004-json-parse-errors.ts": 49116, + "1005-json-nested.ts": 41496, + "1006-json-fs-config.ts": 48813, + "1007-json-rc-stress.ts": 4968, + "1008-json-null-arms.ts": 49375, + "1009-json-optional-fields.ts": 52902, + "101-arithmetic.ts": 4596, + "1010-json-stringify-space.ts": 7197, + "1011-json-unknown-typeof.ts": 38530, + "102-comparisons.ts": 45324, + "1020-async-basics.ts": 5928, + "1021-async-ordering.ts": 3518, + "1022-async-exceptions.ts": 4562, + "1023-async-rc-stress.ts": 49059, + "1024-async-pending-exit.ts": 4366, + "1025-async-promise-capture.ts": 4983, + "1026-throw-promise.ts": 47886, + "1027-async-return-promise.ts": 3187, + "1028-async-return-record-literals.ts": 53064, + "1029-async-eager-chains.ts": 5109, + "103-ternary.ts": 4538, + "104-ternary-empty-arrays.ts": 50460, + "1050-comptime-tables.ts": 7149, + "1051-comptime-strings.ts": 4737, + "1052-comptime-records.ts": 37872, + "1053-comptime-json.ts": 4779, + "1054-comptime-modules/main.ts": 7660, + "110-number-radix.ts": 4935, + "111-record-entries.ts": 7207, + "1110-math-members.ts": 4805, + "1111-math-random.ts": 5313, + "1113-string-methods.ts": 39688, + "1114-string-unicode-island.ts": 61280, + "1115-parse-globals.ts": 4273, + "1116-island-static-mix.ts": 58945, + "1117-typeof-static-union.ts": 4726, + "1118-object-spread-conditional.ts": 5790, + "1119-switch-union.ts": 3967, + "112-class-descriptor-key.js": 6359, + "1121-infinity-number-tostring.ts": 6448, + "1122-any-captures.ts": 5744, + "1124-union-narrowed-retag.ts": 48623, + "113-promise-checked-exits.ts": 5906, + "114-live-record-delete.ts": 5041, + "115-array-compound.js": 45694, + "116-text-decoder-runtime.js": 42554, + "117-weak-cache-cycle.js": 4096, + "118-fs-stored-callbacks.cjs": 67405, + "119-native-patterns.js": 6976, + "1200-regex-test-basics.ts": 59964, + "1201-regex-replace.ts": 59629, + "1202-regex-substitutions.ts": 64765, + "1203-regex-split.ts": 40181, + "1204-regex-empty-unicode.ts": 4019, + "1205-regex-rc-stress.ts": 6786, + "1300-errors-basics.ts": 4602, + "1301-errors-subclass.ts": 4547, + "1302-errors-typed-catch.ts": 5456, + "1303-errors-rc-stress.ts": 3915, + "1304-errors-uncaught.ts": 4301, + "1305-errors-async-rejections.ts": 25668, + "1306-errors-runtime-instances.ts": 56774, + "1350-path-normalize-join.ts": 4099, + "1351-path-parts.ts": 3517, + "1352-path-resolve-relative.ts": 4602, + "1353-os-basics.ts": 4075, + "1354-builtin-bare-specifiers.ts": 4565, + "1355-url-parse.ts": 3650, + "1356-url-file-bridge.ts": 5481, + "1357-fsp-roundtrip.ts": 4525, + "1358-crypto-random.ts": 3809, + "1359-json-module/main.ts": 4642, + "1360-spawn-sync.ts": 14534, + "1361-spawn-events.ts": 3384, + "1362-spawn-timers.ts": 9556, + "1363-spawn-unhandled-error.ts": 3577, + "1364-union-truthiness.ts": 4455, + "1365-union-logical.ts": 5263, + "1366-union-equality.ts": 5404, + "1367-destructuring.ts": 6097, + "1368-constructor-functions.ts": 4502, + "1369-promise-union.ts": 5171, + "1370-spread.ts": 5455, + "1371-union-template-tostring.ts": 5704, + "1372-loose-null-tests.ts": 4863, + "1373-union-array-arms.ts": 6061, + "140-bitwise-operators.ts": 5704, + "1400-typedarray-basics.ts": 4417, + "1401-typedarray-slice-set.ts": 6150, + "1402-buffer-encodings.ts": 6652, + "1403-buffer-fs.ts": 4712, + "1404-zlib-crypto-bytes.ts": 8302, + "1405-bytes-unions-arrays.ts": 4908, + "1406-dataview-mp4.ts": 4190, + "1407-dataview-bounds.ts": 5248, + "1408-string-indexing.ts": 6549, + "1409-typedarray-integer-loops.ts": 5748, + "1420-number-statics.ts": 4080, + "1421-number-parse-strings.ts": 3030, + "1422-date-iso.ts": 4656, + "1423-text-codec.ts": 42827, + "1424-fs-options.ts": 4763, + "1425-stdin-tty.ts": 3515, + "1426-stdin-read.ts": 4428, + "1427-fromcharcode-lastindexof.ts": 4393, + "1428-settled-await-order.ts": 3638, + "1429-promise-catch-finally.ts": 6438, + "1430-promise-race.ts": 5872, + "1431-caught-tostring.ts": 4401, + "1432-destructured-params.ts": 3887, + "1433-filter-narrow.ts": 5268, + "1434-async-never.ts": 3971, + "1435-math-spread.ts": 5075, + "1436-default-undef-param.ts": 4896, + "1437-pad-default.ts": 5306, + "1438-promise-all.ts": 8026, + "1440-interval-basics.ts": 3886, + "1441-interval-clear-cross.ts": 8806, + "1442-interval-throw.ts": 3908, + "1443-signal-handlers.ts": 10098, + "1444-exit-listeners.ts": 6271, + "1445-exit-process-exit.ts": 6288, + "1446-exit-uncaught.ts": 4829, + "1447-stdin-closed-events.ts": 5308, + "1448-stream-columns.ts": 3842, + "1450-incdec-expression.ts": 4062, + "1451-instanceof-uint8array-unknown.ts": 4913, + "1452-return-through-finally.ts": 3940, + "1453-pmap-settled.ts": 5769, + "1454-nonnull-narrow-and-fcc-bytes.ts": 5066, + "1455-lambda-union-return-adoption.ts": 4687, + "1460-console-error-warn.ts": 4173, + "1461-process-pid-getuid-kill.ts": 3798, + "1462-exec-sync.ts": 4955, + "1463-timeout-unref.ts": 3605, + "1464-env-writes.ts": 3898, + "1465-env-value.ts": 5166, + "1466-child-containers.ts": 4567, + "1467-string-match.ts": 31065, + "1468-exec-path.ts": 3971, + "1469-remove-listener.ts": 5771, + "1470-child-lifecycle.ts": 4259, + "1471-child-unref.ts": 8596, + "1472-errno-code.ts": 3697, + "1473-promisify-execfile.ts": 5268, + "1474-string-decoder.ts": 4402, + "1475-readline-closed-stdin.ts": 7198, + "1476-assign-expression.ts": 4160, + "1477-in-expressions.ts": 3377, + "1478-promise-reject.ts": 4766, + "1479-destructuring-assign.ts": 3620, + "1480-os-network-interfaces.ts": 5191, + "1481-string-case-static.ts": 47079, + "1482-spawnsync-error.ts": 4222, + "1483-array-slice.ts": 37812, + "1520-fs-wider-surface.ts": 4505, + "1520-string-split-static.ts": 5103, + "1521-fs-lstat-lock.ts": 4862, + "1521-string-trim-pad-static.ts": 4149, + "1522-parseint-static.ts": 3342, + "1522-spawnsync-options.ts": 6589, + "1523-isnan-floor-static.ts": 4386, + "1523-spawn-options.ts": 4864, + "1524-atomics-sleep-static.ts": 5554, + "1524-catch-narrowing.ts": 4776, + "1525-child-exit-signal.ts": 3419, + "1525-unknown-typeof-validation.ts": 4171, + "1526-set-spread.ts": 6387, + "1527-logical-mixed-operands.ts": 56825, + "1528-delete-records-env.ts": 3989, + "1529-class-with-statics.ts": 4851, + "1530-array-push-variadic.ts": 4575, + "1530-spread-override-completion.ts": 4651, + "1531-delete-optional-fields.ts": 5027, + "1531-process-arch-versions.ts": 4345, + "1532-array-splice-shift.ts": 5472, + "1532-union-shared-field-read.ts": 4768, + "1533-bool-equality.ts": 4449, + "1533-path-platform-namespaces.ts": 3877, + "1534-crypto-hash-chain.ts": 4113, + "1534-union-as-arm-cast.ts": 3510, + "1535-spawn-fd-stdio.ts": 3466, + "1535-union-param-defaults.ts": 3648, + "1536-destructuring-defaults.ts": 3985, + "1536-string-array-sweep.ts": 4779, + "1537-chalk-hybrid/main.ts": 4311, + "1537-os-release-spawnsync-stdio.ts": 3803, + "1538-await-promiselike-return.ts": 4183, + "1538-math-static-scalar.ts": 4776, + "1539-readonly-set-map.ts": 4240, + "1539-unknown-truthiness.ts": 3925, + "1540-os-userinfo.ts": 3976, + "1540-void-statement.ts": 3920, + "1541-fs-readdir-dirent.ts": 6148, + "1541-union-keyed-reads.ts": 5049, + "1542-map-promise-values.ts": 4830, + "1542-record-literal-into-union.ts": 4691, + "1543-rest-destructuring.ts": 4682, + "1543-set-server-handles.ts": 11403, + "1544-dyn-json-reads.ts": 5540, + "1544-string-matchall.ts": 4621, + "1545-spread-order-and-optional.ts": 4810, + "1546-union-element-reads.ts": 4735, + "1547-computed-key-fold.ts": 4346, + "1548-boolean-condition-forms.ts": 4311, + "1549-array-isarray-unions.ts": 4783, + "1550-param-defaults-func-set.ts": 4654, + "1551-dyn-receiver-methods.ts": 47581, + "1552-exec-options-record.ts": 4931, + "1553-truthy-hof-predicates.ts": 3759, + "1554-caught-into-unknown.ts": 4792, + "1555-index-spread-into-declared.ts": 5295, + "1556-union-retag-width-arms.ts": 4339, + "1557-url-host.ts": 4062, + "1558-any-joins-and-dyn-validation.ts": 4201, + "1559-conditional-spread-index-merge.ts": 4811, + "1560-forof-homogeneous-tuples.ts": 3801, + "1561-forof-strings.ts": 4569, + "1561-promise-then.ts": 5688, + "1562-optional-chain-tails.ts": 4544, + "1562-spawn-conditional-spread.ts": 5015, + "1563-forof-iterator-projections.ts": 3931, + "1563-string-raw-fold.ts": 2934, + "1564-fs-watch.ts": 4633, + "1564-string-raw.ts": 4462, + "1565-spawn-pipe-streams.ts": 4825, + "1565-union-element-join.ts": 4303, + "1566-child-duck-interface.ts": 3784, + "1567-server-close-override.ts": 8452, + "1568-x509-fingerprint.ts": 4642, + "1569-fsp-mkdir-unlink-chmod.ts": 4604, + "1570-child-unref-kill-reffed.ts": 10519, + "1571-optional-call-tostring-tail.ts": 4149, + "1571-stdin-set-raw-mode-non-tty.ts": 3975, + "1572-promise-reject-all-tuple.ts": 4421, + "1572-x509-validity-date-gettime.ts": 3928, + "1573-promisify-execfile-env-spread.ts": 4371, + "1573-tdz-scalar-forward-capture.ts": 3510, + "1574-dyn-optional-method-number-keys.ts": 5406, + "1574-promise-all-tuple-literal.ts": 4446, + "1575-unknown-assert-into-record.ts": 4160, + "1576-width-coercions.ts": 4905, + "1577-url-hostname.ts": 3830, + "1578-exec-input-optional.ts": 4111, + "1579-matchall-index.ts": 3935, + "1580-exec-env-conditional-spread.ts": 4157, + "1581-declare-const-read.ts": 4532, + "1582-timer-sleep-resolve.ts": 5668, + "1583-loops-and-stream-captures.ts": 4447, + "1584-union-field-unassigned.ts": 4778, + "1585-union-field-conditional-ctor.ts": 4205, + "1586-derived-field-before-super-init.ts": 4167, + "1590-js-unannotated.js": 4511, + "1591-js-closures.js": 4889, + "1592-js-classes.js": 7239, + "1593-js-jsdoc-records.js": 5280, + "1594-js-async.js": 3437, + "1595-js-island-gap/main.js": 3858, + "1596-cjs-modules/main.js": 3826, + "1597-mjs-graph/main.mjs": 4207, + "1598-cjs-builtin-require/main.js": 4782, + "1599-js-uncaught-throw.js": 3029, + "1600-assert-passing.ts": 4584, + "1601-assert-fail-exit.ts": 5710, + "1602-assert-caught-error.ts": 5606, + "1603-assert-scalar-messages.ts": 6055, + "1604-assert-deep-structures.ts": 4164, + "1605-assert-import-forms.ts": 4744, + "1606-assert-strict-module.ts": 3846, + "1607-assert-throws-match.ts": 3634, + "1608-cjs-assert/main.js": 22902, + "1609-assert-async.ts": 5276, + "1610-path-win32-full.ts": 4297, + "1611-url-file-bridge-neutral.ts": 4511, + "1612-cjs-module-globals.cjs": 4120, + "1613-cjs-esm-proxy-named/main.mjs": 4168, + "1614-js-fence-dodges.cjs": 5147, + "1615-cjs-export-shapes/main.cjs": 5790, + "1616-cjs-esm-lexer-invisible/main.mjs": 3074, + "1617-cjs-esm-lexer-visible/main.mjs": 4703, + "1618-cjs-esm-poisoned-tail/main.mjs": 4175, + "1619-cjs-esm-reexport-invisible/main.mjs": 3250, + "1620-cjs-require-effects-order/main.js": 4047, + "1621-cjs-require-cache-hit/main.js": 3190, + "1622-cjs-require-conditional/main.js": 4002, + "1623-cjs-require-diamond/main.js": 3383, + "1624-cjs-require-dir-mid-file/main.js": 4621, + "1625-cjs-require-lazy-fn/main.js": 4138, + "1626-cjs-require-mjs/main.js": 3518, + "1627-mjs-import-cjs-requires/main.mjs": 4705, + "1628-checked-dynamic-builtin-args.cjs": 4815, + "1629-require-main-filename.cjs": 3830, + "1630-inspect-scalars.ts": 3402, + "1630-rmsync-retry-options.cjs": 4168, + "1631-inspect-arrays.ts": 5636, + "1632-inspect-records.ts": 5322, + "1633-inspect-map-set.ts": 4905, + "1634-inspect-classes.ts": 50857, + "1635-inspect-buffer.ts": 3662, + "1636-util-format.ts": 3856, + "1637-inspect-dyn.ts": 4713, + "1638-inspect-cjs.cjs": 4782, + "1639-versions-openssl-probe.ts": 3624, + "1640-fd-read-decode.ts": 4777, + "1641-string-search.ts": 42621, + "1642-object-fromentries-rows.ts": 3842, + "1643-metadata-dyn-return.cjs": 6131, + "1644-ee-basics.ts": 4824, + "1645-ee-extends.ts": 4269, + "1646-ee-once-remove.ts": 5597, + "1647-ee-meta-events.ts": 4609, + "1648-ee-error-event.ts": 3894, + "1649-ee-names-counts.ts": 3445, + "1650-ee-prepend.ts": 5882, + "1651-ee-max-listeners.ts": 3513, + "1652-ee-snapshot.ts": 3828, + "1653-ee-cjs.cjs": 5160, + "1654-ee-namespace.ts": 4086, + "1655-spawnsync-neutral.ts": 5575, + "1656-execsync-neutral.ts": 5201, + "1657-spawn-async-neutral.ts": 4183, + "1660-buffer-read-write-num.ts": 4602, + "1661-buffer-encodings-full.ts": 4532, + "1662-string-decoder-encodings.ts": 4447, + "1663-buffer-compare-search-fill.ts": 6507, + "1664-dyn-fn-boundary.cjs": 3753, + "1665-dyn-fn-mustcall/main.cjs": 3637, + "1666-dyn-fn-identity.ts": 4113, + "1667-dyn-fn-not-callable.cjs": 5226, + "1668-dyn-fn-throws.cjs": 3927, + "1669-symbol-identity.ts": 5374, + "1670-symbol-registry.ts": 5422, + "1671-symbol-typeof.ts": 5011, + "1672-symbol-containers.ts": 6131, + "1673-symbol-cjs.cjs": 3807, + "1674-symbol-inspect.ts": 4101, + "1676-func-array-surface.ts": 3917, + "1677-emitter-listeners.ts": 5384, + "1678-emitter-dyn-listeners.cjs": 6837, + "1679-console-dyn.js": 5132, + "1680-assert-bytes.ts": 5780, + "1681-assert-funcs.ts": 4542, + "1685-stream-readable-basics.ts": 6799, + "1686-stream-readable-paused.ts": 7460, + "1687-stream-readable-flow-control.ts": 6103, + "1688-stream-writable-basics.ts": 8189, + "1689-stream-writable-async-drain.ts": 6061, + "1690-stream-duplex.ts": 8154, + "1691-stream-transform.ts": 8459, + "1692-stream-pipe.ts": 8943, + "1693-stream-pipe-backpressure.ts": 7445, + "1694-stream-destroy.ts": 4337, + "1695-stream-props.ts": 4409, + "1696-stream-read-inside-read.ts": 4780, + "1697-stream-tick-vs-timer.ts": 4369, + "1698-stream-uncaught-error.ts": 9453, + "1699-stream-callback-shapes.ts": 6489, + "1700-mustcall-common/main.cjs": 5513, + "1701-mustcall-exit-report/main.cjs": 5169, + "1702-dyn-proto-dispatch.cjs": 3843, + "1703-arguments-rest-props.cjs": 5139, + "1710-cjs-export-class/main.js": 4603, + "1711-cjs-export-single-values/main.js": 4271, + "1712-field-incdec.ts": 4369, + "1713-js-dyn-fields.js": 3948, + "1720-assert-throws-shape.ts": 4422, + "1721-assert-throws-regex-class.ts": 3508, + "1722-assert-rejects.ts": 4110, + "1723-assert-does-not-reject.ts": 4852, + "1724-assert-iferror.ts": 5098, + "1725-assert-symbols.ts": 4520, + "1726-promise-with-resolvers.ts": 4144, + "1727-assert-throws-shape-exit.ts": 4544, + "1730-countdown-symbol-keys/main.js": 4981, + "1731-symbol-field-shapes.cjs": 4983, + "1732-symbol-field-cross-module/main.js": 6365, + "1740-stream-extends-readable.ts": 4706, + "1741-stream-extends-writable.ts": 8537, + "1742-stream-extends-duplex-transform.ts": 8628, + "1743-stream-extends-vt-dispatch.ts": 7490, + "1744-stream-set-encoding.ts": 3923, + "1745-stream-encoding-js.cjs": 3912, + "1746-stream-for-await.ts": 5266, + "1747-stream-for-await-js.cjs": 9157, + "1750-http-agent-options.ts": 4824, + "1751-options-record-stance.ts": 4860, + "1760-surplus-args-drop.cjs": 3596, + "1761-emitter-special-event-names.cjs": 5408, + "1770-assert-dyn-strict.ts": 4549, + "1771-assert-dyn-deep.ts": 4653, + "1772-assert-dyn-js.cjs": 4842, + "1773-assert-dyn-exit.ts": 3322, + "1780-http-res-surface.ts": 7900, + "1781-http-server-shapes.cjs": 5025, + "1790-computed-key-folds.ts": 4472, + "1791-searchparams-core.ts": 3100, + "1792-searchparams-encoding.ts": 4024, + "1793-searchparams-iteration.ts": 2933, + "1794-searchparams-url-live.ts": 2969, + "1795-dyn-handle-request.cjs": 8538, + "1796-dyn-handle-body.cjs": 8773, + "1797-dyn-handle-socket.cjs": 5230, + "1798-dyn-handle-typed-box.ts": 9154, + "1800-immediate-basics.ts": 3918, + "1801-immediate-handle.ts": 3182, + "1802-immediate-unref-exit.ts": 3903, + "1803-timeout-refresh.ts": 3243, + "1804-timers-module.ts": 3435, + "1805-timer-callback-args.ts": 3958, + "1806-timer-delay-trunc.ts": 4233, + "1810-stream-options-const-record.ts": 3952, + "1811-stream-option-value-callbacks.cjs": 4066, + "1812-stream-super-options-forwarding.cjs": 8532, + "1813-stream-finished.ts": 3971, + "1814-stream-pipeline.cjs": 4413, + "1815-stream-state-reads.cjs": 4085, + "1820-static-block-basics.ts": 3479, + "1821-static-block-order.ts": 4110, + "1822-static-block-js.js": 3095, + "1823-static-instance-method-names.ts": 3531, + "1824-for-of-destructuring-defaults.ts": 3925, + "1825-exhaustive-typeof-switch.ts": 3439, + "1826-settimeout-arguments-callback.js": 3758, + "1830-enum-numeric-basics.ts": 3846, + "1831-enum-string-const-reverse.ts": 3347, + "1832-enum-modules/main.ts": 3603, + "1835-var-basics.ts": 3009, + "1836-var-loop-capture.ts": 4162, + "1837-var-undefined-hoisting.ts": 3457, + "1838-var-modules/main.ts": 4306, + "1839-var-js/main.cjs": 4870, + "1840-jsdoc-import-type-only/main.js": 3497, + "1850-overload-basics.ts": 4398, + "1851-overload-return-narrowing.ts": 3452, + "1852-overload-class-members.ts": 3733, + "1853-overload-modules/main.ts": 3524, + "1854-ambient-declare-fn.ts": 4169, + "1855-ambient-declare-fn-uncaught.ts": 2640, + "1870-unit-type-values.ts": 4848, + "1871-empty-array-never.ts": 3051, + "1872-template-tostring-composite.ts": 3835, + "1880-json-declared-field-order.ts": 5173, + "1881-default-anon/main.ts": 3809, + "1882-default-cjs-interop/main.ts": 3893, + "1883-default-exports/main.ts": 4076, + "1890-ns-imports/main.ts": 3441, + "1891-ns-reexport/main.ts": 3946, + "1940-class-values-basics.ts": 3823, + "1941-class-values-registry.ts": 3834, + "1942-class-expressions.ts": 3250, + "1943-class-statics-expanded.ts": 3491, + "1944-class-values-modules/main.ts": 3807, + "1950-generic-fn-values.ts": 4479, + "1951-generic-classes-basics.ts": 4288, + "1952-generic-class-statics-values.ts": 4461, + "1953-generic-class-hierarchy.ts": 2769, + "1954-generic-modules/main.ts": 4012, + "1960-namespace-basics.ts": 4063, + "1961-namespace-nested.ts": 4436, + "1962-namespace-classes.ts": 3835, + "1963-namespace-aliases.ts": 4480, + "1964-namespace-type-only.ts": 4245, + "1965-namespace-ambient.ts": 3646, + "1966-namespace-modules/main.ts": 3158, + "1967-namespace-alias-typeonly.ts": 2894, + "1968-namespace-import-eq-snapshot.ts": 4133, + "1970-decorators-basics.ts": 5269, + "1971-decorators-rebinding.ts": 4674, + "1972-decorators-throwing.ts": 3103, + "1973-decorators-ambient.ts": 3465, + "1980-primitive-proto-statics.ts": 4370, + "1981-date-utc.ts": 3865, + "1982-freeze-resolve-passthrough.ts": 4409, + "1983-array-tuple-surfaces.ts": 4749, + "1990-labels-basics.ts": 3921, + "1991-for-in-loops.ts": 4875, + "1992-small-syntax.ts": 4940, + "200-strings.ts": 2950, + "2000-generic-methods-basic.ts": 19968, + "2001-generic-methods-generic-class.ts": 3103, + "2002-generic-methods-inheritance.ts": 4643, + "2003-generic-methods-object-literal.ts": 4397, + "2004-generic-methods-statics.ts": 2813, + "201-templates.ts": 3364, + "2010-generators-basics.ts": 4186, + "2011-generators-forof.ts": 4950, + "2012-generators-return-throw.ts": 4210, + "2013-generators-sent-values.ts": 4475, + "2014-generators-values.ts": 4791, + "2015-generators-yieldstar.ts": 3849, + "2016-generators-rc-stress.ts": 4017, + "2017-generators-async.ts": 4735, + "2018-generators-uncaught.ts": 4005, + "2019-generators-loops.ts": 2646, + "2020-generic-value-bindings.ts": 4401, + "2021-generic-value-binding-modules/main.ts": 3358, + "2022-width-index-capture.ts": 3719, + "2023-width-readonly.ts": 3719, + "2024-width-array-elems.ts": 3231, + "2025-width-union-compose.ts": 3698, + "2026-width-spread.ts": 3241, + "2030-width-nested.ts": 4055, + "2031-width-tuples.ts": 3342, + "2032-cjs-export-assigned-class-expression/main.cjs": 3882, + "2033-property-assigned-class-extends.cjs": 3781, + "2035-ternary-array-retag.cjs": 3818, + "2036-evolving-array-decl.cjs": 4090, + "2037-fn-decl-hoisting.cjs": 3678, + "2038-evolving-array-js.cjs": 5045, + "2040-any-bindings.ts": 3791, + "2040-mixin-heritage.ts": 4699, + "2041-any-params-returns.ts": 3681, + "2041-mixin-values.ts": 4051, + "2042-any-flow-loops.ts": 3594, + "2042-mixin-modules/main.ts": 4173, + "2043-any-dom-values.ts": 2471, + "2043-mixin-rc-stress.ts": 4344, + "2044-vtable-sibling-slots.ts": 3559, + "2045-objlit-accessors-basic.ts": 3871, + "2045-parameter-properties.ts": 4491, + "2046-abstract-classes.ts": 5595, + "2046-objlit-accessors-effects.ts": 2807, + "2047-objlit-accessors-shapes.ts": 3455, + "2047-optional-class-fields.ts": 5630, + "2050-dynamic-import-own-module/main.ts": 3193, + "2051-dynamic-import-then/main.ts": 4043, + "2052-dynamic-import-self.ts": 4058, + "2053-typeof-static-fold.ts": 3537, + "2054-destructuring-island-source.ts": 3138, + "2060-empty-tuple.ts": 3805, + "2070-computed-key-folds.ts": 4750, + "2071-integer-key-enumeration-order.ts": 3546, + "2072-expando-function-members.ts": 4747, + "2073-destructuring-assignment.ts": 3553, + "2074-island-destructuring.ts": 4229, + "2075-index-signature-runtime-keys.ts": 5005, + "2080-destructuring-defaults.ts": 4463, + "2081-destructuring-rest.ts": 3264, + "2082-destructuring-assignment.ts": 4012, + "2085-destructuring-heads-rest-params.ts": 3930, + "2087-destructuring-for-heads.ts": 3872, + "2090-index-signature-number-keys.ts": 4103, + "2091-index-signature-string-intersection.ts": 3918, + "2092-package-imports/main.ts": 3799, + "2093-timers-promises.ts": 3870, + "2094-diagnostics-channel.ts": 4547, + "2095-js-catch-unknown.js": 4236, + "2096-os-type.ts": 3673, + "2097-js-evolving-globals.js": 3604, + "210-string-methods.ts": 3491, + "2100-stream-default-hwm.ts": 6786, + "2101-dyn-param-defaults.ts": 2902, + "2102-empty-pattern-decls.ts": 2680, + "2105-computed-key-static-folds.ts": 4156, + "2106-comma-expressions.ts": 4616, "211-string-unicode.ts": 3897, - "2110-top-object-types.ts": 3438, - "2111-json-stringify-unknown.ts": 3888, - "2112-array-at-findlast.ts": 3424, - "2113-string-index-methods.js": 3570, - "212-string-aliasing-append.ts": 3570, - "2120-package-self-import/main.ts": 3971, - "2121-esm-cycle-inert-backedge/main.ts": 2650, - "2123-ambient-import-crash/main.ts": 3746, - "2124-imports-field-wildcard/main.ts": 2731, - "2140-uri-component-codecs.ts": 3381, - "2160-dc-tracing-channel.cjs": 4690, - "2161-js-object-literal-identity.cjs": 4257, - "2162-js-dyn-destructure.cjs": 3551, - "2163-js-selfref-const.cjs": 4654, - "2164-js-then-dyn-handler.cjs": 5156, - "2165-js-throw-dyn.cjs": 3523, - "2166-cjs-getter-this/main.cjs": 3882, - "2170-island-array-exits.ts": 3858, - "2171-island-json-stringify.ts": 3712, - "2172-island-regexp-boundary.ts": 3327, - "2190-new-object-and-string-wrappers.ts": 2850, - "2191-uri-encoders.ts": 2942, - "2192-object-default-tostring.ts": 3177, - "2193-discarded-stdlib-reads.ts": 3355, - "2194-ambient-undef-chains.ts": 3563, - "2195-require-missing-package/main.mjs": 4117, - "2196-island-computed-key-chain.ts": 3932, - "2210-dyn-promise-crossing.cjs": 5102, - "2211-dc-trace-promise.cjs": 4621, - "2212-unhandled-rejection-listener.cjs": 4270, - "2213-async-local-storage.cjs": 4068, - "2214-dc-bind-store.cjs": 5707, - "2215-process-emit-warning-exit.cjs": 4386, - "2240-width-class-into-record.ts": 3665, - "2241-width-record-into-class.ts": 3361, - "2242-width-statics-into-record.ts": 3708, - "2243-width-assert-satisfies-shapes.ts": 3967, - "2250-tagged-templates.ts": 3434, - "2252-class-iterators.ts": 4459, - "2253-union-coercions.ts": 2359, - "2260-http2-constants.cjs": 3538, - "2280-builtin-namespace-destructure.cjs": 3057, - "2281-domexception-atob-btoa.cjs": 3389, - "2282-queue-microtask.cjs": 5820, - "2283-structured-clone.cjs": 4600, - "2284-regexp-constructor.cjs": 3741, - "2285-iferror-dyn.cjs": 2861, - "2286-dyn-object-walks.cjs": 3243, - "2300-dyn-record-spread-and-keyed-access.cjs": 2809, - "2301-cjs-export-table-dom-attach.cjs": 2887, - "2310-process-next-tick.ts": 4130, - "2311-next-tick-js-callbacks.js": 4068, - "2312-stream-underscore-assign.ts": 6594, - "2313-stream-underscore-assign-js.cjs": 4269, - "2314-process-introspection.ts": 3297, - "2320-await-unit.ts": 3657, - "2321-emitter-static-setmax.cjs": 4316, - "2322-dyn-array-sort.cjs": 3658, - "2323-timer-callback-returns.ts": 4288, - "2330-tls-server-runtime-options.cjs": 57265, - "2331-tls-server-options-typed.ts": 24831, - "2350-nan-global.ts": 3780, - "2351-async-methods.ts": 4037, - "2352-void-coercions.ts": 4230, - "2353-decorators-member-ambient.ts": 3783, - "2354-decorators-expression-ambient.ts": 3425, - "2360-tuple-to-array.ts": 4066, - "2361-assign-index-record.ts": 3954, - "2362-execsync-inherit.ts": 3811, - "2363-nullish-retag.ts": 4019, - "2364-in-runtime-key.ts": 3905, - "2365-dyn-into-island.ts": 4006, - "2366-string-well-formed.ts": 2861, - "2367-regexp-escape.ts": 3081, - "2368-set-methods.ts": 3869, - "2369-promise-try.ts": 4228, - "2370-group-by.ts": 4759, - "2371-iterator-helpers.ts": 4028, - "2380-buffer-module-named-import.ts": 3715, - "2381-builtin-default-imports.js": 3602, - "2382-cycle-two-decl/main.ts": 2942, - "2383-cycle-assertdoc/main.js": 2814, - "2384-cycle-mixed-bindings/main.ts": 2985, - "2385-builtin-reexport-facade/main.ts": 2368, - "2386-string-to-chars.ts": 3688, - "2387-tonumber-argv.ts": 4524, - "2388-tonumber-grammar-zoo.ts": 3447, - "2389-tonumber-unary-plus.ts": 3631, - "2390-dot-requires/main.cjs": 3823, - "2391-default-builtin-imports/main.ts": 4261, - "2392-block-guard-alias-scope.ts": 3432, - "2393-loop-exit-guard-narrow.ts": 4204, - "2394-loop-narrow-containment.ts": 3545, - "2395-while-cond-guard.ts": 3342, - "2396-born-narrowed-decl.ts": 3204, - "2397-branch-kill-merge.ts": 2872, - "2398-switch-arm-kill.ts": 2478, - "2399-reassign-kill-polarity.ts": 3975, - "240-stdout-write.ts": 3714, - "2400-kill-return-edge.ts": 2788, - "2401-kill-break-staging.ts": 3266, - "2402-labeled-break-kill.ts": 3546, - "2403-kill-continue-backedge.ts": 3341, - "2404-kill-throw-catch.ts": 3390, - "2405-sibling-arm-narrow.ts": 3636, - "2406-switch-clause-sibling-narrow.ts": 3321, - "2407-infinite-loop-seal.ts": 3706, - "2408-loop-terminality-reopen.ts": 3556, - "2409-loop-body-return-not-terminal.ts": 2952, - "2410-stacked-cases-terminality.ts": 2785, - "2411-exhaustive-switch-terminality.ts": 2898, - "2412-dowhile-guard-trailing-test.ts": 3018, - "2413-dowhile-kill-renarrow.ts": 3619, - "2414-dowhile-continue-kill.ts": 3030, - "2415-dowhile-break-trailing-test.ts": 3541, - "2416-spread-ternary-positions.ts": 3398, - "2417-ternary-local-inference.ts": 2779, - "2418-wrapped-ternary-arms.ts": 3414, - "2419-selector-ternary-union.ts": 2916, - "2420-nullish-null-identity.ts": 2738, - "2421-float-lane-inference.ts": 3483, - "2422-ieee-div-rem-corners.ts": 3493, - "2423-param-null-reassign.ts": 2469, - "2424-ternary-miss-first-narrowing.ts": 2704, - "2425-elseif-head-exit-narrow.ts": 3239, - "2426-default-snapshot-mutable/main.ts": 3047, - "2427-perf-hooks-now.ts": 3594, - "2428-field-redeclare-inherited.ts": 3306, - "2429-destructure-class-instance.ts": 3925, - "2430-empty-literal-unknown-field.js": 3247, - "2431-primitive-ctor-values.ts": 4135, - "2432-generic-member-fields-async.ts": 4525, - "2433-as-const-command-tables.ts": 4328, - "2434-deferred-init-fields.ts": 3024, - "2435-loose-same-kind-equality.ts": 3478, - "2440-console-inspect-args.ts": 5890, - "2441-console-process-argv.ts": 3753, - "2442-union-literal-arm-widening.ts": 3136, - "2443-union-literal-shadow-narrowing.ts": 3135, - "2444-union-literal-reducer-spread.ts": 2966, - "2445-math-minmax-nary.ts": 3844, - "2446-performance-global.ts": 3708, - "2447-island-boundary-slots/main.ts": 4610, - "2448-entries-null-arms-regex-arrays.ts": 4797, - "2450-private-instance-methods.ts": 4126, - "2451-private-fields.ts": 3682, - "2452-private-statics.ts": 3833, - "2453-private-accessors.ts": 3714, - "2454-private-generator-methods.ts": 4326, - "2455-private-brand-checks.ts": 2955, - "2456-private-async-methods.ts": 4273, - "2457-private-members.js": 3893, - "2460-qs-parse-grammar.ts": 5096, - "2461-qs-parse-options.ts": 3628, - "2462-qs-stringify.ts": 4992, - "2463-qs-escape-unescape.ts": 3734, - "2464-qs-require-forms.cjs": 4220, - "2470-mockable-module-shape.js": 2876, - "2471-record-keyed-write-hasown.js": 4081, - "2472-string-regexp-union.ts": 2606, - "2473-option-table-widths.js": 4586, - "2474-island-literal-forms.ts": 4522, - "2475-variadic-wrapper-island.js": 3845, - "2476-map-regex-values.ts": 3182, - "2480-recursive-record-tree.ts": 3879, - "2481-mutual-recursive-records.ts": 3675, - "2482-recursive-union-tree.ts": 3577, - "2483-recursive-record-cycles.ts": 3205, - "2484-json-stringify-circular.ts": 3643, - "2485-inspect-circular-refs.ts": 3845, - "2486-recursive-record-boundaries.ts": 2991, - "2487-recursive-deep-equal.ts": 4100, - "2488-ast-walker.ts": 4477, - "2490-find-miss-null-compare.ts": 3671, - "2491-strict-unit-compare-no-arm.ts": 3227, - "2492-loose-null-compare-unions.ts": 3901, - "2493-switch-unit-cases.ts": 3674, - "2494-no-arm-compare-effects.ts": 3403, - "2500-net-autosel-timeout.ts": 3482, - "2510-dyn-evolving-array-map.ts": 3667, - "2511-dyn-evolving-array-filter-foreach.ts": 4096, - "2512-dyn-evolving-array-mixed-push.ts": 4423, - "2520-private-statics-class-name-calls.ts": 3265, - "2521-private-statics-class-expression.ts": 3750, - "2522-private-statics-decorated.ts": 3195, - "2523-private-statics-aliased-class.ts": 3584, - "2530-object-destructuring-decl.ts": 3283, - "2531-array-tuple-destructuring-decl.ts": 4032, - "2532-param-destructuring-options.ts": 4645, - "2533-forof-destructuring.ts": 4187, - "2534-object-rest-decl.ts": 4358, - "2535-destructuring-assign-basics.ts": 3621, - "2536-destructuring-assign-nested.ts": 3573, - "2537-destructuring-assign-member-targets.ts": 3272, - "2538-destructuring-assign-class-source.ts": 3962, - "2539-class-instance-rest.ts": 4142, - "2540-accessor-destructuring-defaults.ts": 3446, - "2541-destructuring-eval-order.ts": 3928, - "2550-generics-keyof-pick.ts": 3409, - "2551-generics-value-aliases.ts": 3346, - "2552-generics-iface-methods.ts": 3488, - "2553-generics-signature-bindings.ts": 3749, - "2554-generics-frontier-mix.ts": 3794, - "2555-generics-keyof-writes.ts": 3364, - "2556-crypto-introspection.ts": 3435, - "2556-width-hybrid-shapes.ts": 4079, - "2557-tls-ca-store.ts": 3530, - "2557-width-field-lifts.ts": 4176, - "2558-index-signature-func-values.ts": 4225, - "2558-rejection-events.cjs": 3844, - "2559-index-signature-container-values.ts": 4449, - "2560-arraybuffer-dataview-set.ts": 3087, - "2561-object-is.ts": 4355, - "2562-intl-numberformat-en-us.ts": 3901, - "2563-stream-promises-pipeline.ts": 3564, - "2564-stream-promises-finished.ts": 6034, - "2565-stream-promises-js.cjs": 4473, - "2566-promise-reject-dyn-reason.js": 3377, - "2567-rest-spread-forward.js": 3534, - "2568-rest-spread-forward-dynamic.js": 4104, - "2569-upcast-identity.ts": 3496, - "2570-buffer-arg-validation.cjs": 5910, - "2571-searchparams-arg-validation.cjs": 4428, - "2572-readable-emitted-readable-flag.cjs": 3512, - "2573-fs-url-arg-ladders.cjs": 3763, - "2574-emitter-max-listeners-ladders.cjs": 3689, - "2575-string-destructuring-decl.ts": 4712, - "2576-string-destructuring-assign.ts": 3735, - "2577-builtin-global-destructuring.js": 4445, - "2578-jsval-into-unknown-rows.ts": 3828, - "2579-jsval-object-param-crossing.js": 3036, - "2580-jsval-routed-keyed-ops.js": 3956, - "2581-jsval-routed-calls.js": 3809, - "2582-jsval-object-statics.js": 3967, - "2582-jsval-routed-keyed-ops.js": 2714, - "2583-dyn-nullish-coalesce.js": 3955, - "2583-jsval-routed-calls.js": 4033, - "2584-jsval-object-statics.js": 3852, - "2584-union-dyn-collapse.ts": 3199, - "2585-dyn-nullish-coalesce.js": 4086, - "2585-unknown-array.ts": 3037, - "2586-object-assign-spread.js": 4129, - "2587-array-entries-forof.ts": 3963, - "2588-array-entries-chains.ts": 4778, - "2589-object-create-null.cjs": 3994, - "2590-object-create-dynamic.js": 3840, - "2591-ambient-generic-traps.ts": 3572, - "2592-ambient-trap-uncaught.ts": 3517, - "2593-generic-inert-bindings.ts": 3984, - "2594-nullish-generic-bindings.ts": 3028, - "2595-fs-arg-ladders.cjs": 6103, - "2596-net-arg-ladders.cjs": 3811, - "2597-dgram-send-ladders.cjs": 4888, - "2598-tls-arg-ladders.cjs": 26930, - "2599-stream-arg-ladders.cjs": 6141, - "2600-dyn-keyed-write-harness.js": 2931, - "2601-dyn-keyed-write-ops.js": 2148, - "2602-dyn-array-destructure.js": 2954, - "2603-island-keyed-write-dyn.js": 2848, - "2604-cycle-classes-mutual/main.ts": 3417, - "2605-cycle-three-module/main.ts": 3678, - "2606-dynamic-import-cycle/main.ts": 3530, - "2608-regex-named-groups.ts": 4497, - "2609-regex-named-replace.ts": 3665, - "2610-regex-named-matchall.ts": 3003, - "2611-regex-named-groups-js.cjs": 4787, - "2613-for-init-uninitialized-let.ts": 3768, - "2614-trap-binding-later-writes.ts": 2989, - "2615-nullish-field-record-binding.ts": 3529, - "2616-js-collect-probe-defers.js": 3466, - "2617-enum-static-field-import/main.ts": 3293, - "2618-ee-emit-override.ts": 3565, - "2619-ee-override-chain.ts": 3727, - "2620-ee-override-once-order.ts": 4249, - "2621-ee-override-error-throw.ts": 3855, - "2622-ee-override-filter.ts": 3910, - "2623-ee-job-queue.ts": 3743, - "2624-ee-override-js.cjs": 3084, - "2625-bytes-views.ts": 3970, - "2626-stream-event-names.ts": 4359, - "2627-stream-ticks-are-nextticks.ts": 7617, - "2628-stream-push-encodings.cjs": 3343, - "2629-stream-consumers.ts": 4441, - "2630-stream-consumers-errors.ts": 5041, - "2631-create-require/main.ts": 3703, - "2632-dyn-jsval-iterate.js": 3831, - "2633-island-promise-crossing.js": 5160, - "2634-stream-pipeline-arg-ladders.cjs": 3923, - "2635-trap-binding-unmappable-written.ts": 3043, - "2636-trap-binding-ambient-rooted-rewrite.ts": 3569, - "2637-create-require-bare/main.ts": 2767, - "2638-http-dyn-res-compat.cjs": 8125, - "2639-http-dyn-req-pause.cjs": 8808, - "2640-net-dyn-socket-compat.cjs": 4119, - "2641-http-agent-surface.cjs": 8974, - "2642-http-agent-maxsockets.cjs": 7586, - "2643-or-default-retag.ts": 3938, - "2644-http-client-url-argument.ts": 8788, - "2645-https-client-url-argument.ts": 5188, - "2646-top-level-await.ts": 3543, - "2647-top-level-await-modules/main.ts": 3228, - "2648-top-level-await-rejection.ts": 3718, - "2649-top-level-await-pending.ts": 3680, - "2650-top-level-await-self-import.ts": 3580, - "2651-top-level-await-pending-unhandled.ts": 3616, - "2652-top-level-await-dynamic/main.ts": 3624, - "2653-top-level-await-rejection-stops-loop.ts": 3405, - "2654-top-level-await-unrelated-rejection.ts": 3746, - "2655-top-level-await-cycle/main.ts": 3633, - "2656-top-level-await-cycle-order/main.ts": 3581, - "2657-top-level-await-cycle-dynamic/main.ts": 3334, - "2658-top-level-await-sync-completion/main.ts": 3454, - "2659-top-level-await-dynamic-cycle/main.ts": 2695, - "2660-top-level-await-cycle-rejection/main.ts": 3883, - "2661-top-level-await-dynamic-runtime-root/main.ts": 3717, - "2662-top-level-await-cycle-external-wait/main.ts": 3322, - "2663-top-level-await-dependency-errors/main.ts": 4049, - "2664-top-level-await-same-checkpoint-rejection.ts": 4075, - "2665-top-level-await-unhandled-listener-liveness.ts": 3625, - "2666-array-to-sorted.ts": 8369, - "2668-stored-number-array-iterator.ts": 3915, - "2669-array-copying-methods.ts": 4422, - "2670-uint8array-copy-iterate.ts": 4692, - "2671-array-copying-js.cjs": 3615, - "2672-http-request-response-callback.ts": 3326, - "2673-top-level-await-implicit-module.ts": 2622, - "2674-top-level-for-await-implicit-module.ts": 3487, - "2675-create-require-nested-esm.js": 3107, - "2675-process-self-reexec.ts": 3537, - "2676-indexed-read-strict-equality.ts": 3497, - "2676-record-clone-overrides.ts": 3652, - "2676-top-level-await-ambiguous/main.ts": 3641, - "2677-runtime-optional-closure.ts": 4530, - "2677-top-level-await-module-scope/main.ts": 3142, - "2678-date-instances.ts": 4477, - "2678-large-string-sparse-index.ts": 3931, - "2678-util-parseargs.ts": 7627, - "2679-util-parseargs-cjs.cjs": 4984, - "2680-util-parseargs-default.ts": 2670, - "2681-util-parseargs-dynamic.js": 3233, - "2682-fs-rename.ts": 4087, - "2683-filter-truthy-predicate.ts": 4348, - "2683-fs-rename-js.cjs": 2621, - "2684-filter-no-predicate-dyn.cjs": 3942, - "2684-fs-rename-abort.ts": 3403, - "2685-array-unshift-reverse.ts": 3942, - "2685-fs-write-sync.ts": 4263, - "2686-fs-file-handle.ts": 6233, - "2687-fsp-write-file-options.ts": 3951, - "2687-process-write-args.ts": 2844, - "2688-fs-stats-disk-fields.ts": 4789, - "2689-http-server-timeout-properties.ts": 3279, - "2690-https-server-timeout-option.ts": 56311, - "2691-retained-lowering-record-order.ts": 5946, - "2692-inline-record-assert-index.ts": 3857, - "2692-string-accumulation.ts": 3602, - "2693-math-constants.ts": 3816, - "2700-array-sort-complexity.ts": 3912, - "2700-http-static-trailers.ts": 6657, - "2700-wasi-core.ts": 3863, - "2701-array-sort-snapshot.ts": 3906, - "2701-http-static-trailer-wire.ts": 3412, - "2701-import-meta/main.mjs": 4097, - "2702-http-static-trailer-end.ts": 8433, - "2702-type-import-link-static/main.ts": 2947, - "2702-uint8array-to-sorted.ts": 3549, - "2703-array-sparse-sort.ts": 8716, - "2703-type-import-link-static-reexport/main.ts": 3510, - "2704-array-sparse-to-sorted.ts": 8447, - "2704-type-import-link-static-success/main.ts": 3172, - "2705-array-sparse-sort-append.ts": 7740, - "2705-type-import-link-dynamic/main.ts": 3687, - "2706-array-search-missing-needle.ts": 3192, - "2706-type-import-link-dynamic-success/main.ts": 4191, - "2707-array-search-huge-sparse.ts": 48438, - "2707-type-import-link-static-default-reexport/main.ts": 3502, - "2708-type-import-link-dynamic/main.ts": 3358, - "2720-array-read-parity.ts": 3686, - "2721-array-nested-missing-receiver.ts": 2904, - "2750-array-sparse-foundation.ts": 3895, - "2751-buffer-concat-sparse-list.ts": 3589, - "2752-array-optional-stores.ts": 3503, - "2753-array-optional-method-values.ts": 2814, - "2754-array-property-undefined.ts": 2681, - "2755-array-optional-literal-forwarding.ts": 3614, - "2780-array-parity-composition.ts": 12116, - "2781-array-missing-value-escape.ts": 3458, - "2782-array-sparse-callbacks.ts": 3870, - "2783-array-defaults-rest.ts": 3473, - "2784-array-reduce-missing-result.ts": 3973, - "2785-array-missing-destructuring.ts": 4123, - "2786-array-sparse-serialization.ts": 4457, - "2787-array-missing-string-arithmetic.ts": 3381, - "2788-array-missing-builtin-conversions.ts": 3415, - "2789-array-missing-optional-tostring.ts": 2621, - "2790-dynamic-import-self-name/main.ts": 3399, - "2791-record-optional-keys.ts": 3271, - "2792-record-optional-spread-entries.ts": 4055, - "2793-union-conversion-identity-capture.ts": 4295, - "2794-array-generic-callback-values.ts": 3662, - "2795-array-optional-typedarray-source.ts": 38684, - "2796-array-sparse-class-value-instanceof.ts": 3585, - "2800-array-expression-consumers.ts": 3265, - "2801-array-switch-consumers.ts": 4057, - "2820-array-missing-method-receivers.ts": 3301, - "2821-array-optional-numeric-comparisons.ts": 2316, - "2830-cjs-require-self-name/main.cjs": 3030, - "2840-finally-completions.ts": 3523, - "2841-using-sync.ts": 3234, - "2842-await-using.ts": 3418, - "2843-using-suppressed-error.ts": 3352, - "2844-node-disposable-resources.ts": 5430, - "2845-for-using-of.ts": 3355, - "2846-generator-using.ts": 3702, - "2850-async-generators-protocol.ts": 4747, - "2851-async-generators-values.ts": 4111, - "2852-timers-promises-interval.ts": 3376, - "2854-leading-bom-literals.ts": 2675, - "2855-searchparams-sort-complexity.ts": 2462, - "2856-dynamic-any-local-operators.ts": 3959, - "2857-branded-primitives.ts": 3738, - "2858-import-meta-resolve/main.mjs": 2597, - "2859-import-meta-resolve-dynamic/main.mjs": 2565, - "2860-require-resolve/main.cjs": 3076, - "2861-readable-iterator-close.ts": 3422, - "2862-web-readable-async-iteration.ts": 55094, - "2863-class-async-iterator.ts": 3586, - "2864-array-class-method-receivers.ts": 4152, - "2865-cjs-process-alias.cjs": 3499, - "2866-dyn-switch.ts": 3318, - "2867-array-shift-length.js": 3797, - "2868-empty-record-promise-presence.js": 3592, - "2869-nullish-mixed-lazy.ts": 3886, - "2870-and-dropped-truthy-arm.ts": 3748, - "2871-optional-promise-to-unknown.ts": 3966, - "2872-unobserved-dynamic-event.ts": 3095, - "2873-optional-receiver-loop-lifetime.js": 3310, - "2874-nullable-callback-field-cycle.js": 4239, - "2875-evolving-let-read-before-write.js": 2007, - "2876-class-unknown-roundtrip.ts": 3485, - "2877-child-unknown-roundtrip.ts": 3462, - "2878-class-private-unknown.cjs": 3481, - "2880-cjs-module-graph/main.cjs": 4418, - "2890-crypto-static-utility.ts": 3693, - "2891-json-record-key-escapes.ts": 3227, - "2892-windows-console-unicode.ts": 3154, - "2893-child-stdin-duplex.ts": 3517, - "2894-child-stdin-backpressure.ts": 4232, - "2895-child-stdin-write-after-end.ts": 3755, - "2896-child-stdin-write-after-finish.ts": 4128, - "2897-child-stdin-destroy.ts": 2592, - "2898-child-stdin-spawn-failure.ts": 3984, - "2899-nested-mutual-recursion.ts": 3524, - "2900-float64array-static.ts": 2647, - "2900-void-conditional-arrow.ts": 3544, - "2901-bigint-core.ts": 3085, - "2902-bigint-bytes.ts": 3574, - "2903-bigint-storage.ts": 4190, - "2904-bigint-errors.ts": 3820, - "2905-bigint-edges.ts": 3695, - "2906-bigint-wasi-width.ts": 3566, - "2910-overloaded-callable-alias.ts": 2729, - "2911-execfile-callback.ts": 3798, - "2912-execfile-callback-options.ts": 3803, - "2912-promisify-fs-readfile.ts": 3648, - "2913-builtin-callable-alias.ts": 5737, - "2914-fixed-tuple-call-spread.ts": 3851, - "2915-path-function-values.ts": 4013, - "2916-path-function-values-cjs.ts": 3957, - "2917-builtin-callable-widths.ts": 3640, - "2918-builtin-callable-widths-cjs.ts": 3701, - "2919-fs-function-values.ts": 3810, - "2920-fs-promises-function-values.ts": 3724, - "2921-zlib-callbacks.ts": 5492, - "2922-dyn-bitwise-not.cjs": 3645, - "2923-cjs-factory-export/main.cjs": 3645, - "2930-union-receiver-calls.ts": 4841, - "2931-union-dynamic-field-call.js": 3975, - "2932-create-require-program/main.ts": 4060, - "2933-static-dynamic-import/main.ts": 3736, - "2934-static-import-stored.ts": 3490, - "2935-module-namespace-values/main.ts": 3371, - "2936-static-loose-equality.ts": 4954, - "2937-bitwise-hot-loop.ts": 3448, - "2938-fs-sync-overloads.cjs": 3181, - "2939-child-shell-text.ts": 4371, - "2940-date-parse.ts": 3212, - "2940-fsp-realpath.ts": 3484, - "2941-fsp-lstat-identity.ts": 3903, - "2941-process-exit-code.ts": 3406, - "2942-fsp-readdir-dirent.ts": 4202, - "2942-process-exit-code-override.ts": 3082, - "2943-process-exit-code-invalid.ts": 3479, - "2944-process-exit-code-wrap.ts": 3266, - "2945-url-origin-username.ts": 2899, - "2946-child-fork-ipc/main.ts": 4761, - "2946-url-port-hash.ts": 2865, - "2947-set-readonly-seeds.ts": 3446, - "2948-child-fork-eof-callback/main.ts": 3476, - "2948-stdio-callback-record.ts": 3365, - "2949-child-fork-default/main.mjs": 3332, - "2949-url-password.ts": 3628, - "2950-fs-descriptor-publication.ts": 3569, - "2951-math-static-analytic.ts": 3919, - "2952-math-static-remaining.ts": 3652, - "2953-http-header-validation.ts": 7274, - "2954-http-outgoing-headers.ts": 9450, - "2955-http-static-state.ts": 6516, - "2956-http-static-informational.ts": 6092, - "2957-http-static-response-controls.ts": 6929, - "2961-emitter-computed-names.cjs": 4004, - "2962-emitter-computed-optional.ts": 2860, - "2963-child-fork-dispatch/main.ts": 3483, - "2964-indexed-compound.ts": 4204, - "2966-numeric-array-read-fusion.ts": 4381, - "2967-numeric-array-read-lifetime.ts": 3892, - "2968-numeric-array-borrow.ts": 3610, - "2969-scalar-record-results.ts": 4035, - "2970-constant-numeric-tables.ts": 2720, - "2971-constant-table-modules/main.ts": 3311, - "2972-http-static-distinct-snapshots.ts": 4474, - "2972-math-receiver-borrow.ts": 4401, - "2973-http-static-agent.ts": 3997, - "2973-integer-bitwise-arithmetic.ts": 3629, - "2974-array-search-from-index.ts": 116997, - "2974-http-static-module-values.ts": 7598, - "2974-numeric-remainder.ts": 3511, - "2975-bigint-default-radix.ts": 3179, - "2975-http-static-client-controls.ts": 3852, - "2976-http-static-incoming-state.ts": 8478, - "2976-json-stringify-no-arguments.js": 3354, - "2977-http-static-incoming-timeout.ts": 3463, - "2977-nested-array-binding-defaults.js": 2952, - "2978-http-static-client-timeout.ts": 4066, - "2978-regexp-optional-subject.js": 2771, - "2979-array-search-mixed-needles.js": 3599, - "2979-http-static-server-timeout.ts": 3821, - "2980-http-static-server-timeout-default.ts": 3238, - "2980-string-position-arguments.js": 3754, - "2981-http-static-events.ts": 3579, - "2981-string-optional-positions.ts": 3623, - "2982-http-static-close-all.ts": 2800, - "2982-string-position-coercion-order.js": 4005, - "2983-http-static-close-idle.ts": 3208, - "2984-http-static-close-upgrade.ts": 3773, - "2985-http-static-message-destroy.ts": 3787, - "2986-http-static-client-socket-finish.ts": 3574, - "2987-http-static-timeout-errors.ts": 3533, - "2988-http-static-client-abort.ts": 4341, - "2989-http-static-response-timeout-handled.ts": 3444, - "2990-http-static-request-timeout-handled.ts": 3719, - "2991-array-indexed-equality.ts": 3650, - "2992-stream-rows.ts": 3551, - "2993-fiber-stack-lifetimes.ts": 3792, - "2994-fromcharcode-scalar.ts": 4459, - "2995-math-hyperbolic.ts": 3860, - "2996-math-near-one.ts": 3086, - "2997-math-integer-float.ts": 3955, - "300-if-else.ts": 3194, - "3001-caught-typeof-object.js": 4263, - "3002-promise-then-two.ts": 4357, - "301-while.ts": 3525, - "302-for.ts": 3433, - "3020-string-last-index-position.ts": 3282, - "3021-buffer-union-narrow-callback.ts": 3951, - "3022-string-affix-positions.ts": 2990, - "3023-string-affix-position-coercion.js": 3327, - "3024-string-number-narrow-for-in.ts": 3695, - "3025-string-search-position-coercion.js": 3055, - "3026-array-last-index-of.js": 3971, - "3027-array-last-index-of-records.ts": 3174, - "3028-string-search-dynamic-needle.js": 3488, - "3029-string-search-union-needle.js": 2317, - "303-break-continue.ts": 3497, - "3030-array-search-no-arg.js": 3148, - "3031-array-relative-index-coercion.js": 4248, - "3031-string-last-index-search-value.js": 2998, - "3032-string-search-value.js": 3484, - "3033-string-search-needle-coercion.js": 3256, - "3034-arguments-with-parameters.js": 3316, - "3035-string-positioned-search-value.js": 3436, - "3036-string-object-search-value.js": 3562, - "3037-number-nullish-conversion.js": 3657, - "3038-number-scalar-unions.ts": 2371, - "3039-string-repeat-count.js": 3353, - "304-compound-incdec.ts": 3802, - "3040-string-prototype-call.js": 4850, - "3041-string-prototype-object-call.js": 3234, - "3042-string-padding-coercion.js": 3916, - "3043-string-split-arguments.js": 3976, - "3044-array-slice-splice-positions.js": 4465, - "3045-array-indexed-mutation.js": 3477, - "3046-array-indexed-ref-identity.ts": 3717, - "3047-object-prototype-tag.js": 7241, - "3048-object-own-prototype.ts": 2902, - "3049-array-flat-depth.ts": 4100, - "305-truthiness.ts": 3370, - "3050-array-splice-insert.ts": 4056, - "3051-array-join-default.ts": 3538, - "3052-array-construction.ts": 4542, - "3053-array-construction-js.js": 3392, - "3054-dynamic-abort-record.ts": 30732, - "3055-default-builtin-nodenext/main.ts": 3399, - "3056-default-builtin-bundler/main.ts": 3748, - "3057-default-builtin-nodenext-dynamic/main.ts": 3727, - "3058-optional-array-chain-join.ts": 3025, - "3059-arguments-property-names.ts": 3619, - "3061-concurrent-fiber-stacks.ts": 4083, - "3062-runtime-optional-record-guards.ts": 4619, - "3063-runtime-optional-class-guards.ts": 4458, - "3064-installed-entry-imports/main.ts": 2755, - "3065-installed-entry-js/main.js": 2496, - "3066-source-debugging/main.ts": 3345, - "3067-cjs-function-export-require/main.cjs": 3584, - "3068-debug-variables/main.ts": 2803, - "3068-url-checked-identity.ts": 3525, - "3069-set-checked-seed.js": 3730, - "3069-tuple-spread.ts": 3638, - "3070-checked-object-accessors.js": 3937, - "3070-collection-views.ts": 3112, - "3071-checked-specialization-narrowing.js": 4666, - "3071-map-contextual-record-seeds.ts": 3637, - "3072-optional-union-receivers.ts": 4348, - "3072-weak-process-streams.js": 3937, - "3073-optional-callable-module.js": 3783, - "3073-union-keyed-reads.ts": 3349, - "3074-discriminated-intersections.ts": 3833, - "3075-recursive-contextual-literals.ts": 4956, - "3076-nullish-record-defaults.ts": 3537, - "3077-optional-union-array-reads.ts": 4192, - "3078-forward-mutable-captures.ts": 4709, - "3079-forward-mutable-tdz.ts": 4069, - "3080-exhaustive-never-bindings.ts": 3678, - "3081-recursive-array-destinations.ts": 3824, - "3082-forward-write-unwind.ts": 3698, - "3083-set-string-seed.ts": 3916, - "3084-record-own-membership.ts": 4502, - "3085-conditional-record-construction.ts": 4272, - "3086-error-constructor-options.ts": 2549, - "3087-error-options-lifetime.ts": 3996, - "3088-array-wide-callbacks.ts": 4379, - "3089-array-find-narrowing.ts": 4095, - "3090-json-discriminated-records.ts": 4621, - "3091-json-recursive-discriminants.ts": 4799, - "3092-number-union-predicates.ts": 3661, - "3093-error-option-data.ts": 3834, - "3094-json-replacer-traversal.ts": 3366, - "3095-json-reviver-traversal.ts": 3492, - "3096-json-callback-nonfinite.ts": 3652, - "3097-json-callback-reentrancy.ts": 4051, - "3098-json-callback-space.ts": 4000, - "3099-json-callback-functions.ts": 4355, - "3100-json-callback-holder.js": 4131, - "3101-json-callback-bytes.ts": 4053, - "3102-json-unknown-fields.ts": 3096, - "3103-scalar-record-nested-control-flow.ts": 3773, - "3104-native-analysis-tables-loops.ts": 3270, - "3105-nullable-collections.ts": 3945, - "3106-mixed-insertion-spreads.ts": 4363, - "3107-nullable-collection-lifetimes.ts": 4026, - "3108-for-await-sync-arrays.js": 5613, - "3108-identity-map-keys.ts": 3552, - "3109-destructuring-unknown-defaults.js": 3464, - "3109-identity-union-collections.ts": 4940, - "3110-builtin-error-families.ts": 3056, - "3110-identity-collection-mutation.ts": 4022, - "3111-identity-collection-cycles.ts": 4287, - "3112-union-switch-control-flow.ts": 3956, - "3113-union-array-removal.ts": 4360, - "3114-union-record-field-write.ts": 3442, - "3115-zlib-static-compression-levels.ts": 5168, - "3116-sequence-expression-lifetimes.ts": 4189, - "3117-unknown-switch-control-flow.ts": 4180, - "3118-recursive-union-spread.ts": 3041, - "3119-runtime-optional-spread.ts": 3381, - "3120-dynamic-property-descriptors.js": 2965, - "3120-generator-method-loop-bindings.ts": 4201, - "3120-ir-nonfinite-numbers.ts": 4055, - "3121-compound-assignment-values.js": 3508, - "3121-dynamic-accessor-descriptors.js": 5206, - "3122-dynamic-delete-descriptors.cjs": 3618, - "3122-dynamic-delete-descriptors.js": 3463, - "3122-js-async-class-methods.js": 3826, - "3123-destructured-global-tdz.js": 3445, - "3124-array-prototype-borrow.js": 4427, - "3125-regex-global-match.ts": 2948, - "3126-js-number-radix/main.ts": 3569, - "3127-spawn-runtime-options.ts": 3489, - "3128-regex-last-index.ts": 4225, - "3129-js-token-union/main.ts": 4007, - "3130-child-generic-streams.ts": 4070, - "3131-child-rest-listeners.js": 3532, - "3132-child-generic-stream-completion.ts": 11386, - "3133-text-decoder-streaming.ts": 19582, - "3134-fs-vectors.ts": 4100, - "3135-fs-file-handle-controls.ts": 5084, - "3136-fs-file-handle-options.ts": 5319, - "3137-fs-vector-callbacks.cjs": 4121, - "3138-array-large-storage.ts": 5662, - "3139-regex-native-deep-alternatives.ts": 37923, - "3140-array-dense-access.ts": 5683, - "3141-map-string-key-hash.ts": 3292, - "3150-integer-remainder.ts": 4041, - "3151-array-push-writes.ts": 4409, - "3170-number-conversion-fast-paths.ts": 3918, - "3171-method-census-data-writes.ts": 4678, - "400-fib.ts": 3649, - "401-mutual-recursion.ts": 2468, - "402-string-functions.ts": 3526, - "403-void-and-params.ts": 3277, - "4030-runtime-object-truthiness.ts": 4681, - "4031-event-emitter-long-tuples.ts": 3970, - "4032-inline-rc-fast-paths.ts": 6135, - "404-rc-stress.ts": 3734, - "4040-adapted-function-identity.ts": 4226, - "4041-adapted-function-properties.ts": 3785, - "4042-object-is-union-subclass.ts": 3204, - "4043-nonnull-missing-element.ts": 4658, - "4044-adapted-callback-modules/main.ts": 3502, - "4045-optional-element-projections.ts": 4551, - "4046-captured-parameter-values.ts": 4678, - "4047-captured-parameter-rebinding.ts": 3804, - "405-params-optional.ts": 3480, - "406-params-defaults.ts": 3673, - "4060-cycle-shared-instance/main.ts": 2973, - "4060-stack-union-reads.ts": 3684, - "4061-cycle-evaluation-order/main.ts": 3762, - "4061-nullable-ref-fields.ts": 5610, - "4062-cycle-tdz-read/main.ts": 3351, - "4063-cycle-hoisted-calls/main.ts": 3608, - "4064-cycle-classes-after-init/main.ts": 3570, - "4065-cycle-init-throws/main.ts": 3220, - "4066-cycle-top-level-tdz/main.ts": 2340, - "4067-dynamic-import-cycle-tdz/main.ts": 3378, - "407-params-rest.ts": 3809, - "408-params-ctors-inheritance.ts": 4026, - "4080-optional-read-presence-tests.ts": 3072, - "4080-string-index-bounds.ts": 2694, - "4081-hoisted-function-tdz.ts": 4427, - "4081-string-index-unproven.ts": 3902, - "4082-hoisted-function-tdz-uncaught.ts": 2748, - "4083-dynamic-import-failure/main.ts": 3742, - "4084-record-optional-field-copies.ts": 4621, - "4085-generator-loop-close.ts": 4491, - "4086-optional-capture-defaults.ts": 2947, - "4088-class-static-tdz.ts": 3366, - "4089-class-wrapper-tdz.js": 2781, - "409-params-async-generics.ts": 4252, - "4090-computed-key-tdz.js": 3408, - "4091-class-evaluation-deferred.ts": 2828, - "410-params-rc-stress.ts": 2917, - "4140-array-callback-split-visit.ts": 6798, - "4141-array-callback-ambient-receiver/main.ts": 3870, - "4142-array-callback-factories.ts": 4472, - "4143-union-refinement-intersection-arms.ts": 4107, - "420-dead-strip-modules/main.ts": 2681, - "4290-acyclic-immutable-trees.ts": 3286, - "4291-acyclic-constructor-escapes.ts": 3619, - "4292-acyclic-readonly-bypass.ts": 4006, - "4293-acyclic-dynamic-writes.ts": 3787, - "4294-console-line-sizes.ts": 5430, - "4295-console-template-parts.ts": 3102, - "4296-console-glued-long-parts.ts": 4254, - "4410-inline-object-allocation.ts": 4263, - "4411-nullable-ref-values.ts": 5324, - "4412-nullable-record-values.ts": 4337, - "4413-cycle-old-late-death.ts": 3017, - "4413-nullable-null-and-undefined.ts": 4035, - "4414-cycle-old-weak-keys.ts": 3820, - "4414-nullable-string-values.ts": 5821, - "4415-identity-borrowed-operands.ts": 4327, - "4415-nullable-container-values.ts": 5953, - "4431-exception-pending-contexts.ts": 5399, - "4432-checked-downcast-failures.ts": 4507, - "4451-int32-field-storage.ts": 5079, - "4452-int32-field-dynamic-writes.ts": 4478, - "4453-int32-closed-locals.ts": 3221, - "4454-int32-field-reflection-reads.ts": 4583, - "4455-live-view-reads-without-stores.ts": 4961, - "4471-unassigned-field-reads.ts": 4391, - "4476-string-ascii-header-fact.ts": 4538, - "4477-buffer-write-ascii-runs.ts": 4115, - "4478-string-large-index-reads.ts": 4211, - "4481-array-optional-push.ts": 3640, - "4482-instanceof-static-class-optional.ts": 2991, - "4483-array-splice-statement.ts": 5079, - "4484-array-length-reset.ts": 3655, - "4485-array-splice-optional-item.ts": 4264, - "4486-array-field-element-borrows.ts": 3950, - "4487-array-literal-optional-values.ts": 5139, - "4520-optional-guard-narrowing.ts": 4441, - "4521-array-callback-element-presence.ts": 6451, - "4522-captured-parameter-lifetimes.ts": 3198, - "4523-array-pop-removal.ts": 4334, - "4524-array-callback-supertype-params.ts": 5586, - "4541-nullable-wrap-borrows.ts": 4310, - "4542-preserving-call-borrows.ts": 4231, - "4543-walk-borrowed-locals.ts": 3976, - "4544-checked-cast-aliases.ts": 4280, - "4545-borrowed-returns.ts": 4524, - "4546-rebound-borrowed-params.ts": 4010, - "4560-field-store-borrowed-receivers.ts": 3877, - "4561-virtual-borrowed-parameters.ts": 4633, - "4562-string-self-concat-move.ts": 3881, - "4563-array-read-projection-receivers.ts": 4188, - "4564-literal-choice-strings.ts": 4026, - "4568-for-of-hole-elements.ts": 4432, - "4569-shorthand-missing-elements.ts": 4672, - "4570-map-lookup-default-record.ts": 3777, - "4591-weak-keys-union-records.ts": 3889, - "4592-cycle-const-from-import/main.ts": 2581, - "4593-weak-keys-empty-objects.ts": 3813, - "4594-union-class-field-mixed-types.ts": 7147, - "4595-union-class-field-optional-receiver.ts": 3827, - "4596-error-subclass-int-fields.ts": 3477, - "4596-tdz-nullable-forward-capture.ts": 3990, - "4597-callback-field-method-name.ts": 4176, - "4598-live-array-ref-element-access.ts": 9941, - "4598-map-set-clear-reuse.ts": 5807, - "4598-os-available-parallelism.ts": 3624, - "4598-publish-constructor-stores.ts": 3208, - "4599-construction-only-field-borrows.ts": 5064, - "4600-construction-only-fields-dynamic-writes.ts": 3234, - "4601-cycle-holders.ts": 3389, - "4602-constructor-escape-order.ts": 3798, - "4610-array-ext-dyn-refresh.ts": 4533, - "4620-optional-chain-borrowed-receivers.ts": 4161, - "4621-edge-preserving-callees/main.ts": 4709, - "4630-contract-int32.ts": 4369, - "4630-reference-write-call-arguments.ts": 4010, - "4631-contract-nothrow.ts": 4027, - "4631-reference-write-aliases.ts": 4138, - "4632-contract-immutable.ts": 3925, - "4632-reference-write-loops-and-walks.ts": 4126, - "4633-contract-program-lifetime.ts": 5198, - "4633-reference-write-callbacks-returns.ts": 4361, - "4634-contract-program-lifetime-publish.ts": 51728, - "4634-optional-element-borrowed-returns.ts": 3758, - "4640-bitwise-identity-ranges.ts": 4521, - "4641-nothrow-try-catch.ts": 3856, - "4642-acyclic-contract.ts": 4836, - "4650-stale-property-narrowing.ts": 5065, - "4651-map-string-get-entry.ts": 3204, - "4652-stale-closure-binding-narrowing.ts": 4161, - "4660-typed-rest-spread-forwarding.ts": 2965, - "4671-scoped-array-read-borrows.ts": 4639, - "4690-cycle-bypass-long-lived.ts": 6384, - "4691-publish-constructor-self-alias.ts": 43679, - "4692-borrowed-result-mutating-callees.ts": 4134, - "4720-cold-throw-paths.ts": 3925, - "4721-integer-induction-numbers.ts": 3986, - "4730-touint32-large-magnitudes.ts": 3378, - "4731-string-mixed-ascii-slices.ts": 3992, - "4732-buffer-write-utf16le-runs.ts": 4419, - "4733-typed-array-read-compares.ts": 3723, - "4750-map-string-absent-filter.ts": 4339, - "4751-string-search-multibyte-needles.ts": 2934, - "4795-published-untyped-member-reads.ts": 4864, - "4806-uint32-loop-accumulators.ts": 4131, - "4810-union-identity-retags.ts": 45852, - "4811-union-retag-checked-cast.ts": 3777, - "4812-int32-wrapping-sums.ts": 4491, - "4813-typed-array-read-equality-bindings.ts": 5104, - "4820-sort-comparator-lent-arguments.ts": 4547, - "4821-callback-lent-arguments.ts": 4044, - "4822-stable-capture-reads.ts": 3520, - "4823-array-store-receivers.ts": 3708, - "4830-typed-teardown-chains.ts": 5155, - "4831-cycle-bypass-probe-windows.ts": 6539, - "4840-array-hole-free-prefix.ts": 5312, - "4860-int32-local-storage.ts": 5193, - "4870-array-pipeline-fusion.ts": 9277, - "4871-array-pipeline-analytics.ts": 4466, - "4872-array-pipeline-temporaries.ts": 8037, - "4875-stream-consumers-array-buffer.ts": 4195, - "4876-array-buffer-inspect.ts": 3460, - "4880-await-call-turn-order.ts": 3196, - "4881-await-call-exceptions.ts": 3913, - "4882-await-call-request-chain.ts": 3966, - "4883-await-values-and-hops.ts": 3305, - "4884-await-call-unhandled-sibling.ts": 3775, - "4885-await-call-checkpoints.ts": 3389, - "4890-regex-literal-sites.ts": 4481, - "4891-regex-plain-text-patterns.ts": 4954, - "4892-regex-exec-read-captures.ts": 5836, - "4900-bigint-division-cross-check.ts": 4132, - "4900-console-instances.ts": 3398, - "4901-bigint-radix-text.ts": 4240, - "4901-console-instance-errors.ts": 4118, - "4902-bigint-compound-assign.ts": 3348, - "4903-bigint-fixed-width.ts": 4053, - "4904-bigint-large-products.ts": 4084, - "4905-bigint-fixed-width-fusion.ts": 4866, - "4906-bigint-small-value-trees.ts": 4495, - "4907-bigint-random-trees.ts": 6985, - "4910-hole-free-prefix-upkeep.ts": 3869, - "4920-string-literal-switch.ts": 3948, - "4930-typed-record-reflection.ts": 6446, - "4931-typed-data-generic-walks.ts": 6005, - "4932-typed-json-unknown.ts": 4690, - "4940-async-return-adoption.ts": 4747, - "4941-async-return-adoption-try.ts": 4808, - "4942-async-return-adoption-values.ts": 4525, - "4943-async-return-adoption-interleaved.ts": 4076, - "4950-regex-compiled-captures.ts": 5853, - "4951-regex-compiled-last-index.ts": 4237, - "4952-regex-compiled-anchors-classes.ts": 2970, - "4953-regex-compiled-backtracking.ts": 4881, - "4954-regex-log-report.ts": 4017, - "4955-regex-compiled-differential.ts": 17656, - "4970-int32-call-abi.ts": 4034, - "4980-generator-early-exit-finally.ts": 4293, - "4981-generator-delegation-iterables.ts": 4701, - "4982-generator-sent-values.ts": 3850, - "4983-generator-reuse-iterables.ts": 4013, - "4984-generator-exceptions.ts": 3941, - "4985-generator-lazy-pipeline.ts": 5191, - "4986-generator-default-channels.ts": 4218, - "4987-generator-closures-methods.ts": 3564, - "4988-generator-async-interplay.ts": 4129, - "4989-generator-step-drives.ts": 3945, - "4990-lone-surrogates.ts": 4283, - "4991-lone-surrogate-halves.ts": 3965, - "4992-lone-surrogate-search.ts": 4450, - "4993-lone-surrogate-json.ts": 4533, - "4994-lone-surrogate-uri.ts": 3275, - "4995-lone-surrogate-regex.ts": 4305, - "4996-lone-surrogate-stdio.ts": 3980, - "4997-lone-surrogate-stdout-patch.js": 3708, - "4998-lone-surrogate-buffers.ts": 3397, - "4999-lone-surrogate-io.ts": 4183, - "500-array-basics.ts": 3681, - "501-array-push-pop.ts": 3744, - "5010-lifetime-region-generations.ts": 4361, - "5011-lifetime-region-outside-references.ts": 3723, - "5012-lifetime-region-shapes.ts": 5352, - "5013-lifetime-region-async.ts": 4836, - "5014-lifetime-region-nesting.ts": 4098, - "5015-lifetime-region-publish.ts": 44284, - "5016-lifetime-region-weak-keys.ts": 4090, - "5017-lifetime-region-cycles.ts": 2993, - "5018-lifetime-region-hierarchies.ts": 4448, - "5019-lifetime-region-values.ts": 4593, - "502-array-for-of.ts": 3697, - "5020-lifetime-region-large.ts": 6810, - "5021-lifetime-region-opaque-holders.ts": 3221, - "5022-lifetime-region-workers.ts": 43902, - "503-array-functions.ts": 3221, - "504-array-rc-stress.ts": 3902, - "5040-promise-all-race-turns.ts": 3963, - "5041-promise-all-turns.js": 3961, - "5042-async-generator-return-promise.ts": 4464, - "5043-async-generator-return-forms.ts": 3956, - "5045-generator-delegation-typed-next.ts": 4940, - "5046-generator-delegation-return-throw.ts": 4744, - "5047-generator-delegation-iterables-typed.ts": 5495, - "5048-generator-delegation-async.ts": 4004, - "5049-generator-delegation-edges.ts": 3818, - "5050-inherited-in-membership.ts": 2952, - "5051-typed-record-prototypes.ts": 4128, - "5052-class-for-in-unknown.ts": 4437, - "5053-json-replacer-arrays.ts": 4585, - "5054-required-field-delete.ts": 3565, - "5055-object-create-record-literal.ts": 3433, - "5056-generator-in-unknown.ts": 3552, - "5060-child-fork-exit-after-messages/main.ts": 4059, - "5061-child-fork-local-disconnect/main.ts": 3921, - "5062-child-fork-message-before-eof/main.ts": 5311, - "5065-global-increment-initializers.ts": 3409, - "5066-global-compound-updates.ts": 3878, - "5067-global-updates-in-functions.ts": 3060, - "5068-global-var-let-const-updates.ts": 3099, - "5069-global-update-modules/main.ts": 3105, - "5070-optional-read-bindings.ts": 3986, - "5071-optional-chain-scalars.ts": 4053, - "5072-optional-nullish-ternary.ts": 3786, - "5073-optional-results.ts": 3653, - "5074-optional-pop-shift.ts": 3809, - "5075-optional-reads-unchecked/main.ts": 4486, - "5076-optional-escapes.ts": 3781, - "5080-boolean-array-storage.ts": 9389, - "5081-boolean-array-dynamic-views.ts": 5005, - "5085-promise-allsettled-turns.ts": 5227, - "5086-promise-any-turns.ts": 4926, - "5087-promise-allsettled-any-dyn.js": 5648, - "5088-promise-combinator-thenables.js": 6097, - "5089-promise-settled-records.ts": 4902, - "5090-generator-finished-result-value.ts": 3980, - "5091-generator-delegation-arrays-strings.ts": 4920, - "5092-generator-delegation-sets-maps.ts": 5655, - "5095-console-count-group.ts": 4543, - "5096-console-assert-dir.ts": 3659, - "5097-console-table.ts": 4019, - "5098-console-time-warnings.ts": 7779, - "5099-console-methods-dynamic.cjs": 4211, - "510-array-map-filter-foreach.ts": 3693, - "511-array-indexof-includes.ts": 2587, - "5110-var-hoisting-early-reads.ts": 3722, - "5111-var-hoisting-closures-classes.ts": 3558, - "5112-var-hoisting-function-scope.ts": 3736, - "5113-tdz-let-const-class.ts": 3427, - "5114-var-hoisting-js.js": 2426, - "5115-regex-replace-compiled.ts": 4045, - "5116-regex-capture-reads.ts": 3563, - "5117-regex-log-report-spans.ts": 3810, - "5118-regex-replace-char-chains.ts": 3242, - "512-array-join-chains.ts": 3887, - "5120-frame-records.ts": 4007, - "5121-frame-objects.ts": 3950, - "5122-frame-result-slots.ts": 3225, - "5123-frame-reassigned.ts": 3642, - "5124-frame-objects-control.ts": 2980, - "5125-frame-mutating-methods.ts": 3316, - "5126-frame-returned-params.ts": 3759, - "5127-frame-loop-bindings.ts": 4535, - "513-array-methods-rc-stress.ts": 3991, - "5130-event-target-dispatch.js": 5194, - "5131-event-target-listener-errors.js": 5170, - "5132-event-target-typed.ts": 5485, - "5133-abort-signal-event-target.ts": 30480, - "5134-events-error-monitor.ts": 3910, - "5135-event-target-warnings.js": 38892, - "5136-events-error-monitor-string-name.ts": 3923, - "5137-events-error-monitor-computed-name.js": 4432, - "5138-events-error-monitor-shared-listener.ts": 3642, - "5139-event-target-listener-throw.ts": 4714, - "514-array-find-some-every.ts": 3747, - "5140-os-host-facts.ts": 4713, - "5141-os-constants.ts": 3991, - "5142-path-parse-format.ts": 3463, - "5145-path-matches-glob-basics.ts": 4364, - "5146-path-matches-glob-braces.ts": 5382, - "5147-path-matches-glob-extglob.ts": 3804, - "5148-path-matches-glob-classes.ts": 3686, - "5149-path-matches-glob-win32.ts": 4358, - "515-array-flatmap.ts": 4323, - "5150-small-array-inline-slots.ts": 4485, - "5155-cycle-header-types.ts": 32161, - "516-array-reduce.ts": 4410, - "5160-field-callback-receiver.ts": 4515, - "5161-field-callback-receiver-escape.ts": 3931, - "5162-field-method-reference-receiver.ts": 3961, - "5163-field-callback-receiver.cjs": 4008, - "5164-worker-field-callback-receiver.ts": 43587, - "5165-interface-method-dispatch.ts": 4146, - "5166-interface-method-values.ts": 5178, - "5167-interface-method-order.ts": 4344, - "5168-interface-method-hierarchy.ts": 5405, - "5169-interface-method-chains.ts": 5047, - "517-array-hof-index-args.ts": 3899, - "5170-string-scan-eviction.ts": 2657, - "5171-lone-surrogate-replace-seams.ts": 3047, - "5175-forin-typed-as-unknown.ts": 3918, - "5176-object-keys-typed-as-unknown.ts": 2645, - "5177-forin-dynamic-objects.ts": 3654, - "5178-forin-keys-js.js": 2761, - "5179-forin-typed-shapes.ts": 3622, - "518-array-sort.ts": 4004, - "518-promise-void-union-callbacks.ts": 3964, - "5180-interface-arrays.ts": 4400, - "5181-interface-array-methods.ts": 13672, - "5182-interface-array-boundaries.ts": 3272, - "5183-interface-property-reads.ts": 4146, - "5184-interface-property-objects.ts": 3495, - "5185-util-inherits.cjs": 6043, - "5186-util-inherits.ts": 6829, - "5187-util-deprecate.cjs": 6304, - "5188-util-deprecate-flags.cjs": 4852, - "5189-util-deprecate.ts": 5176, - "519-array-from-length.ts": 4670, - "519-promise-union-await-values.ts": 3522, - "5190-util-callbackify.cjs": 4881, - "5191-util-callbackify.ts": 5163, - "5192-util-debuglog.cjs": 5490, - "5193-util-debuglog.ts": 3737, - "5194-process-emit-warning-tick.cjs": 4043, - "5195-object-entries-typed-as-unknown.ts": 3294, - "5196-object-values-typed-as-unknown.ts": 4153, - "5197-object-entries-dynamic-objects.ts": 4163, - "5198-object-entries-values-js.js": 3223, - "5199-object-entries-identity.ts": 4287, - "520-map-basics.ts": 3177, - "5200-array-sort-keyed-numbers.ts": 5498, - "5201-array-sort-keyed-records.ts": 6386, - "5202-array-sort-keyed-lookalikes.ts": 3643, - "5203-typed-array-sort-default.ts": 7538, - "5204-typed-array-sort-comparators.ts": 5252, - "521-map-number-keys.ts": 3394, - "5210-process-memory-usage.ts": 2806, - "5211-process-identity.ts": 3698, - "5212-perf-marks-measures.ts": 4803, - "5213-perf-timing-errors.ts": 4464, - "5214-perf-entry-inspect.ts": 4525, - "5215-perf-timing-validation.js": 4263, - "5216-perf-spread-arguments.js": 4935, - "5217-perf-spread-typed.ts": 3571, - "522-map-foreach.ts": 2998, - "5220-url-parse-warnings.ts": 5276, - "5221-url-parse-shapes.ts": 5152, - "5222-url-parse-hosts.ts": 5614, - "5223-url-parse-query.ts": 5852, - "5224-url-format-objects.ts": 5092, - "5225-url-format-whatwg.ts": 5939, - "5226-url-resolve.ts": 4968, - "5227-url-legacy-dependency/main.ts": 5444, - "5228-url-domain-conversion.ts": 2782, - "5229-url-legacy-errors.cjs": 6339, - "523-map-ref-values.ts": 3549, - "5230-inline-union-fields.ts": 4686, - "5231-inline-union-field-kinds.ts": 4192, - "5232-inline-union-fields-dynamic.ts": 4074, - "5233-inline-union-fields-shapes.ts": 4531, - "5234-inline-union-class-fields.ts": 4699, - "5235-inline-union-fields-publish.ts": 3783, - "5236-inline-union-unchecked-reads.ts": 3109, - "5237-inline-union-frame-objects.ts": 2338, - "524-map-cycles.ts": 3268, - "5240-event-target-subclass.ts": 5177, - "5241-event-subclass.ts": 5478, - "5242-event-target-subclass-hierarchy.ts": 4631, - "5243-event-target-subclass-dynamic.ts": 4520, - "5244-event-target-subclass.js": 5329, - "5245-event-target-subclass-signals.ts": 33048, - "5246-event-target-subclass-listener-throw.ts": 3829, - "5247-event-target-subclass-lifetimes.ts": 6504, - "5248-event-target-subclass-warnings.ts": 4300, - "5249-event-target-subclass-unconstructed.ts": 4427, - "525-map-rc-stress.ts": 3704, - "5250-cipher-aes-gcm.ts": 7929, - "5251-cipher-aes-cbc.ts": 15678, - "5252-cipher-aes-ctr.ts": 26018, - "5253-cipher-chacha20-poly1305.ts": 7999, - "5254-cipher-errors.js": 26643, - "5255-cipher-encodings.cjs": 20470, - "5256-cipher-deprecation.cjs": 48818, - "5257-cipher-vectors.ts": 18839, - "5258-cipher-handles.js": 21996, - "5259-cipher-chunked.ts": 21780, - "526-set-basics.ts": 3497, - "5260-record-unknown-identity.ts": 3759, - "5261-optional-field-identity.ts": 3633, - "5262-record-unknown-many.ts": 4065, - "527-set-foreach.ts": 3282, - "5270-url-parse-no-deprecation.cjs": 4123, - "5271-url-parse-throw-deprecation.cjs": 5457, - "5275-http-end-callback-order.ts": 4317, - "5276-style-text-hex-colors.cjs": 4489, - "5277-fs-read-file-buffer-option.cjs": 3576, - "5278-host-null-bytes.cjs": 8285, - "5279-search-params-null-init.cjs": 3511, - "528-set-seeded.ts": 3372, - "5285-blob-construct.ts": 4331, - "5286-blob-readers.ts": 3684, - "5287-blob-inspect.ts": 4285, - "5288-blob-validation.js": 4292, - "5289-blob-read-order.ts": 3682, - "529-map-seeded.ts": 3677, - "5290-blob-dynamic.js": 4399, - "5295-readline-promises-question.ts": 3697, - "5296-readline-lines.ts": 3534, - "5297-readline-callback-events.cjs": 3926, - "5298-readline-abort.cjs": 12732, - "5299-readline-stdin.ts": 4774, - "530-record-arrays.ts": 3665, - "5300-stream-add-abort-signal.ts": 34654, - "5301-stream-add-abort-signal-errors.cjs": 12589, - "5302-stream-promises-options.ts": 13246, - "5303-stream-finished-callback-opts.cjs": 9506, - "5305-json-stringify-typed-arrays.ts": 5926, - "531-record-array-hofs.ts": 3761, - "5315-map-iterate-after-front-deletes.ts": 3399, - "5316-map-lru-eviction.ts": 4060, - "5317-map-iterate-while-mutating.ts": 3994, - "5318-set-iterate-after-deletes.ts": 3956, - "5319-map-iteration-values.ts": 4002, - "532-record-arrays-rc-stress.ts": 3024, - "5320-map-iterate-across-compaction.ts": 4445, - "5321-integer-closed-arithmetic-loops.ts": 3363, - "5321-json-parse-cycles.ts": 3162, - "5322-integer-variable-step-loops.ts": 3747, - "5322-json-stringify-parsed-trees.ts": 4167, - "5323-dyn-numeric-index-reads.ts": 3375, - "5323-int32-nonnegative-slot-facts.ts": 3657, - "5324-int32-initializer-locals.ts": 2946, - "5324-structured-clone-documents.ts": 4653, - "5325-record-boundary-returns.ts": 3627, - "5326-record-boundary-params.ts": 3878, - "5327-record-boundary-identity.ts": 2625, - "5328-record-boundary-open.ts": 3032, - "5329-record-boundary-recursion.ts": 3600, - "533-array-element-cycles.ts": 3019, - "5330-record-boundary-fields.ts": 3682, - "5331-record-boundary-methods.ts": 3949, - "5332-int32-narrowed-slot-facts.ts": 3391, - "5333-integer-guarded-while-counters.ts": 3537, - "5333-record-boundary-nullable-argument.ts": 4003, - "5334-fetch-mentions-without-calls.ts": 3134, - "5335-stream-operators-values.ts": 5552, - "5335-top-level-await-pending-exit-code.ts": 3309, - "5336-stream-operators-promise-timing.ts": 3761, - "5336-top-level-await-pending-exit-listener.ts": 4072, - "5337-dc-subscriber-throw-next-tick.cjs": 4314, - "5337-stream-operators-concurrency.ts": 9296, - "5338-js-tdz-function-element.js": 2718, - "5338-stream-operators-checks.cjs": 4825, - "5339-array-buffer-constructor.js": 3399, - "5339-stream-for-await-hops.ts": 5761, - "534-record-width-subtyping.ts": 3917, - "5340-readable-from-options.ts": 4100, - "5341-compound-any-operand.ts": 4139, - "5341-generator-callback-params.ts": 4032, - "5341-integer-recursion-boundaries.ts": 3324, - "5341-readable-from-dynamic.cjs": 5054, - "5342-compound-any-operand.cjs": 3210, - "5342-generator-scalar-channels.ts": 3572, - "5342-integer-recursion-stack-and-mutual.ts": 4091, - "5342-stream-compose.ts": 8635, - "5343-any-flow-compound.ts": 3298, - "5343-integer-recursion-array-index.ts": 4086, - "5343-iterator-result-records.ts": 3462, - "5343-stream-compose-edges.ts": 8761, - "5344-json-parse-undeclared-keys.ts": 4683, - "5344-stream-pipeline-timing.ts": 3627, - "5345-object-values-for-of-unknown.ts": 3893, - "5346-object-values-length-dynamic.ts": 4302, - "5347-object-values-loop-control.ts": 3777, - "5348-object-values-for-of-js.js": 3584, - "5349-object-entries-values-optional.ts": 3677, - "535-object-statics.ts": 4668, - "5350-object-values-wide-record.ts": 4386, - "5351-object-values-methods-index.ts": 3615, - "5352-final-field-loop-reads.ts": 3880, - "5353-captured-const-values.ts": 4470, - "5354-captured-const-tdz.ts": 3331, - "5355-captured-function-declarations.ts": 3574, - "5356-captured-tdz-ordering.ts": 3626, - "5357-init-only-module-bindings.ts": 3698, - "536-map-seed-array.ts": 3057, - "5360-array-sort-comparator-calls.ts": 4503, - "5361-array-sort-inconsistent-comparators.ts": 4396, - "5362-array-sort-comparator-throws.ts": 3173, - "5363-array-sort-comparator-writes.ts": 12179, - "5364-array-sort-union-and-boolean-elements.ts": 14770, - "5365-array-sort-dynamic-values.js": 4175, - "537-map-iter-drains.ts": 3108, - "5370-zlib-stream-roundtrip.ts": 6069, - "5371-zlib-stream-chunking.cjs": 3999, - "5372-zlib-stream-errors.cjs": 4377, - "5373-zlib-stream-options.cjs": 4901, - "5374-zlib-stream-flush-params.ts": 4306, - "5375-zlib-stream-promises.ts": 5322, - "5376-zlib-constants.cjs": 3332, - "5377-zlib-stream-backpressure.cjs": 5428, - "5378-zlib-sync-options.cjs": 5415, - "5379-zlib-callback-options.ts": 5768, - "538-map-set-for-of.ts": 3575, - "5390-interface-loop-element-lifetimes.ts": 4065, - "5391-interface-dispatch-hierarchies.ts": 4925, - "5392-interface-receiver-bindings.ts": 3293, - "5393-interface-array-holes.ts": 3549, - "5394-interface-implementers.ts": 4320, - "5395-locale-compare-ascii.ts": 4299, - "5396-locale-compare-latin.ts": 3694, - "5397-locale-compare-sorting.ts": 4218, - "540-tuples-basics.ts": 3768, - "5400-json-parse-typed-keys.ts": 4494, - "5405-buffer-arraybuffer-window.ts": 3875, - "5406-util-types-keys.ts": 4065, - "5407-http-header-field-limit.ts": 2684, - "5408-http-unread-request-end.ts": 4832, - "5409-http-held-request-body.ts": 4395, - "541-ref-array-json.ts": 4658, - "5410-inspect-class-values.ts": 4013, - "5411-inspect-class-hierarchies.ts": 3695, - "5412-inspect-dynamic-collections.ts": 2565, - "5413-inspect-class-values.cjs": 4189, - "5415-zlib-dynamic-inputs.cjs": 3913, - "542-union-element-arrays.ts": 4031, - "5420-readable-from-generators.ts": 5476, - "5421-readable-from-generators.cjs": 3700, - "5422-stream-async-push-wakeup.ts": 4528, - "5423-stream-end-and-eos-timing.ts": 3712, - "5424-stream-write-buffer-encoding.ts": 3446, - "5425-pipeline-generator-stage.ts": 3465, - "5426-pipeline-generator-errors.ts": 4156, - "5427-pipeline-generator-backpressure.ts": 3689, - "5428-pipeline-generator-stages.cjs": 5519, - "5429-pipeline-generator-buffers.ts": 4449, - "5430-dyn-number-string-boxes.ts": 3851, - "5435-crypto-hash-algorithms.ts": 4090, - "5436-crypto-hash-names.js": 3513, - "5437-crypto-hmac-algorithms.ts": 3873, - "5438-crypto-kdf-digests.ts": 4076, - "5439-crypto-kdf-callbacks.js": 3741, - "5440-crypto-hash-encodings.js": 5108, - "5441-crypto-hash-output-length.ts": 5257, - "5442-crypto-random-values.ts": 4596, - "5443-crypto-random-arguments.js": 4093, - "5444-crypto-timing-safe-equal.js": 3904, - "5445-crypto-secret-key-objects.ts": 3885, - "5445-stream-buffer-chunks.ts": 4371, - "5446-crypto-secret-key-errors.js": 3542, - "5446-stream-buffer-chunks-dynamic.js": 5530, - "5447-fs-readdir-order.ts": 3865, - "5448-fs-glob-patterns.ts": 3617, - "5449-fs-glob-options.ts": 4047, - "5450-fs-glob-validation.js": 4514, - "5451-fs-promises-glob.ts": 4041, - "5452-fs-glob-callback.ts": 3311, - "5455-power-of-two-remainder.ts": 3496, - "5456-remainder-large-integer-dividends.ts": 3106, - "5457-lcg-modulus.ts": 3217, - "5458-fractional-remainder.ts": 3231, - "5460-locale-compare-contractions.ts": 4279, - "5461-locale-compare-equivalents.ts": 4168, - "5462-locale-compare-probe-sweep.ts": 5118, - "5463-locale-compare-combining-letters.ts": 4089, - "5464-locale-compare-fractions.ts": 3465, - "5465-dyn-index-read-arrays.ts": 2910, - "5466-dyn-index-read-special.ts": 3472, - "5470-strip-vt-osc.cjs": 2950, - "5471-strip-vt-csi.cjs": 3252, - "5472-strip-vt-random.cjs": 3939, - "5473-strip-vt-unterminated.cjs": 4153, - "5474-strip-vt-surrogates.ts": 3689, - "5510-assert-error-properties.js": 3848, - "5511-assert-error-class.ts": 3354, - "5512-assert-error-options.js": 3961, - "5513-assert-deep-equal-loose.js": 4575, - "5514-assert-deep-equal-typed.ts": 4346, - "5515-assert-deep-strict-typed-messages.ts": 3857, - "5516-assert-deep-equal-edges.js": 4060, - "5517-assert-partial-deep-equal.js": 4428, - "5518-assert-partial-deep-typed.ts": 4540, - "5519-assert-partial-deep-typed-edges.ts": 4298, - "5520-assert-record-literal-failures.ts": 4043, - "5520-dyn-property-read-receivers.ts": 3946, - "5521-assert-empty-message.js": 4460, - "5521-dyn-property-read-keys.ts": 3510, - "5522-assert-throws-failure-properties.ts": 3814, - "5523-assert-class-options.js": 4920, - "5524-assert-class-skip-prototype.ts": 3993, - "5530-buffer-pool.ts": 4954, - "5531-buffer-pool-first-slab.ts": 4419, - "5532-buffer-pool-first-slab-untyped.mjs": 156958, - "5540-fs-callback-forms.cjs": 5033, - "5541-fs-stats-fields.cjs": 5031, - "5542-fs-promises-parity.cjs": 3782, - "5543-fs-promises-typed.ts": 4425, - "5544-fs-opendir.cjs": 4598, - "5545-fs-options-encoding.cjs": 3812, - "5546-fs-read-stream.cjs": 4053, - "5547-fs-write-stream.cjs": 5026, - "5548-fs-callback-arguments.cjs": 3447, - "5549-fs-callback-option-checks.cjs": 4220, - "5550-locale-compare-ascii-words.ts": 3391, - "5551-array-search-references.ts": 4559, - "5552-string-appends.ts": 3836, - "5553-string-append-char-code.ts": 3220, - "5554-fs-streams-typed.ts": 4826, - "5555-fs-callback-turns.cjs": 4160, - "5555-http-server-close-keep-alive.ts": 16562, - "5556-http-client-agent-connection.ts": 7869, - "5557-http-outgoing-header-values.ts": 4486, - "5558-http-incoming-duplicate-headers.ts": 3277, - "5559-http-expect-header.ts": 13540, - "5560-http-response-framing.ts": 11999, - "5561-http-max-header-size.ts": 4546, - "5562-https-verify-errors.ts": 5339, - "5563-http-keep-alive-timeout.ts": 18223, - "5564-http-request-signal.ts": 6038, - "5565-fs-dirent-untyped.mjs": 4190, - "5566-fs-dirent-dyn-boundaries/main.mjs": 4370, - "5567-fs-cpsync.ts": 4231, - "5568-fs-cp-errors.js": 4710, - "5569-fs-cp-symlinks.ts": 3975, - "5570-fs-cp-async.ts": 4871, - "5571-fs-cp-deep.ts": 4651, - "5585-record-results-inlined.ts": 3799, - "5595-net-ref-unref.ts": 2930, - "5600-dyn-cycle-self.ts": 2377, - "5601-dyn-cycle-mutual.ts": 3087, - "5602-dyn-cycle-arrays.ts": 3074, - "5603-dyn-cycle-identity.ts": 3151, - "5604-dyn-cycle-checks.ts": 4016, - "5605-dyn-cycle-containers.ts": 4827, - "5606-dyn-cycle-capsules.ts": 3409, - "5610-readable-from-sets-and-views.ts": 6055, - "5611-readable-from-class-iterables.ts": 4787, - "5612-readable-from-iterables.cjs": 4888, - "5613-readable-from-iterable-timing.cjs": 4572, - "5614-readable-from-iterable-errors.cjs": 4862, - "5615-next-tick-callback-phases.ts": 4035, - "5616-next-tick-callback-phases.cjs": 3650, - "5617-pipeline-function-ends.ts": 55330, - "5618-pipeline-function-ends-errors.ts": 9347, - "5619-pipeline-function-ends.cjs": 5502, - "5620-timers-promises-values.ts": 3441, - "5621-util-format-float.ts": 4023, - "5622-events-once.mjs": 2752, - "5623-events-once.ts": 3430, - "5624-timers-promises-unawaited.ts": 3337, - "5625-promisify-exec.ts": 7797, - "5626-promisify-forms.ts": 2892, - "5627-exec-callback.ts": 2500, - "5628-promisify-timers.ts": 4069, - "5629-promisify-stream.ts": 4133, - "5630-promisify-zlib.ts": 3777, - "5631-promisify-crypto.ts": 2600, - "5632-promisify-dns.ts": 2000, - "5644-net-socket-addresses.ts": 3299, - "5645-net-socket-callbacks.ts": 4363, - "5646-net-server-connections.ts": 4089, - "5647-net-is-ip.ts": 3406, - "5648-dns-lookup-forms.ts": 4891, - "5649-dns-service-servers.ts": 4574, - "5650-dns-lookup-errors-untyped.cjs": 4634, - "5651-tls-socket-protocol.ts": 4232, - "5652-http-client-trailer-overflow.ts": 3846, - "5653-net-socket-read-ahead.ts": 5725, - "5654-https-empty-servername.ts": 5753, - "5655-dgram-socket-options.ts": 5148, - "5656-dgram-option-states.ts": 4307, - "5657-net-reset-and-address.ts": 3700, - "5658-net-reset-dynamic.cjs": 3925, - "5659-net-blocklist-socketaddress.ts": 4339, - "5664-tls-client-identity.ts": 5675, - "5674-union-instanceof-array-arms.ts": 4342, - "5680-array-growth-after-copy.ts": 5326, - "5681-array-pop-and-length.ts": 4603, - "5682-publish-wide-objects.ts": 2847, - "5700-cycle-release-retained.ts": 2881, - "5701-cycle-release-old-edges.ts": 2910, - "5702-publish-candidate-buffers.ts": 3240, - "5703-lifetime-region-debug.ts": 2720, - "5704-publish-refused-restores-counts.ts": 3978, - "5710-map-number-keys-hashed.ts": 4622, - "5711-map-number-write-after-read.ts": 4051, - "5712-map-number-overwrite-at-growth.ts": 3797, - "5714-cycle-large-candidate-buffers.ts": 5014, - "5715-json-parse-fitted-tables.ts": 4538, - "5717-set-prototype-of-primitives.ts": 3446, - "5719-int32-fields-dynamic-operators.ts": 3704, - "5720-intern-table-basics.ts": 4156, - "5721-intern-table-values.ts": 4709, - "5722-intern-table-workers.ts": 39327, - "5723-intern-table-shared-types.ts": 5477, - "5724-intern-table-array-keys.ts": 5614, - "5725-intern-table-callbacks.ts": 3793, - "5726-intern-table-key-limits.ts": 4034, - "5740-atomics-operation-semantics.ts": 3727, - "5741-atomics-contended-counters.ts": 24517, - "5742-atomics-lock-ordering.ts": 5553, - "5743-atomics-wait-notify.ts": 29359, - "5744-atomics-ring-buffer.ts": 32353, - "5745-atomics-semaphore-stress.ts": 39374, - "5746-shared-bulk-operations.ts": 4179, - "5747-fs-stat-throw-if-no-entry.ts": 3952, - "5748-fs-stat-throw-if-no-entry-js.cjs": 4210, - "5752-string-number-concat.ts": 2959, - "5760-crypto-hash-stream.ts": 3973, - "5761-crypto-hash-stream-states.ts": 3637, - "5762-crypto-hash-stream.cjs": 3895, - "5763-crypto-sha-blocks.ts": 3916, - "5764-class-structural-view-writes.ts": 4447, - "5764-crypto-hmac-edges.cjs": 3134, - "5765-class-structural-view-identity.ts": 3804, - "5766-class-structural-view-callbacks.ts": 3899, - "5767-class-opaque-accessor-view.ts": 3629, - "5776-power-of-two-remainder-integer-path.ts": 4355, - "5780-readline-history-options.ts": 2574, - "5781-readline-history-options.cjs": 2685, - "5782-readline-terminal-editing.ts": 7458, - "5783-readline-terminal-completion.cjs": 9987, - "5784-readline-terminal-promises.ts": 7899, - "5785-readline-terminal-keys.ts": 8463, - "5786-readline-terminal-history.cjs": 4186, - "5787-readline-cursor-helpers.cjs": 4616, - "5788-readline-promises-readline.ts": 4151, - "5789-readline-cursor-pos.cjs": 8106, - "5790-readline-keypress-events.ts": 4768, - "5791-dyn-constant-key-read-sites.ts": 3912, - "5791-readline-keypress-interfaces.cjs": 4765, - "5792-json-parse-repeated-layouts.ts": 4527, - "5792-readline-keypress-listeners.ts": 5406, - "5793-worker-message-channel.ts": 5212, - "5794-worker-message-port-close-order.ts": 4655, - "5795-worker-message-port-batches.ts": 3502, - "5796-worker-message-channel.cjs": 4995, - "5797-worker-message-port-transfer.ts": 23371, - "5800-broadcast-channel.ts": 4829, - "5801-broadcast-channel.cjs": 36650, - "5802-broadcast-channel-workers.ts": 3203, - "5803-worker-environment-data.ts": 6261, - "5804-worker-environment-data.cjs": 3356, - "5805-worker-receive-message-parent-port.ts": 3933, - "5806-worker-resource-limits.ts": 22085, - "5807-worker-error-values.ts": 5689, - "5808-worker-unhandled-rejections.ts": 6775, - "5809-process-exit-and-rejections.cjs": 38724, - "5810-mock-method-records.ts": 6060, - "5811-mock-tracker-restore.ts": 5297, - "5812-dyn-box-async-fields.ts": 4153, - "5813-mock-timers-module.ts": 3845, - "5814-mock-timers-date.ts": 10489, - "5830-timers-promises-signal.ts": 5868, - "5831-util-types-brands.ts": 3846, - "5832-util-types-brands-dynamic.js": 3912, - "5833-url-search-params-iterators.ts": 3034, - "5834-url-search-params-iterators-dynamic.mjs": 3877, - "5835-util-format-integer-specifiers.ts": 2899, - "5836-url-search-params-tuple-pairs.ts": 2897, - "5837-util-format-json-circular.ts": 2745, - "5838-qs-stringify-bigint.ts": 2868, - "5839-timers-promises-scheduler.ts": 3136, - "5840-promise-with-resolvers-js.js": 2701, - "5841-json-typed-dyn-members.ts": 4508, - "5842-qs-parse-null-prototype.ts": 3749, - "5843-qs-parse-null-prototype-js.mjs": 3308, - "5844-date-unknown-values.ts": 3966, - "5845-groupby-null-prototype.ts": 3946, - "5846-events-esm-default-max.ts": 3102, - "5847-events-cjs-default-max.cjs": 3039, - "5849-class-view-observations.ts": 3234, - "5850-using-disposable-values.ts": 3491, - "5851-using-suppressed-error-values.ts": 4335, - "5852-using-disposable-values-js.js": 3438, - "5853-set-methods-map-arguments.ts": 3861, - "5854-array-from-async.ts": 4644, - "5855-array-from-async-js.js": 3880, - "5856-error-is-error.ts": 3947, - "5857-regexp-unicode-sets.ts": 3156, - "5858-disposable-stack.ts": 4000, - "5859-disposable-stack-js.js": 4197, - "5860-url-ipv4-hosts.ts": 3379, - "5870-worker-thread-names.ts": 5388, - "5871-worker-untransferable.cjs": 38904, - "5872-readline-positional-create-interface.mjs": 4683, - "5873-readline-promises-namespace.cjs": 3786, - "5874-worker-stdio-streams.ts": 8408, - "5875-worker-stdout-pipe.cjs": 36125, - "5879-worker-stdin.ts": 56815, - "5880-emitter-leak-warning-delivery.ts": 3928, - "5881-inspect-weak-collections.ts": 3161, - "5882-string-decoder-runtime-encoding.ts": 3686, - "5883-os-set-priority.ts": 2593, - "5884-inspect-layout-options.ts": 3958, - "5885-events-max-listener-helpers.ts": 3524, - "5886-inspect-dates.ts": 3606, - "5887-inspect-typed-arrays.ts": 3660, - "5888-inspect-sorted.ts": 2960, - "5889-timers-scheduler-signal.ts": 3671, - "5890-while-string-length-counters.ts": 3347, - "5892-buffer-write-utf16le-runs.ts": 3722, - "5900-float16-array.ts": 3748, - "5901-float16-array-js.js": 3979, - "5904-async-generator-completion.ts": 6741, - "5905-array-from-async-generator.ts": 4080, - "5906-array-from-async-generator-js.js": 3999, - "5907-regex-groups-match-rows.ts": 3750, - "5910-set-prototype-of-primitive-object-kinds.ts": 4285, - "5911-dyn-class-to-primitive.ts": 6260, - "5912-dyn-class-conversion-methods.ts": 4623, - "5913-prototype-type-error-messages.ts": 3542, - "5914-dyn-in-class-prototype-members.ts": 2963, - "5915-dyn-error-string-conversions.ts": 2860, - "5920-promise-try-args.ts": 2731, - "5921-promise-try-args-js.js": 2533, - "5922-matchall-groups-callbacks.ts": 4812, - "5923-matchall-groups-js.js": 4191, - "5924-js-literal-identity.js": 2661, - "5925-class-view-identity-observers.ts": 2640, - "5926-class-view-switch-js.js": 2843, - "5927-switch-object-identity.ts": 3333, - "5928-groupby-iterables.ts": 4581, - "5929-groupby-js.js": 3288, - "5930-contract-int32-arrays.ts": 4209, - "5930-method-census-asserted-number-keys.ts": 3405, - "5931-asserted-reads-keep-number-parameters.ts": 3441, - "5932-generic-class-observed-methods.ts": 4594, - "5933-class-fields-unknown-object.ts": 4036, - "5934-js-class-fields-property-order.js": 4840, - "5935-js-subclass-fields-and-element-calls.js": 4505, - "5936-checked-js-class-types.js": 3902, - "5937-override-narrowed-union-returns.ts": 3617, - "5938-object-literal-computed-keys-keep-methods.ts": 7194, - "5939-js-let-object-reassigned-wider.js": 3070, - "5940-callback-helper-specialization.ts": 5355, - "5941-callback-specialization-recursion.ts": 4385, - "5942-callback-specialization-throws.ts": 3535, - "5943-fields-read-before-assignment.ts": 72293, - "5944-js-fields-read-before-assignment.js": 40310, - "5945-local-class-observed-methods.ts": 6212, - "5946-nested-record-field-optional-writes.ts": 68117, - "5950-tuple-predicate-methods.ts": 5999, - "5951-result-never-widening.ts": 3370, - "5952-record-missing-keys.ts": 20400, - "5953-nan-coded-method-returns.ts": 15600, - "5955-any-promise-methods.js": 3616, - "5956-erased-generic-members.ts": 6191, - "5958-asserted-union-receiver.ts": 2929, - "5959-date-to-json.ts": 2856, - "5960-generic-mapped-types.ts": 3526, - "5970-net-connect-host-name.ts": 2998, - "5971-buffer-chunks-to-string.ts": 3483, - "5972-net-set-encoding-listeners.ts": 7935, - "5974-typeof-module-exports.cjs": 2121, - "5975-zlib-class-values.ts": 4200, - "5990-worker-uncloneable.mjs": 37308, - "5991-worker-async-dispose.mjs": 7506, - "5992-worker-thread-name-lifetime.mjs": 44550, + "2110-top-object-types.ts": 3870, + "2111-json-stringify-unknown.ts": 4435, + "2112-array-at-findlast.ts": 4707, + "2113-string-index-methods.js": 3454, + "212-string-aliasing-append.ts": 3894, + "2120-package-self-import/main.ts": 2683, + "2121-esm-cycle-inert-backedge/main.ts": 2391, + "2123-ambient-import-crash/main.ts": 3826, + "2124-imports-field-wildcard/main.ts": 4011, + "2140-uri-component-codecs.ts": 4495, + "2160-dc-tracing-channel.cjs": 5323, + "2161-js-object-literal-identity.cjs": 4357, + "2162-js-dyn-destructure.cjs": 3222, + "2163-js-selfref-const.cjs": 3731, + "2164-js-then-dyn-handler.cjs": 3928, + "2165-js-throw-dyn.cjs": 3594, + "2166-cjs-getter-this/main.cjs": 2580, + "2170-island-array-exits.ts": 5872, + "2171-island-json-stringify.ts": 3235, + "2172-island-regexp-boundary.ts": 4811, + "2190-new-object-and-string-wrappers.ts": 3881, + "2191-uri-encoders.ts": 2785, + "2192-object-default-tostring.ts": 3767, + "2193-discarded-stdlib-reads.ts": 2753, + "2194-ambient-undef-chains.ts": 3966, + "2195-require-missing-package/main.mjs": 3949, + "2196-island-computed-key-chain.ts": 3859, + "2210-dyn-promise-crossing.cjs": 5056, + "2211-dc-trace-promise.cjs": 4674, + "2212-unhandled-rejection-listener.cjs": 3832, + "2213-async-local-storage.cjs": 4800, + "2214-dc-bind-store.cjs": 4857, + "2215-process-emit-warning-exit.cjs": 4319, + "2240-width-class-into-record.ts": 4526, + "2241-width-record-into-class.ts": 3828, + "2242-width-statics-into-record.ts": 3590, + "2243-width-assert-satisfies-shapes.ts": 4657, + "2250-tagged-templates.ts": 3291, + "2252-class-iterators.ts": 4007, + "2253-union-coercions.ts": 2990, + "2260-http2-constants.cjs": 3422, + "2280-builtin-namespace-destructure.cjs": 3322, + "2281-domexception-atob-btoa.cjs": 3717, + "2282-queue-microtask.cjs": 4471, + "2283-structured-clone.cjs": 6184, + "2284-regexp-constructor.cjs": 3737, + "2285-iferror-dyn.cjs": 3898, + "2286-dyn-object-walks.cjs": 3663, + "2300-dyn-record-spread-and-keyed-access.cjs": 3720, + "2301-cjs-export-table-dom-attach.cjs": 3384, + "2310-process-next-tick.ts": 5910, + "2311-next-tick-js-callbacks.js": 2877, + "2312-stream-underscore-assign.ts": 8104, + "2313-stream-underscore-assign-js.cjs": 4045, + "2314-process-introspection.ts": 4555, + "2320-await-unit.ts": 3726, + "2321-emitter-static-setmax.cjs": 4139, + "2322-dyn-array-sort.cjs": 3726, + "2323-timer-callback-returns.ts": 3622, + "2330-tls-server-runtime-options.cjs": 27710, + "2331-tls-server-options-typed.ts": 27128, + "2350-nan-global.ts": 4123, + "2351-async-methods.ts": 4008, + "2352-void-coercions.ts": 4044, + "2353-decorators-member-ambient.ts": 3507, + "2354-decorators-expression-ambient.ts": 3756, + "2360-tuple-to-array.ts": 3301, + "2361-assign-index-record.ts": 4658, + "2362-execsync-inherit.ts": 3671, + "2363-nullish-retag.ts": 4322, + "2364-in-runtime-key.ts": 3872, + "2365-dyn-into-island.ts": 4202, + "2366-string-well-formed.ts": 4097, + "2367-regexp-escape.ts": 2500, + "2368-set-methods.ts": 4362, + "2369-promise-try.ts": 4105, + "2370-group-by.ts": 5234, + "2371-iterator-helpers.ts": 3705, + "2380-buffer-module-named-import.ts": 3866, + "2381-builtin-default-imports.js": 3690, + "2382-cycle-two-decl/main.ts": 3053, + "2383-cycle-assertdoc/main.js": 3424, + "2384-cycle-mixed-bindings/main.ts": 3805, + "2385-builtin-reexport-facade/main.ts": 3157, + "2386-string-to-chars.ts": 3939, + "2387-tonumber-argv.ts": 2788, + "2388-tonumber-grammar-zoo.ts": 3308, + "2389-tonumber-unary-plus.ts": 4585, + "2390-dot-requires/main.cjs": 3582, + "2391-default-builtin-imports/main.ts": 3597, + "2392-block-guard-alias-scope.ts": 3540, + "2393-loop-exit-guard-narrow.ts": 4327, + "2394-loop-narrow-containment.ts": 3359, + "2395-while-cond-guard.ts": 3736, + "2396-born-narrowed-decl.ts": 3669, + "2397-branch-kill-merge.ts": 3852, + "2398-switch-arm-kill.ts": 3957, + "2399-reassign-kill-polarity.ts": 3597, + "240-stdout-write.ts": 2582, + "2400-kill-return-edge.ts": 3990, + "2401-kill-break-staging.ts": 3661, + "2402-labeled-break-kill.ts": 3719, + "2403-kill-continue-backedge.ts": 3491, + "2404-kill-throw-catch.ts": 3664, + "2405-sibling-arm-narrow.ts": 3896, + "2406-switch-clause-sibling-narrow.ts": 3538, + "2407-infinite-loop-seal.ts": 3968, + "2408-loop-terminality-reopen.ts": 3262, + "2409-loop-body-return-not-terminal.ts": 3183, + "2410-stacked-cases-terminality.ts": 4213, + "2411-exhaustive-switch-terminality.ts": 4119, + "2412-dowhile-guard-trailing-test.ts": 2693, + "2413-dowhile-kill-renarrow.ts": 3480, + "2414-dowhile-continue-kill.ts": 3748, + "2415-dowhile-break-trailing-test.ts": 3696, + "2416-spread-ternary-positions.ts": 3541, + "2417-ternary-local-inference.ts": 4012, + "2418-wrapped-ternary-arms.ts": 3646, + "2419-selector-ternary-union.ts": 4650, + "2420-nullish-null-identity.ts": 4115, + "2421-float-lane-inference.ts": 3944, + "2422-ieee-div-rem-corners.ts": 4159, + "2423-param-null-reassign.ts": 2605, + "2424-ternary-miss-first-narrowing.ts": 4261, + "2425-elseif-head-exit-narrow.ts": 2714, + "2426-default-snapshot-mutable/main.ts": 3509, + "2427-perf-hooks-now.ts": 3643, + "2428-field-redeclare-inherited.ts": 3729, + "2429-destructure-class-instance.ts": 3764, + "2430-empty-literal-unknown-field.js": 3619, + "2431-primitive-ctor-values.ts": 2975, + "2432-generic-member-fields-async.ts": 3894, + "2433-as-const-command-tables.ts": 4279, + "2434-deferred-init-fields.ts": 3904, + "2435-loose-same-kind-equality.ts": 2449, + "2440-console-inspect-args.ts": 4983, + "2441-console-process-argv.ts": 3366, + "2442-union-literal-arm-widening.ts": 3510, + "2443-union-literal-shadow-narrowing.ts": 4296, + "2444-union-literal-reducer-spread.ts": 4322, + "2445-math-minmax-nary.ts": 4287, + "2446-performance-global.ts": 2765, + "2447-island-boundary-slots/main.ts": 30163, + "2448-entries-null-arms-regex-arrays.ts": 5050, + "2450-private-instance-methods.ts": 3745, + "2451-private-fields.ts": 4055, + "2452-private-statics.ts": 4122, + "2453-private-accessors.ts": 3729, + "2454-private-generator-methods.ts": 4591, + "2455-private-brand-checks.ts": 3790, + "2456-private-async-methods.ts": 4068, + "2457-private-members.js": 3733, + "2460-qs-parse-grammar.ts": 4511, + "2461-qs-parse-options.ts": 5074, + "2462-qs-stringify.ts": 5146, + "2463-qs-escape-unescape.ts": 4740, + "2464-qs-require-forms.cjs": 3706, + "2470-mockable-module-shape.js": 4001, + "2471-record-keyed-write-hasown.js": 4306, + "2472-string-regexp-union.ts": 4333, + "2473-option-table-widths.js": 4080, + "2474-island-literal-forms.ts": 3640, + "2475-variadic-wrapper-island.js": 3607, + "2476-map-regex-values.ts": 3840, + "2480-recursive-record-tree.ts": 3961, + "2481-mutual-recursive-records.ts": 3629, + "2482-recursive-union-tree.ts": 3442, + "2483-recursive-record-cycles.ts": 3728, + "2484-json-stringify-circular.ts": 3926, + "2485-inspect-circular-refs.ts": 4207, + "2486-recursive-record-boundaries.ts": 3631, + "2487-recursive-deep-equal.ts": 4488, + "2488-ast-walker.ts": 3489, + "2490-find-miss-null-compare.ts": 3128, + "2491-strict-unit-compare-no-arm.ts": 3378, + "2492-loose-null-compare-unions.ts": 3406, + "2493-switch-unit-cases.ts": 4046, + "2494-no-arm-compare-effects.ts": 3576, + "2500-net-autosel-timeout.ts": 6361, + "2510-dyn-evolving-array-map.ts": 4082, + "2511-dyn-evolving-array-filter-foreach.ts": 4487, + "2512-dyn-evolving-array-mixed-push.ts": 3602, + "2520-private-statics-class-name-calls.ts": 3443, + "2521-private-statics-class-expression.ts": 4261, + "2522-private-statics-decorated.ts": 3872, + "2523-private-statics-aliased-class.ts": 3793, + "2530-object-destructuring-decl.ts": 3717, + "2531-array-tuple-destructuring-decl.ts": 4697, + "2532-param-destructuring-options.ts": 4524, + "2533-forof-destructuring.ts": 4725, + "2534-object-rest-decl.ts": 4160, + "2535-destructuring-assign-basics.ts": 3008, + "2536-destructuring-assign-nested.ts": 3971, + "2537-destructuring-assign-member-targets.ts": 4117, + "2538-destructuring-assign-class-source.ts": 3926, + "2539-class-instance-rest.ts": 3983, + "2540-accessor-destructuring-defaults.ts": 2587, + "2541-destructuring-eval-order.ts": 4204, + "2550-generics-keyof-pick.ts": 4104, + "2551-generics-value-aliases.ts": 3651, + "2552-generics-iface-methods.ts": 3134, + "2553-generics-signature-bindings.ts": 4036, + "2554-generics-frontier-mix.ts": 4173, + "2555-generics-keyof-writes.ts": 3734, + "2556-crypto-introspection.ts": 3814, + "2556-width-hybrid-shapes.ts": 4554, + "2557-tls-ca-store.ts": 4247, + "2557-width-field-lifts.ts": 3310, + "2558-index-signature-func-values.ts": 3316, + "2558-rejection-events.cjs": 3816, + "2559-index-signature-container-values.ts": 4363, + "2560-arraybuffer-dataview-set.ts": 4259, + "2561-object-is.ts": 3615, + "2562-intl-numberformat-en-us.ts": 4400, + "2563-stream-promises-pipeline.ts": 3735, + "2564-stream-promises-finished.ts": 8470, + "2565-stream-promises-js.cjs": 4670, + "2566-promise-reject-dyn-reason.js": 3862, + "2567-rest-spread-forward.js": 4241, + "2568-rest-spread-forward-dynamic.js": 3805, + "2569-upcast-identity.ts": 2741, + "2570-buffer-arg-validation.cjs": 5723, + "2571-searchparams-arg-validation.cjs": 4325, + "2572-readable-emitted-readable-flag.cjs": 3665, + "2573-fs-url-arg-ladders.cjs": 3433, + "2574-emitter-max-listeners-ladders.cjs": 4082, + "2575-string-destructuring-decl.ts": 4618, + "2576-string-destructuring-assign.ts": 4254, + "2577-builtin-global-destructuring.js": 3582, + "2578-jsval-into-unknown-rows.ts": 4068, + "2579-jsval-object-param-crossing.js": 4185, + "2580-jsval-routed-keyed-ops.js": 4278, + "2581-jsval-routed-calls.js": 4541, + "2582-jsval-object-statics.js": 4272, + "2582-jsval-routed-keyed-ops.js": 3765, + "2583-dyn-nullish-coalesce.js": 3622, + "2583-jsval-routed-calls.js": 4186, + "2584-jsval-object-statics.js": 3517, + "2584-union-dyn-collapse.ts": 5179, + "2585-dyn-nullish-coalesce.js": 4450, + "2585-unknown-array.ts": 4082, + "2586-object-assign-spread.js": 3285, + "2587-array-entries-forof.ts": 4350, + "2588-array-entries-chains.ts": 4523, + "2589-object-create-null.cjs": 4020, + "2590-object-create-dynamic.js": 3068, + "2591-ambient-generic-traps.ts": 4200, + "2592-ambient-trap-uncaught.ts": 3460, + "2593-generic-inert-bindings.ts": 3588, + "2594-nullish-generic-bindings.ts": 3726, + "2595-fs-arg-ladders.cjs": 6740, + "2596-net-arg-ladders.cjs": 6682, + "2597-dgram-send-ladders.cjs": 5257, + "2598-tls-arg-ladders.cjs": 28958, + "2599-stream-arg-ladders.cjs": 4068, + "2600-dyn-keyed-write-harness.js": 4122, + "2601-dyn-keyed-write-ops.js": 3049, + "2602-dyn-array-destructure.js": 3757, + "2603-island-keyed-write-dyn.js": 3437, + "2604-cycle-classes-mutual/main.ts": 3996, + "2605-cycle-three-module/main.ts": 3537, + "2606-dynamic-import-cycle/main.ts": 3810, + "2608-regex-named-groups.ts": 4091, + "2609-regex-named-replace.ts": 2758, + "2610-regex-named-matchall.ts": 4465, + "2611-regex-named-groups-js.cjs": 6008, + "2613-for-init-uninitialized-let.ts": 3817, + "2614-trap-binding-later-writes.ts": 4020, + "2615-nullish-field-record-binding.ts": 3220, + "2616-js-collect-probe-defers.js": 3633, + "2617-enum-static-field-import/main.ts": 3698, + "2618-ee-emit-override.ts": 2900, + "2619-ee-override-chain.ts": 3741, + "2620-ee-override-once-order.ts": 3799, + "2621-ee-override-error-throw.ts": 3035, + "2622-ee-override-filter.ts": 3418, + "2623-ee-job-queue.ts": 3306, + "2624-ee-override-js.cjs": 4196, + "2625-bytes-views.ts": 4141, + "2626-stream-event-names.ts": 5209, + "2627-stream-ticks-are-nextticks.ts": 3902, + "2628-stream-push-encodings.cjs": 3828, + "2629-stream-consumers.ts": 5554, + "2630-stream-consumers-errors.ts": 4330, + "2631-create-require/main.ts": 4336, + "2632-dyn-jsval-iterate.js": 4764, + "2633-island-promise-crossing.js": 5106, + "2634-stream-pipeline-arg-ladders.cjs": 3877, + "2635-trap-binding-unmappable-written.ts": 3449, + "2636-trap-binding-ambient-rooted-rewrite.ts": 4109, + "2637-create-require-bare/main.ts": 3645, + "2638-http-dyn-res-compat.cjs": 7173, + "2639-http-dyn-req-pause.cjs": 7147, + "2640-net-dyn-socket-compat.cjs": 5745, + "2641-http-agent-surface.cjs": 7414, + "2642-http-agent-maxsockets.cjs": 4580, + "2643-or-default-retag.ts": 4099, + "2644-http-client-url-argument.ts": 4758, + "2645-https-client-url-argument.ts": 45938, + "2646-top-level-await.ts": 3701, + "2647-top-level-await-modules/main.ts": 4075, + "2648-top-level-await-rejection.ts": 3331, + "2649-top-level-await-pending.ts": 3587, + "2650-top-level-await-self-import.ts": 3982, + "2651-top-level-await-pending-unhandled.ts": 3896, + "2652-top-level-await-dynamic/main.ts": 3670, + "2653-top-level-await-rejection-stops-loop.ts": 3674, + "2654-top-level-await-unrelated-rejection.ts": 4358, + "2655-top-level-await-cycle/main.ts": 3663, + "2656-top-level-await-cycle-order/main.ts": 3641, + "2657-top-level-await-cycle-dynamic/main.ts": 3605, + "2658-top-level-await-sync-completion/main.ts": 3738, + "2659-top-level-await-dynamic-cycle/main.ts": 3937, + "2660-top-level-await-cycle-rejection/main.ts": 3839, + "2661-top-level-await-dynamic-runtime-root/main.ts": 4277, + "2662-top-level-await-cycle-external-wait/main.ts": 3840, + "2663-top-level-await-dependency-errors/main.ts": 4026, + "2664-top-level-await-same-checkpoint-rejection.ts": 3900, + "2665-top-level-await-unhandled-listener-liveness.ts": 3124, + "2666-array-to-sorted.ts": 7343, + "2668-stored-number-array-iterator.ts": 4155, + "2669-array-copying-methods.ts": 4893, + "2670-uint8array-copy-iterate.ts": 4534, + "2671-array-copying-js.cjs": 4071, + "2672-http-request-response-callback.ts": 25478, + "2673-top-level-await-implicit-module.ts": 3661, + "2674-top-level-for-await-implicit-module.ts": 4714, + "2675-create-require-nested-esm.js": 3731, + "2675-process-self-reexec.ts": 3793, + "2676-indexed-read-strict-equality.ts": 3177, + "2676-record-clone-overrides.ts": 3884, + "2676-top-level-await-ambiguous/main.ts": 3335, + "2677-runtime-optional-closure.ts": 4747, + "2677-top-level-await-module-scope/main.ts": 2879, + "2678-date-instances.ts": 3537, + "2678-large-string-sparse-index.ts": 3659, + "2678-util-parseargs.ts": 8501, + "2679-util-parseargs-cjs.cjs": 5362, + "2680-util-parseargs-default.ts": 3698, + "2681-util-parseargs-dynamic.js": 5047, + "2682-fs-rename.ts": 4318, + "2683-filter-truthy-predicate.ts": 4083, + "2683-fs-rename-js.cjs": 4168, + "2684-filter-no-predicate-dyn.cjs": 3139, + "2684-fs-rename-abort.ts": 3244, + "2685-array-unshift-reverse.ts": 3752, + "2685-fs-write-sync.ts": 3562, + "2686-fs-file-handle.ts": 5916, + "2687-fsp-write-file-options.ts": 4133, + "2687-process-write-args.ts": 3739, + "2688-fs-stats-disk-fields.ts": 4196, + "2689-http-server-timeout-properties.ts": 9510, + "2690-https-server-timeout-option.ts": 26255, + "2691-retained-lowering-record-order.ts": 5714, + "2692-inline-record-assert-index.ts": 4256, + "2692-string-accumulation.ts": 4000, + "2693-math-constants.ts": 3814, + "2700-array-sort-complexity.ts": 4128, + "2700-http-static-trailers.ts": 3673, + "2700-wasi-core.ts": 3941, + "2701-array-sort-snapshot.ts": 5063, + "2701-http-static-trailer-wire.ts": 4002, + "2701-import-meta/main.mjs": 4298, + "2702-http-static-trailer-end.ts": 4488, + "2702-type-import-link-static/main.ts": 3632, + "2702-uint8array-to-sorted.ts": 4201, + "2703-array-sparse-sort.ts": 7778, + "2703-type-import-link-static-reexport/main.ts": 3591, + "2704-array-sparse-to-sorted.ts": 8196, + "2704-type-import-link-static-success/main.ts": 3547, + "2705-array-sparse-sort-append.ts": 6478, + "2705-type-import-link-dynamic/main.ts": 3402, + "2706-array-search-missing-needle.ts": 4264, + "2706-type-import-link-dynamic-success/main.ts": 3801, + "2707-array-search-huge-sparse.ts": 45112, + "2707-type-import-link-static-default-reexport/main.ts": 3162, + "2708-type-import-link-dynamic/main.ts": 2849, + "2720-array-read-parity.ts": 4418, + "2721-array-nested-missing-receiver.ts": 4224, + "2750-array-sparse-foundation.ts": 3486, + "2751-buffer-concat-sparse-list.ts": 3809, + "2752-array-optional-stores.ts": 3893, + "2753-array-optional-method-values.ts": 4447, + "2754-array-property-undefined.ts": 3437, + "2755-array-optional-literal-forwarding.ts": 3309, + "2780-array-parity-composition.ts": 11152, + "2781-array-missing-value-escape.ts": 3766, + "2782-array-sparse-callbacks.ts": 4827, + "2783-array-defaults-rest.ts": 3752, + "2784-array-reduce-missing-result.ts": 3900, + "2785-array-missing-destructuring.ts": 4350, + "2786-array-sparse-serialization.ts": 4399, + "2787-array-missing-string-arithmetic.ts": 3532, + "2788-array-missing-builtin-conversions.ts": 2629, + "2789-array-missing-optional-tostring.ts": 4012, + "2790-dynamic-import-self-name/main.ts": 3567, + "2791-record-optional-keys.ts": 4180, + "2792-record-optional-spread-entries.ts": 3957, + "2793-union-conversion-identity-capture.ts": 4016, + "2794-array-generic-callback-values.ts": 3192, + "2795-array-optional-typedarray-source.ts": 39238, + "2796-array-sparse-class-value-instanceof.ts": 3057, + "2800-array-expression-consumers.ts": 3984, + "2801-array-switch-consumers.ts": 3844, + "2820-array-missing-method-receivers.ts": 4015, + "2821-array-optional-numeric-comparisons.ts": 3715, + "2830-cjs-require-self-name/main.cjs": 3843, + "2840-finally-completions.ts": 3843, + "2841-using-sync.ts": 3805, + "2842-await-using.ts": 3336, + "2843-using-suppressed-error.ts": 3417, + "2844-node-disposable-resources.ts": 4668, + "2845-for-using-of.ts": 3487, + "2846-generator-using.ts": 4293, + "2850-async-generators-protocol.ts": 4610, + "2851-async-generators-values.ts": 4267, + "2852-timers-promises-interval.ts": 3195, + "2854-leading-bom-literals.ts": 3717, + "2855-searchparams-sort-complexity.ts": 3679, + "2856-dynamic-any-local-operators.ts": 3601, + "2857-branded-primitives.ts": 3846, + "2858-import-meta-resolve/main.mjs": 3869, + "2859-import-meta-resolve-dynamic/main.mjs": 3441, + "2860-require-resolve/main.cjs": 3856, + "2861-readable-iterator-close.ts": 8658, + "2862-web-readable-async-iteration.ts": 60491, + "2863-class-async-iterator.ts": 3807, + "2864-array-class-method-receivers.ts": 3808, + "2865-cjs-process-alias.cjs": 3058, + "2866-dyn-switch.ts": 4091, + "2867-array-shift-length.js": 3560, + "2868-empty-record-promise-presence.js": 3622, + "2869-nullish-mixed-lazy.ts": 3214, + "2870-and-dropped-truthy-arm.ts": 3668, + "2871-optional-promise-to-unknown.ts": 3151, + "2872-unobserved-dynamic-event.ts": 3479, + "2873-optional-receiver-loop-lifetime.js": 3838, + "2874-nullable-callback-field-cycle.js": 3416, + "2875-evolving-let-read-before-write.js": 3393, + "2876-class-unknown-roundtrip.ts": 3172, + "2877-child-unknown-roundtrip.ts": 3088, + "2878-class-private-unknown.cjs": 3951, + "2880-cjs-module-graph/main.cjs": 4546, + "2890-crypto-static-utility.ts": 4147, + "2891-json-record-key-escapes.ts": 4489, + "2892-windows-console-unicode.ts": 3631, + "2893-child-stdin-duplex.ts": 4001, + "2894-child-stdin-backpressure.ts": 3911, + "2895-child-stdin-write-after-end.ts": 4040, + "2896-child-stdin-write-after-finish.ts": 4046, + "2897-child-stdin-destroy.ts": 4182, + "2898-child-stdin-spawn-failure.ts": 3819, + "2899-nested-mutual-recursion.ts": 3391, + "2900-float64array-static.ts": 4170, + "2900-void-conditional-arrow.ts": 2973, + "2901-bigint-core.ts": 3785, + "2902-bigint-bytes.ts": 3878, + "2903-bigint-storage.ts": 4174, + "2904-bigint-errors.ts": 3154, + "2905-bigint-edges.ts": 3535, + "2906-bigint-wasi-width.ts": 3636, + "2910-overloaded-callable-alias.ts": 3507, + "2911-execfile-callback.ts": 3775, + "2912-execfile-callback-options.ts": 3546, + "2912-promisify-fs-readfile.ts": 3527, + "2913-builtin-callable-alias.ts": 5224, + "2914-fixed-tuple-call-spread.ts": 4266, + "2915-path-function-values.ts": 4335, + "2916-path-function-values-cjs.ts": 3661, + "2917-builtin-callable-widths.ts": 4692, + "2918-builtin-callable-widths-cjs.ts": 3911, + "2919-fs-function-values.ts": 3993, + "2920-fs-promises-function-values.ts": 3700, + "2921-zlib-callbacks.ts": 4702, + "2922-dyn-bitwise-not.cjs": 3792, + "2923-cjs-factory-export/main.cjs": 3686, + "2930-union-receiver-calls.ts": 4496, + "2931-union-dynamic-field-call.js": 3249, + "2932-create-require-program/main.ts": 4121, + "2933-static-dynamic-import/main.ts": 3790, + "2934-static-import-stored.ts": 2637, + "2935-module-namespace-values/main.ts": 4033, + "2936-static-loose-equality.ts": 4807, + "2937-bitwise-hot-loop.ts": 3730, + "2938-fs-sync-overloads.cjs": 2978, + "2939-child-shell-text.ts": 4396, + "2940-date-parse.ts": 3909, + "2940-fsp-realpath.ts": 3670, + "2941-fsp-lstat-identity.ts": 4973, + "2941-process-exit-code.ts": 2597, + "2942-fsp-readdir-dirent.ts": 3959, + "2942-process-exit-code-override.ts": 3773, + "2943-process-exit-code-invalid.ts": 3459, + "2944-process-exit-code-wrap.ts": 4312, + "2945-url-origin-username.ts": 2754, + "2946-child-fork-ipc/main.ts": 4571, + "2946-url-port-hash.ts": 3017, + "2947-set-readonly-seeds.ts": 3976, + "2948-child-fork-eof-callback/main.ts": 4009, + "2948-stdio-callback-record.ts": 2902, + "2949-child-fork-default/main.mjs": 3935, + "2949-url-password.ts": 3040, + "2950-fs-descriptor-publication.ts": 2555, + "2951-math-static-analytic.ts": 4273, + "2952-math-static-remaining.ts": 3480, + "2953-http-header-validation.ts": 6668, + "2954-http-outgoing-headers.ts": 4292, + "2955-http-static-state.ts": 3942, + "2956-http-static-informational.ts": 8174, + "2957-http-static-response-controls.ts": 4254, + "2961-emitter-computed-names.cjs": 2876, + "2962-emitter-computed-optional.ts": 3963, + "2963-child-fork-dispatch/main.ts": 3170, + "2964-indexed-compound.ts": 4621, + "2966-numeric-array-read-fusion.ts": 3495, + "2967-numeric-array-read-lifetime.ts": 3370, + "2968-numeric-array-borrow.ts": 4623, + "2969-scalar-record-results.ts": 3919, + "2970-constant-numeric-tables.ts": 2953, + "2971-constant-table-modules/main.ts": 2780, + "2972-http-static-distinct-snapshots.ts": 7024, + "2972-math-receiver-borrow.ts": 4560, + "2973-http-static-agent.ts": 8993, + "2973-integer-bitwise-arithmetic.ts": 3843, + "2974-array-search-from-index.ts": 102834, + "2974-http-static-module-values.ts": 6368, + "2974-numeric-remainder.ts": 4108, + "2975-bigint-default-radix.ts": 3498, + "2975-http-static-client-controls.ts": 3623, + "2976-http-static-incoming-state.ts": 2971, + "2976-json-stringify-no-arguments.js": 3696, + "2977-http-static-incoming-timeout.ts": 4074, + "2977-nested-array-binding-defaults.js": 4142, + "2978-http-static-client-timeout.ts": 9714, + "2978-regexp-optional-subject.js": 49628, + "2979-array-search-mixed-needles.js": 4303, + "2979-http-static-server-timeout.ts": 6006, + "2980-http-static-server-timeout-default.ts": 7270, + "2980-string-position-arguments.js": 3086, + "2981-http-static-events.ts": 3123, + "2981-string-optional-positions.ts": 3368, + "2982-http-static-close-all.ts": 3822, + "2982-string-position-coercion-order.js": 3928, + "2983-http-static-close-idle.ts": 3614, + "2984-http-static-close-upgrade.ts": 3907, + "2985-http-static-message-destroy.ts": 3388, + "2986-http-static-client-socket-finish.ts": 3798, + "2987-http-static-timeout-errors.ts": 4096, + "2988-http-static-client-abort.ts": 2850, + "2989-http-static-response-timeout-handled.ts": 3345, + "2990-http-static-request-timeout-handled.ts": 4813, + "2991-array-indexed-equality.ts": 4275, + "2992-stream-rows.ts": 3533, + "2993-fiber-stack-lifetimes.ts": 4327, + "2994-fromcharcode-scalar.ts": 4187, + "2995-math-hyperbolic.ts": 4005, + "2996-math-near-one.ts": 4413, + "2997-math-integer-float.ts": 3945, + "300-if-else.ts": 4350, + "3001-caught-typeof-object.js": 3508, + "3002-promise-then-two.ts": 4636, + "301-while.ts": 3775, + "302-for.ts": 3729, + "3020-string-last-index-position.ts": 2972, + "3021-buffer-union-narrow-callback.ts": 3784, + "3022-string-affix-positions.ts": 3752, + "3023-string-affix-position-coercion.js": 3717, + "3024-string-number-narrow-for-in.ts": 4025, + "3025-string-search-position-coercion.js": 2818, + "3026-array-last-index-of.js": 4346, + "3027-array-last-index-of-records.ts": 2717, + "3028-string-search-dynamic-needle.js": 3694, + "3029-string-search-union-needle.js": 3379, + "303-break-continue.ts": 3648, + "3030-array-search-no-arg.js": 3591, + "3031-array-relative-index-coercion.js": 3587, + "3031-string-last-index-search-value.js": 4017, + "3032-string-search-value.js": 3564, + "3033-string-search-needle-coercion.js": 3378, + "3034-arguments-with-parameters.js": 3967, + "3035-string-positioned-search-value.js": 3417, + "3036-string-object-search-value.js": 3926, + "3037-number-nullish-conversion.js": 4703, + "3038-number-scalar-unions.ts": 3646, + "3039-string-repeat-count.js": 3646, + "304-compound-incdec.ts": 3722, + "3040-string-prototype-call.js": 4670, + "3041-string-prototype-object-call.js": 3431, + "3042-string-padding-coercion.js": 3284, + "3043-string-split-arguments.js": 3505, + "3044-array-slice-splice-positions.js": 3592, + "3045-array-indexed-mutation.js": 3564, + "3046-array-indexed-ref-identity.ts": 4051, + "3047-object-prototype-tag.js": 4202, + "3048-object-own-prototype.ts": 4672, + "3049-array-flat-depth.ts": 3327, + "305-truthiness.ts": 3686, + "3050-array-splice-insert.ts": 4238, + "3051-array-join-default.ts": 3649, + "3052-array-construction.ts": 5275, + "3053-array-construction-js.js": 4051, + "3054-dynamic-abort-record.ts": 31946, + "3055-default-builtin-nodenext/main.ts": 3742, + "3056-default-builtin-bundler/main.ts": 3900, + "3057-default-builtin-nodenext-dynamic/main.ts": 3548, + "3058-optional-array-chain-join.ts": 4351, + "3059-arguments-property-names.ts": 3823, + "3061-concurrent-fiber-stacks.ts": 4696, + "3062-runtime-optional-record-guards.ts": 4448, + "3063-runtime-optional-class-guards.ts": 4574, + "3064-installed-entry-imports/main.ts": 3681, + "3065-installed-entry-js/main.js": 3134, + "3066-source-debugging/main.ts": 3285, + "3067-cjs-function-export-require/main.cjs": 3758, + "3068-debug-variables/main.ts": 3691, + "3068-url-checked-identity.ts": 3668, + "3069-set-checked-seed.js": 3693, + "3069-tuple-spread.ts": 4624, + "3070-checked-object-accessors.js": 4486, + "3070-collection-views.ts": 3364, + "3071-checked-specialization-narrowing.js": 3480, + "3071-map-contextual-record-seeds.ts": 3949, + "3072-optional-union-receivers.ts": 5187, + "3072-weak-process-streams.js": 3596, + "3073-optional-callable-module.js": 2912, + "3073-union-keyed-reads.ts": 4086, + "3074-discriminated-intersections.ts": 3579, + "3075-recursive-contextual-literals.ts": 4053, + "3076-nullish-record-defaults.ts": 4277, + "3077-optional-union-array-reads.ts": 3951, + "3078-forward-mutable-captures.ts": 4480, + "3079-forward-mutable-tdz.ts": 4237, + "3080-exhaustive-never-bindings.ts": 3901, + "3081-recursive-array-destinations.ts": 4116, + "3082-forward-write-unwind.ts": 3019, + "3083-set-string-seed.ts": 4323, + "3084-record-own-membership.ts": 4601, + "3085-conditional-record-construction.ts": 4376, + "3086-error-constructor-options.ts": 4642, + "3087-error-options-lifetime.ts": 3925, + "3088-array-wide-callbacks.ts": 4497, + "3089-array-find-narrowing.ts": 4974, + "3090-json-discriminated-records.ts": 4438, + "3091-json-recursive-discriminants.ts": 5400, + "3092-number-union-predicates.ts": 3730, + "3093-error-option-data.ts": 2865, + "3094-json-replacer-traversal.ts": 4373, + "3095-json-reviver-traversal.ts": 4032, + "3096-json-callback-nonfinite.ts": 3197, + "3097-json-callback-reentrancy.ts": 3379, + "3098-json-callback-space.ts": 3597, + "3099-json-callback-functions.ts": 4206, + "3100-json-callback-holder.js": 4588, + "3101-json-callback-bytes.ts": 4349, + "3102-json-unknown-fields.ts": 3200, + "3103-scalar-record-nested-control-flow.ts": 4214, + "3104-native-analysis-tables-loops.ts": 2623, + "3105-nullable-collections.ts": 4138, + "3106-mixed-insertion-spreads.ts": 3715, + "3107-nullable-collection-lifetimes.ts": 4148, + "3108-for-await-sync-arrays.js": 6166, + "3108-identity-map-keys.ts": 4867, + "3109-destructuring-unknown-defaults.js": 4021, + "3109-identity-union-collections.ts": 5097, + "3110-builtin-error-families.ts": 3559, + "3110-identity-collection-mutation.ts": 3934, + "3111-identity-collection-cycles.ts": 3848, + "3112-union-switch-control-flow.ts": 3478, + "3113-union-array-removal.ts": 4714, + "3114-union-record-field-write.ts": 3240, + "3115-zlib-static-compression-levels.ts": 4206, + "3116-sequence-expression-lifetimes.ts": 4356, + "3117-unknown-switch-control-flow.ts": 3816, + "3118-recursive-union-spread.ts": 4372, + "3119-runtime-optional-spread.ts": 4825, + "3120-dynamic-property-descriptors.js": 3522, + "3120-generator-method-loop-bindings.ts": 4192, + "3120-ir-nonfinite-numbers.ts": 4200, + "3121-compound-assignment-values.js": 3684, + "3121-dynamic-accessor-descriptors.js": 4951, + "3122-dynamic-delete-descriptors.cjs": 4063, + "3122-dynamic-delete-descriptors.js": 3650, + "3122-js-async-class-methods.js": 4320, + "3123-destructured-global-tdz.js": 3748, + "3124-array-prototype-borrow.js": 4580, + "3125-regex-global-match.ts": 2619, + "3126-js-number-radix/main.ts": 4047, + "3127-spawn-runtime-options.ts": 4379, + "3128-regex-last-index.ts": 4682, + "3129-js-token-union/main.ts": 4567, + "3130-child-generic-streams.ts": 4888, + "3131-child-rest-listeners.js": 2682, + "3132-child-generic-stream-completion.ts": 9689, + "3133-text-decoder-streaming.ts": 21112, + "3134-fs-vectors.ts": 3917, + "3135-fs-file-handle-controls.ts": 5050, + "3136-fs-file-handle-options.ts": 5320, + "3137-fs-vector-callbacks.cjs": 5540, + "3138-array-large-storage.ts": 6344, + "3139-regex-native-deep-alternatives.ts": 31598, + "3140-array-dense-access.ts": 6506, + "3141-map-string-key-hash.ts": 4564, + "3150-integer-remainder.ts": 4200, + "3151-array-push-writes.ts": 4614, + "3170-number-conversion-fast-paths.ts": 4996, + "3171-method-census-data-writes.ts": 4891, + "400-fib.ts": 4470, + "401-mutual-recursion.ts": 3443, + "402-string-functions.ts": 3554, + "403-void-and-params.ts": 2749, + "4030-runtime-object-truthiness.ts": 2971, + "4031-event-emitter-long-tuples.ts": 3712, + "4032-inline-rc-fast-paths.ts": 6866, + "404-rc-stress.ts": 3585, + "4040-adapted-function-identity.ts": 3063, + "4041-adapted-function-properties.ts": 4165, + "4042-object-is-union-subclass.ts": 3846, + "4043-nonnull-missing-element.ts": 3736, + "4044-adapted-callback-modules/main.ts": 4121, + "4045-optional-element-projections.ts": 4159, + "4046-captured-parameter-values.ts": 3178, + "4047-captured-parameter-rebinding.ts": 4100, + "405-params-optional.ts": 3985, + "406-params-defaults.ts": 3592, + "4060-cycle-shared-instance/main.ts": 3695, + "4060-stack-union-reads.ts": 5003, + "4061-cycle-evaluation-order/main.ts": 3985, + "4061-nullable-ref-fields.ts": 7201, + "4062-cycle-tdz-read/main.ts": 3866, + "4063-cycle-hoisted-calls/main.ts": 3773, + "4064-cycle-classes-after-init/main.ts": 3673, + "4065-cycle-init-throws/main.ts": 3693, + "4066-cycle-top-level-tdz/main.ts": 3937, + "4067-dynamic-import-cycle-tdz/main.ts": 4237, + "407-params-rest.ts": 4125, + "408-params-ctors-inheritance.ts": 3692, + "4080-optional-read-presence-tests.ts": 3038, + "4080-string-index-bounds.ts": 3844, + "4081-hoisted-function-tdz.ts": 3262, + "4081-string-index-unproven.ts": 4125, + "4082-hoisted-function-tdz-uncaught.ts": 2818, + "4083-dynamic-import-failure/main.ts": 3160, + "4084-record-optional-field-copies.ts": 5146, + "4085-generator-loop-close.ts": 4113, + "4086-optional-capture-defaults.ts": 3684, + "4088-class-static-tdz.ts": 3477, + "4089-class-wrapper-tdz.js": 2771, + "409-params-async-generics.ts": 4030, + "4090-computed-key-tdz.js": 3578, + "4091-class-evaluation-deferred.ts": 4329, + "410-params-rc-stress.ts": 4376, + "4140-array-callback-split-visit.ts": 7471, + "4141-array-callback-ambient-receiver/main.ts": 3909, + "4142-array-callback-factories.ts": 3472, + "4143-union-refinement-intersection-arms.ts": 3347, + "420-dead-strip-modules/main.ts": 3742, + "4290-acyclic-immutable-trees.ts": 4974, + "4291-acyclic-constructor-escapes.ts": 4252, + "4292-acyclic-readonly-bypass.ts": 4530, + "4293-acyclic-dynamic-writes.ts": 4090, + "4294-console-line-sizes.ts": 7343, + "4295-console-template-parts.ts": 3542, + "4296-console-glued-long-parts.ts": 5181, + "4410-inline-object-allocation.ts": 4560, + "4411-nullable-ref-values.ts": 6207, + "4412-nullable-record-values.ts": 5237, + "4413-cycle-old-late-death.ts": 5172, + "4413-nullable-null-and-undefined.ts": 4068, + "4414-cycle-old-weak-keys.ts": 4401, + "4414-nullable-string-values.ts": 7453, + "4415-identity-borrowed-operands.ts": 3629, + "4415-nullable-container-values.ts": 5776, + "4431-exception-pending-contexts.ts": 4992, + "4432-checked-downcast-failures.ts": 4520, + "4451-int32-field-storage.ts": 4554, + "4452-int32-field-dynamic-writes.ts": 4987, + "4453-int32-closed-locals.ts": 4516, + "4454-int32-field-reflection-reads.ts": 3494, + "4455-live-view-reads-without-stores.ts": 4871, + "4471-unassigned-field-reads.ts": 3438, + "4476-string-ascii-header-fact.ts": 4141, + "4477-buffer-write-ascii-runs.ts": 4249, + "4478-string-large-index-reads.ts": 4215, + "4481-array-optional-push.ts": 3757, + "4482-instanceof-static-class-optional.ts": 3228, + "4483-array-splice-statement.ts": 4359, + "4484-array-length-reset.ts": 3824, + "4485-array-splice-optional-item.ts": 4447, + "4486-array-field-element-borrows.ts": 4170, + "4487-array-literal-optional-values.ts": 3597, + "4520-optional-guard-narrowing.ts": 4519, + "4521-array-callback-element-presence.ts": 6504, + "4522-captured-parameter-lifetimes.ts": 3501, + "4523-array-pop-removal.ts": 4310, + "4524-array-callback-supertype-params.ts": 4795, + "4541-nullable-wrap-borrows.ts": 4219, + "4542-preserving-call-borrows.ts": 4390, + "4543-walk-borrowed-locals.ts": 4424, + "4544-checked-cast-aliases.ts": 4017, + "4545-borrowed-returns.ts": 5010, + "4546-rebound-borrowed-params.ts": 4038, + "4560-field-store-borrowed-receivers.ts": 4292, + "4561-virtual-borrowed-parameters.ts": 3188, + "4562-string-self-concat-move.ts": 3258, + "4563-array-read-projection-receivers.ts": 4193, + "4564-literal-choice-strings.ts": 4376, + "4568-for-of-hole-elements.ts": 4040, + "4569-shorthand-missing-elements.ts": 5489, + "4570-map-lookup-default-record.ts": 4379, + "4591-weak-keys-union-records.ts": 3376, + "4592-cycle-const-from-import/main.ts": 3235, + "4593-weak-keys-empty-objects.ts": 4125, + "4594-union-class-field-mixed-types.ts": 6642, + "4595-union-class-field-optional-receiver.ts": 3958, + "4596-error-subclass-int-fields.ts": 3809, + "4596-tdz-nullable-forward-capture.ts": 5432, + "4597-callback-field-method-name.ts": 4265, + "4598-live-array-ref-element-access.ts": 9798, + "4598-map-set-clear-reuse.ts": 5772, + "4598-os-available-parallelism.ts": 3841, + "4598-publish-constructor-stores.ts": 4373, + "4599-construction-only-field-borrows.ts": 4185, + "4600-construction-only-fields-dynamic-writes.ts": 3870, + "4601-cycle-holders.ts": 3436, + "4602-constructor-escape-order.ts": 4107, + "4610-array-ext-dyn-refresh.ts": 4200, + "4620-optional-chain-borrowed-receivers.ts": 3633, + "4621-edge-preserving-callees/main.ts": 4459, + "4630-contract-int32.ts": 3693, + "4630-reference-write-call-arguments.ts": 3005, + "4631-contract-nothrow.ts": 3977, + "4631-reference-write-aliases.ts": 4000, + "4632-contract-immutable.ts": 4206, + "4632-reference-write-loops-and-walks.ts": 3622, + "4633-contract-program-lifetime.ts": 4928, + "4633-reference-write-callbacks-returns.ts": 4472, + "4634-contract-program-lifetime-publish.ts": 58146, + "4634-optional-element-borrowed-returns.ts": 3892, + "4640-bitwise-identity-ranges.ts": 3488, + "4641-nothrow-try-catch.ts": 3941, + "4642-acyclic-contract.ts": 4488, + "4650-stale-property-narrowing.ts": 5393, + "4651-map-string-get-entry.ts": 4850, + "4652-stale-closure-binding-narrowing.ts": 4646, + "4660-typed-rest-spread-forwarding.ts": 3964, + "4671-scoped-array-read-borrows.ts": 4659, + "4690-cycle-bypass-long-lived.ts": 6611, + "4691-publish-constructor-self-alias.ts": 32098, + "4692-borrowed-result-mutating-callees.ts": 4121, + "4720-cold-throw-paths.ts": 3462, + "4721-integer-induction-numbers.ts": 4315, + "4730-touint32-large-magnitudes.ts": 4331, + "4731-string-mixed-ascii-slices.ts": 4955, + "4732-buffer-write-utf16le-runs.ts": 4567, + "4733-typed-array-read-compares.ts": 4680, + "4750-map-string-absent-filter.ts": 3842, + "4751-string-search-multibyte-needles.ts": 4006, + "4795-published-untyped-member-reads.ts": 3280, + "4806-uint32-loop-accumulators.ts": 4561, + "4810-union-identity-retags.ts": 35042, + "4811-union-retag-checked-cast.ts": 4067, + "4812-int32-wrapping-sums.ts": 5061, + "4813-typed-array-read-equality-bindings.ts": 6041, + "4820-sort-comparator-lent-arguments.ts": 5459, + "4821-callback-lent-arguments.ts": 5557, + "4822-stable-capture-reads.ts": 4662, + "4823-array-store-receivers.ts": 3343, + "4830-typed-teardown-chains.ts": 4609, + "4831-cycle-bypass-probe-windows.ts": 6532, + "4840-array-hole-free-prefix.ts": 5275, + "4860-int32-local-storage.ts": 4493, + "4870-array-pipeline-fusion.ts": 9864, + "4871-array-pipeline-analytics.ts": 5983, + "4872-array-pipeline-temporaries.ts": 10585, + "4875-stream-consumers-array-buffer.ts": 5489, + "4876-array-buffer-inspect.ts": 4454, + "4880-await-call-turn-order.ts": 4340, + "4881-await-call-exceptions.ts": 3334, + "4882-await-call-request-chain.ts": 4240, + "4883-await-values-and-hops.ts": 3792, + "4884-await-call-unhandled-sibling.ts": 4171, + "4885-await-call-checkpoints.ts": 4125, + "4890-regex-literal-sites.ts": 3489, + "4891-regex-plain-text-patterns.ts": 3217, + "4892-regex-exec-read-captures.ts": 3864, + "4900-bigint-division-cross-check.ts": 4497, + "4900-console-instances.ts": 4959, + "4901-bigint-radix-text.ts": 4256, + "4901-console-instance-errors.ts": 2879, + "4902-bigint-compound-assign.ts": 3676, + "4903-bigint-fixed-width.ts": 3178, + "4904-bigint-large-products.ts": 3926, + "4905-bigint-fixed-width-fusion.ts": 5267, + "4906-bigint-small-value-trees.ts": 5678, + "4907-bigint-random-trees.ts": 7288, + "4910-hole-free-prefix-upkeep.ts": 4535, + "4920-string-literal-switch.ts": 4267, + "4930-typed-record-reflection.ts": 5782, + "4931-typed-data-generic-walks.ts": 6195, + "4932-typed-json-unknown.ts": 4431, + "4940-async-return-adoption.ts": 4857, + "4941-async-return-adoption-try.ts": 4613, + "4942-async-return-adoption-values.ts": 6005, + "4943-async-return-adoption-interleaved.ts": 3930, + "4950-regex-compiled-captures.ts": 5282, + "4951-regex-compiled-last-index.ts": 4338, + "4952-regex-compiled-anchors-classes.ts": 4435, + "4953-regex-compiled-backtracking.ts": 5380, + "4954-regex-log-report.ts": 5479, + "4955-regex-compiled-differential.ts": 20554, + "4970-int32-call-abi.ts": 4776, + "4980-generator-early-exit-finally.ts": 4365, + "4981-generator-delegation-iterables.ts": 5570, + "4982-generator-sent-values.ts": 4472, + "4983-generator-reuse-iterables.ts": 2952, + "4984-generator-exceptions.ts": 4164, + "4985-generator-lazy-pipeline.ts": 5491, + "4986-generator-default-channels.ts": 3496, + "4987-generator-closures-methods.ts": 4260, + "4988-generator-async-interplay.ts": 4288, + "4989-generator-step-drives.ts": 4530, + "4990-lone-surrogates.ts": 4508, + "4991-lone-surrogate-halves.ts": 4237, + "4992-lone-surrogate-search.ts": 4305, + "4993-lone-surrogate-json.ts": 4527, + "4994-lone-surrogate-uri.ts": 4891, + "4995-lone-surrogate-regex.ts": 4198, + "4996-lone-surrogate-stdio.ts": 3963, + "4997-lone-surrogate-stdout-patch.js": 4611, + "4998-lone-surrogate-buffers.ts": 4299, + "4999-lone-surrogate-io.ts": 4020, + "500-array-basics.ts": 4115, + "501-array-push-pop.ts": 4134, + "5010-lifetime-region-generations.ts": 4583, + "5011-lifetime-region-outside-references.ts": 3728, + "5012-lifetime-region-shapes.ts": 4853, + "5013-lifetime-region-async.ts": 5075, + "5014-lifetime-region-nesting.ts": 4021, + "5015-lifetime-region-publish.ts": 41998, + "5016-lifetime-region-weak-keys.ts": 3440, + "5017-lifetime-region-cycles.ts": 3981, + "5018-lifetime-region-hierarchies.ts": 5065, + "5019-lifetime-region-values.ts": 4354, + "502-array-for-of.ts": 3573, + "5020-lifetime-region-large.ts": 6813, + "5021-lifetime-region-opaque-holders.ts": 3165, + "5022-lifetime-region-workers.ts": 44993, + "5023-lifetime-region-await.ts": 5986, + "5024-lifetime-region-await-forms.ts": 5123, + "503-array-functions.ts": 4084, + "504-array-rc-stress.ts": 3791, + "5040-promise-all-race-turns.ts": 5348, + "5041-promise-all-turns.js": 4084, + "5042-async-generator-return-promise.ts": 4929, + "5043-async-generator-return-forms.ts": 3900, + "5045-generator-delegation-typed-next.ts": 4863, + "5046-generator-delegation-return-throw.ts": 4938, + "5047-generator-delegation-iterables-typed.ts": 4203, + "5048-generator-delegation-async.ts": 4733, + "5049-generator-delegation-edges.ts": 5078, + "5050-inherited-in-membership.ts": 4630, + "5051-typed-record-prototypes.ts": 4286, + "5052-class-for-in-unknown.ts": 4449, + "5053-json-replacer-arrays.ts": 4672, + "5054-required-field-delete.ts": 3969, + "5055-object-create-record-literal.ts": 3612, + "5056-generator-in-unknown.ts": 3544, + "5060-child-fork-exit-after-messages/main.ts": 3945, + "5061-child-fork-local-disconnect/main.ts": 3909, + "5062-child-fork-message-before-eof/main.ts": 4129, + "5065-global-increment-initializers.ts": 3769, + "5066-global-compound-updates.ts": 4136, + "5067-global-updates-in-functions.ts": 3795, + "5068-global-var-let-const-updates.ts": 3571, + "5069-global-update-modules/main.ts": 3587, + "5070-optional-read-bindings.ts": 3671, + "5071-optional-chain-scalars.ts": 4013, + "5072-optional-nullish-ternary.ts": 4374, + "5073-optional-results.ts": 4392, + "5074-optional-pop-shift.ts": 3500, + "5075-optional-reads-unchecked/main.ts": 3399, + "5076-optional-escapes.ts": 4284, + "5080-boolean-array-storage.ts": 10145, + "5081-boolean-array-dynamic-views.ts": 5152, + "5085-promise-allsettled-turns.ts": 5572, + "5086-promise-any-turns.ts": 4418, + "5087-promise-allsettled-any-dyn.js": 6479, + "5088-promise-combinator-thenables.js": 3786, + "5089-promise-settled-records.ts": 4701, + "5090-generator-finished-result-value.ts": 4294, + "5091-generator-delegation-arrays-strings.ts": 4885, + "5092-generator-delegation-sets-maps.ts": 3752, + "5095-console-count-group.ts": 4618, + "5096-console-assert-dir.ts": 5191, + "5097-console-table.ts": 3751, + "5098-console-time-warnings.ts": 9353, + "5099-console-methods-dynamic.cjs": 4255, + "510-array-map-filter-foreach.ts": 4191, + "511-array-indexof-includes.ts": 3499, + "5110-var-hoisting-early-reads.ts": 3823, + "5111-var-hoisting-closures-classes.ts": 4157, + "5112-var-hoisting-function-scope.ts": 3874, + "5113-tdz-let-const-class.ts": 3814, + "5114-var-hoisting-js.js": 3818, + "5115-regex-replace-compiled.ts": 3620, + "5116-regex-capture-reads.ts": 2873, + "5117-regex-log-report-spans.ts": 4784, + "5118-regex-replace-char-chains.ts": 3663, + "512-array-join-chains.ts": 2771, + "5120-frame-records.ts": 3939, + "5121-frame-objects.ts": 2783, + "5122-frame-result-slots.ts": 3197, + "5123-frame-reassigned.ts": 3173, + "5124-frame-objects-control.ts": 3904, + "5125-frame-mutating-methods.ts": 3799, + "5126-frame-returned-params.ts": 3813, + "5127-frame-loop-bindings.ts": 4488, + "513-array-methods-rc-stress.ts": 3775, + "5130-event-target-dispatch.js": 6111, + "5131-event-target-listener-errors.js": 4456, + "5132-event-target-typed.ts": 7166, + "5133-abort-signal-event-target.ts": 23098, + "5134-events-error-monitor.ts": 4010, + "5135-event-target-warnings.js": 31124, + "5136-events-error-monitor-string-name.ts": 4008, + "5137-events-error-monitor-computed-name.js": 4468, + "5138-events-error-monitor-shared-listener.ts": 3052, + "5139-event-target-listener-throw.ts": 4657, + "514-array-find-some-every.ts": 3980, + "5140-os-host-facts.ts": 3296, + "5141-os-constants.ts": 4894, + "5142-path-parse-format.ts": 4155, + "5145-path-matches-glob-basics.ts": 3777, + "5146-path-matches-glob-braces.ts": 5827, + "5147-path-matches-glob-extglob.ts": 4341, + "5148-path-matches-glob-classes.ts": 2888, + "5149-path-matches-glob-win32.ts": 4096, + "515-array-flatmap.ts": 4332, + "5150-small-array-inline-slots.ts": 3637, + "5155-cycle-header-types.ts": 43009, + "516-array-reduce.ts": 4514, + "5160-field-callback-receiver.ts": 4758, + "5161-field-callback-receiver-escape.ts": 3837, + "5162-field-method-reference-receiver.ts": 4262, + "5163-field-callback-receiver.cjs": 5679, + "5164-worker-field-callback-receiver.ts": 38682, + "5165-interface-method-dispatch.ts": 4568, + "5166-interface-method-values.ts": 5588, + "5167-interface-method-order.ts": 5287, + "5168-interface-method-hierarchy.ts": 6196, + "5169-interface-method-chains.ts": 4139, + "517-array-hof-index-args.ts": 4188, + "5170-string-scan-eviction.ts": 3592, + "5171-lone-surrogate-replace-seams.ts": 3960, + "5175-forin-typed-as-unknown.ts": 4247, + "5176-object-keys-typed-as-unknown.ts": 3688, + "5177-forin-dynamic-objects.ts": 4079, + "5178-forin-keys-js.js": 3608, + "5179-forin-typed-shapes.ts": 4197, + "518-array-sort.ts": 4624, + "518-promise-void-union-callbacks.ts": 4051, + "5180-interface-arrays.ts": 3814, + "5181-interface-array-methods.ts": 11031, + "5182-interface-array-boundaries.ts": 3743, + "5183-interface-property-reads.ts": 4427, + "5184-interface-property-objects.ts": 3309, + "5185-util-inherits.cjs": 5164, + "5186-util-inherits.ts": 4876, + "5187-util-deprecate.cjs": 4074, + "5188-util-deprecate-flags.cjs": 4955, + "5189-util-deprecate.ts": 5071, + "519-array-from-length.ts": 4423, + "519-promise-union-await-values.ts": 3904, + "5190-util-callbackify.cjs": 7841, + "5191-util-callbackify.ts": 6629, + "5192-util-debuglog.cjs": 6718, + "5193-util-debuglog.ts": 4689, + "5194-process-emit-warning-tick.cjs": 3727, + "5195-object-entries-typed-as-unknown.ts": 5084, + "5196-object-values-typed-as-unknown.ts": 3864, + "5197-object-entries-dynamic-objects.ts": 4955, + "5198-object-entries-values-js.js": 4220, + "5199-object-entries-identity.ts": 3999, + "520-map-basics.ts": 3545, + "5200-array-sort-keyed-numbers.ts": 5325, + "5201-array-sort-keyed-records.ts": 7394, + "5202-array-sort-keyed-lookalikes.ts": 5009, + "5203-typed-array-sort-default.ts": 8431, + "5204-typed-array-sort-comparators.ts": 5119, + "521-map-number-keys.ts": 3823, + "5210-process-memory-usage.ts": 4235, + "5211-process-identity.ts": 3797, + "5212-perf-marks-measures.ts": 5056, + "5213-perf-timing-errors.ts": 4031, + "5214-perf-entry-inspect.ts": 4809, + "5215-perf-timing-validation.js": 6147, + "5216-perf-spread-arguments.js": 4892, + "5217-perf-spread-typed.ts": 4228, + "522-map-foreach.ts": 4028, + "5220-url-parse-warnings.ts": 3469, + "5221-url-parse-shapes.ts": 6083, + "5222-url-parse-hosts.ts": 5268, + "5223-url-parse-query.ts": 5608, + "5224-url-format-objects.ts": 5477, + "5225-url-format-whatwg.ts": 3013, + "5226-url-resolve.ts": 6250, + "5227-url-legacy-dependency/main.ts": 6988, + "5228-url-domain-conversion.ts": 4749, + "5229-url-legacy-errors.cjs": 6936, + "523-map-ref-values.ts": 4339, + "5230-inline-union-fields.ts": 4733, + "5231-inline-union-field-kinds.ts": 5128, + "5232-inline-union-fields-dynamic.ts": 4858, + "5233-inline-union-fields-shapes.ts": 3241, + "5234-inline-union-class-fields.ts": 3221, + "5235-inline-union-fields-publish.ts": 3389, + "5236-inline-union-unchecked-reads.ts": 4250, + "5237-inline-union-frame-objects.ts": 4148, + "524-map-cycles.ts": 2484, + "5240-event-target-subclass.ts": 7308, + "5241-event-subclass.ts": 5029, + "5242-event-target-subclass-hierarchy.ts": 4680, + "5243-event-target-subclass-dynamic.ts": 6118, + "5244-event-target-subclass.js": 4898, + "5245-event-target-subclass-signals.ts": 8806, + "5246-event-target-subclass-listener-throw.ts": 3474, + "5247-event-target-subclass-lifetimes.ts": 5918, + "5248-event-target-subclass-warnings.ts": 4004, + "5249-event-target-subclass-unconstructed.ts": 3498, + "525-map-rc-stress.ts": 3774, + "5250-cipher-aes-gcm.ts": 8740, + "5251-cipher-aes-cbc.ts": 42449, + "5252-cipher-aes-ctr.ts": 26060, + "5253-cipher-chacha20-poly1305.ts": 8385, + "5254-cipher-errors.js": 28463, + "5255-cipher-encodings.cjs": 25164, + "5256-cipher-deprecation.cjs": 45696, + "5257-cipher-vectors.ts": 7138, + "5258-cipher-handles.js": 24870, + "5259-cipher-chunked.ts": 7052, + "526-set-basics.ts": 3756, + "5260-record-unknown-identity.ts": 4341, + "5261-optional-field-identity.ts": 3817, + "5262-record-unknown-many.ts": 3331, + "527-set-foreach.ts": 4129, + "5270-url-parse-no-deprecation.cjs": 5103, + "5271-url-parse-throw-deprecation.cjs": 6761, + "5275-http-end-callback-order.ts": 4622, + "5276-style-text-hex-colors.cjs": 4317, + "5277-fs-read-file-buffer-option.cjs": 3338, + "5278-host-null-bytes.cjs": 64320, + "5279-search-params-null-init.cjs": 2979, + "528-set-seeded.ts": 2529, + "5285-blob-construct.ts": 4818, + "5286-blob-readers.ts": 3080, + "5287-blob-inspect.ts": 3383, + "5288-blob-validation.js": 4818, + "5289-blob-read-order.ts": 4674, + "529-map-seeded.ts": 3233, + "5290-blob-dynamic.js": 4041, + "5295-readline-promises-question.ts": 3501, + "5296-readline-lines.ts": 5784, + "5297-readline-callback-events.cjs": 3985, + "5298-readline-abort.cjs": 10936, + "5299-readline-stdin.ts": 5881, + "530-record-arrays.ts": 4186, + "5300-stream-add-abort-signal.ts": 25846, + "5301-stream-add-abort-signal-errors.cjs": 8721, + "5302-stream-promises-options.ts": 13350, + "5303-stream-finished-callback-opts.cjs": 5087, + "5305-json-stringify-typed-arrays.ts": 6867, + "531-record-array-hofs.ts": 4059, + "5315-map-iterate-after-front-deletes.ts": 3530, + "5316-map-lru-eviction.ts": 3884, + "5317-map-iterate-while-mutating.ts": 4053, + "5318-set-iterate-after-deletes.ts": 4066, + "5319-map-iteration-values.ts": 4477, + "532-record-arrays-rc-stress.ts": 3905, + "5320-map-iterate-across-compaction.ts": 4243, + "5321-integer-closed-arithmetic-loops.ts": 3710, + "5321-json-parse-cycles.ts": 3383, + "5322-integer-variable-step-loops.ts": 3384, + "5322-json-stringify-parsed-trees.ts": 3838, + "5323-dyn-numeric-index-reads.ts": 3192, + "5323-int32-nonnegative-slot-facts.ts": 3774, + "5324-int32-initializer-locals.ts": 2663, + "5324-structured-clone-documents.ts": 4264, + "5325-record-boundary-returns.ts": 4089, + "5326-record-boundary-params.ts": 3793, + "5327-record-boundary-identity.ts": 3464, + "5328-record-boundary-open.ts": 4146, + "5329-record-boundary-recursion.ts": 3748, + "533-array-element-cycles.ts": 3379, + "5330-record-boundary-fields.ts": 2753, + "5331-record-boundary-methods.ts": 3914, + "5332-int32-narrowed-slot-facts.ts": 3588, + "5333-integer-guarded-while-counters.ts": 3896, + "5333-record-boundary-nullable-argument.ts": 3869, + "5334-fetch-mentions-without-calls.ts": 3676, + "5335-stream-operators-values.ts": 6378, + "5335-top-level-await-pending-exit-code.ts": 3377, + "5336-stream-operators-promise-timing.ts": 4282, + "5336-top-level-await-pending-exit-listener.ts": 3680, + "5337-dc-subscriber-throw-next-tick.cjs": 3947, + "5337-stream-operators-concurrency.ts": 8858, + "5338-js-tdz-function-element.js": 3181, + "5338-stream-operators-checks.cjs": 5284, + "5339-array-buffer-constructor.js": 4102, + "5339-stream-for-await-hops.ts": 5704, + "534-record-width-subtyping.ts": 3856, + "5340-readable-from-options.ts": 4031, + "5341-compound-any-operand.ts": 3905, + "5341-generator-callback-params.ts": 4564, + "5341-integer-recursion-boundaries.ts": 4375, + "5341-readable-from-dynamic.cjs": 5807, + "5342-compound-any-operand.cjs": 3381, + "5342-generator-scalar-channels.ts": 3638, + "5342-integer-recursion-stack-and-mutual.ts": 3513, + "5342-stream-compose.ts": 7562, + "5343-any-flow-compound.ts": 2631, + "5343-integer-recursion-array-index.ts": 4214, + "5343-iterator-result-records.ts": 2610, + "5343-stream-compose-edges.ts": 10326, + "5344-json-parse-undeclared-keys.ts": 5823, + "5344-stream-pipeline-timing.ts": 4092, + "5345-object-values-for-of-unknown.ts": 4269, + "5346-object-values-length-dynamic.ts": 3585, + "5347-object-values-loop-control.ts": 4004, + "5348-object-values-for-of-js.js": 4048, + "5349-object-entries-values-optional.ts": 3374, + "535-object-statics.ts": 4653, + "5350-object-values-wide-record.ts": 3999, + "5351-object-values-methods-index.ts": 3750, + "5352-final-field-loop-reads.ts": 4118, + "5353-captured-const-values.ts": 3887, + "5354-captured-const-tdz.ts": 3465, + "5355-captured-function-declarations.ts": 4030, + "5356-captured-tdz-ordering.ts": 4031, + "5357-init-only-module-bindings.ts": 3717, + "536-map-seed-array.ts": 3444, + "5360-array-sort-comparator-calls.ts": 3618, + "5361-array-sort-inconsistent-comparators.ts": 4844, + "5362-array-sort-comparator-throws.ts": 4204, + "5363-array-sort-comparator-writes.ts": 13543, + "5364-array-sort-union-and-boolean-elements.ts": 21219, + "5365-array-sort-dynamic-values.js": 3456, + "537-map-iter-drains.ts": 3991, + "5370-zlib-stream-roundtrip.ts": 4546, + "5371-zlib-stream-chunking.cjs": 6071, + "5372-zlib-stream-errors.cjs": 6496, + "5373-zlib-stream-options.cjs": 6767, + "5374-zlib-stream-flush-params.ts": 5113, + "5375-zlib-stream-promises.ts": 6129, + "5376-zlib-constants.cjs": 3393, + "5377-zlib-stream-backpressure.cjs": 4992, + "5378-zlib-sync-options.cjs": 4120, + "5379-zlib-callback-options.ts": 4524, + "538-map-set-for-of.ts": 3571, + "5390-interface-loop-element-lifetimes.ts": 3555, + "5391-interface-dispatch-hierarchies.ts": 5018, + "5392-interface-receiver-bindings.ts": 2922, + "5393-interface-array-holes.ts": 4247, + "5394-interface-implementers.ts": 4974, + "5395-locale-compare-ascii.ts": 3055, + "5396-locale-compare-latin.ts": 5056, + "5397-locale-compare-sorting.ts": 5049, + "540-tuples-basics.ts": 4222, + "5400-json-parse-typed-keys.ts": 5019, + "5405-buffer-arraybuffer-window.ts": 3206, + "5406-util-types-keys.ts": 3783, + "5407-http-header-field-limit.ts": 3678, + "5408-http-unread-request-end.ts": 4813, + "5409-http-held-request-body.ts": 4829, + "541-ref-array-json.ts": 4046, + "5410-inspect-class-values.ts": 3502, + "5411-inspect-class-hierarchies.ts": 3285, + "5412-inspect-dynamic-collections.ts": 3541, + "5413-inspect-class-values.cjs": 4035, + "5415-zlib-dynamic-inputs.cjs": 4054, + "542-union-element-arrays.ts": 4182, + "5420-readable-from-generators.ts": 5843, + "5421-readable-from-generators.cjs": 3752, + "5422-stream-async-push-wakeup.ts": 3679, + "5423-stream-end-and-eos-timing.ts": 4453, + "5424-stream-write-buffer-encoding.ts": 3204, + "5425-pipeline-generator-stage.ts": 3700, + "5426-pipeline-generator-errors.ts": 4597, + "5427-pipeline-generator-backpressure.ts": 4175, + "5428-pipeline-generator-stages.cjs": 9702, + "5429-pipeline-generator-buffers.ts": 6406, + "5430-dyn-number-string-boxes.ts": 3692, + "5435-crypto-hash-algorithms.ts": 4078, + "5436-crypto-hash-names.js": 3345, + "5437-crypto-hmac-algorithms.ts": 3794, + "5438-crypto-kdf-digests.ts": 3694, + "5439-crypto-kdf-callbacks.js": 3780, + "5440-crypto-hash-encodings.js": 4405, + "5441-crypto-hash-output-length.ts": 4754, + "5442-crypto-random-values.ts": 5239, + "5443-crypto-random-arguments.js": 4330, + "5444-crypto-timing-safe-equal.js": 2751, + "5445-crypto-secret-key-objects.ts": 4863, + "5445-stream-buffer-chunks.ts": 4296, + "5446-crypto-secret-key-errors.js": 4577, + "5446-stream-buffer-chunks-dynamic.js": 8609, + "5447-fs-readdir-order.ts": 3829, + "5448-fs-glob-patterns.ts": 3945, + "5449-fs-glob-options.ts": 5046, + "5450-fs-glob-validation.js": 3911, + "5451-fs-promises-glob.ts": 5150, + "5452-fs-glob-callback.ts": 4895, + "5455-power-of-two-remainder.ts": 3875, + "5456-remainder-large-integer-dividends.ts": 3066, + "5457-lcg-modulus.ts": 3468, + "5458-fractional-remainder.ts": 3767, + "5460-locale-compare-contractions.ts": 3556, + "5461-locale-compare-equivalents.ts": 4015, + "5462-locale-compare-probe-sweep.ts": 5293, + "5463-locale-compare-combining-letters.ts": 4084, + "5464-locale-compare-fractions.ts": 3409, + "5465-dyn-index-read-arrays.ts": 3798, + "5466-dyn-index-read-special.ts": 4384, + "5470-strip-vt-osc.cjs": 3494, + "5471-strip-vt-csi.cjs": 3770, + "5472-strip-vt-random.cjs": 3968, + "5473-strip-vt-unterminated.cjs": 4621, + "5474-strip-vt-surrogates.ts": 3567, + "5510-assert-error-properties.js": 5349, + "5511-assert-error-class.ts": 4329, + "5512-assert-error-options.js": 3469, + "5513-assert-deep-equal-loose.js": 4138, + "5514-assert-deep-equal-typed.ts": 3792, + "5515-assert-deep-strict-typed-messages.ts": 3601, + "5516-assert-deep-equal-edges.js": 4686, + "5517-assert-partial-deep-equal.js": 2953, + "5518-assert-partial-deep-typed.ts": 4685, + "5519-assert-partial-deep-typed-edges.ts": 4346, + "5520-assert-record-literal-failures.ts": 4088, + "5520-dyn-property-read-receivers.ts": 4057, + "5521-assert-empty-message.js": 3734, + "5521-dyn-property-read-keys.ts": 3703, + "5522-assert-throws-failure-properties.ts": 4256, + "5523-assert-class-options.js": 4903, + "5524-assert-class-skip-prototype.ts": 4411, + "5530-buffer-pool.ts": 4413, + "5531-buffer-pool-first-slab.ts": 5557, + "5532-buffer-pool-first-slab-untyped.mjs": 220640, + "5540-fs-callback-forms.cjs": 4591, + "5541-fs-stats-fields.cjs": 6904, + "5542-fs-promises-parity.cjs": 4673, + "5543-fs-promises-typed.ts": 5025, + "5544-fs-opendir.cjs": 4673, + "5545-fs-options-encoding.cjs": 5256, + "5546-fs-read-stream.cjs": 5295, + "5547-fs-write-stream.cjs": 6075, + "5548-fs-callback-arguments.cjs": 4982, + "5549-fs-callback-option-checks.cjs": 4309, + "5550-locale-compare-ascii-words.ts": 3614, + "5551-array-search-references.ts": 4656, + "5552-string-appends.ts": 3810, + "5553-string-append-char-code.ts": 4013, + "5554-fs-streams-typed.ts": 4873, + "5555-fs-callback-turns.cjs": 3708, + "5555-http-server-close-keep-alive.ts": 15618, + "5556-http-client-agent-connection.ts": 4177, + "5557-http-outgoing-header-values.ts": 4083, + "5558-http-incoming-duplicate-headers.ts": 2888, + "5559-http-expect-header.ts": 14863, + "5560-http-response-framing.ts": 11391, + "5561-http-max-header-size.ts": 4316, + "5562-https-verify-errors.ts": 4777, + "5563-http-keep-alive-timeout.ts": 17783, + "5564-http-request-signal.ts": 10735, + "5565-fs-dirent-untyped.mjs": 4337, + "5566-fs-dirent-dyn-boundaries/main.mjs": 4371, + "5567-fs-cpsync.ts": 4945, + "5568-fs-cp-errors.js": 4099, + "5569-fs-cp-symlinks.ts": 3686, + "5570-fs-cp-async.ts": 4176, + "5571-fs-cp-deep.ts": 5306, + "5585-record-results-inlined.ts": 3957, + "5595-net-ref-unref.ts": 5321, + "5600-dyn-cycle-self.ts": 3365, + "5601-dyn-cycle-mutual.ts": 4239, + "5602-dyn-cycle-arrays.ts": 3453, + "5603-dyn-cycle-identity.ts": 3497, + "5604-dyn-cycle-checks.ts": 3761, + "5605-dyn-cycle-containers.ts": 4084, + "5606-dyn-cycle-capsules.ts": 3095, + "5610-readable-from-sets-and-views.ts": 5921, + "5611-readable-from-class-iterables.ts": 3857, + "5612-readable-from-iterables.cjs": 5191, + "5613-readable-from-iterable-timing.cjs": 5131, + "5614-readable-from-iterable-errors.cjs": 4553, + "5615-next-tick-callback-phases.ts": 4347, + "5616-next-tick-callback-phases.cjs": 3259, + "5617-pipeline-function-ends.ts": 60581, + "5618-pipeline-function-ends-errors.ts": 13092, + "5619-pipeline-function-ends.cjs": 14768, + "5620-timers-promises-values.ts": 3726, + "5621-util-format-float.ts": 3395, + "5622-events-once.mjs": 3355, + "5623-events-once.ts": 4676, + "5624-timers-promises-unawaited.ts": 4420, + "5625-promisify-exec.ts": 8488, + "5626-promisify-forms.ts": 3100, + "5627-exec-callback.ts": 3311, + "5628-promisify-timers.ts": 3913, + "5629-promisify-stream.ts": 3357, + "5630-promisify-zlib.ts": 3392, + "5631-promisify-crypto.ts": 3727, + "5632-promisify-dns.ts": 5476, + "5644-net-socket-addresses.ts": 3677, + "5645-net-socket-callbacks.ts": 4544, + "5646-net-server-connections.ts": 3663, + "5647-net-is-ip.ts": 3569, + "5648-dns-lookup-forms.ts": 5746, + "5649-dns-service-servers.ts": 4846, + "5650-dns-lookup-errors-untyped.cjs": 4466, + "5651-tls-socket-protocol.ts": 30873, + "5652-http-client-trailer-overflow.ts": 3512, + "5653-net-socket-read-ahead.ts": 6212, + "5654-https-empty-servername.ts": 6322, + "5655-dgram-socket-options.ts": 5089, + "5656-dgram-option-states.ts": 4267, + "5657-net-reset-and-address.ts": 3588, + "5658-net-reset-dynamic.cjs": 4002, + "5659-net-blocklist-socketaddress.ts": 5090, + "5664-tls-client-identity.ts": 6340, + "5674-union-instanceof-array-arms.ts": 3943, + "5680-array-growth-after-copy.ts": 4581, + "5681-array-pop-and-length.ts": 4279, + "5682-publish-wide-objects.ts": 3376, + "5700-cycle-release-retained.ts": 3414, + "5701-cycle-release-old-edges.ts": 4210, + "5702-publish-candidate-buffers.ts": 3848, + "5703-lifetime-region-debug.ts": 2875, + "5704-publish-refused-restores-counts.ts": 3759, + "5710-map-number-keys-hashed.ts": 3686, + "5711-map-number-write-after-read.ts": 3642, + "5712-map-number-overwrite-at-growth.ts": 4057, + "5714-cycle-large-candidate-buffers.ts": 4303, + "5715-json-parse-fitted-tables.ts": 4861, + "5717-set-prototype-of-primitives.ts": 3977, + "5719-int32-fields-dynamic-operators.ts": 4013, + "5720-intern-table-basics.ts": 5183, + "5721-intern-table-values.ts": 4244, + "5722-intern-table-workers.ts": 37693, + "5723-intern-table-shared-types.ts": 25115, + "5724-intern-table-array-keys.ts": 43939, + "5725-intern-table-callbacks.ts": 3924, + "5726-intern-table-key-limits.ts": 3414, + "5740-atomics-operation-semantics.ts": 4541, + "5741-atomics-contended-counters.ts": 5176, + "5742-atomics-lock-ordering.ts": 44911, + "5743-atomics-wait-notify.ts": 25944, + "5744-atomics-ring-buffer.ts": 3295, + "5745-atomics-semaphore-stress.ts": 39641, + "5746-shared-bulk-operations.ts": 3506, + "5747-fs-stat-throw-if-no-entry.ts": 3747, + "5748-fs-stat-throw-if-no-entry-js.cjs": 4239, + "5752-string-number-concat.ts": 2903, + "5760-crypto-hash-stream.ts": 3720, + "5761-crypto-hash-stream-states.ts": 3947, + "5762-crypto-hash-stream.cjs": 3953, + "5763-crypto-sha-blocks.ts": 4280, + "5764-class-structural-view-writes.ts": 4359, + "5764-crypto-hmac-edges.cjs": 3178, + "5765-class-structural-view-identity.ts": 4251, + "5766-class-structural-view-callbacks.ts": 3950, + "5767-class-opaque-accessor-view.ts": 3507, + "5770-guarded-union-narrows.ts": 3945, + "5771-guarded-downcasts.ts": 3443, + "5772-guarded-catch-narrows.ts": 3695, + "5773-stale-narrowing-inherited.ts": 3758, + "5776-power-of-two-remainder-integer-path.ts": 3584, + "5780-readline-history-options.ts": 3008, + "5781-readline-history-options.cjs": 5419, + "5782-readline-terminal-editing.ts": 5323, + "5783-readline-terminal-completion.cjs": 5914, + "5784-readline-terminal-promises.ts": 8841, + "5785-readline-terminal-keys.ts": 7210, + "5786-readline-terminal-history.cjs": 5018, + "5787-readline-cursor-helpers.cjs": 4120, + "5788-readline-promises-readline.ts": 3931, + "5789-readline-cursor-pos.cjs": 10833, + "5790-readline-keypress-events.ts": 5781, + "5791-dyn-constant-key-read-sites.ts": 3910, + "5791-readline-keypress-interfaces.cjs": 10593, + "5792-json-parse-repeated-layouts.ts": 4520, + "5792-readline-keypress-listeners.ts": 3779, + "5793-worker-message-channel.ts": 6071, + "5794-worker-message-port-close-order.ts": 4996, + "5795-worker-message-port-batches.ts": 2995, + "5796-worker-message-channel.cjs": 3812, + "5797-worker-message-port-transfer.ts": 3633, + "5800-broadcast-channel.ts": 40203, + "5801-broadcast-channel.cjs": 5126, + "5802-broadcast-channel-workers.ts": 4593, + "5803-worker-environment-data.ts": 5183, + "5804-worker-environment-data.cjs": 3173, + "5805-worker-receive-message-parent-port.ts": 2696, + "5806-worker-resource-limits.ts": 3922, + "5807-worker-error-values.ts": 6807, + "5808-worker-unhandled-rejections.ts": 7138, + "5809-process-exit-and-rejections.cjs": 33202, + "5810-mock-method-records.ts": 6251, + "5811-mock-tracker-restore.ts": 6093, + "5812-dyn-box-async-fields.ts": 3948, + "5813-mock-timers-module.ts": 5361, + "5814-mock-timers-date.ts": 7472, + "5830-timers-promises-signal.ts": 4170, + "5831-util-types-brands.ts": 3902, + "5832-util-types-brands-dynamic.js": 4287, + "5833-url-search-params-iterators.ts": 3492, + "5834-url-search-params-iterators-dynamic.mjs": 3994, + "5835-util-format-integer-specifiers.ts": 3659, + "5836-url-search-params-tuple-pairs.ts": 3814, + "5837-util-format-json-circular.ts": 4225, + "5838-qs-stringify-bigint.ts": 5010, + "5839-timers-promises-scheduler.ts": 3897, + "5840-promise-with-resolvers-js.js": 3596, + "5841-json-typed-dyn-members.ts": 5082, + "5842-qs-parse-null-prototype.ts": 3325, + "5843-qs-parse-null-prototype-js.mjs": 3033, + "5844-date-unknown-values.ts": 4145, + "5845-groupby-null-prototype.ts": 4290, + "5846-events-esm-default-max.ts": 2759, + "5847-events-cjs-default-max.cjs": 3509, + "5849-class-view-observations.ts": 4659, + "5850-using-disposable-values.ts": 3072, + "5851-using-suppressed-error-values.ts": 3950, + "5852-using-disposable-values-js.js": 3905, + "5853-set-methods-map-arguments.ts": 3831, + "5854-array-from-async.ts": 5635, + "5855-array-from-async-js.js": 3433, + "5856-error-is-error.ts": 3928, + "5857-regexp-unicode-sets.ts": 3859, + "5858-disposable-stack.ts": 5135, + "5859-disposable-stack-js.js": 3801, + "5860-url-ipv4-hosts.ts": 4018, + "5870-worker-thread-names.ts": 7328, + "5871-worker-untransferable.cjs": 43661, + "5872-readline-positional-create-interface.mjs": 6166, + "5873-readline-promises-namespace.cjs": 3811, + "5874-worker-stdio-streams.ts": 50741, + "5875-worker-stdout-pipe.cjs": 50279, + "5879-worker-stdin.ts": 57033, + "5880-emitter-leak-warning-delivery.ts": 4319, + "5881-inspect-weak-collections.ts": 3631, + "5882-string-decoder-runtime-encoding.ts": 3362, + "5883-os-set-priority.ts": 3308, + "5884-inspect-layout-options.ts": 4849, + "5885-events-max-listener-helpers.ts": 3588, + "5886-inspect-dates.ts": 2966, + "5887-inspect-typed-arrays.ts": 3325, + "5888-inspect-sorted.ts": 3559, + "5889-timers-scheduler-signal.ts": 8928, + "5890-while-string-length-counters.ts": 3822, + "5892-buffer-write-utf16le-runs.ts": 3465, + "5900-float16-array.ts": 3954, + "5901-float16-array-js.js": 3925, + "5904-async-generator-completion.ts": 6639, + "5905-array-from-async-generator.ts": 4467, + "5906-array-from-async-generator-js.js": 4458, + "5907-regex-groups-match-rows.ts": 4698, + "5910-set-prototype-of-primitive-object-kinds.ts": 4445, + "5911-dyn-class-to-primitive.ts": 5410, + "5912-dyn-class-conversion-methods.ts": 4298, + "5913-prototype-type-error-messages.ts": 3454, + "5914-dyn-in-class-prototype-members.ts": 3792, + "5915-dyn-error-string-conversions.ts": 3851, + "5920-promise-try-args.ts": 3195, + "5921-promise-try-args-js.js": 3082, + "5922-matchall-groups-callbacks.ts": 5275, + "5923-matchall-groups-js.js": 4883, + "5924-js-literal-identity.js": 3065, + "5925-class-view-identity-observers.ts": 2685, + "5926-class-view-switch-js.js": 3057, + "5927-switch-object-identity.ts": 2661, + "5928-groupby-iterables.ts": 4500, + "5929-groupby-js.js": 3482, + "5930-contract-int32-arrays.ts": 4745, + "5930-method-census-asserted-number-keys.ts": 4815, + "5931-asserted-reads-keep-number-parameters.ts": 3015, + "5932-generic-class-observed-methods.ts": 5678, + "5933-class-fields-unknown-object.ts": 4834, + "5934-js-class-fields-property-order.js": 4883, + "5935-js-subclass-fields-and-element-calls.js": 4470, + "5936-checked-js-class-types.js": 4183, + "5937-override-narrowed-union-returns.ts": 3827, + "5938-object-literal-computed-keys-keep-methods.ts": 4019, + "5939-js-let-object-reassigned-wider.js": 4037, + "5940-callback-helper-specialization.ts": 4548, + "5941-callback-specialization-recursion.ts": 4448, + "5942-callback-specialization-throws.ts": 3443, + "5943-fields-read-before-assignment.ts": 4319, + "5944-js-fields-read-before-assignment.js": 3945, + "5945-local-class-observed-methods.ts": 4458, + "5946-nested-record-field-optional-writes.ts": 3537, + "5950-tuple-predicate-methods.ts": 4018, + "5951-result-never-widening.ts": 3970, + "5952-record-missing-keys.ts": 5020, + "5953-nan-coded-method-returns.ts": 2689, + "5955-any-promise-methods.js": 3182, + "5956-erased-generic-members.ts": 5824, + "5958-asserted-union-receiver.ts": 3206, + "5959-date-to-json.ts": 3819, + "5960-frame-records-own-references.ts": 3535, + "5960-generic-mapped-types.ts": 3052, + "5961-frame-spread-updates.ts": 3732, + "5962-frame-tuples.ts": 3372, + "5970-net-connect-host-name.ts": 3461, + "5971-buffer-chunks-to-string.ts": 4886, + "5972-net-set-encoding-listeners.ts": 4672, + "5973-large-closure-environment.ts": 5145, + "5974-typeof-module-exports.cjs": 3216, + "5975-zlib-class-values.ts": 4063, + "5990-worker-uncloneable.mjs": 4117, + "5991-worker-async-dispose.mjs": 40350, + "5992-worker-thread-name-lifetime.mjs": 47859, "5993-array-length-loop-resizing.ts": 4127, "5994-array-length-sparse-loops.ts": 2815, "5995-array-dense-loop-boundaries.ts": 4171, - "600-closures-basic.ts": 3477, - "601-closures-loops.ts": 2866, - "602-closures-identity-recursion.ts": 3704, - "6020-class-extends-function-constructor.js": 3671, - "6021-asserted-literal-union-arm.ts": 7200, - "603-closures-rc-stress.ts": 3096, - "604-closures-for-of.ts": 3045, - "605-closures-forward-capture-tdz.ts": 3323, - "700-classes-basic.ts": 2577, - "701-classes-composition.ts": 3154, - "702-classes-this-capture.ts": 2733, - "703-classes-rc-stress.ts": 3485, - "710-inheritance-basics.ts": 3238, - "711-inheritance-dispatch.ts": 3078, - "712-inheritance-instanceof.ts": 3534, - "713-inheritance-rc-stress.ts": 3301, - "720-accessors-basics.ts": 3158, - "721-accessors-eval-order.ts": 2971, - "722-accessors-inheritance.ts": 3316, - "723-accessors-rc-stress.ts": 3170, - "750-cycle-closure-box.ts": 2126, - "751-cycle-records-mutual.ts": 2363, - "752-cycle-classes.ts": 1960, - "753-cycle-owned-arrays.ts": 2692, - "754-cycle-external-ref.ts": 2903, - "755-cycle-async-promise.ts": 3043, - "756-cycle-inheritance.ts": 2972, - "757-cycle-cross-generation.ts": 2984, - "762-any-boundary.ts": 2786, - "764-any-async.ts": 3084, - "765-any-optional-chain.ts": 3008, - "766-any-union-boundary.ts": 3499, - "767-string-literal-keys.ts": 3514, - "768-any-uninitialized.ts": 3560, - "800-switch-basics.ts": 2767, - "801-switch-lazy-tests.ts": 2686, - "802-switch-loops.ts": 3125, - "803-switch-rc-stress.ts": 3547, - "804-switch-braced-blocks.ts": 2839, - "810-do-while.ts": 2218, - "820-multi-decl.ts": 3261, - "830-let-uninitialized.ts": 3097, - "900-records-basics.ts": 3422, - "901-records-eval-order.ts": 2695, - "902-records-functions-closures.ts": 3207, - "903-records-rc-stress.ts": 2631, - "904-records-optional-fields.ts": 2009, - "905-records-optional-rc-stress.ts": 2569, - "906-records-utility-types.ts": 3252, - "907-records-utility-generics.ts": 3311, - "908-records-index-signatures.ts": 3591, - "909-records-index-json.ts": 3947, - "910-records-index-rc-stress.ts": 3536, - "911-records-index-dot-access.ts": 3503, - "912-unknown-slots.ts": 3313, - "913-records-index-iteration.ts": 4350, + "600-closures-basic.ts": 3688, + "601-closures-loops.ts": 2905, + "602-closures-identity-recursion.ts": 3340, + "6020-class-extends-function-constructor.js": 3739, + "6021-asserted-literal-union-arm.ts": 3498, + "603-closures-rc-stress.ts": 2788, + "604-closures-for-of.ts": 3472, + "6041-error-cause-redeclared.ts": 4631, + "6042-regex-match-object-destructuring.ts": 3091, + "6043-string-index-narrowed-union.ts": 3627, + "605-closures-forward-capture-tdz.ts": 4043, + "6140-cjs-require-tdz-throws/main.js": 2989, + "6141-cjs-require-tdz-checked/main.js": 4062, + "6142-cjs-require-published-early/main.js": 5156, + "6143-cjs-require-json/main.js": 3050, + "6144-cjs-require-builtin-nested/main.js": 3329, + "6145-cjs-require-cycle/main.js": 4761, + "700-classes-basic.ts": 2717, + "701-classes-composition.ts": 3694, + "702-classes-this-capture.ts": 3151, + "703-classes-rc-stress.ts": 3285, + "710-inheritance-basics.ts": 2592, + "711-inheritance-dispatch.ts": 3301, + "712-inheritance-instanceof.ts": 3603, + "713-inheritance-rc-stress.ts": 2631, + "720-accessors-basics.ts": 2515, + "721-accessors-eval-order.ts": 3454, + "722-accessors-inheritance.ts": 3466, + "723-accessors-rc-stress.ts": 3570, + "750-cycle-closure-box.ts": 3720, + "751-cycle-records-mutual.ts": 2782, + "752-cycle-classes.ts": 3168, + "753-cycle-owned-arrays.ts": 3490, + "754-cycle-external-ref.ts": 3578, + "755-cycle-async-promise.ts": 3053, + "756-cycle-inheritance.ts": 2275, + "757-cycle-cross-generation.ts": 3630, + "762-any-boundary.ts": 3627, + "764-any-async.ts": 3271, + "765-any-optional-chain.ts": 2987, + "766-any-union-boundary.ts": 3659, + "767-string-literal-keys.ts": 3306, + "768-any-uninitialized.ts": 3041, + "800-switch-basics.ts": 3127, + "801-switch-lazy-tests.ts": 3237, + "802-switch-loops.ts": 3396, + "803-switch-rc-stress.ts": 3243, + "804-switch-braced-blocks.ts": 3060, + "810-do-while.ts": 3366, + "820-multi-decl.ts": 3412, + "830-let-uninitialized.ts": 2806, + "900-records-basics.ts": 2799, + "901-records-eval-order.ts": 3424, + "902-records-functions-closures.ts": 2868, + "903-records-rc-stress.ts": 3996, + "904-records-optional-fields.ts": 3692, + "905-records-optional-rc-stress.ts": 3288, + "906-records-utility-types.ts": 2706, + "907-records-utility-generics.ts": 2748, + "908-records-index-signatures.ts": 3143, + "909-records-index-json.ts": 3697, + "910-records-index-rc-stress.ts": 4050, + "911-records-index-dot-access.ts": 3683, + "912-unknown-slots.ts": 2923, + "913-records-index-iteration.ts": 4112, "914-records-from-entries.ts": 3768, - "915-unknown-tostring-eq.ts": 2630, - "916-unknown-bytes.ts": 3440, - "917-record-array-index-dot.ts": 3157, - "950-modules-basic/main.ts": 2848, - "951-modules-diamond/main.ts": 3198, - "952-modules-cross/main.ts": 3183, - "953-modules-default/main.ts": 3167, - "954-modules-reexport/main.ts": 2018, - "957-builtins-namespace.ts": 3430, - "960-generics-basics.ts": 3705, - "961-generics-recursion.ts": 2537, - "962-generics-closures.ts": 3548, - "963-generics-modules/main.ts": 2784, - "964-generics-rc-stress.ts": 3384, - "965-generics-async.ts": 2822, - "965-unions-retag.ts": 3386, - "966-unions-retag-rc-stress.ts": 2717, - "967-record-field-widening.ts": 2715, - "969-unions-arm-matrix.ts": 3012, - "970-unions-basics.ts": 2986, - "971-unions-switch.ts": 3685, - "972-unions-nested.ts": 3090, - "973-unions-rc-stress.ts": 3424, - "974-unions-modules/main.ts": 3121, - "975-unions-undefined.ts": 2840, - "976-unions-null.ts": 2783, - "977-unions-unit-rc-stress.ts": 3216, - "978-unions-nullish.ts": 3540, - "979-unions-optional-chaining.ts": 3197, - "980-exceptions-basics.ts": 3555, - "981-exceptions-values.ts": 3193, - "982-exceptions-rc-stress.ts": 2933, - "983-exceptions-control-flow.ts": 3085, - "984-exceptions-finally.ts": 3513, - "985-exceptions-call-chains.ts": 2381, - "986-exceptions-uncaught.ts": 2898, - "987-exceptions-result-unions.ts": 2879, - "990-process-basics.ts": 3199, - "991-process-exit.ts": 3081, - "992-fs-roundtrip.ts": 2369, - "993-fs-readdir.ts": 3082, - "994-fs-errors.ts": 3422, - "995-fs-uncaught.ts": 3294, - "996-fs-rc-stress.ts": 3471, - "997-fs-modules/main.ts": 2673, - "998-process-env.ts": 3051, - "abstract-property-dispatch.ts": 3176, - "arguments-arrow-capture.mjs": 3073, - "arguments-reexport/main.ts": 2672, - "array-argument-lifetimes-exits.ts": 3589, - "array-argument-lifetimes-mutation.ts": 3438, - "array-argument-lifetimes-strings.ts": 3059, - "array-argument-lifetimes-values.ts": 3883, - "array-buffer-conversions.js": 2989, - "array-buffer-storage.ts": 3822, - "array-checked-callback-results.mjs": 3408, - "array-checked-constructor.js": 3489, - "array-concat-widening.ts": 3866, - "array-deque-unshift.ts": 2667, - "array-element-compound-updates.ts": 5084, - "array-fill-unit-values.ts": 3524, - "array-from-checked.js": 4344, - "array-from-value.mjs": 3171, - "array-isarray-value/main.js": 2914, - "array-numeric-own-keys.ts": 3622, - "array-optional-number-write-index.ts": 2652, - "array-primitive-ordering.ts": 4006, - "array-queue-head-room.ts": 3597, - "array-read-helper-effects.ts": 3562, - "array-refined-storage.ts": 4149, - "array-sort-dense-effects.ts": 4479, - "array-sort-dense-values.ts": 4819, - "array-sort-holes-published.ts": 7708, - "array-sort-runs.ts": 7566, - "array-sort-runtime-comparator.ts": 6150, - "array-sort-unknown-comparator.ts": 2544, - "array-storage-transitions.ts": 3926, - "array-truncate-reuse.ts": 3660, - "async-backend-factory.mjs": 3134, - "async-local-typed-results.ts": 3527, - "atomics-integer-operations.ts": 4356, - "bigint-checked-casts.ts": 2554, - "bigint-checked-storage.js": 3784, - "bigint-union-conversion.ts": 3322, - "boxed-error-rethrows.mjs": 2897, - "buffer-codec-boundaries.ts": 3387, - "buffer-primitive-predicate.ts": 3237, - "builtin-prototype-method-values.mjs": 3628, - "byte-loop-bounds.ts": 3700, - "byte-number-pipeline.ts": 3420, - "byte-record-windows.ts": 3513, - "call-lifetimes-argument-order.ts": 3157, - "call-lifetimes-control-flow.ts": 3596, - "call-lifetimes-owned-boundaries.ts": 3515, - "call-lifetimes-projections.ts": 2258, - "call-lifetimes-union-values.ts": 3157, - "call-lifetimes-virtual-optionals.ts": 3774, - "callable-module-members.mjs": 3196, - "callable-properties.mjs": 3885, - "callable-property-cycles.js": 3532, - "callable-reexport/main.ts": 3427, - "captured-class-refinement.ts": 3597, - "catch-capture.ts": 2987, - "caught-class-identity.ts": 4072, - "caught-standalone-class.ts": 2672, - "caught-system-error-fields.ts": 3700, - "checked-addition.js": 3105, - "checked-any-addition.ts": 2239, - "checked-array-assignment.ts": 3049, - "checked-array-flat/main.ts": 3431, - "checked-bitwise/main.js": 3320, - "checked-builder-cycles.js": 2792, - "checked-byte-storage/main.ts": 3747, - "checked-callback-options.ts": 2687, - "checked-class-descriptors.mjs": 3712, - "checked-class-factory.mjs": 2771, - "checked-collection-iterators.ts": 3380, - "checked-collection-symbol-methods.ts": 2530, - "checked-dispatch-input-lifetimes.js": 3328, - "checked-increment/main.js": 3104, - "checked-inherited-fields.ts": 2621, - "checked-iterator-consumption.js": 4294, - "checked-numeric-arithmetic.js": 3111, - "checked-object-module-alias.js": 3420, - "checked-optional-calls.mjs": 3475, - "checked-promise-recovery.ts": 3214, - "checked-proxy-callback/main.ts": 2353, - "checked-record-constructor.ts": 3432, - "checked-renderer-defaults.js": 3283, - "checked-rest-function-adapters.js": 3083, - "checked-storage-transitions.js": 3622, - "checked-symbol-array.ts": 3310, - "checked-value-input-lifetimes.ts": 3545, - "class-accessor-returned-function.js": 3128, - "class-array-optional-return.ts": 2098, - "class-bracket-method-calls.js": 3772, - "class-brand-overload.js": 2492, - "class-callback-replacement.js": 4751, - "class-callback-storage.ts": 4435, - "class-checked-composites.ts": 2988, - "class-checked-upcast.ts": 3528, - "class-collection-insertion.ts": 3819, - "class-computed-presence.ts": 3069, - "class-computed-symbols.js": 4319, - "class-covariant-returns.ts": 2381, - "class-curried-factory.mjs": 4502, - "class-data-descriptors.js": 3422, - "class-factory-inherited-statics.mjs": 3137, - "class-factory-parameter-base.mjs": 3744, - "class-factory-record-base.mjs": 4712, - "class-factory-recursive-statics.mjs": 3419, - "class-factory-static-members.mjs": 3588, - "class-function-base/main.js": 3762, - "class-instance-constructor.js": 3074, - "class-interface-protocols.ts": 5102, - "class-interface-refinements.ts": 3720, - "class-json-checked.ts": 2934, - "class-local-function-base.mjs": 3255, - "class-method-spreads.ts": 4902, - "class-narrowed-views.ts": 3371, - "class-property-call-values.mjs": 4011, - "class-prototype-data.js": 3004, - "class-prototype-descriptor-copy.mjs": 3813, - "class-specialized-computed-base.mjs": 4267, - "class-static-data.js": 3151, - "class-subclass-assertions.ts": 3297, - "class-super-surplus-spread.mjs": 3182, - "class-symbol-accessors.ts": 3548, - "class-symbol-cache.mjs": 4032, - "class-value-constructor-exceptions.ts": 2673, - "closed-virtual-dispatch-modules/main.ts": 2555, - "closed-virtual-dispatch.ts": 3659, - "closure-nullable-union-return.ts": 3544, - "closure-union-locals.ts": 3476, - "collection-array-cycles.ts": 3864, - "collection-array-maps.ts": 4225, - "collection-array-missing.ts": 4159, - "collection-array-sets.ts": 4385, - "collection-copy-identities.ts": 2778, - "collection-data-unions.ts": 3634, - "collection-ingestion-mappers.ts": 3206, - "collection-ingestion-protocol/main.ts": 3833, - "collection-ingestion-references.ts": 3449, - "collection-ingestion.ts": 3258, - "collection-storage-copies.ts": 3108, - "collection-value-keys.ts": 4397, - "compound-field-receivers.ts": 3249, - "compound-presence-guards.ts": 2877, - "conditional-tuple-destructuring.ts": 2382, - "console-imports.cjs": 3167, - "console-native-value.js": 3394, - "const-enum-module-cycle/main.ts": 2006, - "constant-callback-dispatch.ts": 2991, - "constant-module-globals/main.ts": 2958, - "constant-number-remainders.ts": 3341, - "constructed-class-dispatch.ts": 2784, - "contextual-array-union-write.ts": 7276, - "contextual-return-layouts.ts": 3888, - "counted-loop-numbers.ts": 3637, - "counted-loop-storage.ts": 2691, - "crypto-hash-optional-input.ts": 3463, - "cycle-generations-long-lived.ts": 3441, - "cycle-growth-yield.ts": 3944, - "date-checked-native.js": 2845, - "declared-index-spread.ts": 4567, - "deep-reference-teardown.ts": 3926, - "default-undefined-parameters.ts": 3319, - "deferred-field-updates.ts": 3102, - "deferred-registry-many.ts": 3953, - "derived-numeric-updates.ts": 3389, - "destructure-call-assignment.js": 2983, - "destructure-inferred-row-defaults.js": 3512, - "destructure-union-arrays.ts": 2816, - "dynamic-function-descriptors.js": 3146, - "error-cause-writes.js": 3354, - "error-inherited-message.mjs": 3845, - "error-inherited-name.mjs": 2619, - "error-property-writes.mjs": 3158, - "error-prototype-tostring.js": 3672, - "error-stack-frames.ts": 3288, - "error-stack-limit.ts": 2624, - "error-tostring-overrides.ts": 3434, - "error-values-inspect.ts": 2196, - "exact-index-round-trip.ts": 3473, - "expression-runtime-values.ts": 3088, - "fiber-switch-stress.ts": 4040, - "fiberless-async-ordering.ts": 3692, - "fiberless-async-unhandled.ts": 2796, - "field-assignment-values.ts": 3175, - "file-handle-values.ts": 4245, - "file-read-storage.ts": 3850, - "file-url-percent-decoding.ts": 3346, - "final-field-borrows.ts": 4200, - "for-multiple-bindings.ts": 3350, - "for-multiple-lexical-bindings.ts": 2400, - "for-of-checked-iterator.js": 2766, - "for-of-subclass-elements.ts": 3269, - "forward-generic-signatures.ts": 3369, - "fresh-array-union-layout.js": 2566, - "frozen-checked-dictionaries.mjs": 3872, - "fs-native-realpath.ts": 3355, - "fs-null-byte-paths-js.cjs": 2643, - "fs-null-byte-paths.ts": 5975, - "fs-read-encodings.ts": 3730, - "fs-read-utf8-edges.ts": 4190, - "fs-read-utf8-handle-forms.ts": 3943, - "fs-remove-readonly.ts": 3417, - "fs-write-string-bytes-union.ts": 3274, - "function-apply-value.mjs": 3476, - "function-constructor-global.mjs": 3249, - "function-constructor-kinds/main.js": 3769, - "function-custom-prototype.js": 3876, - "function-custom-to-string.mjs": 3155, - "function-object-assign.js": 3527, - "function-own-prototype/main.js": 3460, - "generator-checked-protocol.ts": 2621, - "generator-checked-return.js": 3221, - "generator-custom-delegation/main.ts": 5126, - "generator-default-return-pattern.ts": 3182, - "generator-delegation-values.ts": 3197, - "generator-inferred-date.js": 3585, - "generator-mixed-checked-channels.ts": 3199, - "generator-untyped-consumer/main.ts": 3049, - "generic-base-specializations.ts": 3459, - "generic-binding-ownership.ts": 3288, - "generic-class-js-functions/main.ts": 2834, - "generic-class-recovery.ts": 3640, - "generic-namespace-factories/main.ts": 2618, - "generic-nullable-collections.ts": 3599, - "generic-pattern-bindings.ts": 3103, - "generic-record-index.ts": 3516, - "generic-visitor-void.ts": 3557, - "global-accumulator-loops.ts": 3302, - "global-error-subclasses.ts": 2292, - "global-runtime-probes.js": 3435, - "global-stored-probes.js": 2946, - "global-string-cache/main.js": 2368, - "global-symbol-cache/main.js": 2737, - "guarded-native-iterables.ts": 3541, - "heap-input-aliases.ts": 3756, - "heap-input-collections.ts": 4265, - "in-array-runtime-index.ts": 3804, - "indexed-assignment-values.js": 3469, - "indexed-assignment-values.ts": 2742, - "indexed-element-field-reads.ts": 3016, - "inferred-array-assignment-values.mjs": 2506, - "inferred-class-default.mjs": 2376, - "inferred-compound-values.mjs": 2280, - "inferred-conditional-class.mjs": 3032, - "inferred-error-fields.js": 3161, - "inferred-map-patterns.mjs": 3075, - "inferred-method-override.js": 3123, - "inferred-partial-destructuring.mjs": 3133, - "inferred-primitive-properties.mjs": 2211, - "inferred-record-return.mjs": 3298, - "inferred-recursive-record.mjs": 3328, - "inferred-undefined-field.mjs": 2721, - "input-lifetime-intervals.ts": 3442, - "input-lifetimes-modules/main.ts": 3449, - "instanceof-class-record-union.ts": 3488, - "integer-flow-arithmetic.ts": 3827, - "integer-loop-forms.ts": 3201, - "integer-view-control.ts": 3231, - "integer-view-numbers.ts": 3409, - "integer-view-storage.ts": 3994, - "intl-grapheme-conformance/main.ts": 3445, - "intl-grapheme.ts": 2906, - "iterator-typed-returns.ts": 4729, - "js-abort-portable.js": 27919, - "js-array-constructor.js": 3813, - "js-array-default-buffer.js": 2697, - "js-array-iterators.js": 3607, - "js-arrow-bind.cjs": 4009, - "js-buffer-callback-brand.cjs": 3617, - "js-callable-proxy.js": 4304, - "js-chained-native-results.mjs": 2822, - "js-checked-array-iterator.js": 3340, - "js-checked-array-reference.js": 3923, - "js-checked-number-negation.mjs": 2222, - "js-checked-sort-result.js": 3358, - "js-child-error-listener.cjs": 3277, - "js-cjs-callable-snapshots/main.cjs": 2133, - "js-class-added-parameters.js": 4197, - "js-class-checked-overrides.js": 3307, - "js-class-computed-fields.js": 2995, - "js-class-enumeration.js": 4227, - "js-class-field-accessor-override.js": 3739, - "js-class-fluent-overrides.js": 3694, - "js-class-late-method-values.js": 3823, - "js-class-member-dispatch.js": 2888, - "js-class-return-shapes.js": 4179, - "js-class-shadowed-methods.js": 3019, - "js-class-stored-method-receiver.js": 3182, - "js-class-subclass-properties.js": 4548, - "js-class-symbol-spread.cjs": 3271, - "js-computed-prototype-additions.js": 3652, - "js-constructor-returned-callable.js": 3080, - "js-constructor-spread.js": 3311, - "js-dataview-dispatch.js": 2584, - "js-declared-fields.cjs": 4858, - "js-default-listener-arguments.cjs": 2246, - "js-default-options/main.ts": 2763, - "js-deferred-field-initializers.js": 3209, - "js-deferred-registry-effects.js": 3112, - "js-derived-constructor-hoisting.js": 2435, - "js-dormant-array-write.js": 2504, - "js-dormant-overrides.js": 2426, - "js-expando-records.js": 2649, - "js-implicit-call-results.js": 2821, - "js-inferred-callback-exports/main.js": 4081, - "js-inferred-class-array-return.js": 3706, - "js-inferred-object-values.js": 2559, - "js-inherited-field-storage.js": 3955, - "js-inherited-parameter-abi.js": 2394, - "js-iterable-spread.js": 3349, - "js-loose-dynamic-primitives.js": 3110, - "js-map-object-seeds.js": 3942, - "js-member-increment.js": 4274, - "js-module-function-values.js": 3403, - "js-mutable-null-members.js": 2899, - "js-nested-native-descriptors.js": 3202, - "js-normalize-dispatch.js": 3282, - "js-nullish-inherited-fields.mjs": 2655, - "js-object-receiver-storage.js": 3904, - "js-object-returning-constructors.mjs": 2279, - "js-object-shared-arrays.js": 3613, - "js-omitted-typed-arguments.js": 2937, - "js-open-binding-writes.js": 2903, - "js-optional-class-fields.js": 3536, - "js-optional-member-call.js": 2325, - "js-primitive-union-addition.js": 3324, - "js-promise-all-values.js": 3699, - "js-promise-catch-handler.js": 3309, - "js-promise-finally-order.js": 3229, - "js-promise-pending-reactions.js": 3312, - "js-prototype-host-boundary.js": 3876, - "js-reflect-receivers.js": 2676, - "js-regex-record-captures.js": 3109, - "js-scalar-iterables.js": 3335, - "js-shared-method-dispatch.js": 3207, - "js-specialized-field-method.js": 3320, - "js-static-accessors.js": 3426, - "js-static-method-values.js": 3661, - "js-static-registries.cjs": 3718, - "js-super-accessor-initialization.js": 2555, - "js-uninitialized-native-fields.js": 3260, - "json-guarded-map-values.ts": 2760, - "json-output-bulk.ts": 3183, - "json-runtime-options.mjs": 3276, - "json-stringify-value.js": 3464, - "json-typed-parse-direct.ts": 4317, - "json-typed-parse-index-signatures.ts": 4012, - "json-typed-parse-optional-members.ts": 4377, - "json-typed-parse-union-members.ts": 4357, - "literal-switch-dispatch.ts": 2642, - "live-reference-shared-converters.ts": 5581, - "llvm-read-receiver-lifetime.ts": 3426, - "local-class-call-spreads.js": 3773, - "local-class-declaration.ts": 3293, - "local-class-evaluation.ts": 2921, - "local-class-inheritance.ts": 3273, - "local-class-lifetimes.ts": 3403, - "local-class-namespace/main.js": 4002, - "local-class-prototype-data.js": 3135, - "local-class-specialization.js": 3358, - "local-class-unknown.ts": 3386, - "local-class-values.ts": 3003, - "local-union-storage.ts": 3264, - "locale-compare-root-order.ts": 2579, - "logical-assignment-dynamic.js": 3596, - "logical-assignment-values.ts": 2685, - "logical-runtime-optional-record.ts": 3575, - "loop-reference-lifetimes.ts": 2726, - "map-checked-boundary/main.ts": 3371, - "map-checked-seed.js": 2974, - "map-get-set-fusion.ts": 3516, - "map-number-keys-dense.ts": 3426, - "map-read-lifetimes-exits.ts": 2870, - "map-read-lifetimes.ts": 2755, - "map-seeds-and-spreads.ts": 3696, - "map-typed-array-values.ts": 3121, - "math-function-values.js": 3080, - "missing-read-lambda-results.ts": 2590, - "missing-read-narrowed-storage.ts": 3503, - "missing-read-number-conversions.ts": 3648, - "module-byte-loops.ts": 3462, - "module-fallback-functions/main.js": 3043, - "narrowed-nullish-values.ts": 2912, - "native-any-timer-callback.ts": 1952, - "native-array-borrowed-find-last.js": 2795, - "native-array-borrowed-slice.js": 3711, - "native-array-copying-methods.js": 3069, - "native-array-fill-copywithin.js": 3430, - "native-array-frozen-noops.js": 3638, - "native-array-index-boundaries.js": 2630, - "native-array-integrity.js": 3935, - "native-array-length.js": 3375, - "native-array-named-properties.js": 3404, - "native-array-prototype/main.js": 3369, - "native-array-read-lifetimes.ts": 3688, - "native-array-reduce-find-last.js": 3264, - "native-array-search-from-index.js": 3220, - "native-array-splice-coercion.js": 3281, - "native-array-splice-flat.js": 3336, - "native-buffer-coercion.js": 2766, - "native-callback-dispatch.ts": 3779, - "native-class-array-boundaries.ts": 3630, - "native-class-cache.js": 3925, - "native-class-properties.cjs": 3940, - "native-class-property-cycles.cjs": 2802, - "native-class-property-order.cjs": 3298, - "native-class-type-predicates.ts": 3174, - "native-factory-records.js": 3338, - "native-method-values.js": 4444, - "native-method-values.ts": 3470, - "native-npm-imports/main.ts": 4028, - "native-object-descriptors.js": 2892, - "native-object-for-in-minimal.js": 2799, - "native-object-property-attributes.js": 3744, - "native-object-prototype.js": 2121, - "native-property-names.ts": 2951, - "native-proxy-env.js": 4417, - "native-worker-arena-reuse.ts": 38589, - "native-worker-bounded-errors.ts": 3955, - "native-worker-buffer-consumers.ts": 3076, - "native-worker-cancel-hot.ts": 3811, - "native-worker-class-fields.ts": 3737, - "native-worker-clone-errors.ts": 3557, - "native-worker-commonjs.cjs": 3258, - "native-worker-delayed-messages.ts": 3234, - "native-worker-discarded-heaps.ts": 8633, - "native-worker-environment.ts": 2690, - "native-worker-error.ts": 2115, - "native-worker-exception-state.ts": 37223, - "native-worker-exit-listeners.ts": 4215, - "native-worker-io.ts": 4024, - "native-worker-loop-cancellation.ts": 3683, - "native-worker-message-graphs.ts": 4038, - "native-worker-messages.ts": 2850, - "native-worker-poll-exceptions.ts": 3386, - "native-worker-port-lifetime.ts": 3672, - "native-worker-process-exit.ts": 4483, - "native-worker-publish-classes.ts": 43586, - "native-worker-publish-refusals.ts": 3568, - "native-worker-published-graphs.ts": 4341, - "native-worker-references.ts": 3658, - "native-worker-roots/main.ts": 3661, - "native-worker-shared-views.ts": 3873, - "native-worker-stack-overflow.ts": 3498, - "native-worker-terminate-exception-state.ts": 4768, - "native-worker-terminate-loop.ts": 3671, - "native-worker-terminate-recursion.ts": 2944, - "native-worker-terminate-suspended.ts": 4867, - "native-worker-terminate-tested-loops.ts": 3737, - "native-worker-terminate-wait.ts": 3200, - "native-worker-typed-arrays.ts": 2972, - "nested-map-cycles.ts": 3092, - "nested-map-values.ts": 3902, - "never-returning-calls.ts": 3512, - "next-tick-commonjs-entry.cjs": 3497, - "node24-buffer-encoding-errors.ts": 2874, - "node24-buffer-encoding.ts": 2697, - "node24-crypto-kdf-errors.ts": 3771, - "node24-crypto-kdf-options.ts": 2897, - "node24-crypto-kdf.ts": 3236, - "node24-crypto-sha2.ts": 3082, - "node24-deep-equality-properties.js": 3692, - "node24-deep-equality.cjs": 4490, - "node24-deep-equality.ts": 2856, - "node24-env-files-errors.ts": 2870, - "node24-env-files.ts": 3392, - "node24-env-imports.cjs": 2365, - "node24-env-parse-errors.ts": 3439, - "node24-env-parse.ts": 3033, - "node24-esm-metadata/main.mjs": 3209, - "node24-file-url-buffer.ts": 3465, - "node24-file-url-errors.js": 3937, - "node24-file-url-options.ts": 3735, - "node24-fs-links-callbacks.cjs": 3621, - "node24-fs-links-errors.cjs": 3404, - "node24-fs-links-options.cjs": 6459, - "node24-fs-links-promise-errors.cjs": 3319, - "node24-fs-links-promises.ts": 2636, - "node24-fs-links.ts": 3567, - "node24-fs-statfs-callbacks.cjs": 2515, - "node24-fs-statfs-errors.cjs": 2787, - "node24-fs-statfs-options.cjs": 3945, - "node24-fs-statfs.ts": 3105, - "node24-fs-timestamps-callbacks.cjs": 3550, - "node24-fs-timestamps-errors.cjs": 2070, - "node24-fs-timestamps-promises.ts": 3342, - "node24-fs-timestamps-symlinks.ts": 3375, - "node24-fs-timestamps.ts": 3308, - "node24-no-error-assertions-coercion.js": 3613, - "node24-no-error-assertions.cjs": 2851, - "node24-no-error-assertions.ts": 4400, - "node24-parseargs.js": 5202, - "node24-string-decoder.ts": 3402, - "node24-style-text-environment.js": 3896, - "node24-style-text-validation.js": 3092, - "node24-style-text.cjs": 3244, - "node24-style-text.ts": 2726, - "node24-system-error-validation.js": 3065, - "node24-system-errors.cjs": 2955, - "node24-system-errors.ts": 3258, - "node24-text-codec-properties.ts": 31240, - "node24-text-encode-into.ts": 2827, - "node24-text-utilities-coercion.js": 3019, - "node24-text-utilities-validation.js": 3576, - "node24-text-utilities.cjs": 3204, - "node24-text-utilities.ts": 2533, - "node24-url-authority-coercion.js": 3364, - "node24-url-authority.ts": 3386, - "node24-url-factories.ts": 3341, - "node24-url-factory-errors.ts": 3442, - "node24-url-mutation-coercion.js": 3344, - "node24-url-mutation.ts": 3264, - "node24-util-types.cjs": 3872, - "node24-util-types.js": 3533, - "node24-util-types.ts": 2848, - "non-null-class-iteration.ts": 2837, - "nonnull-element-arguments.ts": 3131, - "nonnull-forwarded-class-values.ts": 2449, - "nullable-object-extension.mjs": 3515, - "nullish-asserted-class-arms.ts": 3564, - "nullish-assignment-values.ts": 3337, - "nullish-long-chain.ts": 4149, - "number-parse-statics.ts": 2899, - "number-predicates-unknown.ts": 2922, - "numeric-call-specialization.ts": 2677, - "object-enumeration-array-reads.ts": 3480, - "object-from-checked-entries.js": 4289, - "object-inherited-to-string.js": 3243, - "object-key-indexes.js": 3558, - "object-prototype-identity.mjs": 3385, - "object-reexport/main.js": 2771, - "object-spread-computed.ts": 3307, - "opentui-byte-queue.js": 3572, - "optional-callback-arity.ts": 3027, - "optional-class-flows.ts": 3557, - "optional-element-defaults.ts": 3575, - "optional-flag-comparisons.ts": 3414, - "optional-native-callables.js": 3002, - "optional-node-list-iteration.ts": 2230, - "optional-string-index/main.ts": 3788, - "path-to-file-url-options.ts": 2444, - "performance-presence.ts": 2497, - "primitive-and-function-descriptors.js": 3169, - "primitive-union-string.ts": 2622, - "process-builtin-values.js": 3706, - "process-constrained-memory.ts": 2749, - "process-env-computed-keys.js": 3550, - "process-hrtime.js": 2677, - "process-named-signals.cjs": 3293, - "process-uncaught-handler-throws.cjs": 2718, - "process-uncaught-loop.cjs": 2801, - "process-uncaught-module.mjs": 3158, - "process-uncaught-monitor.cjs": 3031, - "process-uncaught-rejection.cjs": 3327, - "process-uncaught-sync.cjs": 2443, - "process-version-pin.ts": 2957, - "process-versions-storage.ts": 3651, - "projected-collection-lifetimes.ts": 3241, - "promise-checked-rejections.ts": 3404, - "promise-resolve-void.ts": 3343, - "prototype-method-overrides.mjs": 4289, - "prototype-named-data-records.ts": 3466, - "rc-last-use-moves.ts": 4113, - "rc-private-array-writes.ts": 4261, - "record-field-presence.ts": 4642, - "record-key-order.ts": 3034, - "record-optional-json-presence.ts": 3355, - "record-presence-copies.ts": 2764, - "record-presence-delete-json.ts": 2807, - "record-unchecked-read-presence.ts": 3073, - "record-unknown-values.ts": 4519, - "reflect-own-keys.mjs": 3709, - "reflect-record-union-keys.mjs": 2498, - "reflect-typed-record-keys.ts": 2697, - "regex-callback-replacements.ts": 3004, - "regex-callback-values.js": 2710, - "regex-checked-casts.ts": 3352, - "regex-checked-storage.js": 3330, - "regex-exec-long-subject.ts": 6176, - "regex-exec-result-arrays.ts": 3812, - "regex-fs-text-surfaces.ts": 4280, - "regex-input-lifetimes.ts": 3127, - "regex-native-matcher.ts": 5535, - "regex-optional-captures.ts": 3580, - "regex-optional-templates.ts": 3221, - "regex-split-captures.ts": 2939, - "regex-text-paths.ts": 3596, - "regexp-constructor-repeat.ts": 3069, - "regexp-optional-constructor.ts": 2996, - "regexp-string-coercion.js": 3263, - "renderer-export-dictionaries.js": 3616, - "renderer-null-state.js": 3037, - "renderer-specializations.js": 3634, - "repeat-and-typed-read-errors.ts": 2617, - "rest-optional-array-arguments.ts": 3777, - "rest-optional-elements.ts": 3195, - "return-void-through-finally.ts": 2410, - "runtime-optional-string-flows.ts": 3467, - "scalar-string-slices.ts": 3659, - "set-checked-methods.js": 2038, - "set-checked-storage.ts": 3153, - "set-iterator-seed-references.ts": 3637, - "set-iterator-seeds.ts": 3641, - "set-optional-seeds.ts": 3312, - "small-collection-transitions.ts": 3749, - "speculative-integer-globals.ts": 3132, - "speculative-integer-loops.ts": 3533, - "speculative-integer-reads.ts": 3953, - "stack-depth-async-bodies.ts": 3272, - "stack-overflow-async.ts": 2638, - "stack-overflow-caught.ts": 2219, - "stack-overflow-finally.ts": 3033, - "stack-overflow-shapes.ts": 4491, - "stack-overflow-uncaught.ts": 2225, - "stackless-async-concurrency.ts": 4361, - "stackless-async-context.ts": 2699, - "stackless-async-exceptions.ts": 3282, - "stackless-async-ordering.ts": 3335, - "stackless-async-unhandled.ts": 2784, - "static-field-updates/main.ts": 2292, - "static-method-receivers.ts": 3195, - "stdio-values.mjs": 3475, - "stdio-write-errors.mjs": 3473, - "stdio-write-overrides.mjs": 2782, - "stored-native-builtins.js": 3709, - "stored-object-helpers.js": 3602, - "stream-dynamic-entry-kinds.cjs": 4557, - "stream-dynamic-entry-kinds.ts": 4257, - "stream-encoded-from-entries.cjs": 4266, - "stream-encoded-from-entries.ts": 5622, - "string-char-code-integer-loops.ts": 2285, - "string-code-points.ts": 3745, - "string-concat-number-parts.ts": 3405, - "string-construction-order.ts": 3532, - "string-field-append.ts": 3568, - "string-lifetimes-boundaries.ts": 2538, - "string-lifetimes-evaluation.ts": 3059, - "string-lifetimes-iteration.ts": 2631, - "string-lifetimes-operations.ts": 3387, - "string-normalize.ts": 2789, - "string-pattern-replacement.ts": 3618, - "string-scan-fast-paths.ts": 3272, - "string-split-checked-separator.mjs": 3453, - "string-split-traversal.ts": 4337, - "structural-class-properties.ts": 3247, - "structured-text-boundaries.js": 3686, - "structured-text-storage.ts": 3429, - "switch-integer-dispatch.ts": 3032, - "symbol-checked-boundary/main.ts": 3536, - "symbol-class-fields.ts": 2762, - "symbol-class-fields/main.cjs": 3297, - "symbol-class-methods/main.ts": 3256, - "symbol-fields-deferred-factory.ts": 2417, - "symbol-fields-inferred.js": 3396, - "symbol-object-properties/main.js": 3134, - "synchronous-callback-lifetimes.ts": 3731, - "terminal-stream-properties.ts": 3204, - "text-codec-values/main.ts": 34352, - "text-codec-var.ts": 32460, - "text-encode-into-boundaries.ts": 3355, - "timers-clear-many.ts": 3559, - "tuple-and-string-search.ts": 3678, - "tuple-array-union.ts": 3569, - "tuple-callback-visitation.ts": 4765, - "tuple-forof-visitation.ts": 3560, - "typed-array-bulk-conversion.mjs": 5651, - "typed-array-byte-io.js": 4933, - "typed-array-checked-index.js": 3214, - "typed-array-constructor-alias.ts": 3116, - "typed-array-constructor-identity.js": 2735, - "typed-array-constructor-union.ts": 2841, - "typed-array-constructor-values.mjs": 3638, - "typed-array-dynamic-methods.js": 3255, - "typed-array-integer-widths.ts": 3434, - "typed-array-nan-coded-reads.ts": 3804, - "typed-array-numeric-import.ts": 2396, - "typed-array-present-reads.ts": 4348, - "typed-array-reversed-storage.ts": 3192, - "typed-array-unknown.ts": 2874, - "typed-collection-iterator-references.ts": 4029, - "typed-collection-iterators.ts": 4109, - "typed-collection-views/main.ts": 3005, - "typed-index-arguments.ts": 2798, - "typed-prototype-methods.ts": 3814, - "typed-rest-callables.ts": 2881, - "typed-rest-filtered-return.ts": 3723, - "typedarray-native-inputs.js": 2740, - "typeof-checked-comparison.js": 2277, - "uint8array-sort-domains.ts": 3386, - "unicode-case-paths.ts": 3002, - "unicode-process-argv.ts": 3272, - "union-discriminant-width.ts": 3302, - "union-literal-scalar-discriminants.ts": 2833, - "union-literal-slot-conversion.ts": 4058, - "union-nested-layout-discriminant.ts": 3205, - "union-optional-semantic-identity.ts": 3833, - "union-record-clone.ts": 3862, - "union-record-structural-copy.ts": 3756, - "union-reference-comparison.ts": 2883, - "unknown-array-holes.ts": 2863, - "unknown-collections.ts": 4132, - "unknown-object-enumeration.ts": 4976, - "unknown-record-views.ts": 4014, - "url-runtime-base.ts": 3421, - "utf8-span-decoding.ts": 3446, - "util-parseargs-wrapped/main.ts": 3987, - "virtual-runtime-optional-returns.ts": 4683, - "weak-map-array-buffer.ts": 3291, - "weak-map-fresh-array.js": 2703, - "weak-map-native.js": 3899, - "weak-native-class-identity.ts": 2332, - "weak-set-native.js": 2464, - "worker-class-instance-clone.ts": 46305 + "915-unknown-tostring-eq.ts": 3915, + "916-unknown-bytes.ts": 3466, + "917-record-array-index-dot.ts": 3287, + "950-modules-basic/main.ts": 3531, + "951-modules-diamond/main.ts": 3176, + "952-modules-cross/main.ts": 2507, + "953-modules-default/main.ts": 2473, + "954-modules-reexport/main.ts": 2897, + "957-builtins-namespace.ts": 3213, + "960-generics-basics.ts": 2743, + "961-generics-recursion.ts": 3759, + "962-generics-closures.ts": 3551, + "963-generics-modules/main.ts": 3745, + "964-generics-rc-stress.ts": 3697, + "965-generics-async.ts": 3911, + "965-unions-retag.ts": 2955, + "966-unions-retag-rc-stress.ts": 3416, + "967-record-field-widening.ts": 3252, + "969-unions-arm-matrix.ts": 3502, + "970-unions-basics.ts": 3588, + "971-unions-switch.ts": 3755, + "972-unions-nested.ts": 2659, + "973-unions-rc-stress.ts": 3021, + "974-unions-modules/main.ts": 3329, + "975-unions-undefined.ts": 3414, + "976-unions-null.ts": 3240, + "977-unions-unit-rc-stress.ts": 3807, + "978-unions-nullish.ts": 3471, + "979-unions-optional-chaining.ts": 2680, + "980-exceptions-basics.ts": 3823, + "981-exceptions-values.ts": 3366, + "982-exceptions-rc-stress.ts": 3526, + "983-exceptions-control-flow.ts": 3306, + "984-exceptions-finally.ts": 3693, + "985-exceptions-call-chains.ts": 3523, + "986-exceptions-uncaught.ts": 3377, + "987-exceptions-result-unions.ts": 3446, + "990-process-basics.ts": 3175, + "991-process-exit.ts": 3461, + "992-fs-roundtrip.ts": 3411, + "993-fs-readdir.ts": 3612, + "994-fs-errors.ts": 3748, + "995-fs-uncaught.ts": 3089, + "996-fs-rc-stress.ts": 3714, + "997-fs-modules/main.ts": 3327, + "998-process-env.ts": 2498, + "abstract-property-dispatch.ts": 4365, + "arguments-arrow-capture.mjs": 3544, + "arguments-reexport/main.ts": 3373, + "array-argument-lifetimes-exits.ts": 2870, + "array-argument-lifetimes-mutation.ts": 3721, + "array-argument-lifetimes-strings.ts": 3794, + "array-argument-lifetimes-values.ts": 4076, + "array-buffer-conversions.js": 3267, + "array-buffer-storage.ts": 3982, + "array-checked-callback-results.mjs": 3822, + "array-checked-constructor.js": 3361, + "array-concat-widening.ts": 3515, + "array-deque-unshift.ts": 4273, + "array-element-compound-updates.ts": 5390, + "array-fill-unit-values.ts": 3744, + "array-from-checked.js": 4644, + "array-from-value.mjs": 3261, + "array-isarray-value/main.js": 3569, + "array-numeric-own-keys.ts": 3719, + "array-optional-number-write-index.ts": 3067, + "array-primitive-ordering.ts": 4670, + "array-queue-head-room.ts": 5069, + "array-read-helper-effects.ts": 3808, + "array-refined-storage.ts": 3910, + "array-sort-dense-effects.ts": 4754, + "array-sort-dense-values.ts": 4991, + "array-sort-holes-published.ts": 12914, + "array-sort-runs.ts": 11006, + "array-sort-runtime-comparator.ts": 7044, + "array-sort-unknown-comparator.ts": 2921, + "array-storage-transitions.ts": 4555, + "array-truncate-reuse.ts": 3342, + "async-backend-factory.mjs": 3685, + "async-local-typed-results.ts": 4110, + "atomics-integer-operations.ts": 4324, + "bigint-checked-casts.ts": 3538, + "bigint-checked-storage.js": 3582, + "bigint-union-conversion.ts": 3627, + "boxed-error-rethrows.mjs": 3074, + "buffer-codec-boundaries.ts": 2997, + "buffer-primitive-predicate.ts": 3212, + "builtin-prototype-method-values.mjs": 4169, + "byte-loop-bounds.ts": 3289, + "byte-number-pipeline.ts": 3830, + "byte-record-windows.ts": 4084, + "call-lifetimes-argument-order.ts": 2814, + "call-lifetimes-control-flow.ts": 3242, + "call-lifetimes-owned-boundaries.ts": 3884, + "call-lifetimes-projections.ts": 3960, + "call-lifetimes-union-values.ts": 3288, + "call-lifetimes-virtual-optionals.ts": 4204, + "callable-module-members.mjs": 3631, + "callable-properties.mjs": 3358, + "callable-property-cycles.js": 2892, + "callable-reexport/main.ts": 3566, + "captured-class-refinement.ts": 3716, + "catch-capture.ts": 3398, + "caught-class-identity.ts": 4607, + "caught-standalone-class.ts": 3366, + "caught-system-error-fields.ts": 3842, + "checked-addition.js": 3129, + "checked-any-addition.ts": 3239, + "checked-array-assignment.ts": 3271, + "checked-array-flat/main.ts": 3753, + "checked-bitwise/main.js": 3435, + "checked-builder-cycles.js": 2781, + "checked-byte-storage/main.ts": 3695, + "checked-callback-options.ts": 3641, + "checked-class-descriptors.mjs": 4373, + "checked-class-factory.mjs": 3282, + "checked-collection-iterators.ts": 3261, + "checked-collection-symbol-methods.ts": 2592, + "checked-dispatch-input-lifetimes.js": 2966, + "checked-increment/main.js": 3466, + "checked-inherited-fields.ts": 3091, + "checked-iterator-consumption.js": 4432, + "checked-numeric-arithmetic.js": 3676, + "checked-object-module-alias.js": 3750, + "checked-optional-calls.mjs": 2819, + "checked-promise-recovery.ts": 3546, + "checked-proxy-callback/main.ts": 3548, + "checked-record-constructor.ts": 3491, + "checked-renderer-defaults.js": 2925, + "checked-rest-function-adapters.js": 3233, + "checked-storage-transitions.js": 2999, + "checked-symbol-array.ts": 3209, + "checked-value-input-lifetimes.ts": 2736, + "class-accessor-returned-function.js": 3222, + "class-array-optional-return.ts": 3320, + "class-bracket-method-calls.js": 3856, + "class-brand-overload.js": 3204, + "class-callback-replacement.js": 4854, + "class-callback-storage.ts": 4827, + "class-checked-composites.ts": 3368, + "class-checked-upcast.ts": 3815, + "class-collection-insertion.ts": 5133, + "class-computed-presence.ts": 4064, + "class-computed-symbols.js": 4475, + "class-covariant-returns.ts": 3062, + "class-curried-factory.mjs": 3903, + "class-data-descriptors.js": 4613, + "class-factory-inherited-statics.mjs": 3165, + "class-factory-parameter-base.mjs": 4404, + "class-factory-record-base.mjs": 5117, + "class-factory-recursive-statics.mjs": 3656, + "class-factory-static-members.mjs": 3238, + "class-function-base/main.js": 3349, + "class-instance-constructor.js": 4347, + "class-interface-protocols.ts": 5479, + "class-interface-refinements.ts": 4411, + "class-json-checked.ts": 3478, + "class-local-function-base.mjs": 2889, + "class-method-spreads.ts": 5065, + "class-narrowed-views.ts": 2591, + "class-property-call-values.mjs": 3049, + "class-prototype-data.js": 3914, + "class-prototype-descriptor-copy.mjs": 3673, + "class-specialized-computed-base.mjs": 4340, + "class-static-data.js": 3321, + "class-subclass-assertions.ts": 3532, + "class-super-surplus-spread.mjs": 3433, + "class-symbol-accessors.ts": 3674, + "class-symbol-cache.mjs": 4312, + "class-value-constructor-exceptions.ts": 2729, + "closed-virtual-dispatch-modules/main.ts": 3375, + "closed-virtual-dispatch.ts": 4025, + "closure-nullable-union-return.ts": 4235, + "closure-union-locals.ts": 3743, + "collection-array-cycles.ts": 3119, + "collection-array-maps.ts": 3580, + "collection-array-missing.ts": 3529, + "collection-array-sets.ts": 3755, + "collection-copy-identities.ts": 3108, + "collection-data-unions.ts": 3651, + "collection-ingestion-mappers.ts": 3521, + "collection-ingestion-protocol/main.ts": 4669, + "collection-ingestion-references.ts": 4710, + "collection-ingestion.ts": 3512, + "collection-storage-copies.ts": 3878, + "collection-value-keys.ts": 3854, + "compound-field-receivers.ts": 3456, + "compound-presence-guards.ts": 3018, + "conditional-tuple-destructuring.ts": 3519, + "console-imports.cjs": 3565, + "console-native-value.js": 2620, + "const-enum-module-cycle/main.ts": 2768, + "constant-callback-dispatch.ts": 3226, + "constant-module-globals/main.ts": 3076, + "constant-number-remainders.ts": 3457, + "constructed-class-dispatch.ts": 3935, + "contextual-array-union-write.ts": 5322, + "contextual-return-layouts.ts": 4143, + "counted-loop-numbers.ts": 3668, + "counted-loop-storage.ts": 2925, + "crypto-hash-optional-input.ts": 3821, + "cycle-generations-long-lived.ts": 2954, + "cycle-growth-yield.ts": 4304, + "date-checked-native.js": 3239, + "declared-index-spread.ts": 4205, + "deep-reference-teardown.ts": 3431, + "default-undefined-parameters.ts": 4155, + "deferred-field-updates.ts": 2817, + "deferred-registry-many.ts": 4413, + "derived-numeric-updates.ts": 3113, + "destructure-call-assignment.js": 2699, + "destructure-inferred-row-defaults.js": 3698, + "destructure-union-arrays.ts": 3868, + "dynamic-function-descriptors.js": 3825, + "error-cause-writes.js": 3664, + "error-inherited-message.mjs": 4115, + "error-inherited-name.mjs": 4088, + "error-property-writes.mjs": 3831, + "error-prototype-tostring.js": 3723, + "error-stack-frames.ts": 3316, + "error-stack-limit.ts": 3521, + "error-tostring-overrides.ts": 2788, + "error-values-inspect.ts": 2913, + "exact-index-round-trip.ts": 3953, + "expression-runtime-values.ts": 3293, + "fiber-switch-stress.ts": 4327, + "fiberless-async-ordering.ts": 4160, + "fiberless-async-unhandled.ts": 2861, + "field-assignment-values.ts": 3670, + "file-handle-values.ts": 3758, + "file-read-storage.ts": 5381, + "file-url-percent-decoding.ts": 3379, + "final-field-borrows.ts": 3428, + "for-multiple-bindings.ts": 2948, + "for-multiple-lexical-bindings.ts": 3036, + "for-of-checked-iterator.js": 3188, + "for-of-subclass-elements.ts": 3369, + "forward-generic-signatures.ts": 3512, + "fresh-array-union-layout.js": 3601, + "frozen-checked-dictionaries.mjs": 2948, + "fs-native-realpath.ts": 3654, + "fs-null-byte-paths-js.cjs": 3914, + "fs-null-byte-paths.ts": 5084, + "fs-read-encodings.ts": 3336, + "fs-read-utf8-edges.ts": 4161, + "fs-read-utf8-handle-forms.ts": 3562, + "fs-remove-readonly.ts": 3293, + "fs-write-string-bytes-union.ts": 2935, + "function-apply-value.mjs": 3607, + "function-constructor-global.mjs": 3295, + "function-constructor-kinds/main.js": 2837, + "function-custom-prototype.js": 3522, + "function-custom-to-string.mjs": 3399, + "function-object-assign.js": 3758, + "function-own-prototype/main.js": 2807, + "generator-checked-protocol.ts": 3503, + "generator-checked-return.js": 3369, + "generator-custom-delegation/main.ts": 5410, + "generator-default-return-pattern.ts": 2666, + "generator-delegation-values.ts": 3515, + "generator-inferred-date.js": 3280, + "generator-mixed-checked-channels.ts": 3467, + "generator-untyped-consumer/main.ts": 2805, + "generic-base-specializations.ts": 3523, + "generic-binding-ownership.ts": 4463, + "generic-class-js-functions/main.ts": 2699, + "generic-class-recovery.ts": 4031, + "generic-namespace-factories/main.ts": 3082, + "generic-nullable-collections.ts": 3376, + "generic-pattern-bindings.ts": 3388, + "generic-record-index.ts": 3789, + "generic-visitor-void.ts": 3751, + "global-accumulator-loops.ts": 3531, + "global-error-subclasses.ts": 2383, + "global-runtime-probes.js": 3149, + "global-stored-probes.js": 3656, + "global-string-cache/main.js": 2944, + "global-symbol-cache/main.js": 3152, + "guarded-native-iterables.ts": 3442, + "heap-input-aliases.ts": 3338, + "heap-input-collections.ts": 3866, + "in-array-runtime-index.ts": 4870, + "indexed-assignment-values.js": 3555, + "indexed-assignment-values.ts": 3263, + "indexed-element-field-reads.ts": 3648, + "inferred-array-assignment-values.mjs": 2599, + "inferred-class-default.mjs": 2738, + "inferred-compound-values.mjs": 3388, + "inferred-conditional-class.mjs": 2376, + "inferred-error-fields.js": 2452, + "inferred-map-patterns.mjs": 3504, + "inferred-method-override.js": 2889, + "inferred-partial-destructuring.mjs": 3489, + "inferred-primitive-properties.mjs": 2842, + "inferred-record-return.mjs": 3292, + "inferred-recursive-record.mjs": 3932, + "inferred-undefined-field.mjs": 2401, + "input-lifetime-intervals.ts": 3651, + "input-lifetimes-modules/main.ts": 3648, + "instanceof-class-record-union.ts": 3935, + "integer-flow-arithmetic.ts": 3336, + "integer-loop-forms.ts": 3549, + "integer-view-control.ts": 2594, + "integer-view-numbers.ts": 3585, + "integer-view-storage.ts": 3667, + "intl-grapheme-conformance/main.ts": 4680, + "intl-grapheme.ts": 4135, + "iterator-typed-returns.ts": 4766, + "js-abort-portable.js": 3961, + "js-array-constructor.js": 3335, + "js-array-default-buffer.js": 2734, + "js-array-iterators.js": 3671, + "js-arrow-bind.cjs": 5214, + "js-buffer-callback-brand.cjs": 4283, + "js-callable-proxy.js": 3329, + "js-chained-native-results.mjs": 3307, + "js-checked-array-iterator.js": 3738, + "js-checked-array-reference.js": 3849, + "js-checked-number-negation.mjs": 3465, + "js-checked-sort-result.js": 2437, + "js-child-error-listener.cjs": 2606, + "js-cjs-callable-snapshots/main.cjs": 3122, + "js-class-added-parameters.js": 3654, + "js-class-checked-overrides.js": 3726, + "js-class-computed-fields.js": 3260, + "js-class-enumeration.js": 4284, + "js-class-field-accessor-override.js": 3902, + "js-class-fluent-overrides.js": 3667, + "js-class-late-method-values.js": 3068, + "js-class-member-dispatch.js": 4117, + "js-class-return-shapes.js": 3935, + "js-class-shadowed-methods.js": 4040, + "js-class-stored-method-receiver.js": 2904, + "js-class-subclass-properties.js": 5036, + "js-class-symbol-spread.cjs": 3637, + "js-computed-prototype-additions.js": 2620, + "js-constructor-returned-callable.js": 2532, + "js-constructor-spread.js": 3024, + "js-dataview-dispatch.js": 3608, + "js-declared-fields.cjs": 5015, + "js-default-listener-arguments.cjs": 2326, + "js-default-options/main.ts": 3910, + "js-deferred-field-initializers.js": 2418, + "js-deferred-registry-effects.js": 3462, + "js-derived-constructor-hoisting.js": 2798, + "js-dormant-array-write.js": 3572, + "js-dormant-overrides.js": 2747, + "js-expando-records.js": 3967, + "js-implicit-call-results.js": 2920, + "js-inferred-callback-exports/main.js": 4360, + "js-inferred-class-array-return.js": 3664, + "js-inferred-object-values.js": 3561, + "js-inherited-field-storage.js": 2906, + "js-inherited-parameter-abi.js": 2442, + "js-iterable-spread.js": 2766, + "js-loose-dynamic-primitives.js": 3050, + "js-map-object-seeds.js": 3816, + "js-member-increment.js": 4372, + "js-module-function-values.js": 3724, + "js-mutable-null-members.js": 3894, + "js-nested-native-descriptors.js": 3332, + "js-normalize-dispatch.js": 3662, + "js-nullish-inherited-fields.mjs": 3226, + "js-object-receiver-storage.js": 3635, + "js-object-returning-constructors.mjs": 3324, + "js-object-shared-arrays.js": 3926, + "js-omitted-typed-arguments.js": 3274, + "js-open-binding-writes.js": 3161, + "js-optional-class-fields.js": 3414, + "js-optional-member-call.js": 3623, + "js-primitive-union-addition.js": 3186, + "js-promise-all-values.js": 3364, + "js-promise-catch-handler.js": 2469, + "js-promise-finally-order.js": 3631, + "js-promise-pending-reactions.js": 3621, + "js-prototype-host-boundary.js": 40863, + "js-reflect-receivers.js": 3717, + "js-regex-record-captures.js": 4129, + "js-scalar-iterables.js": 3831, + "js-shared-method-dispatch.js": 3185, + "js-specialized-field-method.js": 2772, + "js-static-accessors.js": 3403, + "js-static-method-values.js": 3866, + "js-static-registries.cjs": 3795, + "js-super-accessor-initialization.js": 3887, + "js-uninitialized-native-fields.js": 3361, + "json-guarded-map-values.ts": 3542, + "json-output-bulk.ts": 3334, + "json-runtime-options.mjs": 2995, + "json-stringify-value.js": 3147, + "json-typed-parse-direct.ts": 3768, + "json-typed-parse-index-signatures.ts": 3707, + "json-typed-parse-optional-members.ts": 4645, + "json-typed-parse-union-members.ts": 2884, + "literal-switch-dispatch.ts": 3317, + "live-reference-shared-converters.ts": 9504, + "llvm-read-receiver-lifetime.ts": 4439, + "local-class-call-spreads.js": 3630, + "local-class-declaration.ts": 3068, + "local-class-evaluation.ts": 3450, + "local-class-inheritance.ts": 3339, + "local-class-lifetimes.ts": 3623, + "local-class-namespace/main.js": 3916, + "local-class-prototype-data.js": 3797, + "local-class-specialization.js": 3033, + "local-class-unknown.ts": 2900, + "local-class-values.ts": 2584, + "local-union-storage.ts": 3820, + "locale-compare-root-order.ts": 3234, + "logical-assignment-dynamic.js": 3066, + "logical-assignment-values.ts": 3751, + "logical-runtime-optional-record.ts": 3473, + "loop-reference-lifetimes.ts": 2819, + "map-checked-boundary/main.ts": 3663, + "map-checked-seed.js": 3370, + "map-get-set-fusion.ts": 3638, + "map-number-keys-dense.ts": 4412, + "map-read-lifetimes-exits.ts": 2579, + "map-read-lifetimes.ts": 3849, + "map-seeds-and-spreads.ts": 3171, + "map-typed-array-values.ts": 3666, + "math-function-values.js": 2486, + "missing-read-lambda-results.ts": 3345, + "missing-read-narrowed-storage.ts": 3729, + "missing-read-number-conversions.ts": 3696, + "module-byte-loops.ts": 3029, + "module-fallback-functions/main.js": 3321, + "narrowed-nullish-values.ts": 3184, + "native-any-timer-callback.ts": 2884, + "native-array-borrowed-find-last.js": 3352, + "native-array-borrowed-slice.js": 3286, + "native-array-copying-methods.js": 2464, + "native-array-fill-copywithin.js": 2771, + "native-array-frozen-noops.js": 3256, + "native-array-index-boundaries.js": 2917, + "native-array-integrity.js": 2583, + "native-array-length.js": 2372, + "native-array-named-properties.js": 3684, + "native-array-prototype/main.js": 3743, + "native-array-read-lifetimes.ts": 3932, + "native-array-reduce-find-last.js": 2450, + "native-array-search-from-index.js": 2847, + "native-array-splice-coercion.js": 3405, + "native-array-splice-flat.js": 3104, + "native-buffer-coercion.js": 3322, + "native-callback-dispatch.ts": 3832, + "native-class-array-boundaries.ts": 3342, + "native-class-cache.js": 3840, + "native-class-properties.cjs": 5572, + "native-class-property-cycles.cjs": 3155, + "native-class-property-order.cjs": 3170, + "native-class-type-predicates.ts": 3052, + "native-factory-records.js": 3387, + "native-method-values.js": 4924, + "native-method-values.ts": 3868, + "native-npm-imports/main.ts": 3901, + "native-object-descriptors.js": 3247, + "native-object-for-in-minimal.js": 3446, + "native-object-property-attributes.js": 3224, + "native-object-prototype.js": 2952, + "native-property-names.ts": 2920, + "native-proxy-env.js": 4531, + "native-worker-arena-reuse.ts": 9740, + "native-worker-bounded-errors.ts": 3428, + "native-worker-buffer-consumers.ts": 4341, + "native-worker-cancel-hot.ts": 3046, + "native-worker-class-fields.ts": 3987, + "native-worker-clone-errors.ts": 3205, + "native-worker-commonjs.cjs": 3563, + "native-worker-delayed-messages.ts": 3820, + "native-worker-discarded-heaps.ts": 9491, + "native-worker-environment.ts": 3678, + "native-worker-error.ts": 3443, + "native-worker-exception-state.ts": 3795, + "native-worker-exit-listeners.ts": 3786, + "native-worker-io.ts": 3497, + "native-worker-loop-cancellation.ts": 3485, + "native-worker-message-graphs.ts": 3324, + "native-worker-messages.ts": 3248, + "native-worker-poll-exceptions.ts": 3463, + "native-worker-port-lifetime.ts": 3679, + "native-worker-process-exit.ts": 25459, + "native-worker-publish-classes.ts": 39360, + "native-worker-publish-refusals.ts": 3725, + "native-worker-published-graphs.ts": 3934, + "native-worker-references.ts": 4072, + "native-worker-roots/main.ts": 3317, + "native-worker-shared-views.ts": 34203, + "native-worker-stack-overflow.ts": 3534, + "native-worker-terminate-exception-state.ts": 4664, + "native-worker-terminate-loop.ts": 3303, + "native-worker-terminate-recursion.ts": 4325, + "native-worker-terminate-suspended.ts": 3580, + "native-worker-terminate-tested-loops.ts": 3001, + "native-worker-terminate-wait.ts": 3399, + "native-worker-typed-arrays.ts": 3056, + "nested-map-cycles.ts": 2892, + "nested-map-values.ts": 4020, + "never-returning-calls.ts": 3353, + "next-tick-commonjs-entry.cjs": 3537, + "node24-buffer-encoding-errors.ts": 3190, + "node24-buffer-encoding.ts": 3056, + "node24-crypto-kdf-errors.ts": 3983, + "node24-crypto-kdf-options.ts": 3444, + "node24-crypto-kdf.ts": 3815, + "node24-crypto-sha2.ts": 3261, + "node24-deep-equality-properties.js": 3213, + "node24-deep-equality.cjs": 4348, + "node24-deep-equality.ts": 4931, + "node24-env-files-errors.ts": 3190, + "node24-env-files.ts": 3237, + "node24-env-imports.cjs": 2806, + "node24-env-parse-errors.ts": 3175, + "node24-env-parse.ts": 2442, + "node24-esm-metadata/main.mjs": 3178, + "node24-file-url-buffer.ts": 2578, + "node24-file-url-errors.js": 3662, + "node24-file-url-options.ts": 3335, + "node24-fs-links-callbacks.cjs": 2914, + "node24-fs-links-errors.cjs": 2718, + "node24-fs-links-options.cjs": 5212, + "node24-fs-links-promise-errors.cjs": 3623, + "node24-fs-links-promises.ts": 3653, + "node24-fs-links.ts": 2754, + "node24-fs-statfs-callbacks.cjs": 3304, + "node24-fs-statfs-errors.cjs": 3642, + "node24-fs-statfs-options.cjs": 3933, + "node24-fs-statfs.ts": 3769, + "node24-fs-timestamps-callbacks.cjs": 3563, + "node24-fs-timestamps-errors.cjs": 3595, + "node24-fs-timestamps-promises.ts": 4047, + "node24-fs-timestamps-symlinks.ts": 2514, + "node24-fs-timestamps.ts": 3364, + "node24-no-error-assertions-coercion.js": 3593, + "node24-no-error-assertions.cjs": 2425, + "node24-no-error-assertions.ts": 4527, + "node24-parseargs.js": 5067, + "node24-string-decoder.ts": 2945, + "node24-style-text-environment.js": 3145, + "node24-style-text-validation.js": 4525, + "node24-style-text.cjs": 3538, + "node24-style-text.ts": 3894, + "node24-system-error-validation.js": 3199, + "node24-system-errors.cjs": 2805, + "node24-system-errors.ts": 3782, + "node24-text-codec-properties.ts": 3181, + "node24-text-encode-into.ts": 2752, + "node24-text-utilities-coercion.js": 2713, + "node24-text-utilities-validation.js": 3711, + "node24-text-utilities.cjs": 3142, + "node24-text-utilities.ts": 3686, + "node24-url-authority-coercion.js": 3699, + "node24-url-authority.ts": 3174, + "node24-url-factories.ts": 3606, + "node24-url-factory-errors.ts": 3314, + "node24-url-mutation-coercion.js": 3050, + "node24-url-mutation.ts": 2529, + "node24-util-types.cjs": 2859, + "node24-util-types.js": 3337, + "node24-util-types.ts": 3883, + "non-null-class-iteration.ts": 3145, + "nonnull-element-arguments.ts": 2747, + "nonnull-forwarded-class-values.ts": 3637, + "nullable-object-extension.mjs": 3028, + "nullish-asserted-class-arms.ts": 2996, + "nullish-assignment-values.ts": 3685, + "nullish-long-chain.ts": 4539, + "number-parse-statics.ts": 2378, + "number-predicates-unknown.ts": 3263, + "numeric-call-specialization.ts": 3397, + "object-enumeration-array-reads.ts": 3721, + "object-from-checked-entries.js": 4400, + "object-inherited-to-string.js": 3338, + "object-key-indexes.js": 4004, + "object-prototype-identity.mjs": 3277, + "object-reexport/main.js": 3532, + "object-spread-computed.ts": 3618, + "opentui-byte-queue.js": 2761, + "optional-callback-arity.ts": 2368, + "optional-class-flows.ts": 2553, + "optional-element-defaults.ts": 3275, + "optional-flag-comparisons.ts": 3105, + "optional-native-callables.js": 3200, + "optional-node-list-iteration.ts": 3422, + "optional-string-index/main.ts": 2937, + "path-to-file-url-options.ts": 3680, + "performance-presence.ts": 3328, + "primitive-and-function-descriptors.js": 3559, + "primitive-union-string.ts": 3162, + "process-builtin-values.js": 4636, + "process-constrained-memory.ts": 2246, + "process-env-computed-keys.js": 3276, + "process-hrtime.js": 3203, + "process-named-signals.cjs": 3440, + "process-uncaught-handler-throws.cjs": 2812, + "process-uncaught-loop.cjs": 2427, + "process-uncaught-module.mjs": 2982, + "process-uncaught-monitor.cjs": 3049, + "process-uncaught-rejection.cjs": 2978, + "process-uncaught-sync.cjs": 2919, + "process-version-pin.ts": 3275, + "process-versions-storage.ts": 3558, + "projected-collection-lifetimes.ts": 3501, + "promise-checked-rejections.ts": 2387, + "promise-resolve-void.ts": 2676, + "prototype-method-overrides.mjs": 7058, + "prototype-named-data-records.ts": 3518, + "rc-last-use-moves.ts": 4127, + "rc-private-array-writes.ts": 4075, + "record-field-presence.ts": 4445, + "record-key-order.ts": 2786, + "record-optional-json-presence.ts": 3499, + "record-presence-copies.ts": 4175, + "record-presence-delete-json.ts": 2958, + "record-unchecked-read-presence.ts": 3597, + "record-unknown-values.ts": 4381, + "reflect-own-keys.mjs": 2660, + "reflect-record-union-keys.mjs": 2359, + "reflect-typed-record-keys.ts": 2855, + "regex-callback-replacements.ts": 3541, + "regex-callback-values.js": 3624, + "regex-checked-casts.ts": 3867, + "regex-checked-storage.js": 3704, + "regex-exec-long-subject.ts": 8130, + "regex-exec-result-arrays.ts": 4036, + "regex-fs-text-surfaces.ts": 4013, + "regex-input-lifetimes.ts": 2860, + "regex-native-matcher.ts": 4866, + "regex-optional-captures.ts": 3208, + "regex-optional-templates.ts": 3554, + "regex-split-captures.ts": 3707, + "regex-text-paths.ts": 2943, + "regexp-constructor-repeat.ts": 3471, + "regexp-optional-constructor.ts": 3547, + "regexp-string-coercion.js": 2902, + "renderer-export-dictionaries.js": 2853, + "renderer-null-state.js": 3392, + "renderer-specializations.js": 3361, + "repeat-and-typed-read-errors.ts": 3813, + "rest-optional-array-arguments.ts": 4116, + "rest-optional-elements.ts": 3072, + "return-void-through-finally.ts": 2672, + "runtime-optional-string-flows.ts": 3420, + "scalar-string-slices.ts": 3228, + "set-checked-methods.js": 3654, + "set-checked-storage.ts": 3542, + "set-iterator-seed-references.ts": 3832, + "set-iterator-seeds.ts": 3864, + "set-optional-seeds.ts": 3189, + "small-collection-transitions.ts": 3703, + "speculative-integer-globals.ts": 2999, + "speculative-integer-loops.ts": 4097, + "speculative-integer-reads.ts": 3960, + "stack-depth-async-bodies.ts": 3593, + "stack-overflow-async.ts": 3327, + "stack-overflow-caught.ts": 3619, + "stack-overflow-finally.ts": 4048, + "stack-overflow-shapes.ts": 4840, + "stack-overflow-uncaught.ts": 3019, + "stackless-async-concurrency.ts": 5553, + "stackless-async-context.ts": 3712, + "stackless-async-exceptions.ts": 4059, + "stackless-async-ordering.ts": 4230, + "stackless-async-unhandled.ts": 3409, + "static-field-updates/main.ts": 3160, + "static-method-receivers.ts": 3269, + "stdio-values.mjs": 3241, + "stdio-write-errors.mjs": 3357, + "stdio-write-overrides.mjs": 3279, + "stored-native-builtins.js": 3593, + "stored-object-helpers.js": 3366, + "stream-dynamic-entry-kinds.cjs": 8165, + "stream-dynamic-entry-kinds.ts": 2619, + "stream-encoded-from-entries.cjs": 4394, + "stream-encoded-from-entries.ts": 4716, + "string-char-code-integer-loops.ts": 3604, + "string-code-points.ts": 2747, + "string-concat-number-parts.ts": 3145, + "string-construction-order.ts": 3430, + "string-field-append.ts": 3228, + "string-lifetimes-boundaries.ts": 3759, + "string-lifetimes-evaluation.ts": 3595, + "string-lifetimes-iteration.ts": 2950, + "string-lifetimes-operations.ts": 3231, + "string-normalize.ts": 3407, + "string-pattern-replacement.ts": 3745, + "string-scan-fast-paths.ts": 3455, + "string-split-checked-separator.mjs": 3539, + "string-split-traversal.ts": 4073, + "structural-class-properties.ts": 3685, + "structured-text-boundaries.js": 4089, + "structured-text-storage.ts": 3938, + "switch-integer-dispatch.ts": 3542, + "symbol-checked-boundary/main.ts": 3823, + "symbol-class-fields.ts": 3105, + "symbol-class-fields/main.cjs": 3306, + "symbol-class-methods/main.ts": 3168, + "symbol-fields-deferred-factory.ts": 2465, + "symbol-fields-inferred.js": 2781, + "symbol-object-properties/main.js": 2729, + "synchronous-callback-lifetimes.ts": 3805, + "terminal-stream-properties.ts": 2859, + "text-codec-values/main.ts": 24961, + "text-codec-var.ts": 35233, + "text-encode-into-boundaries.ts": 2835, + "timers-clear-many.ts": 3438, + "tuple-and-string-search.ts": 3771, + "tuple-array-union.ts": 3450, + "tuple-callback-visitation.ts": 3975, + "tuple-forof-visitation.ts": 3491, + "typed-array-bulk-conversion.mjs": 5922, + "typed-array-byte-io.js": 9466, + "typed-array-checked-index.js": 3008, + "typed-array-constructor-alias.ts": 3321, + "typed-array-constructor-identity.js": 3143, + "typed-array-constructor-union.ts": 2529, + "typed-array-constructor-values.mjs": 3170, + "typed-array-dynamic-methods.js": 4053, + "typed-array-integer-widths.ts": 3519, + "typed-array-nan-coded-reads.ts": 3945, + "typed-array-numeric-import.ts": 4121, + "typed-array-present-reads.ts": 3332, + "typed-array-reversed-storage.ts": 2465, + "typed-array-unknown.ts": 3664, + "typed-collection-iterator-references.ts": 4059, + "typed-collection-iterators.ts": 4014, + "typed-collection-views/main.ts": 2915, + "typed-index-arguments.ts": 3055, + "typed-prototype-methods.ts": 3929, + "typed-rest-callables.ts": 2298, + "typed-rest-filtered-return.ts": 3531, + "typedarray-native-inputs.js": 3581, + "typeof-checked-comparison.js": 2656, + "uint8array-sort-domains.ts": 3223, + "unicode-case-paths.ts": 2409, + "unicode-process-argv.ts": 3053, + "union-discriminant-width.ts": 4248, + "union-literal-scalar-discriminants.ts": 4306, + "union-literal-slot-conversion.ts": 3424, + "union-nested-layout-discriminant.ts": 3343, + "union-optional-semantic-identity.ts": 4104, + "union-record-clone.ts": 3572, + "union-record-structural-copy.ts": 2990, + "union-reference-comparison.ts": 4026, + "unknown-array-holes.ts": 3098, + "unknown-collections.ts": 4172, + "unknown-object-enumeration.ts": 5046, + "unknown-record-views.ts": 2982, + "url-runtime-base.ts": 2879, + "utf8-span-decoding.ts": 37919, + "util-parseargs-wrapped/main.ts": 4014, + "virtual-runtime-optional-returns.ts": 4644, + "weak-map-array-buffer.ts": 3584, + "weak-map-fresh-array.js": 2803, + "weak-map-native.js": 3743, + "weak-native-class-identity.ts": 3008, + "weak-set-native.js": 2800, + "worker-class-instance-clone.ts": 39705 } } From 29c8ad237cdf3c0b70299497b7e76233755ccc83 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 11:36:13 -0500 Subject: [PATCH 7/7] Throw when nm cannot list an executable's symbols in the zero-cost gate The gate read an empty symbol list when nm could not start, was killed by a signal, or exited with a non-zero status, so the dynamic-tier symbol check and the executable comparison passed without any symbols. nmOutput now throws with the binary, the reason and nm's stderr. --- scripts/zero-cost-compare.mjs | 15 +++++++++++++++ scripts/zero-cost-gate.mjs | 3 ++- tests/harness/zero-cost-gate.test.ts | 15 +++++++++++++++ 3 files changed, 32 insertions(+), 1 deletion(-) diff --git a/scripts/zero-cost-compare.mjs b/scripts/zero-cost-compare.mjs index 5367c2957..a89fe4650 100644 --- a/scripts/zero-cost-compare.mjs +++ b/scripts/zero-cost-compare.mjs @@ -232,6 +232,21 @@ export function compareArtifact(kind, baseline, candidate) { /* ── executables ───────────────────────────────────────────────────────── */ +/** The output of `nm` for `binary`, from its spawnSync result. Throws when + * nm could not start, was killed by a signal, or exited with a non-zero + * status, because the symbol checks would otherwise read an empty list. */ +export function nmOutput(binary, result) { + if (result.error) throw new Error(`nm ${binary}: ${result.error.message}`); + if (result.signal) throw new Error(`nm ${binary}: killed by ${result.signal}`); + if (result.status !== 0) { + const detail = typeof result.stderr === "string" ? result.stderr.trim() : ""; + throw new Error( + `nm ${binary}: exited with status ${result.status}${detail ? `: ${detail}` : ""}`, + ); + } + return result.stdout; +} + /** Defined symbols from `nm -S` output (GNU/LLVM nm, address size type * name) or `nm` output without sizes (Apple, address type name). */ export function parseNm(text) { diff --git a/scripts/zero-cost-gate.mjs b/scripts/zero-cost-gate.mjs index db98bf249..f4272ac6a 100644 --- a/scripts/zero-cost-gate.mjs +++ b/scripts/zero-cost-gate.mjs @@ -34,6 +34,7 @@ import { compareExecutables, dynamicTierSymbols, median, + nmOutput, parseNm, programVerdict, timeRatio, @@ -300,7 +301,7 @@ function nm(binary) { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, }); - const text = result.status === 0 ? result.stdout : ""; + const text = nmOutput(binary, result); nmCache.set(binary, text); return text; } diff --git a/tests/harness/zero-cost-gate.test.ts b/tests/harness/zero-cost-gate.test.ts index c75a115c8..0b08da748 100644 --- a/tests/harness/zero-cost-gate.test.ts +++ b/tests/harness/zero-cost-gate.test.ts @@ -1,3 +1,4 @@ +import { spawnSync } from "node:child_process"; import { expect, test } from "vitest"; import { cachegrindCounts, @@ -5,6 +6,7 @@ import { compareCounts, compareExecutables, dynamicTierSymbols, + nmOutput, programVerdict, } from "../../scripts/zero-cost-compare.mjs"; @@ -112,6 +114,19 @@ test("the zero-cost gate compares executables and instruction counts per functio }); }); +test("the zero-cost gate throws when nm does not list a binary's symbols", () => { + const ok = { status: 0, signal: null, stdout: "0000000000001000 T main\n", stderr: "" }; + expect(nmOutput("prog", ok)).toBe(ok.stdout); + const missing = spawnSync("scriptc-missing-nm", ["prog"], { encoding: "utf8" }); + expect(() => nmOutput("prog", missing)).toThrow(/^nm prog: .*ENOENT/); + expect(() => + nmOutput("prog", { status: null, signal: "SIGKILL", stdout: "", stderr: "" }), + ).toThrow("nm prog: killed by SIGKILL"); + expect(() => + nmOutput("prog", { status: 1, signal: null, stdout: "", stderr: "nm: prog: no symbols\n" }), + ).toThrow("nm prog: exited with status 1: nm: prog: no symbols"); +}); + test("the zero-cost gate recognizes dynamic-tier runtime symbols", () => { expect( dynamicTierSymbols([