From 06b0bb293155e30a42f0f2821c40ad6644dce386 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 12:13:11 -0700 Subject: [PATCH 01/47] Write borrowed string slices into stack buffers A slice read only by lending consumers (string equality and ordering, length/charCodeAt/indexOf/includes/startsWith/endsWith, Number/unary plus/parseInt/parseFloat, typed string-keyed Map/Set get/has/set/add/ delete keys, string switch discriminants, and string parameters their callee only lends) is written by scr_str_slice_scratch into a per-site stack buffer as an immortal ASCII ScrStr marked as scratch (cap < len), instead of a heap allocation. Stable locals initialized by such a slice qualify when every read lends. Map/Set insertion stores a heap copy of a scratch key, and probes cache the key hash in the scratch header, so the counting idiom allocates only for new keys. Longer, non-ASCII, and interned results keep the owned slice; coroutines and debug builds are unchanged. Slice bounds are normalized without a libm trunc call. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/src/backend/llvm/emitter.ts | 18 ++ .../src/backend/llvm/expr-containers.ts | 4 +- .../src/backend/llvm/string-slices.test.ts | 151 ++++++++++- .../src/backend/llvm/string-slices.ts | 244 +++++++++++++++++- .../corpus/scratch-string-slices.ts.json | 6 + packages/runtime/src/scr_map.c | 9 +- packages/runtime/src/scr_string.c | 84 +++++- packages/runtime/src/scr_string.h | 8 + packages/runtime/src/scr_string_methods.h | 10 + packages/runtime/test/test_map.c | 31 +++ packages/runtime/test/test_string.c | 32 +++ tests/corpus/scratch-string-slices.ts | 116 +++++++++ 12 files changed, 697 insertions(+), 16 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/scratch-string-slices.ts.json create mode 100644 tests/corpus/scratch-string-slices.ts diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 09bf4979c..de661be9e 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -219,7 +219,10 @@ import { findAppendedArrayLiterals } from "./appended-array-literals.js"; import { AmbientReceiverReaders, findConstantCallbacks } from "./constant-callbacks.js"; import { findScalarStringSlices, + findScratchStringSlices, + findLentStringParameters, emitStringSliceSnapshot, + type LentStringParameters, type StringSliceSnapshot, } from "./string-slices.js"; import { LazyCaptures } from "./lazy-captures.js"; @@ -569,6 +572,10 @@ export class LlEmitter { private loopArrayBorrows: ReadonlySet = new Set(); private scalarStringSlices = new Map(); readonly stringSlices = new Map(); + /** Slices written into stack buffers (findScratchStringSlices). */ + scratchStringSlices: ReadonlySet = new Set(); + /** String parameters a caller may lend scratch slices to. */ + private lentStringParameters: LentStringParameters = new Map(); private localStackUnions = new Map(); private localStackObjects = new Map(); private reassignedStackObjects = new Set(); @@ -1245,6 +1252,8 @@ export class LlEmitter { return shape !== undefined && !recordDynKeepsIdentity(shape); }, ); + this.lentStringParameters = + this.debug === null ? findLentStringParameters(this.fnByName, this.callLifetimes) : new Map(); this.constantCallbacks = findConstantCallbacks(mod, this.callLifetimes); // Integer clones signal a stack overflow through their result, which // needs the single-threaded guard; worker programs also poll for @@ -6373,6 +6382,15 @@ export class LlEmitter { ); this.scalarStringSlices = this.debug === null ? findScalarStringSlices(fn, this.callLifetimes) : new Map(); + this.scratchStringSlices = + this.debug === null + ? findScratchStringSlices( + fn, + this.callLifetimes, + this.scalarStringSlices, + this.lentStringParameters, + ) + : new Set(); this.mapReadLifetimes = findMapReadLifetimes(fn, this.boxedUnionsById, this.callLifetimes); this.readNumberMapWrites = findReadNumberMapWrites(fn); this.mapEntryFusion = this.debug === null ? findMapEntryFusions(fn) : null; diff --git a/packages/compiler/src/backend/llvm/expr-containers.ts b/packages/compiler/src/backend/llvm/expr-containers.ts index a2d5fd35a..d5d192e89 100644 --- a/packages/compiler/src/backend/llvm/expr-containers.ts +++ b/packages/compiler/src/backend/llvm/expr-containers.ts @@ -42,7 +42,7 @@ import { } from "./map-number-lookup.js"; import { emitBorrowedInput } from "./borrowed-inputs.js"; import { emitFusedMapSet, rememberMapEntry } from "./map-entry-fusion.js"; -import { emitStringSliceRead } from "./string-slices.js"; +import { emitScratchStringSlice, emitStringSliceRead } from "./string-slices.js"; import { STRING_CHAR_CODE_AT_DECL, STRING_CHAR_CODE_AT_INT_MARKER, @@ -391,6 +391,7 @@ export function emitStrIntrinsic( false, ); case "slice": + if (host.scratchStringSlices.has(e)) return emitScratchStringSlice(host, e, r, args); return call( "scr_str_slice", "ptr (ptr, double, double)", @@ -399,6 +400,7 @@ export function emitStrIntrinsic( true, ); case "substring": + if (host.scratchStringSlices.has(e)) return emitScratchStringSlice(host, e, r, args); return call( "scr_str_substring", "ptr (ptr, double, double)", diff --git a/packages/compiler/src/backend/llvm/string-slices.test.ts b/packages/compiler/src/backend/llvm/string-slices.test.ts index 53cca6417..b2656e560 100644 --- a/packages/compiler/src/backend/llvm/string-slices.test.ts +++ b/packages/compiler/src/backend/llvm/string-slices.test.ts @@ -1,7 +1,11 @@ import { expect, test } from "vitest"; -import { F64, STRING, VOID, type IrExpr, type IrFunction, type IrStmt } from "../../ir/ir.js"; +import { BOOL, F64, STRING, VOID, type IrExpr, type IrFunction, type IrStmt } from "../../ir/ir.js"; import { analyzeCallLifetimes } from "./call-lifetimes.js"; -import { findScalarStringSlices } from "./string-slices.js"; +import { + findLentStringParameters, + findScalarStringSlices, + findScratchStringSlices, +} from "./string-slices.js"; const loc = { file: "slices.ts", start: 0, end: 0 }; const ref = (id: string): IrExpr => ({ kind: "varRef", localId: id, type: STRING, loc }); function fixture(): IrFunction { @@ -95,3 +99,146 @@ test.each(["escape", "capture", "write", "other-consumer", "suspend"])( expect(facts(fn).size).toBe(0); }, ); + +const slice = (receiver: string, start: number, end: number): IrExpr => ({ + kind: "strIntrinsic", + method: "slice", + receiver: ref(receiver), + args: [ + { kind: "numLit", value: start, type: F64, loc }, + { kind: "numLit", value: end, type: F64, loc }, + ], + type: STRING, + loc, +}); +const equals = (left: IrExpr): IrExpr => ({ + kind: "strEq", + negated: false, + left, + right: { kind: "strLit", value: "GET", type: STRING, loc }, + type: BOOL, + loc, +}); +const parse = (value: IrExpr): IrExpr => ({ + kind: "libCall", + fn: "num.fromString", + args: [value], + type: F64, + loc, +}); +function lending(body: IrStmt[]): IrFunction { + return { + name: "scan", + params: [{ localId: "source", name: "source", type: STRING }], + locals: [ + { id: "source", name: "source", type: STRING, mutable: false }, + { id: "word", name: "word", type: STRING, mutable: false }, + ], + returnType: VOID, + loc, + body, + }; +} +function scratch(fn: IrFunction, extra: IrFunction[] = []): Set { + const functions = new Map([fn, ...extra].map((f) => [f.name, f])); + const lifetimes = analyzeCallLifetimes(functions); + return findScratchStringSlices( + fn, + lifetimes, + findScalarStringSlices(fn, lifetimes), + findLentStringParameters(functions, lifetimes), + ); +} +test("slices read only by lending consumers use a stack buffer", () => { + const inline = slice("source", 0, 3); + const parsed = slice("source", 4, 6); + const init = slice("source", 1, 5); + const fn = lending([ + { kind: "exprStmt", expr: equals(inline), loc }, + { kind: "exprStmt", expr: parse(parsed), loc }, + { kind: "varDecl", localId: "word", init, loc }, + { kind: "exprStmt", expr: equals(ref("word")), loc }, + { kind: "exprStmt", expr: parse(ref("word")), loc }, + ]); + expect(scratch(fn)).toEqual(new Set([inline, parsed, init])); +}); +test.each(["return", "concat", "slice-of-slice", "capture", "async"])( + "a slice local that may be kept (%s) stays owned", + (reason) => { + const init = slice("source", 1, 5); + const fn = lending([ + { kind: "varDecl", localId: "word", init, loc }, + { kind: "exprStmt", expr: equals(ref("word")), loc }, + ]); + if (reason === "return") fn.body.push({ kind: "return", value: ref("word"), loc }); + if (reason === "concat") + fn.body.push({ + kind: "exprStmt", + expr: { + kind: "strConcat", + left: { kind: "strLit", value: "", type: STRING, loc }, + right: ref("word"), + type: STRING, + loc, + }, + loc, + }); + if (reason === "slice-of-slice") + fn.body.push({ kind: "exprStmt", expr: equals(slice("word", 0, 2)), loc }); + if (reason === "capture") fn.locals[1]!.boxed = true; + if (reason === "async") fn.async = true; + expect(scratch(fn).has(init)).toBe(false); + }, +); +function helper(name: string, body: IrStmt[]): IrFunction { + return { + name, + params: [{ localId: "text", name: "text", type: STRING }], + locals: [{ id: "text", name: "text", type: STRING, mutable: false }], + returnType: BOOL, + loc, + body, + }; +} +const callOf = (callee: string, arg: IrExpr): IrExpr => ({ + kind: "call", + callee, + args: [arg], + type: BOOL, + loc, +}); +test("helper parameters read only by lending consumers accept stack slices", () => { + const recursive = helper("isGet", [ + { + kind: "return", + value: { + kind: "logical", + op: "||", + left: equals(ref("text")), + right: callOf("isGet", ref("text")), + type: BOOL, + loc, + }, + loc, + }, + ]); + const keeps = helper("keeps", [{ kind: "return", value: callOf("stores", ref("text")), loc }]); + const stores = helper("stores", [ + { + kind: "exprStmt", + expr: { kind: "arrayLit", elems: [ref("text")], type: { kind: "array", elem: STRING }, loc }, + loc, + }, + { kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc }, + ]); + const lent = slice("source", 0, 3); + const kept = slice("source", 0, 4); + const fn = lending([ + { kind: "exprStmt", expr: callOf("isGet", lent), loc }, + { kind: "exprStmt", expr: callOf("keeps", kept), loc }, + ]); + const functions = [recursive, keeps, stores]; + expect(scratch(fn, functions)).toEqual(new Set([lent])); + const all = new Map([fn, ...functions].map((f) => [f.name, f])); + expect([...findLentStringParameters(all, analyzeCallLifetimes(all)).keys()]).toEqual(["isGet"]); +}); diff --git a/packages/compiler/src/backend/llvm/string-slices.ts b/packages/compiler/src/backend/llvm/string-slices.ts index 71a26e2f3..ae73f1ea1 100644 --- a/packages/compiler/src/backend/llvm/string-slices.ts +++ b/packages/compiler/src/backend/llvm/string-slices.ts @@ -1,4 +1,9 @@ -import { type IrExpr, type IrFunction, type IrStmt } from "../../ir/ir.js"; +import { + type IrExpr, + type IrFunction, + type IrStmt, + type IrStrIntrinsicMethod, +} from "../../ir/ir.js"; import { everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js"; import { F64_INF, f64Lit, sizeToDouble } from "./common.js"; import type { CallLifetimes } from "./call-lifetimes.js"; @@ -6,6 +11,12 @@ import type { LlValue, LlvmEmitterContext } from "./expr-context.js"; type Slice = IrExpr & { kind: "strIntrinsic" }; +function isSlice(value: IrExpr): value is Slice { + return ( + value.kind === "strIntrinsic" && (value.method === "slice" || value.method === "substring") + ); +} + /** A local used exclusively for scalar indexing needs no copied bytes. * Snapshot the receiver and normalized bounds at its initializer, including * side effects in the bounds. Escapes, captures, writes, suspension, and all @@ -111,3 +122,234 @@ export function emitStringSliceRead(host: LlvmEmitterContext, value: Slice): LlV ); return { name: result, type: value.type }; } + +/** Bytes of the stack buffer behind one scratch slice, header included. */ +export const SCRATCH_SLICE_BYTES = 96; + +/** String methods that read a lent receiver or argument only during their + * runtime call and never return it. Methods returning a string can return + * their unchanged receiver, so they stay on the owned path. */ +const LENDING_METHODS: ReadonlySet = new Set([ + "length", + "charCodeAt", + "indexOf", + "includes", + "startsWith", + "endsWith", +]); + +/** Numeric parsers read their text during the call. */ +const LENDING_LIB_FNS: ReadonlySet = new Set([ + "num.fromString", + "num.parseInt", + "num.parseFloat", +]); + +/** Typed string-keyed collection operations: reads probe with the key, and + * an insertion stores scr_str_scratch_keep's copy (scr_map_append). */ +const LENDING_KEY_METHODS: ReadonlySet = new Set(["get", "has", "set", "add", "delete"]); + +function stringKeyed(value: IrExpr & { kind: "mapIntrinsic" | "setIntrinsic" }): boolean { + const receiver = value.receiver.type; + if (receiver.kind === "map") + return receiver.key.kind === "string" && receiver.value.kind !== "dyn"; + if (receiver.kind === "set") return receiver.elem.kind === "string"; + return false; +} + +/** String parameters, by function and index, that the body reads only in + * lending positions (findLentStringParameters). */ +export type LentStringParameters = ReadonlyMap>; + +/** The operands `value` reads only while it runs, keeping no reference. */ +function lentOperands(value: IrExpr, parameters: LentStringParameters): readonly IrExpr[] { + switch (value.kind) { + case "strEq": + case "strCmp": + return [value.left, value.right]; + case "strIntrinsic": + return LENDING_METHODS.has(value.method) ? [value.receiver, ...value.args] : []; + case "libCall": + return LENDING_LIB_FNS.has(value.fn) ? value.args.slice(0, 1) : []; + case "mapIntrinsic": + case "setIntrinsic": + return LENDING_KEY_METHODS.has(value.method) && stringKeyed(value) + ? value.args.slice(0, 1) + : []; + case "call": { + const lent = parameters.get(value.callee); + return lent ? value.args.filter((_, index) => lent.has(index)) : []; + } + default: + return []; + } +} + +interface LendingScan { + /** Slice operands of lending consumers, excluding any node also reached + * in an owning position. */ + scratch: Set; + /** Candidates read anywhere other than a lending position. */ + invalid: Set; + /** Direct callees, for the parameter fixpoint. */ + callees: Set; +} + +/** One pass over `fn`: which candidate bindings only lending consumers read + * (a slice initializer of a candidate local is not itself a read), and + * which slice operands those consumers lend. A switch discriminant is only + * compared with the case tests. */ +function scanLending( + fn: IrFunction, + candidates: ReadonlySet, + initializers: ReadonlyMap, + parameters: LentStringParameters, +): LendingScan { + const scan: LendingScan = { scratch: new Set(), invalid: new Set(), callees: new Set() }; + const owned = new Set(); + function lent(value: IrExpr): boolean { + if (value.kind === "varRef" && candidates.has(value.localId)) return true; + if (!isSlice(value)) return expr(value); + scan.scratch.add(value); + return everyExprChild(value, expr, stmt); + } + function expr(value: IrExpr): boolean { + if (isSlice(value)) owned.add(value); + if (value.kind === "varRef" && candidates.has(value.localId)) scan.invalid.add(value.localId); + if (value.kind === "closure" || value.kind === "classRef") + for (const id of value.captures ?? []) scan.invalid.add(id); + if (value.kind === "call") scan.callees.add(value.callee); + const operands = lentOperands(value, parameters); + if (operands.length === 0) return everyExprChild(value, expr, stmt); + return everyExprChild( + value, + (child) => (operands.includes(child) ? lent(child) : expr(child)), + stmt, + ); + } + function stmt(value: IrStmt): boolean { + // A candidate's single declaration initializes it with its slice. + if (value.kind === "varDecl" && value.init !== null && initializers.has(value.localId)) + return everyExprChild(value.init, expr, stmt); + if (value.kind === "switch" && value.disc.type.kind === "string") { + lent(value.disc); + for (const entry of value.cases) { + if (entry.test) expr(entry.test); + entry.body.forEach(stmt); + } + return true; + } + return everyStmtChild(value, expr, stmt); + } + fn.body.forEach(stmt); + for (const node of owned) scan.scratch.delete(node); + return scan; +} + +/** String parameters that every body reads only in lending positions, + * including lent arguments of other such parameters: a caller may pass a + * scratch slice to them. Start from every borrowed (unchanged) string + * parameter of a synchronous function and drop violations until nothing changes, so + * recursion through a lent parameter stays lent. A coroutine can keep its + * parameters past the caller's frame, so it never lends. */ +export function findLentStringParameters( + functions: ReadonlyMap, + lifetimes: CallLifetimes, +): Map> { + const lent = new Map>(); + for (const fn of functions.values()) { + if (fn.async || fn.generator) continue; + // Borrowed parameters are the unchanged ones nothing redeclares. + const stable = lifetimes.borrowed.get(fn.name); + const indexes = new Set(); + fn.params.forEach((param, index) => { + if (param.type.kind === "string" && stable?.has(index)) indexes.add(index); + }); + if (indexes.size > 0) lent.set(fn.name, indexes); + } + const callers = new Map>(); + const pending = new Set(lent.keys()); + while (pending.size > 0) { + const name = pending.values().next().value as string; + pending.delete(name); + const indexes = lent.get(name); + const fn = functions.get(name); + if (!indexes || !fn) continue; + const ids = new Set([...indexes].map((index) => fn.params[index]!.localId)); + const scan = scanLending(fn, ids, new Map(), lent); + for (const callee of scan.callees) { + let set = callers.get(callee); + if (!set) callers.set(callee, (set = new Set())); + set.add(name); + } + let changed = false; + for (const index of [...indexes]) { + if (!scan.invalid.has(fn.params[index]!.localId)) continue; + indexes.delete(index); + changed = true; + } + if (!changed) continue; + if (indexes.size === 0) lent.delete(name); + const affected = callers.get(name); + if (affected) for (const caller of affected) if (lent.has(caller)) pending.add(caller); + } + return lent; +} + +/** Slices whose every reader borrows them are written into a stack buffer + * instead of a heap allocation (scr_str_slice_scratch): a slice operand of + * a lending consumer, and the initializer of a stable local read only by + * lending consumers. The copy is ASCII, bounded, and immortal for retain and + * release, so it neither pins its source nor needs to be freed; longer or + * non-ASCII results keep the ordinary owned string. Each site owns its + * buffer: a site runs again only after its previous value is dead, since + * nothing can keep it. Coroutine frames do not keep stack buffers across a + * suspension, so they are left alone. */ +export function findScratchStringSlices( + fn: IrFunction, + lifetimes: CallLifetimes, + scalar: ReadonlyMap, + parameters: LentStringParameters = new Map(), +): Set { + if (fn.async || fn.generator) return new Set(); + const bindings = lifetimes.bindings.get(fn.name); + const locals = new Map(); + everyStmtList(fn.body, { + expr: () => true, + stmt: (stmt) => { + if ( + stmt.kind === "varDecl" && + bindings?.has(stmt.localId) && + !scalar.has(stmt.localId) && + stmt.init !== null && + isSlice(stmt.init) + ) + locals.set(stmt.localId, stmt.init); + return true; + }, + }); + const scan = scanLending(fn, new Set(locals.keys()), locals, parameters); + for (const [id, init] of locals) if (!scan.invalid.has(id)) scan.scratch.add(init); + return scan.scratch; +} + +/** Write a scratch slice into its own stack buffer. The result is owned: + * releasing the scratch copy does nothing, and a heap fallback is freed. */ +export function emitScratchStringSlice( + host: LlvmEmitterContext, + slice: Slice, + receiver: LlValue, + args: readonly LlValue[], +): LlValue { + const B = host.B; + const buffer = B.slot(); + B.entryAllocas.push(`${buffer} = alloca [${SCRATCH_SLICE_BYTES} x i8], align 8`); + host.declare( + `declare ptr @scr_str_slice_scratch(ptr, double, double, i1 zeroext, ptr, ${host.sizeType})`, + ); + const result = B.tmp(); + B.line( + `${result} = call ptr @scr_str_slice_scratch(ptr ${receiver.name}, double ${args[0]?.name ?? f64Lit(0)}, double ${args[1]?.name ?? F64_INF}, i1 ${slice.method === "substring" ? "true" : "false"}, ptr ${buffer}, ${host.sizeType} ${SCRATCH_SLICE_BYTES})`, + ); + return host.own({ name: result, type: slice.type }); +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/scratch-string-slices.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/scratch-string-slices.ts.json new file mode 100644 index 000000000..5145c33d1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/scratch-string-slices.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/scratch-string-slices.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_map.c b/packages/runtime/src/scr_map.c index 8e34533ad..14181968c 100644 --- a/packages/runtime/src/scr_map.c +++ b/packages/runtime/src/scr_map.c @@ -77,7 +77,8 @@ static inline uint64_t scr_map_hash_str(const ScrStr *k) { uint32_t h = k->hash; if (__builtin_expect(h != 0, 1)) return scr_map_hash_widen(h); h = scr_map_hash_fold(k->data, k->len); - if (k->rc != SIZE_MAX) ((ScrStr *)k)->hash = h; + /* A scratch slice is a writable stack copy (scr_str_is_scratch). */ + if (k->rc != SIZE_MAX || scr_str_is_scratch(k)) ((ScrStr *)k)->hash = h; return scr_map_hash_widen(h); #else return scr_map_hash_bytes(k->data, k->len); @@ -931,7 +932,11 @@ static void scr_map_append(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val, m->filter |= scr_map_filter_bits(hash); m->nlive++; if (m->key_kind == SCR_MAP_KEY_STR) { - scr_str_retain((ScrStr *)scr_map_slot_to_ptr(key)); /* key is borrowed */ + ScrStr *k = scr_map_slot_to_ptr(key); /* key is borrowed */ + if (__builtin_expect(scr_str_is_scratch(k), 0)) + m->entries[idx].key = scr_map_slot_from_ptr(scr_str_scratch_keep(k)); + else + scr_str_retain(k); } else if (m->key_kind == SCR_MAP_KEY_DYN) { const ScrDyn *d = (ScrDyn *)scr_map_slot_to_ptr(key); if (d->kind == SCR_DYN_NUM && d->v.num == 0) { diff --git a/packages/runtime/src/scr_string.c b/packages/runtime/src/scr_string.c index 6f3529777..43cf21b0c 100644 --- a/packages/runtime/src/scr_string.c +++ b/packages/runtime/src/scr_string.c @@ -1999,20 +1999,34 @@ ScrStr *scr_str_slice(ScrStr *s, double start, double end) { return scr_str_slice_units(s, e, from, to); } +/* One slice() or substring() boundary in [0, length]: ToIntegerOrInfinity, + * then slice's end-relative negative or substring's clamp. Conversion to an + * integer truncates toward zero exactly like ToIntegerOrInfinity, so no + * libm call is needed; NaN fails both comparisons and lands on 0, and a + * negative fraction above -1 is -0, which slice treats as 0. */ +static inline size_t scr_slice_unit(double v, size_t length, bool substring) { + if (v >= 0) return v >= (double)length ? length : (size_t)v; + if (substring || !(v > -(double)length)) return 0; + long long unit = (long long)v; /* in (-length, 0] */ + return unit == 0 ? 0 : (size_t)((long long)length + unit); +} + +/* slice()/substring() boundaries in UTF-16 units over the receiver's length. */ +static void scr_str_slice_bounds(ScrStr *s, ScrSidx *e, double start, double end, bool substring, + size_t *from_out, size_t *to_out) { + size_t length = scr_sidx_len(s, e); + size_t from = scr_slice_unit(start, length, substring); + size_t to = scr_slice_unit(end, length, substring); + if (substring && from > to) { size_t swap = from; from = to; to = swap; } + *from_out = from; + *to_out = to; +} + void scr_str_slice_range(ScrStr *s, double start, double end, bool substring, ScrStringSlice *out) { ScrSidx *e = scr_sidx_for(s); - size_t length = scr_sidx_len(s, e); - double a = scr_to_integer_or_infinity(start), b = scr_to_integer_or_infinity(end); size_t from, to; - if (substring) { - from = a <= 0 ? 0 : a >= (double)length ? length : (size_t)a; - to = b <= 0 ? 0 : b >= (double)length ? length : (size_t)b; - if (from > to) { size_t swap = from; from = to; to = swap; } - } else { - from = scr_slice_boundary(a, length); - to = scr_slice_boundary(b, length); - } + scr_str_slice_bounds(s, e, start, end, substring, &from, &to); out->start = from; out->length = to > from ? to - from : 0; out->split = 0; @@ -2024,6 +2038,56 @@ void scr_str_slice_range(ScrStr *s, double start, double end, bool substring, } } +/* Fill a scratch buffer with `units` ASCII bytes (scr_str_is_scratch). */ +static inline ScrStr *scr_str_scratch_fill(ScrStr *scratch, const char *data, size_t units) { + scratch->rc = SIZE_MAX; + scratch->len = units; + scratch->cap = 0; /* below len: the scratch marker */ + scratch->ascii = 1; +#if SCR_STR_HASH_CACHE + scratch->hash = 0; +#endif + scr_copy_bytes(scratch->data, data, units); + scratch->data[units] = '\0'; + return scratch; +} + +ScrStr *scr_str_slice_scratch(ScrStr *s, double start, double end, bool substring, + ScrStr *scratch, size_t bytes) { + size_t capacity = bytes - sizeof(ScrStr) - 1; + if (__builtin_expect(s->ascii, 1)) { + /* Units are bytes: no index entry, and the bounds are byte offsets. */ + size_t length = s->len; + size_t from = scr_slice_unit(start, length, substring); + size_t to = scr_slice_unit(end, length, substring); + if (substring && from > to) { size_t swap = from; from = to; to = swap; } + size_t units = to > from ? to - from : 0; + /* Shorter results are interned statics. */ + if (units >= 2 && units <= capacity) return scr_str_scratch_fill(scratch, s->data + from, units); + return scr_str_slice_units(s, NULL, from, to); + } + ScrSidx *e = scr_sidx_for(s); + size_t from, to; + scr_str_slice_bounds(s, e, start, end, substring, &from, &to); + size_t units = to > from ? to - from : 0; + if (units >= 2 && units <= capacity) { + /* Equal unit and byte counts between two character boundaries prove + * the span is ASCII: every other character takes more bytes than + * UTF-16 units. Non-ASCII results keep the owned copy and its index. */ + bool first, last; + size_t from_b = scr_u16_to_byte_c(s, e, from, &first); + size_t to_b = scr_u16_to_byte_c(s, e, to, &last); + if (!first && !last && to_b - from_b == units) + return scr_str_scratch_fill(scratch, s->data + from_b, units); + } + return scr_str_slice_units(s, e, from, to); +} + +ScrStr *scr_str_scratch_keep(ScrStr *s) { + if (!scr_str_is_scratch(s)) return scr_str_retain(s); + return scr_str_from_span_ascii(s->data, s->len); +} + double scr_str_slice_char_code_at(ScrStr *s, const ScrStringSlice *range, double index) { double unit = scr_to_integer_or_infinity(index); if (!(unit >= 0) || unit >= (double)range->length) return NAN; diff --git a/packages/runtime/src/scr_string.h b/packages/runtime/src/scr_string.h index e4bf09995..425dfaabf 100644 --- a/packages/runtime/src/scr_string.h +++ b/packages/runtime/src/scr_string.h @@ -184,6 +184,14 @@ static inline ScrStr *scr_str_retain(ScrStr *s) { void scr_str_release(ScrStr *s); /* NULL-tolerant (uninitialized locals) */ +/* A transient stack copy of a slice (scr_str_slice_scratch): immortal for + * retain and release, and valid only while its borrowing consumer runs. No + * other string has a capacity below its length. Containers that keep a + * string they were lent store scr_str_scratch_keep's copy instead. */ +static inline bool scr_str_is_scratch(const ScrStr *s) { + return s->rc == SIZE_MAX && s->cap < s->len; +} + /* ── lone surrogates: canonical WTF-8 storage ───────────────────────── * String storage is UTF-8 extended to lone UTF-16 surrogates: an unpaired * surrogate is its generalized 3-byte encoding ED A0..BF 80..BF, while a diff --git a/packages/runtime/src/scr_string_methods.h b/packages/runtime/src/scr_string_methods.h index 537747530..62354142e 100644 --- a/packages/runtime/src/scr_string_methods.h +++ b/packages/runtime/src/scr_string_methods.h @@ -83,6 +83,16 @@ typedef struct ScrStringSlice { void scr_str_slice_range(ScrStr *s, double start, double end, bool substring, ScrStringSlice *out); double scr_str_slice_char_code_at(ScrStr *s, const ScrStringSlice *range, double index); +/* A slice that only borrowing consumers read (string-slices.ts) is written + * into the caller's `bytes`-sized stack buffer as an immortal ASCII string, + * whose header marks it as a scratch copy (scr_str_is_scratch). Results + * that do not fit, are not ASCII, or are interned statics are returned as + * the ordinary +1 slice. Releasing either result is correct. */ +ScrStr *scr_str_slice_scratch(ScrStr *s, double start, double end, bool substring, + ScrStr *scratch, size_t bytes); +/* The owning reference a container stores for `s`: a heap copy of a scratch + * string, else `s` retained. */ +ScrStr *scr_str_scratch_keep(ScrStr *s); /* repeat(count): count < 0 or Infinity is a JS RangeError; scriptc has no * exceptions, so it prints "scriptc: RangeError: Invalid count value" to diff --git a/packages/runtime/test/test_map.c b/packages/runtime/test/test_map.c index 6eee2d6bb..8899974a8 100644 --- a/packages/runtime/test/test_map.c +++ b/packages/runtime/test/test_map.c @@ -284,6 +284,36 @@ static void test_span_keys(void) { scr_map_release(numbers); } +/* A scratch slice probes like any key; an insertion stores a heap copy, so + * the stored key survives the buffer's next contents. */ +static void test_scratch_keys(void) { + ScrMap *m = scr_map_new(SCR_MAP_KEY_STR, SCR_MAP_VAL_F64, NULL); + ScrStr *line = S("alpha beta alpha"); + _Alignas(16) unsigned char buffer[96]; + ScrStr *alpha = scr_str_slice_scratch(line, 0, 5, false, (ScrStr *)buffer, sizeof buffer); + check(alpha == (ScrStr *)buffer && scr_str_is_scratch(alpha), "short ASCII slice uses the buffer"); + scr_map_set_str_f64(m, alpha, 1); + double out = 0; + check(scr_map_get_str_f64(m, alpha, &out) && out == 1, "scratch key probes its entry"); + ScrStr *beta = scr_str_slice_scratch(line, 6, 10, false, (ScrStr *)buffer, sizeof buffer); + check(!scr_map_has_str(m, beta), "refilled buffer probes its new text"); + scr_map_set_str_f64(m, beta, 2); + ScrStr *again = scr_str_slice_scratch(line, 11, 16, false, (ScrStr *)buffer, sizeof buffer); + scr_map_set_str_f64(m, again, 3); + check(scr_map_size(m) == 2, "scratch overwrite keeps one entry"); + ScrStr *first = scr_map_iter_key_str(m, 0), *second = scr_map_iter_key_str(m, 1); + ScrStr *a = S("alpha"), *b = S("beta"); + check(!scr_str_is_scratch(first) && scr_str_eq(first, a), "stored key is an owned copy"); + check(!scr_str_is_scratch(second) && scr_str_eq(second, b), "second stored key is a copy"); + check(scr_map_get_str_f64(m, a, &out) && out == 3, "overwrite through scratch key"); + scr_str_release(a); + scr_str_release(b); + scr_str_release(first); + scr_str_release(second); + scr_str_release(line); + scr_map_release(m); +} + static void test_same_value_zero(void) { ScrMap *m = scr_map_new(SCR_MAP_KEY_F64, SCR_MAP_VAL_BOOL, NULL); scr_map_set_f64_bool(m, 0.0 / 0.0, true); /* NaN key */ @@ -793,6 +823,7 @@ int main(void) { test_string_entries(); test_same_value_zero(); test_span_keys(); + test_scratch_keys(); test_string_hash_cache(); #ifdef SCR_RC_AUDIT test_rc_accounting(); diff --git a/packages/runtime/test/test_string.c b/packages/runtime/test/test_string.c index 55c49af7e..e49d8eb8b 100644 --- a/packages/runtime/test/test_string.c +++ b/packages/runtime/test/test_string.c @@ -205,6 +205,38 @@ static void surrogate_asserts(void) { } } } + /* Scratch slices hold the materialized text. Only ASCII results of at + * least two units use the caller's buffer, marked as scratch. */ + { + ScrStr *sources[] = {two, s, scr_str_new("GET /api/users 200", 18)}; + const double marks[] = {-INFINITY, -7.5, -3, -0.5, -0.0, 0, 0.5, 1, + 2, 3.9, 5, 9, 40, INFINITY, NAN}; + const size_t nmarks = sizeof marks / sizeof marks[0]; + _Alignas(16) unsigned char buffer[96]; + for (size_t k = 0; k < 3; k++) { + for (size_t a = 0; a < nmarks; a++) { + for (size_t b = 0; b < nmarks; b++) { + for (unsigned substring = 0; substring < 2; substring++) { + ScrStr *src = sources[k]; + ScrStr *scratch = scr_str_slice_scratch(src, marks[a], marks[b], substring != 0, + (ScrStr *)buffer, sizeof buffer); + ScrStr *copy = substring ? scr_str_substring(src, marks[a], marks[b]) + : scr_str_slice(src, marks[a], marks[b]); + bool used = scratch == (ScrStr *)buffer; + bool expected = copy->len >= 2 && scr_bytes_all_ascii(copy->data, copy->len); + total++; + if (scratch->len != copy->len || memcmp(scratch->data, copy->data, copy->len) != 0 || + used != expected || used != scr_str_is_scratch(scratch) || + scr_str_utf16_len(scratch) != scr_str_utf16_len(copy)) + failed++; + scr_str_release(scratch); + scr_str_release(copy); + } + } + } + } + scr_str_release(sources[2]); + } scr_str_release(two); scr_str_release(s); } diff --git a/tests/corpus/scratch-string-slices.ts b/tests/corpus/scratch-string-slices.ts new file mode 100644 index 000000000..487883d6e --- /dev/null +++ b/tests/corpus/scratch-string-slices.ts @@ -0,0 +1,116 @@ +// Slices read only by comparisons, numeric parsers, collection probes, +// switch discriminants and lent helper parameters, including the keys a +// map or set keeps after the slice that produced them is gone. +const ascii = "GET /api/users?id=42 200 17.5ms"; +const mixed = "Aé水x😀yz-12.5e1 ok"; +const bounds = [-Infinity, -40, -8, -2.5, -1, -0.5, -0, 0, 0.5, 1, 2, 3, 4.9, 5, 7, 10, 40, Infinity, NaN]; + +function compare(source: string, start: number, end: number): string { + const s = source.slice(start, end); + const t = source.substring(start, end); + const parts = [ + String(s === "GET"), + String(t === "GET"), + String(source.slice(start, end) === source.substring(start, end)), + String(source.slice(start, end) < "M"), + String(source.substring(start, end) >= "a"), + String(s.length), + String(t.length), + String(s.charCodeAt(0)), + String(t.charCodeAt(t.length - 1)), + String(s.indexOf("a")), + String(t.includes("😀")), + String(s.startsWith("A")), + String(t.endsWith("z")), + ]; + return parts.join(","); +} +for (const source of [ascii, mixed]) { + for (const start of bounds) { + const row: string[] = []; + for (const end of bounds) row.push(compare(source, start, end)); + console.log(row.join(" | ")); + } +} + +// Numeric parsing of slices. +const numbers = " 42|-0|0x1F|1e3|.5|Infinity|-Infinity|12px|abc|+7.25| 9 |0b11|1_000|"; +let offset = 0; +while (offset < numbers.length) { + const bar = numbers.indexOf("|", offset); + const field = numbers.slice(offset, bar); + console.log( + JSON.stringify(field), + Number(field), + +numbers.substring(offset, bar), + parseInt(field), + parseInt(numbers.slice(offset, bar), 16), + parseFloat(field), + Object.is(Number(numbers.slice(offset, bar)), -0), + ); + offset = bar + 1; +} +console.log(Number(mixed.slice(9, 16)), parseFloat(mixed.slice(9)), parseInt(mixed.slice(10, 12))); + +// Collection probes and insertions keyed by slices. The stored keys must +// outlive every later slice written to the same site. +const counts = new Map(); +const seen = new Set(); +const words = "alpha beta gamma alpha delta beta alpha epsilon-with-a-much-longer-key-than-the-stack-buffer-holds-alpha zeta é-key é-key x x"; +for (let round = 0; round < 3; round++) { + let start = 0; + while (start < words.length) { + let end = words.indexOf(" ", start); + if (end < 0) end = words.length; + const word = words.slice(start, end); + counts.set(word, (counts.get(word) ?? 0) + 1); + if (!seen.has(word)) seen.add(word); + if (counts.get(words.substring(start, end)) === 2) seen.delete(word); + start = end + 1; + } +} +console.log([...counts.entries()].map(([key, value]) => `${key}=${value}`).join(",")); +console.log([...seen].join(",")); +console.log(counts.has(ascii.slice(0, 3)), counts.has(words.slice(0, 5)), seen.has(words.slice(6, 10))); +const index = new Map(); +for (let i = 0; i + 3 <= ascii.length; i++) index.set(ascii.slice(i, i + 3), i); +console.log(index.size, index.get("api"), index.get(ascii.substring(5, 8)), [...index.keys()].slice(0, 6).join("/")); +const reads = new Map([["api", "first"], ["users", "second"]]); +console.log(reads.get(ascii.slice(5, 8)), reads.get(ascii.slice(9, 14)) ?? "none", reads.get(ascii.slice(0, 1)) ?? "none"); + +// Switch discriminants. +function method(line: string): number { + switch (line.slice(0, line.indexOf(" "))) { + case "GET": + return 1; + case "POST": + return 2; + case "é": + return 3; + default: + return 0; + } +} +console.log(method(ascii), method("POST /x"), method("é y"), method("PATCH /x"), method("nospace")); + +// Lent helper parameters, including recursion through a lent parameter. +function isKeyword(text: string): boolean { + return text === "let" || text === "const" || text === "return"; +} +function depth(text: string, n: number): number { + if (n === 0) return text.length; + return depth(text, n - 1) + (text === "abc" ? 1 : 0); +} +function keep(text: string): string[] { + return [text]; +} +const program = "let x = 1; const y = 2; return x + y; letter"; +let keywords = 0; +const kept: string[][] = []; +for (let i = 0; i < program.length; i++) { + for (let j = i + 2; j <= Math.min(program.length, i + 6); j++) { + if (isKeyword(program.slice(i, j))) keywords++; + } + if (i % 9 === 0) kept.push(keep(program.slice(i, i + 4))); +} +console.log(keywords, depth("abcdef".slice(0, 3), 4), kept.map((k) => k[0]).join("|")); From 250097dd32d49cd70daaebe6681256fb69203b9d Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 13:57:35 -0700 Subject: [PATCH 02/47] Represent unions of records as the record pointer itself A union of two or more record arms and at most two unit arms (the discriminated unions of object literals behind Result, token, shape and AST types) now holds the record pointer instead of a reference-counted %ScrUnion box, like nullable unions already do. NULL and the existing null sentinel encode the unit arms. Every record shape that is an arm of such a union carries its module-wide shape number in a hidden i32 after the reference count; the arm of a value is that word mapped through a per-union tag helper, which LLVM folds into the consumer's switch. Records share one retain; release and trace dispatch on the arm, and every arm of a union with a traced arm carries a collector header. Wraps move the record, retypes between such unions reuse the pointer, and equality is identity. Record field indices come from the shape's field base. Unions over records that are also arms of runtime-inspected unions (Map keys, Set elements), library builds, lifetime-region programs and debug builds keep boxes. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/src/backend/llvm/dyn.ts | 20 ++- packages/compiler/src/backend/llvm/emitter.ts | 47 ++++-- .../src/backend/llvm/expr-callbacks.ts | 12 +- .../compiler/src/backend/llvm/expr-control.ts | 4 +- .../compiler/src/backend/llvm/expr-records.ts | 14 +- .../src/backend/llvm/expr-stream-bridges.ts | 11 +- .../compiler/src/backend/llvm/lib-datagram.ts | 4 +- .../src/backend/llvm/lib-filesystem.ts | 7 +- .../compiler/src/backend/llvm/lib-lookup.ts | 2 +- .../compiler/src/backend/llvm/lib-network.ts | 2 +- .../src/backend/llvm/nullable-unions.test.ts | 83 ++++++++++ .../src/backend/llvm/nullable-unions.ts | 156 ++++++++++++++++-- packages/compiler/src/backend/llvm/publish.ts | 23 ++- packages/compiler/src/backend/llvm/regions.ts | 9 +- packages/compiler/src/backend/llvm/shapes.ts | 143 +++++++++++++++- .../src/backend/llvm/stack-objects.ts | 12 ++ .../compiler/src/backend/llvm/union-repr.ts | 36 +++- .../src/backend/llvm/union-retype.test.ts | 19 ++- packages/compiler/src/backend/llvm/walkers.ts | 8 +- .../corpus/5930-record-union-pointers.ts.json | 6 + .../5931-record-union-unit-arms.ts.json | 6 + .../corpus/5932-record-union-trees.ts.json | 6 + .../5933-record-union-conversions.ts.json | 6 + .../5934-record-union-set-members.ts.json | 6 + tests/corpus/5930-record-union-pointers.ts | 79 +++++++++ tests/corpus/5931-record-union-unit-arms.ts | 67 ++++++++ tests/corpus/5932-record-union-trees.ts | 77 +++++++++ tests/corpus/5933-record-union-conversions.ts | 78 +++++++++ tests/corpus/5934-record-union-set-members.ts | 25 +++ 29 files changed, 886 insertions(+), 82 deletions(-) create mode 100644 packages/compiler/src/backend/llvm/nullable-unions.test.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5930-record-union-pointers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5931-record-union-unit-arms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5932-record-union-trees.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5933-record-union-conversions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5934-record-union-set-members.ts.json create mode 100644 tests/corpus/5930-record-union-pointers.ts create mode 100644 tests/corpus/5931-record-union-unit-arms.ts create mode 100644 tests/corpus/5932-record-union-trees.ts create mode 100644 tests/corpus/5933-record-union-conversions.ts create mode 100644 tests/corpus/5934-record-union-set-members.ts diff --git a/packages/compiler/src/backend/llvm/dyn.ts b/packages/compiler/src/backend/llvm/dyn.ts index b85ca0062..845633148 100644 --- a/packages/compiler/src/backend/llvm/dyn.ts +++ b/packages/compiler/src/backend/llvm/dyn.ts @@ -1179,12 +1179,13 @@ export class LlDyn { `llvm emitter bug: JSON schema of unknown shape ${t.shapeId}`, ); const struct = mangleRecordStruct(t.shapeId); - const index = new Map(shape.fields.map((f, i) => [f.name, i + 1])); + const base = host.nullableUnions.fieldBase(t.shapeId); + const index = new Map(shape.fields.map((f, i) => [f.name, i + base])); // The runtime names kept-source keys by this index (record-sources.ts). const order = recordSourceFieldOrder(shape); const fieldTy = `{ ptr, ${S}, ${S}, ptr }`; const entries = order.map((fieldName) => { - const field = shape.fields[index.get(fieldName)! - 1]!; + const field = shape.fields[index.get(fieldName)! - base]!; const sub = this.jsonSchema(field.type); const offset = `ptrtoint (ptr getelementptr (%${struct}, ptr null, i64 0, i32 ${index.get(fieldName)}) to ${S})`; return `${fieldTy} { ptr ${host.cstr(fieldName)}, ${S} ${Buffer.byteLength(fieldName, "utf8")}, ${S} ${offset}, ptr @${sub} }`; @@ -1421,18 +1422,19 @@ export class LlDyn { B.line(`call void @scr_arr_outline(ptr ${cached})`); B.line(`call void @scr_arr_outline(ptr ${checked})`); } + const base = t.kind === "record" ? host.nullableUnions.fieldBase(t.shapeId) : 1; const members = t.kind === "record" ? [ ...shape!.fields.map((field, index) => ({ - index: index + 1, + index: index + base, type: llFieldType(field.type, host.inlineUnions.record(field.type)), name: field.name, })), ...(shape!.indexValue ? [ { - index: shape!.fields.length + 1, + index: shape!.fields.length + base, type: "ptr" as const, name: "[key: string] overflow", }, @@ -1693,7 +1695,8 @@ export class LlDyn { `llvm emitter bug: dynCheck of unknown shape ${t.shapeId}`, ); const struct = mangleRecordStruct(t.shapeId); - const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + 1])); + const base = host.nullableUnions.fieldBase(t.shapeId); + const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + base])); const releaseR = (): void => { B.line(`call void ${releaseSym(host, t)}(ptr %r0)`); }; @@ -1870,7 +1873,7 @@ export class LlDyn { const ovfp = B.tmp(); const ovf = B.tmp(); B.line( - `${ovfp} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${shape.fields.length + 1}`, + `${ovfp} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${shape.fields.length + base}`, ); B.line(`${ovf} = load ptr, ptr ${ovfp} ; overflow map`); if (shape.fields.length === 0) { @@ -2443,7 +2446,8 @@ export class LlDyn { if (!shape) throw new InternalCompilerError(`llvm emitter bug: to-dyn of unknown shape ${t.shapeId}`); const struct = mangleRecordStruct(t.shapeId); - const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + 1])); + const base = host.nullableUnions.fieldBase(t.shapeId); + const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + base])); const loadFieldOf = (fname: string, ft: IrType): string => { const p = B.tmp(); B.line( @@ -2567,7 +2571,7 @@ export class LlDyn { const ovfp = B.tmp(); const ovf = B.tmp(); B.line( - `${ovfp} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 ${shape.fields.length + 1}`, + `${ovfp} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 ${shape.fields.length + base}`, ); B.line(`${ovf} = load ptr, ptr ${ovfp} ; overflow map`); const ks = B.tmp(); diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 09bf4979c..a9e840837 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -373,6 +373,7 @@ import { elemAccess, emitInlineRcHelpers, emitNullableRetainWrappers, + emitShapeUnionHelpers, FN_ATTRS, inlineRcDecls, type InlineRcMode, @@ -1071,7 +1072,7 @@ export class LlEmitter { expr: (expr) => !(expr.kind === "libCall" && expr.fn === "error.stack"), }), ); - this.nullableUnions = new NullableUnions(mod); + this.nullableUnions = new NullableUnions(mod, options.debugSources === undefined); this.debug = options.debugSources === undefined ? null @@ -1165,8 +1166,10 @@ export class LlEmitter { // Optional array reads also cover nullable unions: emitLocalArrayRead // then yields the (borrowed or owned) element pointer, not a stack box. // Arrays of such a union are read the same way. - this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById, (id) => - this.nullableUnions.has(id), + this.optionalArrayReads = new OptionalArrayReads( + this.fnByName, + this.unionsById, + (id) => this.nullableUnions.single(id) !== null, ); this.unionSources = { unions: this.boxedUnionsById, @@ -1219,7 +1222,8 @@ export class LlEmitter { (type) => this.plainReference(type) && type.kind !== "string" && - (type.kind !== "union" || this.nullableUnions.get(type.unionId)?.arm.kind !== "string"), + (type.kind !== "union" || + this.nullableUnions.single(type.unionId)?.arm.kind !== "string"), this.walkBorrowsByFunction.get(fn.name) ?? new Set(), ); if (rebound.size === 0) continue; @@ -1270,6 +1274,15 @@ export class LlEmitter { const traced = computeTraced(mod); this.tracedShapes = traced.shapes; this.tracedUnions = traced.unions; + // A shape union's value is whichever record it holds, and the collector + // visits it as that record: when one arm carries a collector header, + // every arm must (nullable-unions.ts). + for (const union of this.nullableUnions.allShapeUnions()) + if ( + this.tracedUnions.has(union.unionId) || + union.arms.some((arm) => this.tracedShapes.has(`record:${arm.shapeId}`)) + ) + for (const arm of union.arms) this.tracedShapes.add(`record:${arm.shapeId}`); this.shapeHost = { sizeType: this.sizeType, cycleBufOffset: this.cycleBufOffset, @@ -3551,6 +3564,7 @@ export class LlEmitter { return [ ...late, ...emitNullableRetainWrappers(this.shapeHost), + ...emitShapeUnionHelpers(this.shapeHost), ...emitInlineRcHelpers(this.shapeHost), ]; } @@ -5527,7 +5541,11 @@ export class LlEmitter { const nullable = this.nullableUnions.get(unionId); if (nullable) { // The owned payload IS the nullable union's value. - if (tag !== nullable.refTag) + if ( + nullable.repr === "single" + ? tag !== nullable.refTag + : !nullable.arms.some((arm) => arm.tag === tag) + ) throw new InternalCompilerError( `llvm emitter bug: payload wrap into unit arm ${tag} of ${unionId}`, ); @@ -5632,7 +5650,7 @@ export class LlEmitter { const index = shape.fields.findIndex((entry) => entry.name === field); if (index < 0) throw new InternalCompilerError(`llvm emitter bug: missing union field ${field}`); - layout = "record:"; + layout = this.nullableUnions.fieldBase(arm.shapeId) === 2 ? "record:tagged;" : "record:"; for (let i = 0; i <= index; i++) { const type = shape.fields[i]!.type; layout += `${llFieldType(type, this.inlineUnions.record(type))};`; @@ -5668,7 +5686,7 @@ export class LlEmitter { ); const p = this.B.tmp(); this.B.line( - `${p} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${idx + 1}`, + `${p} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${idx + this.nullableUnions.fieldBase(shapeId)}`, ); const type = shape.fields[idx]!.type; return { ptr: p, type, inline: this.inlineUnions.record(type) }; @@ -5682,7 +5700,7 @@ export class LlEmitter { const p = this.B.tmp(); const v = this.B.tmp(); this.B.line( - `${p} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${shape.fields.length + 1}`, + `${p} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${shape.fields.length + this.nullableUnions.fieldBase(shapeId)}`, ); this.B.line(`${v} = load ptr, ptr ${p}`); return v; @@ -9564,7 +9582,12 @@ export class LlEmitter { unionsById: this.unionsById, recordsById: this.recordsById, inlineUnions: this.inlineUnions, - nullableArm: (t) => this.nullableUnions.of(t)?.arm ?? null, + nullableArm: (t) => { + const nullable = this.nullableUnions.of(t); + return nullable?.repr === "single" ? nullable.arm : null; + }, + shapeUnion: (t) => this.nullableUnions.of(t)?.repr === "shapes", + fieldBase: (shapeId) => this.nullableUnions.fieldBase(shapeId), classInfo: (className) => { const meta = this.classMetaOf(className); return { @@ -10280,7 +10303,11 @@ export class LlEmitter { const nullable = this.nullableUnions.get(e.unionId); if (!nullable) return null; if (isUnitType(e.value.type)) return e.value.kind === "unitLit" ? "unit" : null; - return e.tag === nullable.refTag && isRefCounted(e.value.type) ? "ref" : null; + const refArm = + nullable.repr === "single" + ? e.tag === nullable.refTag + : nullable.arms.some((arm) => arm.tag === e.tag); + return refArm && isRefCounted(e.value.type) ? "ref" : null; } materializeSplitLocal(localId: string): void { diff --git a/packages/compiler/src/backend/llvm/expr-callbacks.ts b/packages/compiler/src/backend/llvm/expr-callbacks.ts index e5560f14f..d71df333a 100644 --- a/packages/compiler/src/backend/llvm/expr-callbacks.ts +++ b/packages/compiler/src/backend/llvm/expr-callbacks.ts @@ -182,6 +182,7 @@ export function genResultThunkFor( sym = mangleGenResThunk(host.resolveThunks.size); host.resolveThunks.set(key, sym); const shape = host.recordsById.get(recT.shapeId); + const base = host.nullableUnions.fieldBase(recT.shapeId); const valueT = shape?.fields.find((f) => f.name === "value")?.type; if (!shape || !valueT) throw new InternalCompilerError("llvm emitter bug: genResume record lacks its value field"); @@ -242,7 +243,7 @@ export function genResultThunkFor( ` %r = call ptr @${mangleRecordNew(recT.shapeId)}()`, ` %d = call zeroext i1 @scr_gen_done(ptr %g)`, ` %dz = zext i1 %d to i8`, - ` %dp = getelementptr inbounds %${mangleRecordStruct(recT.shapeId)}, ptr %r, i64 0, i32 ${doneIdxD + 1}`, + ` %dp = getelementptr inbounds %${mangleRecordStruct(recT.shapeId)}, ptr %r, i64 0, i32 ${doneIdxD + base}`, ` store i8 %dz, ptr %dp`, ` %has = call zeroext i1 @scr_gen_out_has(ptr %g)`, ` br i1 %has, label %take, label %undefv`, @@ -259,7 +260,7 @@ export function genResultThunkFor( ` br label %join`, `join:`, ` %v = load ptr, ptr %vslot`, - ` %vp = getelementptr inbounds %${mangleRecordStruct(recT.shapeId)}, ptr %r, i64 0, i32 ${valueIdxD + 1}`, + ` %vp = getelementptr inbounds %${mangleRecordStruct(recT.shapeId)}, ptr %r, i64 0, i32 ${valueIdxD + base}`, ` store ptr %v, ptr %vp`, ` ret ptr %r`, `}`, @@ -293,7 +294,7 @@ export function genResultThunkFor( ` %r = call ptr @${mangleRecordNew(recT.shapeId)}()`, ` %d = call zeroext i1 @scr_gen_done(ptr %g)`, ` %dz = zext i1 %d to i8`, - ` %dp = getelementptr inbounds %${mangleRecordStruct(recT.shapeId)}, ptr %r, i64 0, i32 ${doneIdx + 1}`, + ` %dp = getelementptr inbounds %${mangleRecordStruct(recT.shapeId)}, ptr %r, i64 0, i32 ${doneIdx + base}`, ` store i8 %dz, ptr %dp`, ` br i1 %d, label %doneb, label %susp`, ]; @@ -410,7 +411,7 @@ export function genResultThunkFor( ` br label %join`, `join:`, ` %v = load ptr, ptr %vslot`, - ` %vp = getelementptr inbounds %${mangleRecordStruct(recT.shapeId)}, ptr %r, i64 0, i32 ${valueIdx + 1}`, + ` %vp = getelementptr inbounds %${mangleRecordStruct(recT.shapeId)}, ptr %r, i64 0, i32 ${valueIdx + base}`, // An inline value field copies the box's bits and drops the box. ...(host.inlineUnions.record(valueT) ? [ @@ -1092,7 +1093,8 @@ export function settledStoreFor( return { tag, arm }; }; const fieldIndex = (arm: IrType & { kind: "record" }, field: string): number => - host.recordsById.get(arm.shapeId)!.fields.findIndex((f) => f.name === field) + 1; + host.recordsById.get(arm.shapeId)!.fields.findIndex((f) => f.name === field) + + host.nullableUnions.fieldBase(arm.shapeId); const fulfilled = armOf("value"); const rejected = armOf("reason"); const valueT = host.recordsById diff --git a/packages/compiler/src/backend/llvm/expr-control.ts b/packages/compiler/src/backend/llvm/expr-control.ts index 298ea0199..fd4bc8787 100644 --- a/packages/compiler/src/backend/llvm/expr-control.ts +++ b/packages/compiler/src/backend/llvm/expr-control.ts @@ -330,7 +330,7 @@ export function emitControlExpr( ); B.line(`store ${ty} ${t}, ptr ${slot}`); if (host.mayThrow.has(e.retag)) host.emitPendingCheck(); - } else if (host.nullableUnions.has(e.left.type.unionId)) { + } else if (host.nullableUnions.single(e.left.type.unionId)) { // The owned nullable pointer IS the owned arm value. B.line(`store ${ty} ${l.name}, ptr ${slot}`); } else { @@ -440,7 +440,7 @@ export function emitControlExpr( host.emitBranchInto(slot, e.right); B.br(lj); B.startBlock(lv); - if (typeEquals(e.type, e.left.type) || host.nullableUnions.has(def.id)) { + if (typeEquals(e.type, e.left.type) || host.nullableUnions.single(def.id)) { // Pass-through, or a nullable pointer that IS its owned arm value. B.line(`store ${ty} ${l.name}, ptr ${slot}`); } else { diff --git a/packages/compiler/src/backend/llvm/expr-records.ts b/packages/compiler/src/backend/llvm/expr-records.ts index 4b03dbad2..1d1717613 100644 --- a/packages/compiler/src/backend/llvm/expr-records.ts +++ b/packages/compiler/src/backend/llvm/expr-records.ts @@ -62,9 +62,17 @@ export function emitUnionRetype( const from = host.nullableUnions.get(e.fromId); const to = host.nullableUnions.get(e.unionId); if (from && to) { - // Equal encodings make the pointer itself the target value. - if (from.refTag === to.refTag && from.unitTag === to.unitTag && from.nullTag === to.nullTag) - return host.own({ name: value.name, type: e.type }); + // Equal encodings make the pointer itself the target value. A shape + // union derives its record arms from the record, so only the unit + // encodings must agree. + const same = + from.repr === "single" && to.repr === "single" + ? from.refTag === to.refTag && from.unitTag === to.unitTag && from.nullTag === to.nullTag + : from.repr === "shapes" && + to.repr === "shapes" && + from.unitTag === to.unitTag && + from.nullTag === to.nullTag; + if (same) return host.own({ name: value.name, type: e.type }); return host.own({ name: rebuildRetype(host, value.name, e), type: e.type }); } if (from || to) return host.own({ name: rebuildRetype(host, value.name, e), type: e.type }); diff --git a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts index 55fa363cd..76ef35358 100644 --- a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts +++ b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts @@ -500,16 +500,17 @@ export function streamTypedRefCommitAdapter( ` br i1 %missing, label %done, label %swap`, `swap:`, ]; + const base = host.nullableUnions.fieldBase(t.shapeId); const members = [ ...shape.fields.map((field, index) => ({ - index: index + 1, + index: index + base, type: llFieldType(field.type, host.inlineUnions.record(field.type)), name: field.name, })), ...(shape.indexValue ? [ { - index: shape.fields.length + 1, + index: shape.fields.length + base, type: "ptr" as const, name: "[key: string] overflow", }, @@ -943,7 +944,7 @@ export function streamTypedRefMaterializeAdapter( B.line(`${out} = call ptr @scr_dyn_new_arr()`); const fields = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name)); for (const field of fields) { - const index = shape.fields.indexOf(field) + 1; + const index = shape.fields.indexOf(field) + host.nullableUnions.fieldBase(t.shapeId); const fieldPtr = B.tmp(); B.line( `${fieldPtr} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %p, i64 0, i32 ${index}`, @@ -980,7 +981,7 @@ export function streamTypedRefMaterializeAdapter( liveRecordOps(host, t, snapshot, fields); } for (const field of fields) { - const index = shape.fields.indexOf(field) + 1; + const index = shape.fields.indexOf(field) + host.nullableUnions.fieldBase(t.shapeId); const fieldPtr = B.tmp(); B.line( `${fieldPtr} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %p, i64 0, i32 ${index}`, @@ -1202,7 +1203,7 @@ function liveRecordOps( const names = `${snapshot}_names`; const ops = `${snapshot}_rops`; const loadField = (B: BlockBuilder, field: IrRecordShape["fields"][number]): string => { - const index = shape.fields.indexOf(field) + 1; + const index = shape.fields.indexOf(field) + host.nullableUnions.fieldBase(t.shapeId); const fieldPtr = B.tmp(); B.line(`${fieldPtr} = getelementptr inbounds %${struct}, ptr %p, i64 0, i32 ${index}`); return loadStructField( diff --git a/packages/compiler/src/backend/llvm/lib-datagram.ts b/packages/compiler/src/backend/llvm/lib-datagram.ts index 1553ecf4f..72de03830 100644 --- a/packages/compiler/src/backend/llvm/lib-datagram.ts +++ b/packages/compiler/src/backend/llvm/lib-datagram.ts @@ -29,7 +29,7 @@ function messageAdapter(host: LlvmEmitterContext, type: IrType): string { const isString = field === "address" || field === "family"; if (isString) lines.push(` %${field}.owned = call ptr @scr_str_retain_v(ptr %${field})`); lines.push( - ` %${field}.slot = getelementptr inbounds %${mangleRecordStruct(type.shapeId)}, ptr %record, i64 0, i32 ${index + 1}`, + ` %${field}.slot = getelementptr inbounds %${mangleRecordStruct(type.shapeId)}, ptr %record, i64 0, i32 ${index + host.nullableUnions.fieldBase(type.shapeId)}`, ` store ${isString ? "ptr" : "double"} %${field}${isString ? ".owned" : ""}, ptr %${field}.slot`, ); } @@ -167,7 +167,7 @@ export function emitDatagramLibCall(host: LlvmEmitterContext, e: LibCallExpr): L ); const slot = host.B.tmp(); host.B.line( - `${slot} = getelementptr inbounds %${mangleRecordStruct(type.shapeId)}, ptr ${record}, i64 0, i32 ${index + 1}`, + `${slot} = getelementptr inbounds %${mangleRecordStruct(type.shapeId)}, ptr ${record}, i64 0, i32 ${index + host.nullableUnions.fieldBase(type.shapeId)}`, ); host.B.line(`store ${ty} ${value}, ptr ${slot}`); } diff --git a/packages/compiler/src/backend/llvm/lib-filesystem.ts b/packages/compiler/src/backend/llvm/lib-filesystem.ts index 1083c69d5..bcb65c8fa 100644 --- a/packages/compiler/src/backend/llvm/lib-filesystem.ts +++ b/packages/compiler/src/backend/llvm/lib-filesystem.ts @@ -910,11 +910,8 @@ export function emitPathUrlLibCall(host: LlvmEmitterContext, e: LibCallExpr): Ll scopeid.inline, ); } - const rc = vAdapters(host.shapeHost, t); - const rowU = B.tmp(); - B.line( - `${rowU} = call ptr @scr_union_new_ref(i32 ${tag}, ptr ${r}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host.shapeHost, t)})`, - ); + // The row (+1) moves into its union arm (a shape union is the row). + const rowU = host.unionNewOwned(infoT.unionId, tag, { name: r, type: t }); B.line(`store ptr ${rowU}, ptr ${rowSlot}`); B.br(lRow); }; diff --git a/packages/compiler/src/backend/llvm/lib-lookup.ts b/packages/compiler/src/backend/llvm/lib-lookup.ts index 9fc23cb94..a6e76e4e0 100644 --- a/packages/compiler/src/backend/llvm/lib-lookup.ts +++ b/packages/compiler/src/backend/llvm/lib-lookup.ts @@ -65,7 +65,7 @@ export function emitLookupConnect(host: LlvmEmitterContext, e: LibCallExpr): LlV " br i1 %more, label %body, label %finish", "body:", " %record = call ptr @scr_arr_get_ref(ptr %addresses, double %index)", - ` %addressp = getelementptr inbounds %${struct}, ptr %record, i64 0, i32 ${field + 1}`, + ` %addressp = getelementptr inbounds %${struct}, ptr %record, i64 0, i32 ${field + host.nullableUnions.fieldBase(addresses.elem.shapeId)}`, " %address = load ptr, ptr %addressp", " %owned.address = call ptr @scr_str_retain_v(ptr %address)", " call double @scr_arr_push_ref(ptr %ips, ptr %owned.address)", diff --git a/packages/compiler/src/backend/llvm/lib-network.ts b/packages/compiler/src/backend/llvm/lib-network.ts index 3ac9fe050..322479a85 100644 --- a/packages/compiler/src/backend/llvm/lib-network.ts +++ b/packages/compiler/src/backend/llvm/lib-network.ts @@ -168,7 +168,7 @@ export function emitNetworkHttpLibCall(host: LlvmEmitterContext, e: LibCallExpr) const i = shape.fields.findIndex((f) => f.name === name); if (i < 0) throw new InternalCompilerError(`llvm emitter bug: net.serverAddress record lacks ${name}`); - return i + 1; + return i + host.nullableUnions.fieldBase(recT.shapeId); }; const store = (name: string, ty: string, v: string): void => { const p = B.tmp(); diff --git a/packages/compiler/src/backend/llvm/nullable-unions.test.ts b/packages/compiler/src/backend/llvm/nullable-unions.test.ts new file mode 100644 index 000000000..46bd688e7 --- /dev/null +++ b/packages/compiler/src/backend/llvm/nullable-unions.test.ts @@ -0,0 +1,83 @@ +import { expect, test } from "vitest"; +import { + F64, + NULL_T, + UNDEFINED_T, + type IrModule, + type IrType, + type IrUnionDef, +} from "../../ir/ir.js"; +import { NullableUnions } from "./nullable-unions.js"; + +const loc = { file: "nullable-unions.ts", start: 0, end: 0 }; +const a: IrType = { kind: "record", shapeId: "a" }; +const b: IrType = { kind: "record", shapeId: "b" }; +const c: IrType = { kind: "record", shapeId: "c" }; + +function module(unions: IrUnionDef[], extra: Partial = {}): IrModule { + return { + irVersion: 16, + sourceFile: loc.file, + entry: "main", + records: ["a", "b", "c"].map((id) => ({ id, fields: [{ name: id, type: F64 }] })), + unions, + functions: [], + ...extra, + }; +} + +test("unions of two or more records become shape unions", () => { + const unions = new NullableUnions( + module([ + { id: "ab", arms: [a, b] }, + { id: "abu", arms: [a, UNDEFINED_T, b] }, + { id: "abnu", arms: [a, b, NULL_T, UNDEFINED_T] }, + { id: "af", arms: [a, F64] }, + { id: "au", arms: [a, UNDEFINED_T] }, + ]), + ); + expect(unions.shapes("ab")).toMatchObject({ unitTag: -1, nullTag: -1 }); + expect(unions.shapes("abu")).toMatchObject({ unitTag: 1, nullTag: -1 }); + expect(unions.shapes("abnu")).toMatchObject({ unitTag: 3, nullTag: 2 }); + expect(unions.shapes("abnu")?.arms).toEqual([ + { tag: 0, shapeId: "a" }, + { tag: 1, shapeId: "b" }, + ]); + // A scalar arm keeps the box; one record arm is a single-arm nullable. + expect(unions.get("af")).toBeNull(); + expect(unions.single("au")).not.toBeNull(); + expect(unions.shapes("au")).toBeNull(); + // Tagged shapes number from 2 and move their fields after the word. + expect([unions.shapeNumber("a"), unions.shapeNumber("b"), unions.shapeNumber("c")]).toEqual([ + 2, 3, 0, + ]); + expect([unions.fieldBase("a"), unions.fieldBase("c")]).toEqual([2, 1]); + expect(unions.boxedUnions(new Map([["af", { id: "af", arms: [a, F64] }]])).size).toBe(1); +}); + +test("records of runtime-inspected unions keep every union over them boxed", () => { + const set: IrType = { kind: "set", elem: { kind: "union", unionId: "ab" } }; + const unions = new NullableUnions( + module( + [ + { id: "ab", arms: [a, b] }, + { id: "abu", arms: [a, b, UNDEFINED_T] }, + { id: "bc", arms: [b, c] }, + { id: "ac", arms: [a, c] }, + ], + { globals: [{ id: "%g.s", name: "s", type: set, mutable: false }] }, + ), + ); + expect(unions.get("ab")).toBeNull(); + expect(unions.get("abu")).toBeNull(); + expect(unions.get("bc")).toBeNull(); + expect(unions.get("ac")).toBeNull(); + expect(unions.shapeNumber("c")).toBe(0); +}); + +test("library, lifetime-region and debug builds keep record unions boxed", () => { + const unions = [{ id: "ab", arms: [a, b] }]; + expect(new NullableUnions(module(unions), false).get("ab")).toBeNull(); + expect(new NullableUnions(module(unions, { lifetimeRegions: true })).get("ab")).toBeNull(); + expect(new NullableUnions(module(unions)).shapes("ab")).not.toBeNull(); +}); diff --git a/packages/compiler/src/backend/llvm/nullable-unions.ts b/packages/compiler/src/backend/llvm/nullable-unions.ts index b1032f9d4..8729e9649 100644 --- a/packages/compiler/src/backend/llvm/nullable-unions.ts +++ b/packages/compiler/src/backend/llvm/nullable-unions.ts @@ -17,6 +17,7 @@ import { everyModuleNode } from "../../ir/traverse.js"; * every container, field, capture, parameter, and return slot holds the * plain pointer. Every other union keeps the tagged `%ScrUnion` box. */ export interface NullableUnion { + repr: "single"; unionId: string; refTag: number; /** The unit arm NULL encodes. */ @@ -24,7 +25,57 @@ export interface NullableUnion { /** The `null` arm of a two-unit-arm union, encoded by NULLABLE_NULL; * -1 when the union has one unit arm. */ nullTag: number; - arm: NullableRefArm; + /** One of NullableRefArm. Typed as the plain IrType so the self-hosted + * frontend keeps IrType's structurally identical arms one record shape + * (a PointerUnion arm holding the narrowed intersection would split them). */ + arm: IrType; +} + +/** A union of two or more record arms and at most two unit arms (`A | B`, + * `A | B | undefined`, discriminated unions of object literals) whose + * VALUES are the record pointer itself, like a NullableUnion: NULL is the + * unit arm (`undefined` when both exist, NULLABLE_NULL is then `null`). + * Every record shape that is an arm of such a union is a TAGGED shape: its + * struct carries the shape's module-wide number in a hidden `i32` word + * right after the reference count (struct index 1), stored by every + * allocation, so the arm of a pointer is that word mapped through the + * union's arm table (the per-union `@sc_stag.` helper). Records share + * one retain; release and trace dispatch on the arm. */ +export interface ShapeUnion { + repr: "shapes"; + unionId: string; + /** The unit arm NULL encodes; -1 when the union has no unit arm. */ + unitTag: number; + /** The `null` arm of a two-unit-arm union, encoded by NULLABLE_NULL; + * -1 otherwise. */ + nullTag: number; + /** The record arms in tag order. */ + arms: readonly { tag: number; shapeId: string }[]; +} + +/** A union whose values are plain pointers (no `%ScrUnion` box). */ +export type PointerUnion = NullableUnion | ShapeUnion; + +/** The struct index of a tagged record shape's hidden shape-number word. */ +export const SHAPE_WORD_INDEX = 1; + +/** The LLVM type through which any tagged record's shape word is read + * (the reference count, then the word). */ +export function shapeWordHeader(sizeType: "i32" | "i64"): string { + return `{ ${sizeType}, i32 }`; +} + +/** The per-union helper mapping a shape-union value to its tag. */ +export function shapeTagFn(unionId: string): string { + return `@sc_stag.${unionId.replace(/[^A-Za-z0-9_.]/g, "_")}`; +} + +/** The per-union release and trace dispatchers of a shape union. */ +export function shapeReleaseFn(unionId: string): string { + return `@sc_srelease.${unionId.replace(/[^A-Za-z0-9_.]/g, "_")}`; +} +export function shapeTraceFn(unionId: string): string { + return `@sc_strace.${unionId.replace(/[^A-Za-z0-9_.]/g, "_")}`; } /** The module-scope immortal sentinel standing for `null` in a @@ -48,44 +99,98 @@ export type NullableRefArm = | (IrType & { kind: "array" | "map" | "set" }); /** The arm is a JS object: always truthy, compared by identity. */ -export function isObjectArm(nullable: NullableUnion): boolean { - return nullable.arm.kind !== "string"; +export function isObjectArm(nullable: PointerUnion): boolean { + return nullable.repr === "shapes" || nullable.arm.kind !== "string"; } /** The representation decision for every union of one module. It is a * pure function of the module, so serialized-IR and in-memory emission * agree. */ export class NullableUnions { - private readonly byId = new Map(); + private readonly byId = new Map(); + /** Tagged record shapes (arms of a shape union) by their module-wide + * shape number (2 and up: 0 and 1 are the unit encodings' pseudo + * numbers, never stored). */ + private readonly shapeNumbers = new Map(); /** NULL-skipping retain wrappers requested so far: symbol → inner retain * call target. The emitter defines each once. */ readonly retainWrappers = new Map(); /** Some nullable union encodes `null` with NULLABLE_NULL. */ readonly usesNullSentinel: boolean = false; - constructor(mod: IrModule) { + /** `shapes`: allow shape unions (debug builds keep boxes, whose + * debug-info layouts describe every arm). */ + constructor(mod: IrModule, shapes = true) { const emitted = new Set(); for (const cls of mod.classes ?? []) if (!cls.runtime) emitted.add(cls.name); const records = new Set(); for (const shape of mod.records ?? []) records.add(shape.id); const boxed = boxedUnionIds(mod); + // Shape unions stay out of library builds (their host ABI marshals + // boxes) and of programs with lifetime regions (whose walks report a + // reference slot by its type's release entry point). + const allowShapes = shapes && mod.lib === undefined && mod.lifetimeRegions !== true; + // A record that is an arm of a boxed union never becomes a shape + // union's arm: conversions between unions over the same records then + // keep one representation. + const boxedRecords = new Set(); + for (const def of mod.unions ?? []) + if (boxed.has(def.id)) + for (const arm of def.arms) if (arm.kind === "record") boxedRecords.add(arm.shapeId); for (const def of mod.unions ?? []) { if (boxed.has(def.id)) continue; - const nullable = nullableShape(def, emitted, records); + const nullable = + nullableShape(def, emitted, records) ?? + (allowShapes ? shapeUnion(def, records, boxedRecords) : null); if (!nullable) continue; this.byId.set(def.id, nullable); if (nullable.nullTag >= 0) this.usesNullSentinel = true; + if (nullable.repr === "shapes") + for (const arm of nullable.arms) + if (!this.shapeNumbers.has(arm.shapeId)) + this.shapeNumbers.set(arm.shapeId, this.shapeNumbers.size + 2); } } - get(unionId: string): NullableUnion | null { + get(unionId: string): PointerUnion | null { return this.byId.get(unionId) ?? null; } - of(type: IrType): NullableUnion | null { + of(type: IrType): PointerUnion | null { return type.kind === "union" ? this.get(type.unionId) : null; } + /** The single-reference-arm form only (shape unions answer null). */ + single(unionId: string): NullableUnion | null { + const nullable = this.byId.get(unionId); + return nullable?.repr === "single" ? nullable : null; + } + + /** The shape-union form only. */ + shapes(unionId: string): ShapeUnion | null { + const nullable = this.byId.get(unionId); + return nullable?.repr === "shapes" ? nullable : null; + } + + /** Every shape union, in module order. */ + allShapeUnions(): ShapeUnion[] { + const out: ShapeUnion[] = []; + for (const nullable of this.byId.values()) if (nullable.repr === "shapes") out.push(nullable); + return out; + } + + /** The module-wide number a tagged record shape stores in its shape + * word, or 0 for shapes that carry none. */ + shapeNumber(shapeId: string): number { + return this.shapeNumbers.get(shapeId) ?? 0; + } + + /** The struct index of a record shape's first declared field: 2 for + * tagged shapes (after the shape word), 1 otherwise. */ + fieldBase(shapeId: string): number { + return this.shapeNumbers.has(shapeId) ? 2 : 1; + } + has(unionId: string): boolean { return this.byId.has(unionId); } @@ -94,10 +199,11 @@ export class NullableUnions { return this.byId.size; } - /** The reference arm of every nullable union, by union id. */ + /** The reference arm of every single-arm nullable union, by union id. */ armTypes(): Map { const result = new Map(); - for (const [id, nullable] of this.byId) result.set(id, nullable.arm); + for (const [id, nullable] of this.byId) + if (nullable.repr === "single") result.set(id, nullable.arm); return result; } @@ -129,7 +235,7 @@ function nullableShape( if (unitTag < 0 || nullTag < 0) return null; } const arm = def.arms[refTag]!; - const base = { unionId: def.id, refTag, unitTag, nullTag }; + const base = { repr: "single" as const, unionId: def.id, refTag, unitTag, nullTag }; if (arm.kind === "object" && emittedClasses.has(arm.className)) return { ...base, arm: { kind: "object", className: arm.className } }; if (arm.kind === "record" && records.has(arm.shapeId)) @@ -140,6 +246,34 @@ function nullableShape( return null; } +/** Two or more emitted record arms and at most two unit arms (both: + * undefined and null). */ +function shapeUnion( + def: IrUnionDef, + records: ReadonlySet, + boxedRecords: ReadonlySet, +): ShapeUnion | null { + const units = def.arms.filter(isUnitType).length; + if (units > 2 || def.arms.length - units < 2) return null; + const arms: { tag: number; shapeId: string }[] = []; + for (let tag = 0; tag < def.arms.length; tag++) { + const arm = def.arms[tag]!; + if (isUnitType(arm)) continue; + if (arm.kind !== "record" || !records.has(arm.shapeId) || boxedRecords.has(arm.shapeId)) + return null; + arms.push({ tag, shapeId: arm.shapeId }); + } + let unitTag = -1, + nullTag = -1; + if (units === 1) unitTag = def.arms.findIndex(isUnitType); + else if (units === 2) { + unitTag = def.arms.findIndex((arm) => arm.kind === "undefinedT"); + nullTag = def.arms.findIndex((arm) => arm.kind === "nullT"); + if (unitTag < 0 || nullTag < 0) return null; + } + return { repr: "shapes", unionId: def.id, unitTag, nullTag, arms }; +} + /** Unions the runtime itself inspects as tagged boxes keep that * representation: Map keys and Set elements hash and compare union keys by * tag and payload inside the C map. */ diff --git a/packages/compiler/src/backend/llvm/publish.ts b/packages/compiler/src/backend/llvm/publish.ts index c884339af..4f807424b 100644 --- a/packages/compiler/src/backend/llvm/publish.ts +++ b/packages/compiler/src/backend/llvm/publish.ts @@ -25,6 +25,7 @@ import type { IrClassDef, IrRecordShape, IrType, IrUnionDef, SrcLoc } from "../. import { mapOf, STRING, typeKey } from "../../ir/ir.js"; import { mangleClassStruct, mangleRecordStruct } from "../mangle.js"; import { FN_ATTRS } from "./shapes.js"; +import { shapeTagFn } from "./nullable-unions.js"; import type { InlineUnionFields } from "./inline-unions.js"; import { LlvmUnsupportedError } from "./unsupported.js"; @@ -44,6 +45,10 @@ export interface PublishHost { readonly inlineUnions: InlineUnionFields; /** The nullable-pointer representation of a union, when it has one. */ nullableArm(t: IrType): IrType | null; + /** The union's values are tagged record pointers (nullable-unions.ts). */ + shapeUnion(t: IrType): boolean; + /** The struct index of a record shape's first field. */ + fieldBase(shapeId: string): number; /** Class layout: hierarchy membership, preorder interval, field slots * (with their storage types), runtime roots. */ classInfo(className: string): PublishClassInfo; @@ -210,6 +215,19 @@ export class PublishWalkers { if (def.arms.some((arm) => scalarRefusal(arm))) throw new LlvmUnsupportedError(`publish of ${typeKey(t)}`, loc); const live = arms.flatMap((a) => (a.fn === null ? [] : [{ tag: a.tag, fn: a.fn }])); + if (this.host.shapeUnion(t)) { + // The value is the record itself (or a unit encoding): no box to + // mark; the arm's walker marks and walks the record. + const lines = [head, `entry:`]; + lines.push( + ` %tag = call i32 ${shapeTagFn(t.unionId)}(ptr %o)`, + ` switch i32 %tag, label %done [ ${live.map((a) => `i32 ${a.tag}, label %arm${a.tag}`).join(" ")} ]`, + ); + for (const a of live) + lines.push(`arm${a.tag}:`, ` call void ${a.fn}(ptr %o, ptr %ctx)`, ` br label %done`); + lines.push(`done:`, ` ret void`, `}`); + return lines; + } const lines = [ head, `entry:`, @@ -240,17 +258,18 @@ export class PublishWalkers { const shape = this.host.recordsById.get(t.shapeId); if (!shape) throw new LlvmUnsupportedError(`publish of an unknown record ${t.shapeId}`, loc); + const base = this.host.fieldBase(shape.id); const members = [ ...shape.fields.flatMap((f, i) => this.host.inlineUnions.record(f.type) ? [] - : [{ name: f.name, index: i + 1, type: f.type }], + : [{ name: f.name, index: i + base, type: f.type }], ), ...(shape.indexValue ? [ { name: "[key: string]", - index: shape.fields.length + 1, + index: shape.fields.length + base, type: mapOf(STRING, shape.indexValue), }, ] diff --git a/packages/compiler/src/backend/llvm/regions.ts b/packages/compiler/src/backend/llvm/regions.ts index 41f67c0cb..b789c644d 100644 --- a/packages/compiler/src/backend/llvm/regions.ts +++ b/packages/compiler/src/backend/llvm/regions.ts @@ -101,8 +101,8 @@ export class LifetimeRegions { /** Can a value of type `t` hold (or own something that holds) a * reference to a ProgramLifetime instance the walk can explain? */ private reaches(t: IrType): boolean { - const arm = this.host.nullableUnions.of(t)?.arm; - if (arm !== undefined) return this.reaches(arm); + const nullable = this.host.nullableUnions.of(t); + if (nullable?.repr === "single") return this.reaches(nullable.arm); switch (t.kind) { case "object": return this.isLifetime(t.className) || this.reach.get(`object:${t.className}`) === true; @@ -287,7 +287,8 @@ export class LifetimeRegions { * ProgramLifetime instance). */ private reportLines(struct: string, f: Field, i: number): string[] { if (!isRefCounted(f.type) || !this.reaches(f.type)) return []; - const arm = this.host.nullableUnions.of(f.type)?.arm ?? f.type; + const nullable = this.host.nullableUnions.of(f.type); + const arm = nullable?.repr === "single" ? nullable.arm : f.type; const load = [ ` %f${i} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${f.index}`, ` %v${i} = load ptr, ptr %f${i}`, @@ -411,7 +412,7 @@ export class LifetimeRegions { ...this.reportBody( `define internal void ${walk}(ptr %o, ptr %w) ${FN_ATTRS} { ; region walk record ${shape.id}`, mangleRecordStruct(shape.id), - rcMembers(shape, this.host.inlineUnions), + rcMembers(shape, this.host.inlineUnions, this.host.nullableUnions.fieldBase(shape.id)), ), ); rows.push(`{ ptr, ptr } { ptr @${mangleRecordRelease(shape.id)}, ptr ${walk} }`); diff --git a/packages/compiler/src/backend/llvm/shapes.ts b/packages/compiler/src/backend/llvm/shapes.ts index 23565eff4..162b36425 100644 --- a/packages/compiler/src/backend/llvm/shapes.ts +++ b/packages/compiler/src/backend/llvm/shapes.ts @@ -31,7 +31,16 @@ import { import { cycTypeDescriptor, emitObjectAlloc, emitObjectFree } from "./alloc.js"; import type { BlockBuilder } from "./blocks.js"; import { SCR_ARR_FIELD, llvmCommentText } from "./common.js"; -import type { NullableUnions } from "./nullable-unions.js"; +import { + NULLABLE_NULL, + SHAPE_WORD_INDEX, + shapeReleaseFn, + shapeTagFn, + shapeTraceFn, + shapeWordHeader, + type NullableUnions, + type ShapeUnion, +} from "./nullable-unions.js"; import { INLINE_UNION_FIELD, loadInlineUnion, @@ -129,6 +138,7 @@ export { computeTraced } from "../cycle-analysis.js"; * `_v`-shaped. */ export function vAdapters(host: ShapeHost, t: IrType): { retain: string; release: string } { const nullable = host.nullableUnions.of(t); + if (nullable?.repr === "shapes") return shapeUnionRc(nullable); if (nullable) { const arm = vAdapters(host, nullable.arm); return { retain: nullableRetainSym(host, nullable.arm), release: arm.release }; @@ -184,6 +194,7 @@ export function vAdapters(host: ShapeHost, t: IrType): { retain: string; release * Families with a mirrored fast path call the inline helper instead. */ export function retainSym(host: ShapeHost, t: IrType): string { const nullable = host.nullableUnions.of(t); + if (nullable?.repr === "shapes") return shapeUnionRc(nullable).retain; if (nullable) return nullableRetainSym(host, nullable.arm); const stem = runtimeRcStem(t); if (host.rcHelpers !== null && stem !== null && inlineRcFamily(host, stem, "retain") !== null) { @@ -195,6 +206,99 @@ export function retainSym(host: ShapeHost, t: IrType): string { return vAdapters(host, t).retain; } +/** A shape union's RC entry points: every record retain is the same + * NULL- and immortal-skipping increment (the null sentinel is immortal), + * so the first arm's serves; release dispatches on the arm. */ +function shapeUnionRc(union: ShapeUnion): { retain: string; release: string } { + return { + retain: `@${mangleRecordRetain(union.arms[0]!.shapeId)}`, + release: shapeReleaseFn(union.unionId), + }; +} + +/** The tag, release and trace helpers of every shape union + * (nullable-unions.ts). The tag helper maps a value to its arm: NULL and + * the null sentinel are the unit arms, anything else a tagged record whose + * shape word names its arm (the switch folds to a lookup table). */ +export function emitShapeUnionHelpers(host: ShapeHost): string[] { + const out: string[] = []; + const S = host.sizeType; + for (const union of host.nullableUnions.allShapeUnions()) { + const header = shapeWordHeader(S); + const tagFn = shapeTagFn(union.unionId); + const cases = union.arms + .map((arm) => `i32 ${host.nullableUnions.shapeNumber(arm.shapeId)}, label %a${arm.tag}`) + .join(" "); + out.push( + `define internal i32 ${tagFn}(ptr %u) alwaysinline ${FN_ATTRS} { ; shape union tag`, + `entry:`, + ` %isnull = icmp eq ptr %u, null`, + ` br i1 %isnull, label %unit, label %ref`, + `unit:`, + ` ret i32 ${union.unitTag}`, + `ref:`, + ); + if (union.nullTag >= 0) + out.push( + ` %isnullarm = icmp eq ptr %u, ${NULLABLE_NULL}`, + ` br i1 %isnullarm, label %nullarm, label %rec`, + `nullarm:`, + ` ret i32 ${union.nullTag}`, + `rec:`, + ); + out.push( + ` %wp = getelementptr inbounds ${header}, ptr %u, i32 0, i32 ${SHAPE_WORD_INDEX}`, + ` %w = load i32, ptr %wp`, + ` switch i32 %w, label %bad [ ${cases} ]`, + ...union.arms.flatMap((arm) => [`a${arm.tag}:`, ` ret i32 ${arm.tag}`]), + `bad:`, + ` ret i32 -1`, + `}`, + ``, + ); + // release: unit encodings are NULL or immortal; each arm releases + // through its own (NULL- and immortal-tolerant) helper. + out.push( + `define internal void ${shapeReleaseFn(union.unionId)}(ptr %u) ${FN_ATTRS} { ; shape union release`, + `entry:`, + ` %t = call i32 ${tagFn}(ptr %u)`, + ` switch i32 %t, label %done [ ${union.arms.map((arm) => `i32 ${arm.tag}, label %a${arm.tag}`).join(" ")} ]`, + ...union.arms.flatMap((arm) => [ + `a${arm.tag}:`, + ` call void @${mangleRecordRelease(arm.shapeId)}(ptr %u)`, + ` br label %done`, + ]), + `done:`, + ` ret void`, + `}`, + ``, + ); + if (shapeUnionTraced(host, union)) + out.push( + `define internal void ${shapeTraceFn(union.unionId)}(ptr %u, ptr %visit, ptr %ctx) ${FN_ATTRS} { ; shape union trace`, + `entry:`, + ` %t = call i32 ${tagFn}(ptr %u)`, + ` switch i32 %t, label %done [ ${union.arms.map((arm) => `i32 ${arm.tag}, label %a${arm.tag}`).join(" ")} ]`, + ...union.arms.flatMap((arm) => [ + `a${arm.tag}:`, + ` call void @${mangleRecordTrace(arm.shapeId)}(ptr %u, ptr %visit, ptr %ctx)`, + ` br label %done`, + ]), + `done:`, + ` ret void`, + `}`, + ``, + ); + } + return out; +} + +/** A shape union's arms carry collector headers (all or none: the emitter + * traces every arm of a union with one traced arm). */ +function shapeUnionTraced(host: ShapeHost, union: ShapeUnion): boolean { + return union.arms.some((arm) => host.tracedShapes.has(`record:${arm.shapeId}`)); +} + /** The retain entry point of a nullable union's value: the arm's own when * it tolerates NULL (emitted class and record helpers), otherwise a * NULL-skipping wrapper around it (the null sentinel and literals are @@ -233,6 +337,7 @@ export function emitNullableRetainWrappers(host: ShapeHost): string[] { * Families with a mirrored fast path call the inline helper instead. */ export function releaseSym(host: ShapeHost, t: IrType): string { const nullable = host.nullableUnions.of(t); + if (nullable?.repr === "shapes") return shapeUnionRc(nullable).release; if (nullable) return releaseSym(host, nullable.arm); const stem = runtimeRcStem(t); if (host.rcHelpers !== null && stem !== null && inlineRcFamily(host, stem, "release") !== null) { @@ -643,6 +748,8 @@ export function traceAdapter(host: ShapeHost, t: IrType): string | null { return "@scr_promise_trace_v"; case "union": { const nullable = host.nullableUnions.get(t.unionId); + if (nullable?.repr === "shapes") + return shapeUnionTraced(host, nullable) ? shapeTraceFn(nullable.unionId) : null; if (nullable) return traceAdapter(host, nullable.arm); if (!host.tracedUnions.has(t.unionId)) return null; host.declare(`declare void @scr_union_trace_v(ptr, ptr, ptr)`); @@ -945,15 +1052,17 @@ export function mapValKindNum(value: IrType): number { export function rcMembers( shape: IrRecordShape, inline: InlineUnionFields, + /** The struct index of the first field (2 on tagged shapes). */ + base = 1, ): { index: number; type: IrType; name: string }[] { return [ ...shape.fields.flatMap((f, i) => - inline.record(f.type) ? [] : [{ index: i + 1, type: f.type, name: f.name }], + inline.record(f.type) ? [] : [{ index: i + base, type: f.type, name: f.name }], ), ...(shape.indexValue ? [ { - index: shape.fields.length + 1, + index: shape.fields.length + base, type: mapOf(STRING, shape.indexValue), name: "[key: string] overflow", }, @@ -1107,7 +1216,12 @@ export function directDestroyTarget( } function directDestroyKey(host: ShapeHost, type: IrType): string | null { - const t = host.nullableUnions.of(type)?.arm ?? type; + const nullable = host.nullableUnions.of(type); + let t = type; + if (nullable !== null) { + if (nullable.repr === "shapes") return null; + t = nullable.arm; + } if (t.kind === "record") return `record:${t.shapeId}`; return t.kind === "object" ? `object:${t.className}` : null; } @@ -1338,8 +1452,12 @@ export function emitRecordShapes( for (const shape of records) { const struct = mangleRecordStruct(shape.id); - const fieldTys = shape.fields.map((f) => llFieldType(f.type, host.inlineUnions.record(f.type))); + const fieldTys: string[] = shape.fields.map((f) => + llFieldType(f.type, host.inlineUnions.record(f.type)), + ); if (shape.indexValue) fieldTys.push("ptr"); // the overflow ScrMap * + // A tagged shape (an arm of a shape union) carries its shape number. + if (host.nullableUnions.shapeNumber(shape.id) !== 0) fieldTys.unshift("i32"); typeDefs.push( `%${struct} = type { ${host.sizeType}${fieldTys.length ? ", " + fieldTys.join(", ") : ""} } ` + `; record ${shape.id} { ${shape.fields.map((f) => llvmCommentText(f.name)).join("; ")}${shape.indexValue ? "; [key: string]" : ""} }`, @@ -1352,7 +1470,7 @@ export function emitRecordShapes( const candidates: [string, DirectDestroy][] = []; const memberTypes: IrType[] = []; for (const shape of records) { - const members = rcMembers(shape, host.inlineUnions); + const members = rcMembers(shape, host.inlineUnions, host.nullableUnions.fieldBase(shape.id)); for (const m of members) memberTypes.push(m.type); if (!members.some((m) => isRefCounted(m.type) && needsBoundedRelease(m.type))) continue; const release = mangleRecordRelease(shape.id); @@ -1370,7 +1488,9 @@ export function emitRecordShapes( for (const shape of records) { const struct = mangleRecordStruct(shape.id); const traced = host.tracedShapes.has(`record:${shape.id}`); - const members = rcMembers(shape, host.inlineUnions); + const base = host.nullableUnions.fieldBase(shape.id); + const shapeNumber = host.nullableUnions.shapeNumber(shape.id); + const members = rcMembers(shape, host.inlineUnions, base); const refMembers = members.filter((m) => isRefCounted(m.type)); const sizeOf = `ptrtoint (ptr getelementptr (%${struct}, ptr null, i32 1) to ${host.sizeType})`; @@ -1439,6 +1559,11 @@ export function emitRecordShapes( ); nw.push(...emitObjectAlloc(host, sizeOf, traced ? { type: cycType } : null)); nw.push(` store ${host.sizeType} 1, ptr %o`); + if (shapeNumber !== 0) + nw.push( + ` %shp = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${SHAPE_WORD_INDEX}`, + ` store i32 ${shapeNumber}, ptr %shp ; shape number`, + ); if (shape.indexValue) { // The overflow map (string-keyed): value handling is type-directed // exactly like shapes.ts's overflowNewC. @@ -1449,7 +1574,7 @@ export function emitRecordShapes( const trace = valKind === 2 ? traceArg(host, v) : "null"; nw.push( ` %ovf = call ptr @scr_map_new(i32 1, i32 ${valKind}, ptr ${host.mapOps(["null", "null", "null", rc.retain, rc.release, trace, "null"])})`, - ` %ovfp = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${shape.fields.length + 1}`, + ` %ovfp = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${shape.fields.length + base}`, ` store ptr %ovf, ptr %ovfp`, ); } @@ -1465,7 +1590,7 @@ export function emitRecordShapes( ]; let i = 0; for (const field of shape.fields) { - const index = i + 1; + const index = i + base; const inline = host.inlineUnions.record(field.type); const fieldTy = llFieldType(field.type, inline); clone.push( diff --git a/packages/compiler/src/backend/llvm/stack-objects.ts b/packages/compiler/src/backend/llvm/stack-objects.ts index c03c7fb44..3b9f97aae 100644 --- a/packages/compiler/src/backend/llvm/stack-objects.ts +++ b/packages/compiler/src/backend/llvm/stack-objects.ts @@ -14,6 +14,7 @@ import type { CallLifetimes } from "./call-lifetimes.js"; import { emitCallExpr, emitConstruction } from "./expr-calls.js"; import type { LlValue, LlvmEmitterContext } from "./expr-context.js"; import { emitRecordLitFields } from "./expr-primitives.js"; +import { SHAPE_WORD_INDEX } from "./nullable-unions.js"; export type StackObjectSource = IrExpr & { kind: "recordLit" | "new" | "call" }; @@ -159,6 +160,17 @@ export function emitStackObject( } } B.line(`store ${host.sizeType} -1, ptr ${slot}`); + if (type.kind === "record") { + // A tagged shape's word names it to every shape union's tag read. + const shapeNumber = host.nullableUnions.shapeNumber(type.shapeId); + if (shapeNumber !== 0) { + const p = B.tmp(); + B.line( + `${p} = getelementptr inbounds ${struct}, ptr ${slot}, i64 0, i32 ${SHAPE_WORD_INDEX}`, + ); + B.line(`store i32 ${shapeNumber}, ptr ${p}`); + } + } if (e.kind === "call") { // The entry writes the result into the slot it receives last. emitCallExpr( diff --git a/packages/compiler/src/backend/llvm/union-repr.ts b/packages/compiler/src/backend/llvm/union-repr.ts index 415aeb851..959f9e51e 100644 --- a/packages/compiler/src/backend/llvm/union-repr.ts +++ b/packages/compiler/src/backend/llvm/union-repr.ts @@ -2,14 +2,19 @@ * helper generators (walkers, dyn). A tagged union is a `%ScrUnion` box; a * nullable union (nullable-unions.ts) is the arm pointer itself: NULL for * its NULL-encoded unit arm and, in `C | null | undefined`, the immortal - * NULLABLE_NULL sentinel for `null`. Every structural read of a union value + * NULLABLE_NULL sentinel for `null`. A shape union's value is likewise the + * record pointer; its tag comes from the record's shape word. Every structural read of a union value * goes through here. */ import type { BlockBuilder } from "./blocks.js"; -import { NULLABLE_NULL, type NullableUnion } from "./nullable-unions.js"; +import { NULLABLE_NULL, shapeTagFn, type PointerUnion } from "./nullable-unions.js"; /** The i32 tag of a union value. */ -export function emitUnionTag(B: BlockBuilder, nullable: NullableUnion | null, u: string): string { +export function emitUnionTag(B: BlockBuilder, nullable: PointerUnion | null, u: string): string { const t = B.tmp(); + if (nullable?.repr === "shapes") { + B.line(`${t} = call i32 ${shapeTagFn(nullable.unionId)}(ptr ${u})`); + return t; + } if (nullable) { const isNull = B.tmp(); B.line(`${isNull} = icmp eq ptr ${u}, null`); @@ -32,8 +37,13 @@ export function emitUnionTag(B: BlockBuilder, nullable: NullableUnion | null, u: /** i1: a nullable union value holds its reference arm (neither NULL nor * the `null` sentinel). */ -export function emitNullablePresent(B: BlockBuilder, nullable: NullableUnion, u: string): string { +export function emitNullablePresent(B: BlockBuilder, nullable: PointerUnion, u: string): string { const present = B.tmp(); + if (nullable.repr === "shapes" && nullable.unitTag < 0) { + // No unit arm: every value is a record (NULL only as a pending dummy). + B.line(`${present} = icmp ne ptr ${u}, null`); + return present; + } B.line(`${present} = icmp ne ptr ${u}, null`); if (nullable.nullTag < 0) return present; const notNullArm = B.tmp(), @@ -46,12 +56,18 @@ export function emitNullablePresent(B: BlockBuilder, nullable: NullableUnion, u: /** i1: a nullable union value holds the arm `tag` (`negated`: does not). */ export function emitNullableIsTag( B: BlockBuilder, - nullable: NullableUnion, + nullable: PointerUnion, u: string, tag: number, negated: boolean, ): string { - if (tag === nullable.refTag) { + if (nullable.repr === "shapes" && tag !== nullable.unitTag && tag !== nullable.nullTag) { + const actual = emitUnionTag(B, nullable, u), + t = B.tmp(); + B.line(`${t} = icmp ${negated ? "ne" : "eq"} i32 ${actual}, ${tag}`); + return t; + } + if (nullable.repr === "single" && tag === nullable.refTag) { const present = emitNullablePresent(B, nullable, u); if (!negated) return present; const t = B.tmp(); @@ -65,7 +81,7 @@ export function emitNullableIsTag( } /** The BORROWED payload pointer of a reference arm. */ -export function emitUnionPeek(B: BlockBuilder, nullable: NullableUnion | null, u: string): string { +export function emitUnionPeek(B: BlockBuilder, nullable: PointerUnion | null, u: string): string { if (nullable) return u; const p = B.tmp(); const t = B.tmp(); @@ -76,7 +92,9 @@ export function emitUnionPeek(B: BlockBuilder, nullable: NullableUnion | null, u /** Text-template forms for helpers written as raw LLVM lines: `%out` * receives the tag / payload of `u`. */ -export function unionTagLines(nullable: NullableUnion | null, u: string, out: string): string[] { +export function unionTagLines(nullable: PointerUnion | null, u: string, out: string): string[] { + if (nullable?.repr === "shapes") + return [` ${out} = call i32 ${shapeTagFn(nullable.unionId)}(ptr ${u})`]; if (nullable && nullable.nullTag < 0) return [ ` ${out}.isnull = icmp eq ptr ${u}, null`, @@ -95,7 +113,7 @@ export function unionTagLines(nullable: NullableUnion | null, u: string, out: st ]; } -export function unionPeekLines(nullable: NullableUnion | null, u: string, out: string): string[] { +export function unionPeekLines(nullable: PointerUnion | null, u: string, out: string): string[] { // A plain copy of the pointer (NULL included) under the template's name. if (nullable) return [` ${out} = getelementptr i8, ptr ${u}, i64 0`]; return [ diff --git a/packages/compiler/src/backend/llvm/union-retype.test.ts b/packages/compiler/src/backend/llvm/union-retype.test.ts index eca6adcd6..0f0abdb68 100644 --- a/packages/compiler/src/backend/llvm/union-retype.test.ts +++ b/packages/compiler/src/backend/llvm/union-retype.test.ts @@ -183,7 +183,9 @@ test("a nullable-pointer source rebuilds the target box", () => { expect(retag).not.toContain("retype.share"); }); -async function llvmFor(source: string): Promise<{ module: IrModule; ir: string }> { +/** `boxed`: keep every union a tagged box (record unions otherwise become + * shape unions, which retype without any box). */ +async function llvmFor(source: string, boxed = true): Promise<{ module: IrModule; ir: string }> { const dir = await mkdtemp(join(tmpdir(), "scriptc-union-retype-")); try { const entry = join(dir, "main.ts"), @@ -194,7 +196,7 @@ async function llvmFor(source: string): Promise<{ module: IrModule; ir: string } throw new Error(result.diagnostics.map((item) => `${item.code}: ${item.message}`).join("\n")); const module = deserializeModule(await readFile(output, "utf8")); expect(validateModule(module)).toEqual([]); - return { module, ir: emitLlvmModule(module) }; + return { module, ir: emitLlvmModule(boxed ? keepUnionsBoxed(module) : module) }; } finally { await rm(dir, { recursive: true, force: true }); } @@ -253,3 +255,16 @@ console.log(leafValue(parsed)); expect(stored).not.toBeNull(); expect(ir).toContain(`load i8, ptr ${stored![1]}`); }); + +test("record unions retype as the record pointer itself", async () => { + const { module, ir } = await llvmFor(VISITOR, false); + const helpers = module.functions.filter((fn) => fn.name.startsWith("%union.retag.")); + expect(helpers.length).toBeGreaterThan(0); + for (const helper of helpers) { + const symbol = `sc_bf__x25_union_retag_${helper.name.slice("%union.retag.".length)}`; + const retag = body(ir, symbol); + expect(retag).not.toMatch(/@scr_union_new|retype\.share|sc_retype_guard/); + } + // No record of the visitor is ever boxed. + expect(ir).not.toMatch(/call ptr @scr_union_new_ref/); +}); diff --git a/packages/compiler/src/backend/llvm/walkers.ts b/packages/compiler/src/backend/llvm/walkers.ts index e75e1679b..d0593313f 100644 --- a/packages/compiler/src/backend/llvm/walkers.ts +++ b/packages/compiler/src/backend/llvm/walkers.ts @@ -287,7 +287,8 @@ export class LlWalkers { throw new InternalCompilerError( `llvm emitter bug: jsonStringify of unknown shape ${shapeId}`, ); - const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + 1])); + const fieldBase = this.host.nullableUnions.fieldBase(shapeId); + const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + fieldBase])); if (recordMayKeepSource(shape)) this.emitRecordSourceWriter(B, shapeId); // CYCLE-CAPABLE shapes bracket the walk with the circular-detection // stack; edge labels stamp before members whose walk can re-enter — @@ -436,7 +437,8 @@ export class LlWalkers { throw new InternalCompilerError(`llvm emitter bug: field writer of unknown shape ${shapeId}`); const name = `sc_jwf_${this.recordFieldWriters.size}`; this.recordFieldWriters.set(shapeId, name); - const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + 1])); + const fieldBase = this.host.nullableUnions.fieldBase(shapeId); + const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + fieldBase])); const byName = new Map(shape.fields.map((f) => [f.name, f])); const cyclic = traceAdapter(this.host, { kind: "record", shapeId }) !== null; const order = recordSourceFieldOrder(shape); @@ -529,7 +531,7 @@ export class LlWalkers { const ovfp = B.tmp(); const ovf = B.tmp(); B.line( - `${ovfp} = getelementptr inbounds %${mangleRecordStruct(shape.id)}, ptr %v, i64 0, i32 ${shape.fields.length + 1}`, + `${ovfp} = getelementptr inbounds %${mangleRecordStruct(shape.id)}, ptr %v, i64 0, i32 ${shape.fields.length + this.host.nullableUnions.fieldBase(shape.id)}`, ); B.line(`${ovf} = load ptr, ptr ${ovfp} ; overflow map`); host.declare(`declare ptr @scr_map_keys_js_order(ptr)`); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5930-record-union-pointers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5930-record-union-pointers.ts.json new file mode 100644 index 000000000..e6e3632f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5930-record-union-pointers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5930-record-union-pointers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5931-record-union-unit-arms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5931-record-union-unit-arms.ts.json new file mode 100644 index 000000000..53d531568 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5931-record-union-unit-arms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5931-record-union-unit-arms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5932-record-union-trees.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5932-record-union-trees.ts.json new file mode 100644 index 000000000..ee4281193 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5932-record-union-trees.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5932-record-union-trees.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5933-record-union-conversions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5933-record-union-conversions.ts.json new file mode 100644 index 000000000..a1fcec317 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5933-record-union-conversions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5933-record-union-conversions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5934-record-union-set-members.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5934-record-union-set-members.ts.json new file mode 100644 index 000000000..98b0ac1f4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5934-record-union-set-members.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5934-record-union-set-members.ts" + ], + "diags": [] +} diff --git a/tests/corpus/5930-record-union-pointers.ts b/tests/corpus/5930-record-union-pointers.ts new file mode 100644 index 000000000..01882d730 --- /dev/null +++ b/tests/corpus/5930-record-union-pointers.ts @@ -0,0 +1,79 @@ +// Unions whose arms are all object literals (discriminated unions) hold the +// record itself: construction, narrowing, storage in arrays, maps, fields +// and closures, identity, and printing behave exactly as in Node. +type Shape = + | { kind: "circle"; r: number } + | { kind: "rect"; w: number; h: number } + | { kind: "tri"; b: number; h: number; label: string }; + +function area(s: Shape): number { + switch (s.kind) { + case "circle": + return Math.round(3.14159 * s.r * s.r); + case "rect": + return s.w * s.h; + case "tri": + return 0.5 * s.b * s.h; + } +} + +function make(i: number): Shape { + if (i % 3 === 0) return { kind: "circle", r: i }; + if (i % 3 === 1) return { kind: "rect", w: i, h: i + 1 }; + return { kind: "tri", b: i, h: 2, label: "t" + i }; +} + +const shapes: Shape[] = []; +for (let i = 0; i < 9; i++) shapes.push(make(i)); +let total = 0; +for (const s of shapes) total += area(s); +console.log("total", total); +console.log(shapes.map((s) => s.kind).join(",")); +console.log(shapes.filter((s) => s.kind === "rect").length); + +// Identity: the same record compares equal, a structurally equal one does not. +const first = shapes[0]!; +const again: Shape = shapes[0]!; +const copy: Shape = { kind: "circle", r: 0 }; +console.log(first === again, first === copy, shapes.indexOf(again), shapes.includes(copy)); + +// Mutation through one alias is visible through the union value. +const rect = { kind: "rect" as const, w: 2, h: 3 }; +const asShape: Shape = rect; +rect.w = 10; +console.log(area(asShape), asShape === rect); + +// Fields, maps and closures holding union values. +interface Holder { + current: Shape; + history: Shape[]; +} +const holder: Holder = { current: make(1), history: [] }; +for (let i = 0; i < 4; i++) { + holder.history.push(holder.current); + holder.current = make(i + 5); +} +console.log(holder.current.kind, holder.history.map(area).join(" ")); + +const byName = new Map(); +for (const s of shapes) byName.set(s.kind + area(s), s); +console.log(byName.size, byName.get("rect2")?.kind, byName.get("missing") === undefined); + +const pick = (k: Shape["kind"]): (() => Shape | undefined) => { + const found = shapes.find((s) => s.kind === k); + return () => found; +}; +const getTri = pick("tri"); +const tri = getTri(); +console.log(tri !== undefined && tri.kind === "tri" ? tri.label : "none"); + +// Printing and serialization see the plain objects. +console.log(shapes.slice(0, 3)); +console.log(JSON.stringify(shapes.slice(0, 3))); +const second = shapes[2]!; +console.log(`${String(shapes[1]!.kind)} ${"label" in second} ${"label" in shapes[1]!}`); + +// Spread copies and sorting. +const grown = shapes.map((s): Shape => (s.kind === "circle" ? { ...s, r: s.r + 1 } : s)); +grown.sort((a, b) => area(a) - area(b)); +console.log(grown.map((s) => `${s.kind}:${area(s)}`).join(" ")); diff --git a/tests/corpus/5931-record-union-unit-arms.ts b/tests/corpus/5931-record-union-unit-arms.ts new file mode 100644 index 000000000..1ade8a0a3 --- /dev/null +++ b/tests/corpus/5931-record-union-unit-arms.ts @@ -0,0 +1,67 @@ +// Record unions with undefined and null arms: NULL and the null sentinel +// encode the unit arms, optional properties keep their absent state, and +// narrowing, nullish operators and equality agree with Node. +type Ok = { ok: true; value: number }; +type Err = { ok: false; error: string }; +type Res = Ok | Err; + +function parse(text: string): Res { + const n = Number(text); + return Number.isNaN(n) ? { ok: false, error: `bad ${text}` } : { ok: true, value: n }; +} + +function lookup(table: Res[], i: number): Res | undefined { + return i < table.length ? table[i] : undefined; +} + +function maybe(i: number): Res | null | undefined { + if (i % 3 === 0) return null; + if (i % 3 === 1) return undefined; + return parse(String(i)); +} + +const table = ["1", "x", "3"].map(parse); +for (let i = 0; i < 4; i++) { + const r = lookup(table, i); + if (r === undefined) console.log(i, "missing"); + else if (r.ok) console.log(i, "value", r.value); + else console.log(i, "error", r.error); +} + +for (let i = 0; i < 6; i++) { + const m = maybe(i); + const tag = m === null ? "null" : m === undefined ? "undefined" : m.ok ? "ok" : "err"; + console.log(i, tag, m == null, m ?? "default", typeof m); +} + +// Optional properties of a record-union type. +interface Slot { + name: string; + result?: Res; + last?: Res | null; +} +const slots: Slot[] = [ + { name: "a" }, + { name: "b", result: parse("7") }, + { name: "c", result: parse("q"), last: null }, +]; +for (const s of slots) { + console.log(s.name, "result" in s, s.result?.ok, s.last === null, s.last === undefined); +} +console.log(JSON.stringify(slots)); +slots[0]!.result = table[1]; +slots[1]!.result = undefined; +console.log(slots.map((s) => (s.result === undefined ? "-" : s.result.ok ? "ok" : "err")).join("")); + +// Equality across arms and unit encodings. +const a: Res | undefined = table[0]; +const b: Res | undefined = undefined; +const c: Res | null = null; +console.log(a === table[0], a === b, b === undefined, c === null, (c as Res | null) === table[2]); + +// Unions of records reaching unknown and back. +const values: unknown[] = [table[0], table[1], undefined, null]; +for (const v of values) { + if (v === null || v === undefined) console.log("unit", v); + else console.log("object", JSON.stringify(v)); +} diff --git a/tests/corpus/5932-record-union-trees.ts b/tests/corpus/5932-record-union-trees.ts new file mode 100644 index 000000000..060cadc4b --- /dev/null +++ b/tests/corpus/5932-record-union-trees.ts @@ -0,0 +1,77 @@ +// A recursive discriminated union (an expression tree) whose leaf arm holds +// no references: every arm shares the cycle collector's header, so trees +// can be built, rewritten, shared and dropped in cycles. +type Expr = + | { kind: "num"; value: number } + | { kind: "neg"; arg: Expr } + | { kind: "add"; left: Expr; right: Expr } + | { kind: "ref"; target: { expr: Expr | null } }; + +function evaluate(e: Expr): number { + switch (e.kind) { + case "num": + return e.value; + case "neg": + return -evaluate(e.arg); + case "add": + return evaluate(e.left) + evaluate(e.right); + case "ref": + return e.target.expr === null ? 0 : evaluate(e.target.expr); + } +} + +function build(depth: number, seed: number): Expr { + if (depth === 0) return { kind: "num", value: seed % 10 }; + if (seed % 4 === 0) return { kind: "neg", arg: build(depth - 1, seed + 1) }; + return { kind: "add", left: build(depth - 1, seed * 3 + 1), right: build(depth - 1, seed + 7) }; +} + +function simplify(e: Expr): Expr { + switch (e.kind) { + case "neg": { + const inner = simplify(e.arg); + return inner.kind === "neg" ? inner.arg : inner.kind === "num" ? { kind: "num", value: -inner.value } : { kind: "neg", arg: inner }; + } + case "add": { + const l = simplify(e.left); + const r = simplify(e.right); + if (l.kind === "num" && r.kind === "num") return { kind: "num", value: l.value + r.value }; + return l === e.left && r === e.right ? e : { kind: "add", left: l, right: r }; + } + default: + return e; + } +} + +function show(e: Expr): string { + switch (e.kind) { + case "num": + return String(e.value); + case "neg": + return `-(${show(e.arg)})`; + case "add": + return `(${show(e.left)} + ${show(e.right)})`; + case "ref": + return "ref"; + } +} + +let checksum = 0; +for (let round = 0; round < 50; round++) { + const tree = build(6, round); + const simple = simplify(tree); + checksum += evaluate(tree) * 3 + evaluate(simple); + // A cycle through a record arm: the tree refers back to itself. + const target: { expr: Expr | null } = { expr: null }; + const loop: Expr = { kind: "add", left: tree, right: { kind: "ref", target } }; + target.expr = { kind: "num", value: round }; + checksum += evaluate(loop); + target.expr = loop.left; +} +console.log(checksum); +console.log(show(simplify(build(3, 5)))); +console.log(show(build(2, 4)), evaluate(build(4, 2))); + +const shared: Expr = { kind: "num", value: 4 }; +const twice: Expr = { kind: "add", left: shared, right: shared }; +console.log(evaluate(twice), twice.kind === "add" && twice.left === twice.right); diff --git a/tests/corpus/5933-record-union-conversions.ts b/tests/corpus/5933-record-union-conversions.ts new file mode 100644 index 000000000..80b411a9b --- /dev/null +++ b/tests/corpus/5933-record-union-conversions.ts @@ -0,0 +1,78 @@ +// Record unions meet other representations: widening into unions with +// string and number arms, narrowing back, `in` tests on undiscriminated +// arms, generic helpers, class fields and promises. +type Point = { x: number; y: number }; +type Named = { name: string }; +type Item = Point | Named; +type Wide = Item | string | number; + +function describe(i: Item): string { + return "x" in i ? `point(${i.x},${i.y})` : `named(${i.name})`; +} + +function widen(i: Item): Wide { + return i; +} + +function narrow(w: Wide): Item | undefined { + if (typeof w === "string" || typeof w === "number") return undefined; + return w; +} + +const items: Item[] = [{ x: 1, y: 2 }, { name: "a" }, { x: 3, y: 4 }]; +const wide: Wide[] = items.map(widen); +wide.push("text", 42); +for (const w of wide) { + const back = narrow(w); + console.log(typeof w, back === undefined ? "-" : describe(back), back !== undefined && items.includes(back)); +} + +// Generic helpers instantiate over the union. +function firstWhere(xs: T[], pred: (x: T) => boolean): T | undefined { + for (const x of xs) if (pred(x)) return x; + return undefined; +} +const named = firstWhere(items, (i) => "name" in i); +console.log(named === items[1], named !== undefined ? describe(named) : "none"); +const pair: [Item, Item] = [items[2]!, items[0]!]; +const [p0, p1] = pair; +console.log(describe(p0), describe(p1)); + +// Class fields and methods. +class Cursor { + private at: Item; + readonly seen: Item[] = []; + constructor(start: Item) { + this.at = start; + } + move(next: Item): Item { + const prev = this.at; + this.seen.push(prev); + this.at = next; + return prev; + } + get current(): Item { + return this.at; + } +} +const cursor = new Cursor(items[0]!); +for (const i of items) cursor.move(i); +console.log(describe(cursor.current), cursor.seen.map(describe).join(" ")); + +// Promises carry union payloads. +async function load(i: number): Promise { + await null; + return items[i % items.length]!; +} +async function main(): Promise { + const loaded: Item[] = []; + for (const i of [0, 1, 5]) loaded.push(await load(i)); + console.log(loaded.map(describe).join(" "), loaded[0] === items[0]); + const slow = new Promise((resolve) => setTimeout(() => resolve({ x: 9, y: 9 }), 5)); + const raced = await Promise.race([load(1), slow]); + console.log(describe(raced)); + const pending: Promise[] = [load(2), load(0)]; + const all = await Promise.all(pending); + console.log(all.map(describe).join(" "), all[1] === items[0]); +} +main().then(() => console.log("done")); diff --git a/tests/corpus/5934-record-union-set-members.ts b/tests/corpus/5934-record-union-set-members.ts new file mode 100644 index 000000000..46f838870 --- /dev/null +++ b/tests/corpus/5934-record-union-set-members.ts @@ -0,0 +1,25 @@ +// A record union used as Set elements and Map keys keeps the runtime's +// tagged representation; other unions over the same records convert to and +// from it without changing identity semantics. +type Point = { x: number; y: number }; +type Named = { name: string }; +type Item = Point | Named; + +const items: Item[] = [{ x: 1, y: 2 }, { name: "a" }, { x: 3, y: 4 }]; +const marked = new Set(); +marked.add(items[0]!); +marked.add(items[0]!); +marked.add({ x: 1, y: 2 }); +console.log(marked.size, marked.has(items[0]!), marked.has(items[1]!)); + +const counts = new Map(); +for (const i of [...items, items[0]!, items[2]!]) counts.set(i, (counts.get(i) ?? 0) + 1); +console.log([...counts.values()].join(",")); + +function maybeItem(i: number): Item | undefined { + return i < items.length ? items[i] : undefined; +} +for (let i = 0; i < 4; i++) { + const m = maybeItem(i); + console.log(i, m === undefined ? "none" : "x" in m ? m.x : m.name, m !== undefined && marked.has(m)); +} From 714ef5aa09f02c2b4487ea1faf60600d08aec0aa Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 14:48:38 -0700 Subject: [PATCH 03/47] Prove array lengths stable in index loops and version dense array loops Index loops over arrays left the counter a double in several common shapes, and every element access at the counter tested the array's hole-free prefix on each pass: - A syntactic proof (ir/array-length-stability.ts) shows that a loop never changes an array's length: the body runs no user code, never rebinds the array or lets it escape, and only resizes local arrays that no other binding can hold. Element writes at a counter kept below the length are accepted. - Counted loops take a stable `a.length` as their limit, and an element access at the counter makes an unversioned counted loop worthwhile, so strided (`i += 2`) and descending (`i = a.length - 1; i >= 0`) loops get an integer counter. - Array lengths bound while-loop and for-loop counters by their range, which needs no stability proof. - A loop whose array length is stable and whose indexed arrays keep their storage runs as two copies. One test before the loop (the length is at most 2^31 - 1 and at most each indexed array's `filled` bound) selects a fast copy whose element accesses at the counter skip the prefix test and whose counter is an int32. LLVM can vectorize that copy. - Loop counters whose ranges fit in 32 bits convert to double from their low half, so an inlined callee's index conversion folds away. Co-Authored-By: Claude Opus 5.5 --- .../src/backend/llvm/dense-array-access.ts | 18 +- .../backend/llvm/dense-array-loops.test.ts | 131 +++++++++ .../src/backend/llvm/dense-array-loops.ts | 218 +++++++++++++++ packages/compiler/src/backend/llvm/emitter.ts | 108 +++++++- .../src/backend/llvm/expr-containers.ts | 11 +- .../src/backend/llvm/expr-primitives.ts | 24 +- .../src/backend/llvm/integer-values.ts | 7 +- .../src/ir/array-length-stability.test.ts | 129 +++++++++ .../compiler/src/ir/array-length-stability.ts | 259 ++++++++++++++++++ .../compiler/src/ir/integer-loop-facts.ts | 29 +- .../compiler/src/ir/integer-loops.test.ts | 108 ++++++++ packages/compiler/src/ir/integer-loops.ts | 58 +++- .../compiler/src/ir/integer-ranges.test.ts | 55 +++- .../corpus/5960-array-length-loop-resizing.ts | 167 +++++++++++ .../corpus/5961-array-length-sparse-loops.ts | 133 +++++++++ .../5962-array-dense-loop-boundaries.ts | 173 ++++++++++++ 16 files changed, 1599 insertions(+), 29 deletions(-) create mode 100644 packages/compiler/src/backend/llvm/dense-array-loops.test.ts create mode 100644 packages/compiler/src/backend/llvm/dense-array-loops.ts create mode 100644 packages/compiler/src/ir/array-length-stability.test.ts create mode 100644 packages/compiler/src/ir/array-length-stability.ts create mode 100644 tests/corpus/5960-array-length-loop-resizing.ts create mode 100644 tests/corpus/5961-array-length-sparse-loops.ts create mode 100644 tests/corpus/5962-array-dense-loop-boundaries.ts diff --git a/packages/compiler/src/backend/llvm/dense-array-access.ts b/packages/compiler/src/backend/llvm/dense-array-access.ts index aeaf3e70f..cffa8ee94 100644 --- a/packages/compiler/src/backend/llvm/dense-array-access.ts +++ b/packages/compiler/src/backend/llvm/dense-array-access.ts @@ -47,7 +47,8 @@ interface DenseGuard { * then extends the length over hole states exactly the same way). An index * below the hole-free prefix bound branches to `filledLabel` first; both * that block and the returned (state-checked) dense block may use the - * guard's values. */ + * guard's values. A `proven` index is known to lie below the bound (a dense + * array loop's fast copy, dense-array-loops.ts) and always takes it. */ function emitDenseGuard( host: LlvmEmitterContext, array: string, @@ -56,6 +57,7 @@ function emitDenseGuard( slow: string, requireBelowLen: boolean, filledLabel: string, + proven = false, ): DenseGuard { const B = host.B; const size = host.sizeType; @@ -137,8 +139,10 @@ function emitDenseGuard( B.line(`${offset} = trunc i64 ${wide} to i32`); } // The bound never exceeds the length or the dense capacity. - let inFilled = B.tmp(); - B.line(`${inFilled} = icmp ult i64 ${wide}, ${filledWide}`); + // The proof covers the counter's integer value only. + const below = proven && integral === null; + let inFilled = below ? "true" : B.tmp(); + if (!below) B.line(`${inFilled} = icmp ult i64 ${wide}, ${filledWide}`); if (integral) { const t = B.tmp(); B.line(`${t} = and i1 ${integral}, ${inFilled}`); @@ -272,6 +276,7 @@ export function emitDenseArrayGet( element: IrType, getter: string, retain: boolean, + proven = false, ): string { const B = host.B; const ty = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr"; @@ -285,7 +290,7 @@ export function emitDenseArrayGet( const slow = B.newLabel("arr.get.slow"), join = B.newLabel("arr.get.join"), valueLabel = B.newLabel("arr.get.value"); - const guard = emitDenseGuard(host, array, index, indexExpr, slow, true, valueLabel); + const guard = emitDenseGuard(host, array, index, indexExpr, slow, true, valueLabel, proven); const state = loadState(host, guard); const present = B.tmp(); B.line(`${present} = icmp eq i8 ${state}, ${SCR_ARR_VALUE}`); @@ -331,6 +336,7 @@ export function emitDenseArrayNumber( array: string, index: LlValue, indexExpr: IrExpr | undefined, + proven = false, ): string { return emitDenseArrayGet( host, @@ -341,6 +347,7 @@ export function emitDenseArrayNumber( { kind: "f64" }, "scr_arr_get_number", false, + proven, ); } @@ -399,6 +406,7 @@ export function emitDenseArraySet( acc: ArrayAccess, element: IrType, value: string, + proven = false, ): void { const B = host.B; const ty = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr"; @@ -413,7 +421,7 @@ export function emitDenseArraySet( const slow = B.newLabel("arr.set.slow"), join = B.newLabel("arr.set.join"), filledLabel = B.newLabel("arr.set.filled"); - const guard = emitDenseGuard(host, array, index, indexExpr, slow, false, filledLabel); + const guard = emitDenseGuard(host, array, index, indexExpr, slow, false, filledLabel, proven); const { offset, len } = guard; const storeValue = (valuePtr: string): void => { if (acc === "f64") { diff --git a/packages/compiler/src/backend/llvm/dense-array-loops.test.ts b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts new file mode 100644 index 000000000..d9e18d7ef --- /dev/null +++ b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts @@ -0,0 +1,131 @@ +import { expect, test } from "vitest"; +import { BOOL, F64, arrayOf, type IrExpr, type IrLocal, type IrStmt } from "../../ir/ir.js"; +import { countedDenseShape, matchDenseArrayLoop, type DenseLoopShape } from "./dense-array-loops.js"; + +const loc = { file: "dense-array-loops.ts", start: 0, end: 0 }; +const ARR = arrayOf(F64); +const num = (value: number): IrExpr => ({ kind: "numLit", value, type: F64, loc }); +const ref = (localId: string): IrExpr => ({ kind: "varRef", localId, type: F64, loc }); +const arr = (localId: string): IrExpr & { kind: "varRef" } => ({ + kind: "varRef", + localId, + type: ARR, + loc, +}); +const method = ( + receiver: string, + name: Extract["method"], + args: IrExpr[] = [], +): IrExpr => ({ kind: "arrIntrinsic", method: name, receiver: arr(receiver), args, type: F64, loc }); +const read = (receiver: string, index = ref("i")): IrExpr => + method(receiver, "getNumber", [index]); +const write = (receiver: string, value: IrExpr, index = ref("i")): IrStmt => ({ + kind: "arraySet", + arr: arr(receiver), + index, + value, + loc, +}); +const locals = new Map([ + ["i", { id: "i", name: "i", type: F64, mutable: true }], + ["a", { id: "a", name: "a", type: ARR, mutable: false }], + ["b", { id: "b", name: "b", type: ARR, mutable: true }], + ["c", { id: "c", name: "c", type: ARR, mutable: false }], +]); + +/** for (let i = 0; i < a.length; i++) body */ +function loop(body: IrStmt[]): IrStmt & { kind: "for" } { + return { + kind: "for", + loc, + init: { kind: "varDecl", localId: "i", init: num(0), loc }, + cond: { kind: "bin", op: "<", left: ref("i"), right: method("a", "length"), type: BOOL, loc }, + update: { + kind: "assign", + localId: "i", + value: { kind: "bin", op: "+", left: ref("i"), right: num(1), type: F64, loc }, + loc, + }, + body, + }; +} +const shape: DenseLoopShape = { counter: "i", length: arr("a"), range: { min: 0, max: 4294967294 } }; +const match = (body: IrStmt[], initialized = new Set(["a", "b"])) => + matchDenseArrayLoop(loop(body), shape, locals, new Set(), initialized); + +test("arrays indexed at the counter of a length-preserving loop get an int32 fast copy", () => { + const scale = write("b", { + kind: "bin", + op: "*", + left: read("a"), + right: num(2), + type: F64, + loc, + }); + const dense = match([scale]); + expect([...dense!.arrays.keys()].sort()).toEqual(["a", "b"]); + expect(dense!.range).toEqual({ min: 0, max: 2147483646 }); + // A binding not definitely assigned before the loop is not read by the guard. + expect([...match([scale], new Set())!.arrays.keys()]).toEqual(["a"]); +}); + +test("loops that may resize, rebind or move storage keep the ordinary copy only", () => { + expect(match([{ kind: "exprStmt", expr: method("a", "push", [num(1)]), loc }])).toBeNull(); + expect(match([write("a", num(0), ref("unknown"))])).toBeNull(); + expect( + match([{ kind: "exprStmt", expr: { kind: "call", callee: "f", args: [], type: F64, loc }, loc }]), + ).toBeNull(); + // A nested loop would be duplicated too. + expect(match([{ kind: "exprStmt", expr: read("a"), loc }, loop([])])).toBeNull(); + // No access at the counter: nothing to prove. + expect(match([{ kind: "exprStmt", expr: read("a", num(0)), loc }])).toBeNull(); + // Copying the bounding array into another binding lets it escape. + expect( + match([ + { kind: "exprStmt", expr: read("a"), loc }, + { kind: "assign", localId: "b", value: arr("a"), loc }, + ]), + ).toBeNull(); + // A rebound array is not covered, but the bounding array still is. + const rebound = match([ + { kind: "exprStmt", expr: read("b"), loc }, + { kind: "exprStmt", expr: read("a"), loc }, + { kind: "assign", localId: "b", value: arr("c"), loc }, + ]); + expect([...rebound!.arrays.keys()]).toEqual(["a"]); +}); + +test("counted shapes need a non-negative counter strictly below the length", () => { + const ascending = (limit: IrExpr, inclusive: boolean, min = 0) => + countedDenseShape(loop([]), { + localId: "i", + start: num(min), + limit, + step: 1, + inclusive, + range: { min, max: 100 }, + }); + const minus = (offset: number): IrExpr => ({ + kind: "bin", + op: "-", + left: method("a", "length"), + right: num(offset), + type: F64, + loc, + }); + expect(ascending(method("a", "length"), false)?.length.localId).toBe("a"); + expect(ascending(minus(1), true)?.length.localId).toBe("a"); + expect(ascending(method("a", "length"), true)).toBeNull(); + expect(ascending(minus(1), false, -1)).toBeNull(); + const descending = (offset: number) => + countedDenseShape(loop([]), { + localId: "i", + start: minus(offset), + limit: num(0), + step: -1, + inclusive: true, + range: { min: 0, max: 100 }, + }); + expect(descending(1)?.length.localId).toBe("a"); + expect(descending(0)).toBeNull(); +}); diff --git a/packages/compiler/src/backend/llvm/dense-array-loops.ts b/packages/compiler/src/backend/llvm/dense-array-loops.ts new file mode 100644 index 000000000..5009e6c82 --- /dev/null +++ b/packages/compiler/src/backend/llvm/dense-array-loops.ts @@ -0,0 +1,218 @@ +/* Dense array loops: a versioned copy of an index loop over an array whose + * length the loop never changes. + * + * `for (let i = 0; i < a.length; i++) b[i] = a[i] * 2` reads its bound from + * `a`, and every element access at the counter normally tests the index + * against the array's hole-free prefix bound (`filled`, see + * dense-array-access.ts) before it touches the slot. When the loop provably + * never changes `a.length` (ir/array-length-stability.ts) and never moves or + * cuts the storage of the arrays it indexes, one test before the loop covers + * every pass: if `a.length` is at most each indexed array's `filled` bound, + * every counter value the loop can reach (at least 0, below `a.length`) + * names a present value in dense storage. The fast copy then reads and + * replaces those slots directly, which leaves LLVM a loop without + * per-element branches (vectorizable where the body allows it). The same + * test bounds `a.length` by 2^31 - 1, so the fast copy's counter is an int32. + * Arrays longer than that are sparse in practice (a dense one would need + * 16 GB of slots) and take the ordinary copy, as does every array with a + * hole, present undefined or sparse storage below `a.length`. */ + +import type { IrExpr, IrLocal, IrStmt } from "../../ir/ir.js"; +import type { IntegerRange } from "../../ir/integer-ranges.js"; +import { preservesArrayLength } from "../../ir/array-length-stability.js"; +import { everyExprChild, everyStmtChild } from "../../ir/traverse.js"; +import type { LlvmEmitterContext } from "./expr-context.js"; +import { SCR_ARR_FIELD } from "./common.js"; + +export const INT32_MAX = 2147483647; + +export interface DenseArrayLoop { + /** The loop's counter binding. */ + counter: string; + /** The array whose length bounds the counter. */ + length: IrExpr & { kind: "varRef" }; + /** Arrays whose accesses at the counter are proven to be inside the + * hole-free prefix in the fast copy, with a read of each binding. */ + arrays: ReadonlyMap; + /** The counter's range on every pass of the fast copy. */ + range: IntegerRange; +} + +/** The fast copy duplicates the loop; keep the duplicated code small. */ +const MAX_LOOP_NODES = 120; + +/** How a matched integer loop bounds its counter below `length.length`. */ +export interface DenseLoopShape { + counter: string; + length: IrExpr & { kind: "varRef" }; + /** The counter's proven range on every pass of the ordinary loop; the + * fast copy keeps its minimum, which must be at least 0. */ + range: IntegerRange; +} + +/** `length.length - c` (c an integer literal, 0 when absent). */ +function lengthOffset(e: IrExpr): { receiver: IrExpr & { kind: "varRef" }; offset: number } | null { + let offset = 0; + if ( + e.kind === "bin" && + e.op === "-" && + e.right.kind === "numLit" && + Number.isSafeInteger(e.right.value) + ) { + offset = e.right.value; + e = e.left; + } + return e.kind === "arrIntrinsic" && + e.method === "length" && + e.args.length === 0 && + e.receiver.kind === "varRef" && + e.receiver.type.kind === "array" + ? { receiver: e.receiver, offset } + : null; +} + +/** The array bounding a counted loop's counter below its length: an + * ascending loop compared below `a.length - c`, or a descending one starting + * at `a.length - c` (c >= 1). */ +export function countedDenseShape( + loop: IrStmt & { kind: "for" }, + counted: { + localId: string; + start: IrExpr; + limit: IrExpr; + step: number; + inclusive: boolean; + range: IntegerRange; + }, +): DenseLoopShape | null { + if (counted.range.min < 0) return null; + if (counted.step > 0) { + const bound = lengthOffset(counted.limit); + if (!bound || bound.offset < (counted.inclusive ? 1 : 0)) return null; + return { counter: counted.localId, length: bound.receiver, range: counted.range }; + } + // The start is evaluated once, before the loop; the counter only falls. + const start = lengthOffset(counted.start); + if (!start || start.offset < 1 || loop.init?.kind !== "varDecl") return null; + return { counter: counted.localId, length: start.receiver, range: counted.range }; +} + +/** Match the fast copy of a loop of the given shape. `initialized` holds the + * bindings definitely assigned when the loop starts; `unaliased` the local + * arrays no other binding holds. */ +export function matchDenseArrayLoop( + loop: IrStmt & { kind: "for" }, + shape: DenseLoopShape, + locals: ReadonlyMap, + unaliased: ReadonlySet, + initialized: ReadonlySet, +): DenseArrayLoop | null { + const { counter, length } = shape; + if (shape.range.min < 0 || !loop.cond) return null; + let nodes = 0, + nested = false; + const candidates = new Map(); + // Arrays written, resized, or indexed other than at the counter by an + // element write. + const disturbed = new Set(); + const access = (arr: IrExpr, index: IrExpr): void => { + if (arr.kind === "varRef" && index.kind === "varRef" && index.localId === counter) + candidates.set(arr.localId, arr); + }; + const expr = (e: IrExpr): boolean => { + if (++nodes > MAX_LOOP_NODES) return false; + if (e.kind === "assignExpr" || e.kind === "incDec") disturbed.add(e.localId); + if (e.kind === "arrayGet") access(e.arr, e.index); + if (e.kind === "arrIntrinsic") { + if (e.method === "getNumber" && e.args[0]) access(e.receiver, e.args[0]); + else if (e.method !== "length" && e.receiver.kind === "varRef") + disturbed.add(e.receiver.localId); + } + return everyExprChild(e, expr, stmt); + }; + const stmt = (s: IrStmt): boolean => { + if (++nodes > MAX_LOOP_NODES) return false; + if (s.kind === "for" || s.kind === "while" || s.kind === "doWhile" || s.kind === "forOf") + nested = true; + if (s.kind === "assign" || s.kind === "varDecl") disturbed.add(s.localId); + if (s.kind === "arraySet") { + access(s.arr, s.index); + if ( + s.arr.kind === "varRef" && + (s.index.kind !== "varRef" || s.index.localId !== counter) + ) + disturbed.add(s.arr.localId); + } + return everyStmtChild(s, expr, stmt); + }; + if (!loop.body.every(stmt) || !expr(loop.cond) || nested) return null; + if ( + !preservesArrayLength( + [loop.cond, ...loop.body], + { receiver: length.localId, inRange: counter }, + locals, + unaliased, + ) + ) + return null; + const arrays = new Map(); + for (const [id, ref] of candidates) { + const local = locals.get(id); + if ( + !local || + local.type.kind !== "array" || + local.boxed || + local.tdz || + disturbed.has(id) || + (id !== length.localId && !initialized.has(id)) + ) + continue; + arrays.set(id, ref); + } + if (arrays.size === 0) return null; + return { + counter, + length, + arrays, + range: { min: shape.range.min, max: Math.min(shape.range.max, INT32_MAX - 1) }, + }; +} + +/** The fast copy's entry test: the bounding length is at most 2^31 - 1 and + * at most every indexed array's hole-free prefix bound. */ +export function emitDenseLoopGuard(host: LlvmEmitterContext, loop: DenseArrayLoop): string { + const B = host.B; + const size = host.sizeType; + const header = (array: string, field: number): string => { + const ptr = B.tmp(); + B.line(`${ptr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 ${field}`); + host.markMemoryPointer(ptr, "array:header"); + return ptr; + }; + const receiver = host.emitStableReceiver(loop.length, []); + const lenPtr = header(receiver.name, 1), + len = B.tmp(), + small = B.tmp(); + B.line( + `${len} = load ${size}, ptr ${lenPtr}${host.fieldAliasAttachment(lenPtr)}${host.arrayLengthRange}`, + ); + B.line(`${small} = icmp ule ${size} ${len}, ${INT32_MAX}`); + let valid = small; + for (const [id, ref] of loop.arrays) { + const array = id === loop.length.localId ? receiver : host.emitStableReceiver(ref, []); + const filledPtr = header(array.name, SCR_ARR_FIELD.filled), + filled = B.tmp(), + covered = B.tmp(), + both = B.tmp(); + B.line(`${filled} = load i32, ptr ${filledPtr}${host.fieldAliasAttachment(filledPtr)}`); + let bound = filled; + if (size === "i64") { + bound = B.tmp(); + B.line(`${bound} = zext i32 ${filled} to i64`); + } + B.line(`${covered} = icmp ule ${size} ${len}, ${bound}`); + B.line(`${both} = and i1 ${valid}, ${covered}`); + valid = both; + } + return valid; +} diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 2c3a71457..634cf8d79 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -55,6 +55,13 @@ import { matchIntegerBytesForLoop, matchIntegerCountedForLoop, } from "../../ir/integer-loops.js"; +import { findUnaliasedLocalArrays } from "../../ir/array-length-stability.js"; +import { + countedDenseShape, + emitDenseLoopGuard, + matchDenseArrayLoop, + type DenseArrayLoop, +} from "./dense-array-loops.js"; import { emitCountedLoopLimit } from "./counted-loops.js"; import { emitSafeIntegerCheck, @@ -638,6 +645,21 @@ export class LlEmitter { return this.sizeType === "i64" ? ", !range !{i64 0, i64 4294967296}" : ""; } + /** Whether an element access at `index` of `arr` lies in the hole-free + * prefix: the counter of a dense array loop's fast copy indexing one of + * the arrays its entry test covered. */ + provenDenseIndex(arr: IrExpr, index: IrExpr): boolean { + const loop = this.denseLoop; + return ( + loop !== null && + arr.kind === "varRef" && + loop.arrays.has(arr.localId) && + index.kind === "varRef" && + index.localId === loop.counter && + this.integerLoopBindings.has(loop.counter) + ); + } + fieldAliasAttachment(ptr: string): string { const tag = this.fieldPointerTags.get(ptr); return tag === undefined ? "" : `, !tbaa !${tag}`; @@ -991,6 +1013,14 @@ export class LlEmitter { * immortal from construction (classes.ts programLifetimeClass). */ readonly programLifetime: ReadonlySet; private numericLocals = new Map(); + /** Local arrays of the current function that no other binding can hold + * (ir/array-length-stability.ts). */ + private unaliasedArrays: ReadonlySet = new Set(); + /** Dense array loops (dense-array-loops.ts) run in this function. */ + private denseLoopsEnabled = false; + private denseLoopEntries: ReturnType = new Map(); + /** The fast copy of a dense array loop being emitted. */ + private denseLoop: DenseArrayLoop | null = null; private captureIds = new Set(); /** Active induction bindings retain their width independently of size_t. */ integerLoopBindings = new Map< @@ -6553,6 +6583,7 @@ export class LlEmitter { const initializerBindings = this.initializerBindings.get(fn.name) ?? []; const numericFn = withInitializerBindings(fn, initializerBindings); this.numericLocals = new Map(numericFn.locals.map((l) => [l.id, l])); + this.unaliasedArrays = findUnaliasedLocalArrays(fn); this.borrowedParameters.clear(); this.referenceWrites?.enter(fn); this.reboundOwnerSlots.clear(); @@ -6591,6 +6622,12 @@ export class LlEmitter { this.finalFieldBorrows = !fn.async && !fn.generator && constructorClass(fn.name) === null && this.finalFields.size > 0; this.byteWindowsEnabled = this.countedLoopsEnabled; + this.denseLoopsEnabled = this.countedLoopsEnabled; + this.denseLoop = null; + this.denseLoopEntries = + this.denseLoopsEnabled && numericFn.locals.some((l) => l.type.kind === "array") + ? findInitializedByteLoopBindings(fn) + : new Map(); this.byteWindowEntries = this.byteWindowsEnabled && numericFn.locals.some((l) => l.type.kind === "bytes") ? findInitializedByteLoopBindings(fn) @@ -8030,7 +8067,16 @@ export class LlEmitter { const acc = elemAccess(s.arr.type.elem); this.emitPublishedArrayGuard(arr.name, s.arr.type, 0, idx.name); if (acc === "ref") this.moveTemp(v); - emitDenseArraySet(this, arr.name, idx, s.index, acc, s.arr.type.elem, v.name); + emitDenseArraySet( + this, + arr.name, + idx, + s.index, + acc, + s.arr.type.elem, + v.name, + this.provenDenseIndex(s.arr, s.index), + ); break; } case "arraySetLength": { @@ -8447,7 +8493,12 @@ export class LlEmitter { (this.debug === null ? matchIntegerBytesForLoop(s, this.numericLocals) : null); const countedLoop = !integerLoop && this.countedLoopsEnabled - ? matchIntegerCountedForLoop(s, this.numericLocals, this.integerRanges) + ? matchIntegerCountedForLoop( + s, + this.numericLocals, + this.integerRanges, + this.unaliasedArrays, + ) : null; const window = countedLoop && this.byteWindowsEnabled @@ -8460,6 +8511,49 @@ export class LlEmitter { this.byteWindowEntries.get(s) ?? new Set(), ) : null; + const denseShape = !this.denseLoopsEnabled + ? null + : integerArrayLoop + ? { + counter: integerArrayLoop.localId, + length: integerArrayLoop.limitReceiver as IrExpr & { kind: "varRef" }, + range: { min: 0, max: 4294967294 }, + } + : countedLoop && !countedLoop.guarded + ? countedDenseShape(s, countedLoop) + : null; + const dense = + denseShape && !window + ? matchDenseArrayLoop( + s, + denseShape, + this.numericLocals, + this.unaliasedArrays, + this.denseLoopEntries.get(s) ?? new Set(), + ) + : null; + if (dense) { + const valid = emitDenseLoopGuard(this, dense); + const fast = B.newLabel("dense.loop.fast"), + slow = B.newLabel("dense.loop.slow"), + done = B.newLabel("dense.loop.done"); + B.condBr(valid, fast, slow); + this.denseLoopsEnabled = false; + try { + B.startBlock(slow); + this.emitStmt(s); + B.br(done); + B.startBlock(fast); + this.denseLoop = dense; + this.emitStmt(s); + B.br(done); + } finally { + this.denseLoop = null; + this.denseLoopsEnabled = true; + } + B.startBlock(done); + break; + } if (window) { const valid = emitByteWindowGuard(this, window); const fast = B.newLabel("bytes.window.fast"), @@ -8562,7 +8656,10 @@ export class LlEmitter { this.integerLoopBindings.set(integerLoop.localId, { slot: integerSlot, type: this.sizeType, - range: { min: 0, max: integerArrayLoop ? 4294967294 : Number.MAX_SAFE_INTEGER - 1 }, + range: + this.denseLoop?.counter === integerLoop.localId + ? this.denseLoop.range + : { min: 0, max: integerArrayLoop ? 4294967294 : Number.MAX_SAFE_INTEGER - 1 }, }); } else if (countedLoop) { integerSlot = B.slot(); @@ -8577,7 +8674,10 @@ export class LlEmitter { slot: integerSlot, type: "i64", signed: true, - range: countedLoop.range, + range: + this.denseLoop?.counter === countedLoop.localId + ? this.denseLoop.range + : countedLoop.range, }); countedLimit = emitCountedLoopLimit(this, countedLoop); } else if (s.init) { diff --git a/packages/compiler/src/backend/llvm/expr-containers.ts b/packages/compiler/src/backend/llvm/expr-containers.ts index a2d5fd35a..1b0f1e638 100644 --- a/packages/compiler/src/backend/llvm/expr-containers.ts +++ b/packages/compiler/src/backend/llvm/expr-containers.ts @@ -571,7 +571,16 @@ export function emitArrIntrinsic( ? host.constantNumericTables.get(e.receiver.localId) : undefined; if (!table && elem.kind === "f64") - return { name: emitDenseArrayNumber(host, r.name, index, e.args[0]), type: e.type }; + return { + name: emitDenseArrayNumber( + host, + r.name, + index, + e.args[0], + host.provenDenseIndex(e.receiver, e.args[0]!), + ), + type: e.type, + }; host.declare(`declare double @scr_arr_get_number(ptr, double)`); const t = B.tmp(); B.line( diff --git a/packages/compiler/src/backend/llvm/expr-primitives.ts b/packages/compiler/src/backend/llvm/expr-primitives.ts index aaae4c35c..664689e91 100644 --- a/packages/compiler/src/backend/llvm/expr-primitives.ts +++ b/packages/compiler/src/backend/llvm/expr-primitives.ts @@ -64,16 +64,25 @@ export function emitLiteralExpr( const integer = B.tmp(); const number = B.tmp(); B.line(`${integer} = load ${integerSlot.type}, ptr ${integerSlot.slot}`); - // A 64-bit induction value is a safe integer, so its sign bit is - // clear and the signed conversion is exact: one cvtsi2sd instead of - // x86-64's multi-instruction unsigned 64-bit conversion. - const signedConversion = integerSlot.signed === true || integerSlot.type === "i64"; - B.line( - `${number} = ${signedConversion ? "sitofp" : "uitofp"} ${integerSlot.type} ${integer} to double`, - ); const uint32 = integerSlot.type === "i32" ? integer : B.tmp(); if (integerSlot.type !== "i32") B.line(`${uint32} = trunc ${integerSlot.type} ${integer} to i32`); + // A counter whose range fits 32 bits converts from its low half, so + // LLVM folds a later `fptosi` of the double (an inlined callee's + // index) back to the integer. Otherwise a 64-bit induction value is + // a safe integer, so its sign bit is clear and the signed conversion + // is exact: one cvtsi2sd instead of x86-64's multi-instruction + // unsigned 64-bit conversion. + const range = integerSlot.range; + const signedConversion = integerSlot.signed === true || integerSlot.type === "i64"; + if (range && range.min >= -2147483648 && range.max <= 2147483647) + B.line(`${number} = sitofp i32 ${uint32} to double`); + else if (range && range.min >= 0 && range.max <= 4294967295) + B.line(`${number} = uitofp i32 ${uint32} to double`); + else + B.line( + `${number} = ${signedConversion ? "sitofp" : "uitofp"} ${integerSlot.type} ${integer} to double`, + ); return { name: number, type: e.type, @@ -851,6 +860,7 @@ export function emitContainerExpr( elem, `scr_arr_get_${acc}`, true, + host.provenDenseIndex(e.arr, e.index), ); return host.own({ name: t, type: e.type }); } diff --git a/packages/compiler/src/backend/llvm/integer-values.ts b/packages/compiler/src/backend/llvm/integer-values.ts index 63e279d04..53e07462e 100644 --- a/packages/compiler/src/backend/llvm/integer-values.ts +++ b/packages/compiler/src/backend/llvm/integer-values.ts @@ -93,11 +93,16 @@ export function integerNumber( // `x | 0`), while a 64-bit source is not known to convert exactly. So a // counter written `i = (i + 1) | 0` stays an integer instead of taking a // double round trip on every iteration. + // A uint32 (an array index counter) converts from its low half unsigned, + // which LLVM likewise folds back through a later `fptosi` to i64. const int32 = range.min >= -2147483648 && range.max <= 2147483647; + const unsigned = !int32 && range.min >= 0 && range.max <= 4294967295; host.B.line( int32 ? `${number} = sitofp i32 ${uint32} to double` - : `${number} = sitofp i64 ${name} to double`, + : unsigned + ? `${number} = uitofp i32 ${uint32} to double` + : `${number} = sitofp i64 ${name} to double`, ); return { name: number, type, uint32, integer: { name, type: "i64", signed: true, range } }; } diff --git a/packages/compiler/src/ir/array-length-stability.test.ts b/packages/compiler/src/ir/array-length-stability.test.ts new file mode 100644 index 000000000..87e510a3f --- /dev/null +++ b/packages/compiler/src/ir/array-length-stability.test.ts @@ -0,0 +1,129 @@ +import { expect, test } from "vitest"; +import { findUnaliasedLocalArrays, preservesArrayLength } from "./array-length-stability.js"; +import { BOOL, F64, arrayOf, type IrExpr, type IrFunction, type IrLocal, type IrStmt } from "./ir.js"; + +const loc = { file: "array-length-stability.ts", start: 0, end: 0 }; +const ARR = arrayOf(F64); +const num = (value: number): IrExpr => ({ kind: "numLit", value, type: F64, loc }); +const ref = (localId: string): IrExpr => ({ kind: "varRef", localId, type: F64, loc }); +const arr = (localId: string): IrExpr => ({ kind: "varRef", localId, type: ARR, loc }); +const method = ( + receiver: string, + name: Extract["method"], + args: IrExpr[] = [], +): IrExpr => ({ kind: "arrIntrinsic", method: name, receiver: arr(receiver), args, type: F64, loc }); +const length = (receiver: string): IrExpr => method(receiver, "length"); +const read = (receiver: string, index: IrExpr): IrExpr => method(receiver, "getNumber", [index]); +const plus = (left: IrExpr, right: IrExpr): IrExpr => ({ + kind: "bin", + op: "+", + left, + right, + type: F64, + loc, +}); +const stmt = (expr: IrExpr): IrStmt => ({ kind: "exprStmt", expr, loc }); +const set = (receiver: string, index: IrExpr, value: IrExpr): IrStmt => ({ + kind: "arraySet", + arr: arr(receiver), + index, + value, + loc, +}); +const cond: IrExpr = { kind: "bin", op: "<", left: ref("i"), right: length("a"), type: BOOL, loc }; +const sum: IrStmt = { + kind: "assign", + localId: "s", + value: plus(ref("s"), read("a", ref("i"))), + loc, +}; +const locals = new Map([ + ["i", { id: "i", name: "i", type: F64, mutable: true }], + ["s", { id: "s", name: "s", type: F64, mutable: true }], + ["a", { id: "a", name: "a", type: ARR, mutable: false }], + ["b", { id: "b", name: "b", type: ARR, mutable: false }], + ["out", { id: "out", name: "out", type: ARR, mutable: false }], +]); +const preserves = ( + body: IrStmt[], + inRange: string | null = "i", + unaliased: ReadonlySet = new Set(), + scope = locals, +): boolean => preservesArrayLength([cond, ...body], { receiver: "a", inRange }, scope, unaliased); + +test("reads, local arithmetic and element writes at the in-range counter keep the length", () => { + expect(preserves([sum])).toBe(true); + expect(preserves([set("a", ref("i"), num(1)), set("b", ref("i"), read("a", ref("i")))])).toBe( + true, + ); + expect(preserves([stmt(method("a", "indexOf", [num(3)]))])).toBe(true); +}); + +test("writes past the counter, without an in-range counter, or to the counter can grow it", () => { + expect(preserves([set("a", plus(ref("i"), num(1)), num(1))])).toBe(false); + expect(preserves([set("b", ref("s"), num(1))])).toBe(false); + expect(preserves([set("a", ref("i"), num(1))], null)).toBe(false); + expect(preserves([{ kind: "assign", localId: "i", value: num(0), loc }, sum])).toBe(false); +}); + +test("resizing methods, length stores, calls and escapes refuse the proof", () => { + for (const name of ["push", "pop", "shift", "unshift", "splice", "fill"] as const) + expect(preserves([stmt(method("a", name, [num(1)]))])).toBe(false); + // An unrelated array may alias the receiver. + expect(preserves([stmt(method("b", "push", [num(1)]))])).toBe(false); + expect(preserves([{ kind: "arraySetLength", arr: arr("a"), length: num(0), loc }])).toBe(false); + expect(preserves([{ kind: "arrayDelete", arr: arr("a"), index: ref("i"), loc }])).toBe(false); + expect(preserves([stmt({ kind: "call", callee: "f", args: [], type: F64, loc })])).toBe(false); + expect( + preserves([stmt({ kind: "call", callee: "f", args: [arr("a")], type: F64, loc })]), + ).toBe(false); + expect(preserves([{ kind: "varDecl", localId: "b", init: arr("a"), loc }])).toBe(false); + expect(preserves([{ kind: "assign", localId: "a", value: arr("b"), loc }])).toBe(false); +}); + +test("an unaliased local array other than the receiver may grow", () => { + const push = stmt(method("out", "push", [read("a", ref("i"))])); + expect(preserves([push], "i", new Set(["out"]))).toBe(true); + expect(preserves([set("out", ref("s"), num(1))], "i", new Set(["out"]))).toBe(true); + expect(preserves([push])).toBe(false); + // The receiver itself is never resized, even when no alias exists. + expect(preserves([stmt(method("a", "push", [num(1)]))], "i", new Set(["a"]))).toBe(false); +}); + +test("captured receivers have no local proof", () => { + const boxed = new Map(locals); + boxed.set("a", { ...locals.get("a")!, boxed: true }); + expect(preserves([sum], "i", new Set(), boxed)).toBe(false); +}); + +function fn(body: IrStmt[], params: string[] = []): IrFunction { + return { + loc, + name: "f", + params: params.map((localId) => ({ localId, type: ARR })), + returnType: ARR, + locals: [...locals.values()], + body, + } as IrFunction; +} +const fresh: IrExpr = { kind: "arrayLit", elems: [], type: ARR, loc }; + +test("fresh local arrays read only as receivers have no alias", () => { + const body: IrStmt[] = [ + { kind: "varDecl", localId: "out", init: fresh, loc }, + stmt(method("out", "push", [num(1)])), + { kind: "return", value: arr("out"), loc }, + ]; + expect([...findUnaliasedLocalArrays(fn(body))]).toEqual(["out"]); + // Parameters, copies into another binding, and arguments escape. + expect(findUnaliasedLocalArrays(fn(body, ["out"])).size).toBe(0); + const copied = [...body, { kind: "varDecl", localId: "b", init: arr("out"), loc } as IrStmt]; + expect(findUnaliasedLocalArrays(fn(copied)).has("out")).toBe(false); + const passed = [ + ...body, + stmt({ kind: "call", callee: "g", args: [arr("out")], type: F64, loc }), + ]; + expect(findUnaliasedLocalArrays(fn(passed)).has("out")).toBe(false); + const rebound = [...body, { kind: "assign", localId: "out", value: arr("a"), loc } as IrStmt]; + expect(findUnaliasedLocalArrays(fn(rebound)).has("out")).toBe(false); +}); diff --git a/packages/compiler/src/ir/array-length-stability.ts b/packages/compiler/src/ir/array-length-stability.ts new file mode 100644 index 000000000..2ac196d30 --- /dev/null +++ b/packages/compiler/src/ir/array-length-stability.ts @@ -0,0 +1,259 @@ +import type { IrExpr, IrFunction, IrLocal, IrStmt } from "./ir.js"; +import { isBorrowSafeMath } from "./analysis.js"; +import { byteNumberAccess } from "./byte-numbers.js"; +import { everyExprChild, everyStmtChild } from "./traverse.js"; + +/** Array methods that read the receiver without changing its length or its + * slot states and run no user code. */ +const READING_ARRAY_METHODS = new Set([ + "length", + "getNumber", + "indexEq", + "indexOf", + "includes", + "nextPresent", +]); + +/** String methods that read an immutable string and run no user code. */ +const READING_STRING_METHODS = new Set(["length", "charCodeAt", "codePointAt"]); + +/** Expressions that compute from their operands and run no user code. Their + * children are checked separately. */ +const PLAIN_EXPRESSIONS = new Set([ + "numLit", + "strLit", + "boolLit", + "unitLit", + "varRef", + "bin", + "unary", + "incDec", + "toBool", + "logical", + "ternary", + "strEq", + "strCmp", + "fieldGet", + "recordGet", + "unionNarrow", + "unionIsTag", + "unionDisc", + "unionWrap", + "upcast", + "downcast", + "instanceOf", + "nullish", + "seqExpr", +]); + +/** Statements whose own effect is a local write or control flow inside the + * loop. Their children are checked separately. */ +const PLAIN_STATEMENTS = new Set([ + "varDecl", + "assign", + "exprStmt", + "if", + "block", + "break", + "continue", + "for", + "while", + "doWhile", +]); + +/** Array methods whose result is never the receiver itself (unlike + * `reverse`, `fill` or `copyWithin`, which return it). */ +const CONTAINED_RECEIVER_METHODS = new Set([ + ...READING_ARRAY_METHODS, + "push", + "pop", + "shift", + "unshift", + "splice", + "join", + "slice", +]); + +/** Local arrays that no other binding can hold: every write of the local + * stores a fresh array literal and every read of it is the receiver of an + * element access or array method (or the value of a `return`, which ends the + * activation). No alias of such an array exists, so mutating it cannot change + * the length of an array held by any other binding. */ +export function findUnaliasedLocalArrays(fn: IrFunction): ReadonlySet { + const candidates = new Set(); + const captured = new Set( + [...(fn.captures ?? []), ...(fn.classCaptures ?? [])].map((c) => c.localId), + ); + for (const local of fn.locals) + if (local.type.kind === "array" && !local.boxed && !local.tdz && !captured.has(local.id)) + candidates.add(local.id); + for (const param of fn.params) candidates.delete(param.localId); + const written = new Set(); + const fresh = (value: IrExpr | null): boolean => + value !== null && (value.kind === "arrayLit" || value.kind === "arrayNewLen"); + const receiver = (e: IrExpr): void => { + if (e.kind !== "varRef") expr(e); + }; + const expr = (e: IrExpr): boolean => { + switch (e.kind) { + case "varRef": + candidates.delete(e.localId); + return true; + case "assignExpr": + candidates.delete(e.localId); + break; + case "arrIntrinsic": + if (!CONTAINED_RECEIVER_METHODS.has(e.method)) break; + receiver(e.receiver); + e.args.forEach(expr); + return true; + case "arrayGet": + case "arrayHas": + case "arrayState": + receiver(e.arr); + expr(e.index); + return true; + } + return everyExprChild(e, expr, stmt); + }; + const stmt = (s: IrStmt): boolean => { + switch (s.kind) { + case "varDecl": + case "assign": { + const value = s.kind === "varDecl" ? s.init : s.value; + if (fresh(value)) written.add(s.localId); + else if (value) candidates.delete(s.localId); + if (value) expr(value); + return true; + } + case "arraySet": + receiver(s.arr); + expr(s.index); + expr(s.value); + return true; + case "return": + if (s.value) receiver(s.value); + return true; + case "forOf": + case "tryCatch": + if (s.kind === "forOf") candidates.delete(s.localId); + if (s.kind === "tryCatch" && s.catchLocalId) candidates.delete(s.catchLocalId); + break; + } + return everyStmtChild(s, expr, stmt); + }; + fn.body.every(stmt); + // A binding with no visible write takes its value some other way. + for (const id of candidates) if (!written.has(id)) candidates.delete(id); + return candidates; +} + +export interface ArrayLengthLoop { + /** The local holding the array whose length must not change. */ + receiver: string; + /** A binding that holds a value below the array's length wherever the + * loop's condition, body or update reads it (the induction variable of + * `for (let i = 0; i < a.length; i++)` when the body never writes it, as + * long as the length itself has not changed). An element write at this + * index replaces an existing element or sets a non-index property. */ + inRange: string | null; +} + +/** Whether running `nodes` (a loop's condition, body and update) can never + * change the length of the array held by local `loop.receiver`. The proof is + * syntactic and conservative: every expression and statement must be one + * that runs no user code (no calls, callbacks, closures, iterators, + * suspension or exception regions); the binding is never written and only + * ever read as the receiver of an element access or a reading array method, + * so the array cannot escape to code that resizes it; and nothing in the + * nodes resizes any array that may be the same one. Element writes are + * accepted at the in-range binding (no array grows by them: an alias of the + * receiver has the same length) and anywhere in an unaliased local array. + * Array methods that resize an array are accepted only on unaliased local + * arrays other than the receiver. */ +export function preservesArrayLength( + nodes: readonly (IrExpr | IrStmt)[], + loop: ArrayLengthLoop, + locals: ReadonlyMap, + unaliased: ReadonlySet, +): boolean { + const local = locals.get(loop.receiver); + if (!local || local.type.kind !== "array" || local.boxed || local.tdz) return false; + const separate = (e: IrExpr): boolean => + e.kind === "varRef" && e.localId !== loop.receiver && unaliased.has(e.localId); + // A receiver position: the receiver binding itself is read there without + // escaping. + const receiver = (e: IrExpr): boolean => + (e.kind === "varRef" && e.localId === loop.receiver) || expr(e); + const written = (id: string): boolean => id === loop.receiver || id === loop.inRange; + const expr = (e: IrExpr): boolean => { + switch (e.kind) { + case "varRef": + return e.localId !== loop.receiver; + case "assignExpr": + case "incDec": + return !written(e.localId) && everyExprChild(e, expr, stmt); + case "arrayGet": + case "arrayHas": + case "arrayState": + return receiver(e.arr) && expr(e.index); + case "arrIntrinsic": + if (READING_ARRAY_METHODS.has(e.method)) return receiver(e.receiver) && e.args.every(expr); + return separate(e.receiver) && e.args.every(expr); + case "strIntrinsic": + return ( + READING_STRING_METHODS.has(e.method) && + e.receiver.type.kind === "string" && + expr(e.receiver) && + e.args.every(expr) + ); + case "bytesIntrinsic": { + const numeric = byteNumberAccess(e); + return ( + (numeric ? !numeric.write : e.method === "get" || e.method === "length") && + expr(e.receiver) && + e.args.every(expr) + ); + } + case "libCall": + return ( + isBorrowSafeMath(e.fn) && + e.args.every((arg) => arg.type.kind === "f64") && + e.args.every(expr) + ); + case "strConcat": + return ( + e.left.type.kind === "string" && + e.right.type.kind === "string" && + expr(e.left) && + expr(e.right) + ); + default: + return PLAIN_EXPRESSIONS.has(e.kind) && everyExprChild(e, expr, stmt); + } + }; + const stmt = (s: IrStmt): boolean => { + switch (s.kind) { + case "varDecl": + case "assign": + if (written(s.localId)) return false; + break; + case "arraySet": + return ( + (separate(s.arr) || + (s.index.kind === "varRef" && + loop.inRange !== null && + s.index.localId === loop.inRange)) && + receiver(s.arr) && + expr(s.index) && + expr(s.value) + ); + case "return": + return s.value === null || expr(s.value); + default: + if (!PLAIN_STATEMENTS.has(s.kind)) return false; + } + return everyStmtChild(s, expr, stmt); + }; + return nodes.every((node) => ("type" in node ? expr(node as IrExpr) : stmt(node as IrStmt))); +} diff --git a/packages/compiler/src/ir/integer-loop-facts.ts b/packages/compiler/src/ir/integer-loop-facts.ts index 4c1a1ef1f..84fabf956 100644 --- a/packages/compiler/src/ir/integer-loop-facts.ts +++ b/packages/compiler/src/ir/integer-loop-facts.ts @@ -118,6 +118,9 @@ export function boundedIntegerLoopFacts( stable(e.receiver.localId) ) return { min: 0, max: Number.MAX_SAFE_INTEGER }; + // Every evaluation of an array length lies in its range, so the + // condition bounds each pass even when the body resizes the array. + if (isArrayLength(e)) return ARRAY_LENGTH_RANGE; return null; } let step: IntegerRange; @@ -134,12 +137,15 @@ export function boundedIntegerLoopFacts( if (step.min <= 0 || step.max > 2147483647) return result; } const limit = bound(loop.cond.right); - if (!limit || limit.max < start.min) return result; - const distance = limit.max - start.min; + // The counter is an integer, so a strict bound admits passes up to one + // below the limit. + const last = limit && (loop.cond.op === "<" ? limit.max - 1 : limit.max); + if (!limit || last === null || last < start.min) return result; + const distance = last - start.min; const iterations = Math.floor(distance / step.min) + 1; if (!Number.isSafeInteger(distance) || !Number.isSafeInteger(iterations)) return result; // Header facts also cover the failing final condition and zero iterations. - const maximum = Math.max(start.max, limit.max + step.max); + const maximum = Math.max(start.max, last + step.max); if (Number.isSafeInteger(maximum)) result.set(counter, { min: start.min, max: maximum }); for (const [id, hi] of upper) { const range = initial.get(id); @@ -154,6 +160,20 @@ export function boundedIntegerLoopFacts( return result; } +/** Every length an array can have: SCR_ARR_MAX_LENGTH (scr_array.c). */ +export const ARRAY_LENGTH_RANGE: IntegerRange = { min: 0, max: 4294967295 }; + +/** `a.length` of a typed array value (an ordinary JS array). */ +function isArrayLength(e: IrExpr): boolean { + return ( + e.kind === "arrIntrinsic" && + e.method === "length" && + e.args.length === 0 && + e.type.kind === "f64" && + e.receiver.type.kind === "array" + ); +} + /** The most UTF-16 code units a runtime string holds: SCR_STR_MAX_CAP * (scr_runtime.h) caps a string's UTF-8 bytes, and a UTF-16 length never * exceeds the UTF-8 byte length. */ @@ -241,6 +261,9 @@ export function guardedLoopCounterFacts( stable(e.receiver.localId) ) return { min: 0, max: STRING_MAX_UNITS }; + // An array length can change on any pass, but never leaves its range, + // which is all a ceiling needs. + if (isArrayLength(e)) return ARRAY_LENGTH_RANGE; return null; }; // The bounds a condition's conjuncts put on counters while it holds. diff --git a/packages/compiler/src/ir/integer-loops.test.ts b/packages/compiler/src/ir/integer-loops.test.ts index 0f7b9ae13..75968b262 100644 --- a/packages/compiler/src/ir/integer-loops.test.ts +++ b/packages/compiler/src/ir/integer-loops.test.ts @@ -208,3 +208,111 @@ test("a string read at the counter is an integer consumer", () => { s.body = [read(ref("limit"))]; expect(matchIntegerCountedForLoop(s, withText)).toBeNull(); }); + +test("a stable array length bounds a counted loop; a resizing body keeps it a condition", () => { + const ARR = arrayOf(F64); + const array = (localId: string): IrExpr => ({ kind: "varRef", localId, type: ARR, loc }); + const length: IrExpr = { + kind: "arrIntrinsic", + method: "length", + receiver: array("a"), + args: [], + type: F64, + loc, + }; + const read = (index: IrExpr): IrExpr => ({ + kind: "arrIntrinsic", + method: "getNumber", + receiver: array("a"), + args: [index], + type: F64, + loc, + }); + // for (let i = 0; i < a.length; i += 2) a[i]; + const strided = (body: IrStmt[]): IrStmt & { kind: "for" } => { + const s = counted(length); + s.update = { + kind: "assign", + localId: "i", + value: { kind: "bin", op: "+", left: ref("i"), right: number(2), type: F64, loc }, + loc, + }; + s.body = [{ kind: "exprStmt", expr: read(ref("i")), loc }, ...body]; + return s; + }; + const ranges = new Map([[length, { min: 0, max: 4294967295 }]]); + expect(matchIntegerCountedForLoop(strided([]), locals, ranges, new Set())).toMatchObject({ + localId: "i", + guarded: false, + range: { min: 0, max: 4294967294 }, + }); + // Without the alias facts there is no stability proof. + expect(matchIntegerCountedForLoop(strided([]), locals, ranges)).toBeNull(); + const push: IrStmt = { + kind: "exprStmt", + expr: { + kind: "arrIntrinsic", + method: "push", + receiver: array("a"), + args: [number(1)], + type: F64, + loc, + }, + loc, + }; + expect(matchIntegerCountedForLoop(strided([push]), locals, ranges, new Set())).toBeNull(); + // An element write at the counter stays below the length; one past it can grow the array. + const write = (index: IrExpr): IrStmt => ({ + kind: "arraySet", + arr: array("a"), + index, + value: number(0), + loc, + }); + expect( + matchIntegerCountedForLoop(strided([write(ref("i"))]), locals, ranges, new Set()), + ).not.toBeNull(); + const past = { kind: "bin", op: "+", left: ref("i"), right: number(1), type: F64, loc } as const; + expect(matchIntegerCountedForLoop(strided([write(past)]), locals, ranges, new Set())).toBeNull(); +}); + +test("a descending loop from an array's last index takes an integer counter for its reads", () => { + const ARR = arrayOf(F64); + const length: IrExpr = { + kind: "arrIntrinsic", + method: "length", + receiver: { kind: "varRef", localId: "a", type: ARR, loc }, + args: [], + type: F64, + loc, + }; + const start: IrExpr = { kind: "bin", op: "-", left: length, right: number(1), type: F64, loc }; + const s = loop(start); + s.cond = { kind: "bin", op: ">=", left: ref("i"), right: number(0), type: BOOL, loc }; + s.update = { + kind: "assign", + localId: "i", + value: { kind: "bin", op: "-", left: ref("i"), right: number(1), type: F64, loc }, + loc, + }; + s.body = [ + { + kind: "exprStmt", + expr: { + kind: "arrIntrinsic", + method: "getNumber", + receiver: { kind: "varRef", localId: "a", type: ARR, loc }, + args: [ref("i")], + type: F64, + loc, + }, + loc, + }, + ]; + const ranges = new Map([[start, { min: -1, max: 4294967294 }]]); + expect(matchIntegerCountedForLoop(s, locals, ranges)).toMatchObject({ + step: -1, + guarded: false, + range: { min: 0, max: 4294967294 }, + }); +}); diff --git a/packages/compiler/src/ir/integer-loops.ts b/packages/compiler/src/ir/integer-loops.ts index c854a99c5..3ba186376 100644 --- a/packages/compiler/src/ir/integer-loops.ts +++ b/packages/compiler/src/ir/integer-loops.ts @@ -3,6 +3,7 @@ import type { IntegerRange, IntegerRanges } from "./integer-ranges.js"; import { everyExprChild, everyStmtChild, everyStmtList } from "./traverse.js"; import { byteNumberAccess } from "./byte-numbers.js"; +import { preservesArrayLength } from "./array-length-stability.js"; /** A canonical byte loop whose induction variable is mathematically an * unsigned integer for every body entry. Backends may keep this binding in @@ -47,15 +48,17 @@ function constantStep(update: IrStmt | null, id: string): number | null { } /** Pure initial values may be evaluated again on a fallback path. Bounds - * additionally have to remain invariant throughout the loop. Array length - * is allowed only in the initializer; its mutable value is never hoisted - * from a condition. Typed-array lengths are fixed for a given receiver. */ + * additionally have to remain invariant throughout the loop. An array length + * is hoisted from a condition only when `stableLength` proves the loop never + * changes it; otherwise it is allowed only in the initializer. Typed-array + * lengths are fixed for a given receiver. */ function stableLoopValue( value: IrExpr, locals: ReadonlyMap, body: IrStmt[], invariant: boolean, counter: string, + stableLength: (receiver: string) => boolean = () => false, ): boolean { switch (value.kind) { case "numLit": @@ -77,16 +80,16 @@ function stableLoopValue( value.op === "&" || value.op === ">>>" || value.op === "|") && - stableLoopValue(value.left, locals, body, invariant, counter) && - stableLoopValue(value.right, locals, body, invariant, counter) + stableLoopValue(value.left, locals, body, invariant, counter, stableLength) && + stableLoopValue(value.right, locals, body, invariant, counter, stableLength) ); case "bytesIntrinsic": case "arrIntrinsic": return ( (value.method === "length" || (value.kind === "bytesIntrinsic" && value.method === "byteLength")) && - (value.kind === "bytesIntrinsic" || !invariant) && value.receiver.kind === "varRef" && + (value.kind === "bytesIntrinsic" || !invariant || stableLength(value.receiver.localId)) && stableLoopValue(value.receiver, locals, body, invariant, counter) ); default: @@ -103,6 +106,7 @@ export function matchIntegerCountedForLoop( stmt: IrStmt & { kind: "for" }, locals: ReadonlyMap, ranges: IntegerRanges = new Map(), + unaliased: ReadonlySet | null = null, ): IntegerCountedForLoop | null { const init = stmt.init; if (init?.kind !== "varDecl" || !init.init) return null; @@ -135,7 +139,38 @@ export function matchIntegerCountedForLoop( op = ({ "<": ">", "<=": ">=", ">": "<", ">=": "<=" } as Record)[op] ?? ""; } if (step > 0 ? op !== "<" && op !== "<=" : op !== ">" && op !== ">=") return null; - if (!stableLoopValue(limit, locals, stmt.body, true, local.id)) return null; + // An ascending counter compared below `a.length - c` holds an index below + // the length on every pass while that length is unchanged. + const belowLength = (receiver: string): boolean => { + let offset = 0, + length = limit; + if ( + length.kind === "bin" && + length.op === "-" && + length.right.kind === "numLit" && + Number.isFinite(length.right.value) + ) { + offset = length.right.value; + length = length.left; + } + return ( + step > 0 && + length.kind === "arrIntrinsic" && + length.method === "length" && + length.receiver.kind === "varRef" && + length.receiver.localId === receiver && + (op === "<" ? offset >= 0 : offset >= 1) + ); + }; + const stableLength = (receiver: string): boolean => + unaliased !== null && + preservesArrayLength( + [cond, ...stmt.body], + { receiver, inRange: belowLength(receiver) ? local.id : null }, + locals, + unaliased, + ); + if (!stableLoopValue(limit, locals, stmt.body, true, local.id, stableLength)) return null; const inclusive = op === "<=" || op === ">="; const guardLimit = step > 0 ? 2 ** 53 - (inclusive ? 1 : 0) : -(2 ** 53) + (inclusive ? 1 : 0); const boundRange = @@ -178,10 +213,19 @@ export function matchIntegerCountedForLoop( // A string read at the counter indexes with the integer directly. if (e.kind === "strIntrinsic" && e.method === "charCodeAt" && e.args[0] && counter(e.args[0])) useful = true; + // So does an array element read; only a loop that needs no versioned + // copy takes the integer counter for it. + if ( + !guarded && + ((e.kind === "arrayGet" && counter(e.index)) || + (e.kind === "arrIntrinsic" && e.method === "getNumber" && e.args[0] && counter(e.args[0]))) + ) + useful = true; return (!guarded || ++cost <= 80) && everyExprChild(e, expr, bodyStmt); }; const bodyStmt = (s: IrStmt): boolean => { if (s.kind === "bytesSet" && counter(s.index)) useful = true; + if (!guarded && s.kind === "arraySet" && counter(s.index)) useful = true; if ( guarded && (s.kind === "for" || s.kind === "forOf" || s.kind === "while" || s.kind === "doWhile") diff --git a/packages/compiler/src/ir/integer-ranges.test.ts b/packages/compiler/src/ir/integer-ranges.test.ts index e9d1797d1..0d0762d16 100644 --- a/packages/compiler/src/ir/integer-ranges.test.ts +++ b/packages/compiler/src/ir/integer-ranges.test.ts @@ -334,7 +334,8 @@ test("filtered strided loops retain decoded values and bound secondary cursors", const ranges = analyzeIntegerRanges(f); expect(ranges.get(cursor)).toEqual({ min: 0, max: 80 }); expect(ranges.get(decoded)).toEqual({ min: 0, max: 4294967295 }); - expect(ranges.get(conditionRead)).toEqual({ min: 0, max: 124 }); + // The last pass enters at most at 99, so the failing test reads at most 123. + expect(ranges.get(conditionRead)).toEqual({ min: 0, max: 123 }); for (const mutation of ["fraction", "repeat", "overflow", "counter"] as const) { const changed = structuredClone(f); const body = (changed.body[1] as IrStmt & { kind: "for" }).body; @@ -795,6 +796,58 @@ test("a while condition on a string's length bounds a counter, and guarded incre expect(run((inside) => [observe(inside), bump, rebound]).after).toBeNull(); }); +test("an array length bounds while and for counters even when the body resizes the array", () => { + // let i = 0; while (i < items.length) { observe(i); items.push(i); i++; } observe(i); + const ARR = { kind: "array", elem: F64 } as const; + const items: IrExpr = { loc, kind: "varRef", localId: "items", type: ARR }; + const length: IrExpr = { loc, kind: "arrIntrinsic", method: "length", receiver: items, args: [], type: F64 }; + const push: IrStmt = { + loc, + kind: "exprStmt", + expr: { loc, kind: "arrIntrinsic", method: "push", receiver: items, args: [ref("i")], type: F64 }, + }; + const bump: IrStmt = { + loc, + kind: "exprStmt", + expr: { loc, kind: "incDec", op: "+", prefix: false, localId: "i", type: F64 }, + }; + const inside = ref("i"), + after = ref("i"); + const f = fn([ + { loc, kind: "assign", localId: "i", value: num(0) }, + { loc, kind: "while", cond: condition("<", ref("i"), length), body: [observe(inside), push, bump] }, + observe(after), + ]); + f.locals.push( + { id: "i", name: "i", type: F64, mutable: true }, + { id: "items", name: "items", type: ARR, mutable: false }, + ); + const ranges = analyzeIntegerRanges(f); + expect(ranges.get(inside)).toEqual({ min: 0, max: 4294967294 }); + expect(ranges.get(after)).toEqual({ min: 0, max: 4294967295 }); + // A secondary cursor of `for (let j = 0; j < items.length; j++) k++` stays a uint32. + const cursor = ref("k"); + const loop: IrStmt = { + loc, + kind: "for", + init: { loc, kind: "varDecl", localId: "j", init: num(0) }, + cond: condition("<", ref("j"), length), + update: { loc, kind: "assign", localId: "j", value: bin("+", ref("j"), num(1)) }, + body: [ + push, + observe(cursor), + { loc, kind: "assign", localId: "k", value: bin("+", ref("k"), num(1)) }, + ], + }; + const g = fn([{ loc, kind: "assign", localId: "k", value: num(0) }, loop]); + g.locals.push( + { id: "j", name: "j", type: F64, mutable: true }, + { id: "k", name: "k", type: F64, mutable: true }, + { id: "items", name: "items", type: ARR, mutable: false }, + ); + expect(analyzeIntegerRanges(g).get(cursor)).toEqual({ min: 0, max: 4294967295 }); +}); + test("whole-program slot facts seed parameters, field reads and call results", () => { const field: IrExpr = { loc, diff --git a/tests/corpus/5960-array-length-loop-resizing.ts b/tests/corpus/5960-array-length-loop-resizing.ts new file mode 100644 index 000000000..a1d5f6d11 --- /dev/null +++ b/tests/corpus/5960-array-length-loop-resizing.ts @@ -0,0 +1,167 @@ +// Index loops bounded by an array's length whose bodies resize that array, +// directly, through an alias, a helper or a closure: the bound is re-read on +// every pass, exactly like Node. + +function pushInBody(): string { + const a = [1, 2, 3]; + const seen: number[] = []; + for (let i = 0; i < a.length; i++) { + seen.push(a[i]); + if (a.length < 6) a.push(a[i] * 10); + } + return `${seen.join(",")} | ${a.length}`; +} + +function stridedPush(): string { + const a = [0, 1, 2, 3]; + let visits = 0; + for (let i = 0; i < a.length; i += 2) { + visits++; + if (a.length < 9) a.push(i); + } + return `${visits} ${a.join(",")}`; +} + +function truncateInBody(): string { + const a = [5, 6, 7, 8, 9, 10]; + let sum = 0; + for (let i = 0; i < a.length; i++) { + sum += a[i]; + if (i === 2) a.length = 4; + } + return `${sum} ${a.length}`; +} + +function growLengthInBody(): string { + const a = [1, 2]; + let holes = 0; + for (let i = 0; i < a.length; i++) { + if (a[i] === undefined) holes++; + if (i === 0) a.length = 5; + } + return `${holes} ${a.length}`; +} + +function helperPush(xs: number[], v: number): void { + if (xs.length < 7) xs.push(v); +} + +function pushThroughHelper(): string { + const a = [1, 2, 3]; + let sum = 0; + for (let i = 0; i < a.length; i++) { + sum += a[i]; + helperPush(a, i + 100); + } + return `${sum} ${a.length}`; +} + +function pushThroughClosure(): string { + const a = [1, 2, 3]; + const grow = (v: number): void => { + if (a.length < 6) a.push(v); + }; + let sum = 0; + for (let i = 0; i < a.length; i++) { + sum += a[i]; + grow(i); + } + return `${sum} ${a.length}`; +} + +function pushThroughAlias(): string { + const a = [1, 2, 3]; + const alias = a; + let sum = 0; + for (let i = 0; i < a.length; i++) { + sum += a[i]; + if (alias.length < 8) alias.push(i * 2); + } + return `${sum} ${a.length}`; +} + +function aliasedParameters(a: number[], out: number[]): string { + // `out` may be `a` itself. + let n = 0; + for (let i = 0; i < a.length; i++) { + n++; + if (out.length < 10) out.push(a[i]); + } + return `${n} ${a.length} ${out.length}`; +} + +function writePastEnd(): string { + const a = [1, 2, 3]; + let passes = 0; + for (let i = 0; i < a.length; i++) { + passes++; + if (i + 1 === a.length && a.length < 6) a[i + 1] = i; + } + return `${passes} ${a.join(",")}`; +} + +function shiftInBody(): string { + const a = [1, 2, 3, 4, 5, 6]; + const seen: number[] = []; + for (let i = 0; i < a.length; i++) { + seen.push(a[i]); + a.shift(); + } + return `${seen.join(",")} | ${a.join(",")}`; +} + +function spliceInDescendingLoop(): string { + const a = [1, 2, 3, 4, 5, 6, 7]; + for (let i = a.length - 1; i >= 0; i--) if (a[i] % 2 === 0) a.splice(i, 1); + return a.join(","); +} + +function whilePush(): string { + const a = [3, 1]; + let i = 0; + let sum = 0; + while (i < a.length) { + sum += a[i]; + if (a.length < 5) a.push(sum); + i++; + } + return `${sum} ${i} ${a.join(",")}`; +} + +function nestedResize(): string { + const rows = [[1], [2, 3], [4, 5, 6]]; + let total = 0; + for (let r = 0; r < rows.length; r++) { + const row = rows[r]; + for (let c = 0; c < row.length; c++) { + total += row[c]; + if (row.length < 3) row.push(c); + } + } + return `${total} ${rows.map((row) => row.length).join(",")}`; +} + +function pushIntoOther(): string { + const a = [2, 4, 6]; + const out: number[] = []; + for (let i = 0; i < a.length; i++) out.push(a[i] + 1); + for (let i = 0; i < out.length; i += 2) out.push(-1); + return `${out.join(",")}`; +} + +console.log(pushInBody()); +console.log(stridedPush()); +console.log(truncateInBody()); +console.log(growLengthInBody()); +console.log(pushThroughHelper()); +console.log(pushThroughClosure()); +console.log(pushThroughAlias()); +const shared = [7, 8, 9]; +console.log(aliasedParameters(shared, shared)); +console.log(aliasedParameters([7, 8, 9], [])); +console.log(writePastEnd()); +console.log(shiftInBody()); +console.log(spliceInDescendingLoop()); +console.log(whilePush()); +console.log(nestedResize()); +console.log(pushIntoOther()); diff --git a/tests/corpus/5961-array-length-sparse-loops.ts b/tests/corpus/5961-array-length-sparse-loops.ts new file mode 100644 index 000000000..589c1df60 --- /dev/null +++ b/tests/corpus/5961-array-length-sparse-loops.ts @@ -0,0 +1,133 @@ +// Index loops over sparse arrays with lengths beyond 2^31, holes, and arrays +// that become sparse while a loop runs. Dense-loop fast paths must leave all +// of these on the general path. + +function partialAscending(a: number[], limit: number): string { + let sum = 0; + let passes = 0; + for (let i = 0; i < a.length; i++) { + if (passes++ === limit) break; + sum += a[i] === undefined ? -1 : a[i]; + } + return `${passes} ${sum}`; +} + +function partialDescending(a: number[], limit: number): string { + let last = -1; + let passes = 0; + for (let i = a.length - 1; i >= 0; i--) { + if (passes++ === limit) break; + last = i; + } + return `${passes} ${last}`; +} + +function stridedFromEnd(a: number[]): string { + const hits: number[] = []; + for (let i = a.length - 1; i >= 0 && hits.length < 3; i -= 1000000000) hits.push(i); + return hits.join(","); +} + +function whileWithLimit(a: number[], limit: number): number { + let i = 0; + let present = 0; + while (i < a.length && i < limit) { + if (a[i] !== undefined) present++; + i++; + } + return present * 1000 + i; +} + +function writeAtCounter(a: number[], limit: number): string { + for (let i = 0; i < a.length && i < limit; i++) a[i] = i * 2; + return `${a.length} ${a[0]} ${a[limit - 1]} ${a[limit]}`; +} + +function holeSum(a: number[]): string { + let sum = 0; + let nan = 0; + for (let i = 0; i < a.length; i++) { + const v = a[i]; + if (Number.isNaN(v + 0)) nan++; + else sum += v; + } + return `${sum} ${nan}`; +} + +function firstValues(a: number[]): string { + let s = 0; + for (let i = 0; i < a.length; i++) { + if (i === 4) break; + s += a[i]; + } + let t = 0; + for (let i = a.length - 1; i >= 0; i--) { + if (i < a.length - 2) break; + t += a[i]; + } + let u = 0; + for (let i = 0; i < a.length; i += 2) { + if (i > 2) break; + u += a[i]; + } + return `${s} ${t} ${u}`; +} + +const huge: number[] = [1, 2, 3]; +huge.length = 3e9; +console.log(huge.length); +console.log(partialAscending(huge, 5)); +console.log(firstValues(huge), firstValues([1, 2, 3, 4, 5])); +console.log(partialDescending(huge, 4)); +console.log(stridedFromEnd(huge)); +console.log(whileWithLimit(huge, 6)); +console.log(writeAtCounter(huge, 4)); +console.log(huge.length); + +const edge: number[] = []; +edge[4294967294] = 7; +console.log(edge.length, partialDescending(edge, 2), partialAscending(edge, 3)); + +const holey = [1, 2]; +holey[3] = 4; +holey[5] = 6; +console.log(holeSum(holey)); +const sparse: number[] = [1, 2]; +sparse[10] = 5; +console.log(holeSum(sparse)); + +// Becomes sparse mid-loop: a write far past the end through another binding. +function sparseMidLoop(): string { + const a = [1, 2, 3, 4]; + const b = a; + let sum = 0; + for (let i = 0; i < a.length; i++) { + if (i === 1) b[3000000000] = 9; + if (i > 6) break; + sum += a[i] === undefined ? 100 : a[i]; + } + return `${sum} ${a.length}`; +} +console.log(sparseMidLoop()); + +function holeMidLoop(): string { + const a = [1, 2, 3, 4, 5]; + let sum = 0; + for (let i = 0; i < a.length; i++) { + if (i === 1) a.length = 3; + if (i === 2) a.length = 5; + sum += a[i] === undefined ? 100 : a[i]; + } + return `${sum}`; +} +console.log(holeMidLoop()); + +const objects: { v: number }[] = [{ v: 1 }, { v: 2 }, { v: 3 }]; +objects.length = 5; +try { + let total = 0; + for (let i = 0; i < objects.length; i++) total += objects[i].v; + console.log(total); +} catch (e) { + console.log(e instanceof TypeError ? "TypeError" : "other"); +} diff --git a/tests/corpus/5962-array-dense-loop-boundaries.ts b/tests/corpus/5962-array-dense-loop-boundaries.ts new file mode 100644 index 000000000..5efad78ec --- /dev/null +++ b/tests/corpus/5962-array-dense-loop-boundaries.ts @@ -0,0 +1,173 @@ +// Index loops whose array length the loop never changes, run over dense, +// holey, partially filled, aliased and short arrays, with fractional, +// negative and offset bounds, ascending, strided and descending counters. + +interface Point { + x: number; + y: number; +} + +function sum(a: number[]): number { + let s = 0; + for (let i = 0; i < a.length; i++) s += a[i]; + return s; +} + +function scale(a: number[], b: number[]): string { + for (let i = 0; i < a.length; i++) b[i] = a[i] * 2; + return `${b.length}:${b.join(",")}`; +} + +function inPlace(a: number[]): string { + for (let i = 0; i < a.length; i++) a[i] = a[i] + 1; + return a.join(","); +} + +function strided(a: number[], step: number): string { + let s = 0; + if (step === 2) for (let i = 0; i < a.length; i += 2) s += a[i]; + else for (let i = 1; i < a.length; i += 3) s += a[i]; + return `${s}`; +} + +function descending(a: number[]): string { + const out: number[] = []; + for (let i = a.length - 1; i >= 0; i--) out.push(a[i]); + return out.join(","); +} + +function descendingPairs(a: number[]): number { + let s = 0; + for (let i = a.length - 2; i > 0; i -= 2) s += a[i] - a[i + 1]; + return s; +} + +function offsetBounds(a: number[]): string { + let inner = 0; + for (let i = 1; i < a.length - 1; i++) inner += a[i]; + let inclusive = 0; + for (let i = 0; i <= a.length - 1; i++) inclusive += a[i]; + let diffs = 0; + for (let i = 0; i < a.length - 1; i++) diffs += a[i + 1] - a[i]; + return `${inner} ${inclusive} ${diffs}`; +} + +function fractionalBounds(a: number[]): string { + const seen: number[] = []; + for (let i = 0.5; i < a.length; i++) seen.push(a[i] === undefined ? -1 : 1); + for (let i = -2; i < a.length - 3; i++) seen.push(a[i] === undefined ? -2 : a[i]); + for (let i = 0; i < a.length - 0.5; i++) seen.push(i); + return seen.join(","); +} + +function whileLoop(a: number[]): number { + let i = 0; + let s = 0; + while (i < a.length) { + s += a[i] * i; + i++; + } + return s; +} + +function constLength(a: number[]): number { + const n = a.length; + let s = 0; + for (let i = 0; i < n; i++) s += a[i]; + return s; +} + +function points(ps: Point[]): string { + let s = 0; + for (let i = 0; i < ps.length; i++) s += ps[i].x * ps[i].y; + return `${s}`; +} + +function flags(bs: boolean[]): number { + let n = 0; + for (let i = 0; i < bs.length; i++) if (bs[i]) n++; + return n; +} + +function names(ss: string[]): string { + let out = ""; + for (let i = ss.length - 1; i >= 0; i--) out += ss[i]; + return out; +} + +function maybe(xs: (number | undefined)[]): string { + let s = 0; + let missing = 0; + for (let i = 0; i < xs.length; i++) { + const v = xs[i]; + if (v === undefined) missing++; + else s += v; + } + return `${s} ${missing}`; +} + +function nested(g: number[][]): number { + let s = 0; + for (let r = 0; r < g.length; r++) { + const row = g[r]; + for (let c = 0; c < row.length; c++) s += row[c] * (r + 1); + } + return s; +} + +function counterAsNumber(a: number[]): string { + let mixed = 0; + for (let i = 0; i < a.length; i++) mixed += i / 2 + (i | 0) + a[i] * -0; + return `${mixed} ${Object.is(mixed, -0)}`; +} + +function earlyExit(a: number[], target: number): number { + for (let i = 0; i < a.length; i++) if (a[i] === target) return i; + return -1; +} + +const dense = [1, 2, 3, 4, 5, 6, 7, 8]; +console.log(sum(dense), sum([]), sum([0.5, -0.25])); +console.log(scale(dense, new Array(8).fill(0))); +console.log(scale(dense, [9, 9])); +console.log(scale([1, 2, 3], [])); +const self = [1, 2, 3, 4]; +console.log(scale(self, self)); +console.log(inPlace([10, 20, 30])); +console.log(strided(dense, 2), strided(dense, 3)); +console.log(descending(dense), descending([])); +console.log(descendingPairs(dense), descendingPairs([1])); +console.log(offsetBounds(dense), offsetBounds([4]), offsetBounds([])); +console.log(fractionalBounds([1, 2, 3, 4, 5])); +console.log(whileLoop(dense)); +console.log(constLength(dense)); +console.log(points([{ x: 1, y: 2 }, { x: 3, y: 4 }])); +console.log(flags([true, false, true, true])); +console.log(names(["a", "b", "c"])); +console.log(maybe([1, undefined, 3])); +console.log(nested([[1, 2], [3], [], [4, 5, 6]])); +console.log(counterAsNumber([1, 2, 3])); +console.log(earlyExit(dense, 5), earlyExit(dense, 50)); + +// Holes and partially filled storage take the checked path. +const holey = [1]; +holey[2] = 3; +holey[4] = 5; +console.log(sum(holey), descending(holey), whileLoop(holey)); +const target = [0, 0, 0]; +target[4] = 0; +console.log(scale(dense.slice(0, 5), target)); +const gap: number[] = []; +gap[3] = 1; +console.log(sum(gap), scale([1, 2, 3, 4], gap)); +const shortened = [1, 2, 3, 4, 5, 6]; +shortened.length = 3; +shortened.length = 6; +console.log(sum(shortened), constLength(shortened)); +const holeyPoints: Point[] = [{ x: 1, y: 1 }]; +holeyPoints[2] = { x: 2, y: 2 }; +try { + console.log(points(holeyPoints)); +} catch (e) { + console.log(e instanceof TypeError ? "TypeError" : "other"); +} From 39d2a05f880479d4abc05fede0cd0e1ff01db3d1 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 19:03:50 -0700 Subject: [PATCH 04/47] Renumber the array length loop corpus programs past main's numbers Co-Authored-By: Claude Opus 5.5 --- ...length-loop-resizing.ts => 5993-array-length-loop-resizing.ts} | 0 ...y-length-sparse-loops.ts => 5994-array-length-sparse-loops.ts} | 0 ...nse-loop-boundaries.ts => 5995-array-dense-loop-boundaries.ts} | 0 3 files changed, 0 insertions(+), 0 deletions(-) rename tests/corpus/{5960-array-length-loop-resizing.ts => 5993-array-length-loop-resizing.ts} (100%) rename tests/corpus/{5961-array-length-sparse-loops.ts => 5994-array-length-sparse-loops.ts} (100%) rename tests/corpus/{5962-array-dense-loop-boundaries.ts => 5995-array-dense-loop-boundaries.ts} (100%) diff --git a/tests/corpus/5960-array-length-loop-resizing.ts b/tests/corpus/5993-array-length-loop-resizing.ts similarity index 100% rename from tests/corpus/5960-array-length-loop-resizing.ts rename to tests/corpus/5993-array-length-loop-resizing.ts diff --git a/tests/corpus/5961-array-length-sparse-loops.ts b/tests/corpus/5994-array-length-sparse-loops.ts similarity index 100% rename from tests/corpus/5961-array-length-sparse-loops.ts rename to tests/corpus/5994-array-length-sparse-loops.ts diff --git a/tests/corpus/5962-array-dense-loop-boundaries.ts b/tests/corpus/5995-array-dense-loop-boundaries.ts similarity index 100% rename from tests/corpus/5962-array-dense-loop-boundaries.ts rename to tests/corpus/5995-array-dense-loop-boundaries.ts From 611e81420066767adfa92bf13894ca94472568d3 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 19:30:56 -0700 Subject: [PATCH 05/47] Doom unreferenced cycle components without a scan walk A collector pass used to decide once for all its candidates: if any gray object was still externally referenced after markGray, scan walked every candidate's subgraph again, including the dead structures. A pass almost always has one live structure in it (the one under construction when the trigger fires), so most passes paid a second walk over their garbage. markGray now walks each candidate that no earlier walk reached as its own component and keeps the externally referenced count per component, using the header's buffer word as the component number (gray objects are never buffered during a pass). A component that ends its walk with no externally referenced member is garbage: every reference to its members came from inside it, and no later walk can add one. It is doomed at once, and scan runs only from the candidates of referenced components. Limited passes, whose untaken candidates keep their buffer positions, keep the single whole-pass decision. The freed set of every pass is unchanged. The fast path also stops re-reading the dead set: doomed entries skip settle's filtering loop, the level statistics are counted in the teardown loop that reads the type anyway, and the gray-list push is inline. Co-Authored-By: Claude Opus 5.5 --- packages/runtime/src/scr_cycle.c | 176 +++++++++++++++++++++++++------ 1 file changed, 141 insertions(+), 35 deletions(-) diff --git a/packages/runtime/src/scr_cycle.c b/packages/runtime/src/scr_cycle.c index 229122e71..08b43186c 100644 --- a/packages/runtime/src/scr_cycle.c +++ b/packages/runtime/src/scr_cycle.c @@ -31,9 +31,11 @@ * releases are separate paths. White candidates are recorded during scan * and filtered after outside roots settle, avoiding a separate gather walk. * markGray also records the objects it grays and counts those still - * externally referenced (rc > 0 after the trial decrements). When none is, - * every gray object is garbage, which is what scan would find, so the pass - * whitens the recorded set and skips scan. + * externally referenced (rc > 0 after the trial decrements), per pass and + * per component: the objects first reached from one candidate. A component + * with none is garbage, which is what scan would find, so the pass dooms it + * at once; scan runs only when some component is externally referenced, + * and only from there (see scr_cyc_pass). * * ── generations ────────────────────────────────────────────────────── * A pass costs O(objects reachable from its candidates), and a candidate @@ -200,6 +202,9 @@ typedef struct { size_t trigger; size_t alloc_trigger; size_t gray_referenced; + size_t comp_referenced; + uint32_t gray_comp; + ScrVec live_ranges; size_t scheduled_mature_age; size_t xg_freed; size_t mature_dead; @@ -231,6 +236,9 @@ static _Thread_local ScrCycThread scr_cyc_thread = {.gen_limit = SCR_CYC_OLD}; #define scr_cyc_trigger (scr_cyc_thread.trigger) #define scr_cyc_alloc_trigger (scr_cyc_thread.alloc_trigger) #define scr_gray_referenced (scr_cyc_thread.gray_referenced) +#define scr_comp_referenced (scr_cyc_thread.comp_referenced) +#define scr_gray_comp (scr_cyc_thread.gray_comp) +#define scr_live_ranges (scr_cyc_thread.live_ranges) #define scr_cyc_scheduled_mature_age (scr_cyc_thread.scheduled_mature_age) #define scr_xg_freed (scr_cyc_thread.xg_freed) #define scr_cyc_mature_dead (scr_cyc_thread.mature_dead) @@ -316,7 +324,7 @@ void *scr_cyc_alloc(size_t size, ScrCycType *type) { void scr_cyc_free(void *obj) { scr_cyc_free_inline(obj); } -static void scr_cyc_grow(ScrVec *vec) { +static __attribute__((noinline, cold)) void scr_cyc_grow(ScrVec *vec) { /* Candidate positions are 31-bit (ScrCycHdr.buf). */ if (vec->cap > (size_t)(SCR_CYC_BUFFERED_BIT - 1) / 2) scr_cyc_oom(); vec->cap = vec->cap ? vec->cap * 2 : 64; @@ -337,6 +345,16 @@ static inline void scr_cyc_push_work(ScrVec *vec, void *obj) { if (vec->n > vec->used) vec->used = vec->n; } +/* The same push inline, for the gray list markGray fills once per object; + * the pass records the list's high-water mark itself (scr_cyc_note_used). */ +static inline void scr_cyc_push_gray(ScrVec *vec, void *obj) { + if (__builtin_expect(vec->n == vec->cap, 0)) scr_cyc_grow(vec); + vec->v[vec->n++] = obj; +} +static inline void scr_cyc_note_used(ScrVec *vec) { + if (vec->n > vec->used) vec->used = vec->n; +} + /* ── the candidate-root buffers (one per generation) ──────────────────── */ #ifndef SCR_WORKERS @@ -500,9 +518,19 @@ static SCR_TL size_t scr_cyc_alloc_trigger = 0; #endif /* Gray objects whose count is above zero after the trial decrements so far * (see scr_mg_visit). markGray records the gray objects in scr_white while - * there are fewer than SCR_CYC_GRAY_LIST_MAX; a larger walk runs scan. */ + * there are fewer than SCR_CYC_GRAY_LIST_MAX; a larger walk runs scan. + * + * The same count is kept per component (see "components" at scr_cyc_pass): + * the objects one candidate's walk grays first carry that walk's number in + * `buf` (gray objects are never buffered during a pass), and + * scr_comp_referenced counts those still externally referenced. + * scr_live_ranges holds (start, end) ranges of scr_white whose component + * was externally referenced and is left to scan. */ #ifndef SCR_WORKERS static SCR_TL size_t scr_gray_referenced = 0; +static SCR_TL size_t scr_comp_referenced = 0; +static SCR_TL uint32_t scr_gray_comp = 0; +static SCR_TL ScrVec scr_live_ranges; #endif #define SCR_CYC_GRAY_LIST_MAX 65536 @@ -907,7 +935,7 @@ void scr_cyc_on_release(void *obj) { /* Trace callbacks forward an integer depth through their opaque context; * it is never dereferenced. The ABI already carries it through every edge. */ -static void scr_mark_gray(void *obj, uintptr_t depth); +static inline __attribute__((always_inline)) void scr_mark_gray(void *obj, uintptr_t depth); static void scr_mg_visit(void *child, void *ctx) { if (child == NULL || SCR_RC(child) == SIZE_MAX) return; if (scr_cyc_gen(scr_cyc_hdr(child)) > scr_gen_limit) { @@ -916,18 +944,28 @@ static void scr_mg_visit(void *child, void *ctx) { return; } size_t rc = --SCR_RC(child); - if (scr_cyc_color(scr_cyc_hdr(child)) == SCR_CYC_GRAY) { - if (rc == 0) scr_gray_referenced--; + ScrCycHdr *h = scr_cyc_hdr(child); + if (scr_cyc_color(h) == SCR_CYC_GRAY) { + if (rc == 0) { + scr_gray_referenced--; + if (h->buf == scr_gray_comp) scr_comp_referenced--; + } return; } scr_mark_gray(child, (uintptr_t)ctx); } -static void scr_mark_gray(void *obj, uintptr_t depth) { +static inline __attribute__((always_inline)) void scr_mark_gray(void *obj, uintptr_t depth) { ScrCycHdr *h = scr_cyc_hdr(obj); if (scr_cyc_color(h) == SCR_CYC_GRAY) return; scr_cyc_set_color(h, SCR_CYC_GRAY); - if (scr_white.n < SCR_CYC_GRAY_LIST_MAX) scr_cyc_push_work(&scr_white, obj); - if (SCR_RC(obj) > 0) scr_gray_referenced++; + /* A limited pass can gray candidates it did not take; they keep their + * buffer position and are simply never counted as members. */ + if (!scr_cyc_is_buffered(h)) h->buf = scr_gray_comp; + if (scr_white.n < SCR_CYC_GRAY_LIST_MAX) scr_cyc_push_gray(&scr_white, obj); + if (SCR_RC(obj) > 0) { + scr_gray_referenced++; + scr_comp_referenced++; + } if (depth == SCR_CYC_WALK_DEPTH) { scr_cyc_push_work(&scr_pending, obj); return; @@ -948,6 +986,9 @@ static void scr_sb_visit(void *child, void *ctx) { static void scr_scan_black(void *obj, uintptr_t depth) { ScrCycHdr *h = scr_cyc_hdr(obj); scr_cyc_set_color(h, SCR_CYC_BLACK); + /* Drop markGray's component number: a survivor leaves the pass unbuffered + * unless it is a candidate that a limited pass did not take. */ + if (!scr_cyc_is_buffered(h)) scr_cyc_clear_buffered(h); if (scr_cyc_gen(h) < SCR_CYC_OLD) scr_cyc_push_work(&scr_promote, obj); if (depth == SCR_CYC_WALK_DEPTH) { scr_cyc_push_work(&scr_restore_pending, obj); @@ -1054,22 +1095,28 @@ static SCR_CYC_COMPACT void scr_xg_release(void *obj) { * spend their time in the trace and teardown calls they make, so this half is * built for size; the graph walk above it stays fully optimized. Returns how * many objects the pass freed. */ -static SCR_CYC_COMPACT size_t scr_cyc_settle(unsigned gen_limit) { +static SCR_CYC_COMPACT size_t scr_cyc_settle(unsigned gen_limit, bool doomed) { size_t dead = 0; scr_cyc_mature_dead = 0; - for (size_t i = 0; i < scr_white.n; i++) { + scr_cyc_note_used(&scr_white); + /* The list holds the dead set: doomed components, and what scan whitened + * (black once a later outside root restored it), or, when the pass found + * nothing externally referenced, every gray object. `doomed` says that + * every entry is a doomed component's already. */ + for (size_t i = 0; i < scr_white.n && !doomed; i++) { void *obj = scr_white.v[i]; ScrCycHdr *h = scr_cyc_hdr(obj); - if (scr_cyc_color(h) != SCR_CYC_WHITE) continue; - /* A limited pass can reach candidates it did not take: out of their - * buffers before they are freed. */ - if (scr_cyc_take && scr_cyc_is_buffered(h)) scr_cyc_on_dead(obj); - scr_cyc_set_color(h, SCR_CYC_DOOMED); - if (gen_limit < SCR_CYC_OLD) scr_cyc_freed(scr_cyc_type(h), gen_limit); - else scr_cyc_mature_dead += scr_cyc_gen(h) == SCR_CYC_MATURE; + unsigned color = scr_cyc_color(h); + if (color == SCR_CYC_BLACK) continue; + if (color != SCR_CYC_DOOMED) { + /* A limited pass can reach candidates it did not take: out of their + * buffers before they are freed. */ + if (scr_cyc_take && scr_cyc_is_buffered(h)) scr_cyc_on_dead(obj); + scr_cyc_set_color(h, SCR_CYC_DOOMED); + } scr_white.v[dead++] = obj; } - scr_white.n = dead; + if (!doomed) scr_white.n = dead; /* Pin the cross-generation targets of everything about to be freed, while * `gen` still holds the values the walk filtered on (promotion below is @@ -1126,10 +1173,16 @@ static SCR_CYC_COMPACT size_t scr_cyc_settle(unsigned gen_limit) { /* Teardowns run after the full walk. They may release untraced children * (plain RC) — which can re-buffer survivors for the NEXT pass — but * never touch traced (white, already-accounted) edges. */ + /* The level statistics are counted here, where the teardown reads the + * type anyway; they only steer later passes. */ size_t freed = scr_white.n; for (size_t i = 0; i < scr_white.n; i++) { void *obj = scr_white.v[i]; - scr_cyc_type(scr_cyc_hdr(obj))->free_fn(obj); + ScrCycHdr *h = scr_cyc_hdr(obj); + const ScrCycType *type = scr_cyc_type(h); + if (gen_limit < SCR_CYC_OLD) scr_cyc_freed(type, gen_limit); + else scr_cyc_mature_dead += scr_cyc_gen(h) == SCR_CYC_MATURE; + type->free_fn(obj); } scr_white.n = 0; @@ -1196,6 +1249,7 @@ static size_t scr_cyc_pass_done(size_t freed) { scr_cyc_trim(&scr_restore_pending); scr_cyc_trim(&scr_xgen); scr_cyc_trim(&scr_xgen_edges); + scr_cyc_trim(&scr_live_ranges); return freed; } @@ -1261,19 +1315,71 @@ static size_t scr_cyc_pass(unsigned gen_limit) { scr_xgen_edges.n = 0; scr_white.n = 0; scr_gray_referenced = 0; - for (size_t i = 0; i < scr_cands.n; i++) scr_mark_gray(scr_cands.v[i], 0); - while (scr_pending.n) { - void *obj = scr_pending.v[--scr_pending.n]; - scr_gray_holder = obj; - scr_cyc_type(scr_cyc_hdr(obj))->trace(obj, scr_mg_visit, NULL); - } - if (scr_gray_referenced == 0 && scr_white.n < SCR_CYC_GRAY_LIST_MAX) { - for (size_t i = 0; i < scr_white.n; i++) scr_cyc_set_color(scr_cyc_hdr(scr_white.v[i]), SCR_CYC_WHITE); - return scr_cyc_pass_done(scr_cyc_settle(gen_limit)); + scr_live_ranges.n = 0; + /* Components. Each candidate that no earlier walk reached starts a walk + * of its own, and the objects that walk grays first form its component. + * A component whose objects all end the walk at count zero is garbage: + * a count of zero means every reference to the object was trial-deleted, + * i.e. came from an object grayed so far. An earlier component cannot + * hold one (the walk that grayed it would have grayed the target too), + * so every reference comes from inside the component, and a later walk + * cannot add one: its objects would be referencing this component, and + * those references are still counted. scan would whiten exactly this + * set, so it is doomed at once and scan runs only over the components + * that are externally referenced, if any. A limited pass keeps the single + * whole-pass decision below (its untaken candidates cannot carry the + * component number). */ + bool split = scr_cyc_take == NULL; + uint32_t comp = 0; + for (size_t i = 0; i < scr_cands.n; i++) { + void *obj = scr_cands.v[i]; + if (scr_cyc_color(scr_cyc_hdr(obj)) != SCR_CYC_BLACK) continue; /* walked already */ + size_t start = scr_white.n; + scr_gray_comp = split ? ++comp : 0; + scr_comp_referenced = 0; + scr_mark_gray(obj, 0); + while (scr_pending.n) { + void *next = scr_pending.v[--scr_pending.n]; + scr_gray_holder = next; + scr_cyc_type(scr_cyc_hdr(next))->trace(next, scr_mg_visit, NULL); + } + if (!split) continue; + size_t end = scr_white.n; + if (scr_comp_referenced == 0 && end < SCR_CYC_GRAY_LIST_MAX) { + for (size_t j = start; j < end; j++) scr_cyc_set_color(scr_cyc_hdr(scr_white.v[j]), SCR_CYC_DOOMED); + } else if (scr_live_ranges.n && (uintptr_t)scr_live_ranges.v[scr_live_ranges.n - 1] == start) { + scr_live_ranges.v[scr_live_ranges.n - 1] = (void *)(uintptr_t)end; + } else { + scr_cyc_push_work(&scr_live_ranges, (void *)(uintptr_t)start); + scr_cyc_push_work(&scr_live_ranges, (void *)(uintptr_t)end); + } } + scr_cyc_note_used(&scr_white); + /* Nothing externally referenced at all: every gray object is garbage, + * including components that looked referenced only because a later + * component held them. settle dooms the recorded set. */ + if (scr_gray_referenced == 0 && scr_white.n < SCR_CYC_GRAY_LIST_MAX) + return scr_cyc_pass_done(scr_cyc_settle(gen_limit, split && scr_live_ranges.n == 0)); - scr_white.n = 0; - for (size_t i = 0; i < scr_cands.n; i++) scr_scan(scr_cands.v[i], 0); + /* Keep only the doomed components' entries; scan appends what it + * whitens. */ + if (!split) { + scr_white.n = 0; + } else if (scr_live_ranges.n) { + size_t kept = 0, from = 0; + for (size_t k = 0; k < scr_live_ranges.n; k += 2) { + size_t start = (uintptr_t)scr_live_ranges.v[k], end = (uintptr_t)scr_live_ranges.v[k + 1]; + memmove(scr_white.v + kept, scr_white.v + from, (start - from) * sizeof *scr_white.v); + kept += start - from; + from = end; + } + memmove(scr_white.v + kept, scr_white.v + from, (scr_white.n - from) * sizeof *scr_white.v); + scr_white.n = kept + (scr_white.n - from); + } + for (size_t i = 0; i < scr_cands.n; i++) { + void *obj = scr_cands.v[i]; + if (scr_cyc_color(scr_cyc_hdr(obj)) == SCR_CYC_GRAY) scr_scan(obj, 0); + } while (scr_pending.n) { void *obj = scr_pending.v[--scr_pending.n]; /* A later outside root may have restored this deferred white node and @@ -1282,7 +1388,7 @@ static size_t scr_cyc_pass(unsigned gen_limit) { scr_cyc_type(scr_cyc_hdr(obj))->trace(obj, scr_scan_visit, NULL); } - return scr_cyc_pass_done(scr_cyc_settle(gen_limit)); + return scr_cyc_pass_done(scr_cyc_settle(gen_limit, false)); } #ifdef SCR_CYC_TESTING @@ -1317,7 +1423,7 @@ void scr_collect_cycles(void) { void scr_cyc_context_cleanup(void) { scr_collect_cycles(); ScrVec *vectors[] = {&scr_roots[SCR_CYC_NURSERY], &scr_roots[SCR_CYC_MATURE], - &scr_roots[SCR_CYC_OLD], &scr_cands, &scr_promote, &scr_pending, &scr_restore_pending, &scr_white, &scr_xgen, &scr_xgen_edges, + &scr_roots[SCR_CYC_OLD], &scr_cands, &scr_promote, &scr_pending, &scr_restore_pending, &scr_white, &scr_xgen, &scr_xgen_edges, &scr_live_ranges, &scr_pub_holes[SCR_CYC_NURSERY], &scr_pub_holes[SCR_CYC_MATURE], &scr_pub_holes[SCR_CYC_OLD]}; for (size_t i = 0; i < sizeof vectors / sizeof vectors[0]; i++) { free(vectors[i]->v); From d1639298ff7d393fbf127fb07be294464736886a Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 19:39:16 -0700 Subject: [PATCH 06/47] Erase only `import type` edges, following Node's type stripping MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Node runs TypeScript with verbatimModuleSyntax semantics: `import type` and `export type … from` vanish, while `import { type A }` and `export { type A } from` keep an empty clause and still load their module. - Package selection skipped nothing: `import type { X } from "type-fest"` selected type-fest and failed with SC2013, and type imports pulled whole packages into the compile. Erased edges no longer select packages. - Files reached only through erased edges are no longer program modules, so their imports (a `node:vm` import, say) no longer fence the build. - Inline type-only clauses are real module edges again (their modules' side effects ran under Node but not in the binary); a cycle closed by one binds nothing and is admitted like a side-effect import. - Interfaces, type aliases and type literals from an installed package's declarations map structurally, so values the program builds with a type-only package's types compile. Co-Authored-By: Claude Opus 5.5 --- docs/content/docs/dependencies.mdx | 2 + .../compiler/src/frontend/npm-static-prune.ts | 11 +- packages/compiler/src/frontend/pipeline.ts | 5 + packages/compiler/src/frontend/program.ts | 83 +++++----- packages/compiler/src/frontend/type-mapper.ts | 60 ++++++-- .../src/frontend/type-only-imports.ts | 143 ++++++++++++++++++ .../6120-type-only-import-graph/flags.ts | 2 + .../6120-type-only-import-graph/main.ts | 21 +++ .../6120-type-only-import-graph/mixed.ts | 8 + .../6120-type-only-import-graph/models.ts | 4 + .../node_modules/types-only-pkg/index.d.ts | 6 + .../node_modules/types-only-pkg/package.json | 5 + .../6120-type-only-import-graph/payload.ts | 4 + .../6120-type-only-import-graph/reexports.ts | 2 + .../6120-type-only-import-graph/tsconfig.json | 5 + .../6120-type-only-import-graph/uses-vm.ts | 4 + tests/corpus/6121-type-specifier-edges/a.ts | 10 ++ tests/corpus/6121-type-specifier-edges/b.ts | 7 + .../config-barrel.ts | 2 + .../6121-type-specifier-edges/config.ts | 4 + .../corpus/6121-type-specifier-edges/main.ts | 10 ++ .../node_modules/@types/twinned/index.d.ts | 5 + .../node_modules/@types/twinned/package.json | 5 + .../npm-static/node_modules/twinned/index.js | 9 ++ .../node_modules/twinned/package.json | 5 + tests/fixtures/npm-static/twinned-cli.ts | 5 + tests/fixtures/npm-static/type-only-cli.ts | 7 + tests/harness/npm-static.test.ts | 15 ++ 28 files changed, 382 insertions(+), 67 deletions(-) create mode 100644 packages/compiler/src/frontend/type-only-imports.ts create mode 100644 tests/corpus/6120-type-only-import-graph/flags.ts create mode 100644 tests/corpus/6120-type-only-import-graph/main.ts create mode 100644 tests/corpus/6120-type-only-import-graph/mixed.ts create mode 100644 tests/corpus/6120-type-only-import-graph/models.ts create mode 100644 tests/corpus/6120-type-only-import-graph/node_modules/types-only-pkg/index.d.ts create mode 100644 tests/corpus/6120-type-only-import-graph/node_modules/types-only-pkg/package.json create mode 100644 tests/corpus/6120-type-only-import-graph/payload.ts create mode 100644 tests/corpus/6120-type-only-import-graph/reexports.ts create mode 100644 tests/corpus/6120-type-only-import-graph/tsconfig.json create mode 100644 tests/corpus/6120-type-only-import-graph/uses-vm.ts create mode 100644 tests/corpus/6121-type-specifier-edges/a.ts create mode 100644 tests/corpus/6121-type-specifier-edges/b.ts create mode 100644 tests/corpus/6121-type-specifier-edges/config-barrel.ts create mode 100644 tests/corpus/6121-type-specifier-edges/config.ts create mode 100644 tests/corpus/6121-type-specifier-edges/main.ts create mode 100644 tests/fixtures/npm-static/node_modules/@types/twinned/index.d.ts create mode 100644 tests/fixtures/npm-static/node_modules/@types/twinned/package.json create mode 100644 tests/fixtures/npm-static/node_modules/twinned/index.js create mode 100644 tests/fixtures/npm-static/node_modules/twinned/package.json create mode 100644 tests/fixtures/npm-static/twinned-cli.ts create mode 100644 tests/fixtures/npm-static/type-only-cli.ts diff --git a/docs/content/docs/dependencies.mdx b/docs/content/docs/dependencies.mdx index f93952221..80414ef2a 100644 --- a/docs/content/docs/dependencies.mdx +++ b/docs/content/docs/dependencies.mdx @@ -46,6 +46,8 @@ Your callback and the commander implementation both compile to native code. No e scriptc finds packages in `node_modules` with Node.js's resolution rules, including the export conditions in `package.json`, and compiles their dependencies too. TypeScript workspace packages compile as part of your program, including `.js` import specifiers that resolve to `.ts` sources. +Type-only imports follow Node.js's type stripping. `import type` and `export type … from` statements are erased, so a package or module named only by them supplies types and isn't compiled or loaded; it can even be a package with no JavaScript, such as `type-fest`. A clause whose specifiers are all marked `type`, such as `import { type Options } from "./config.ts"`, still loads its module, as it does under Node.js. + ## Which packages compile scriptc compiles a package automatically when it: diff --git a/packages/compiler/src/frontend/npm-static-prune.ts b/packages/compiler/src/frontend/npm-static-prune.ts index c6c1f9caf..2627e69e2 100644 --- a/packages/compiler/src/frontend/npm-static-prune.ts +++ b/packages/compiler/src/frontend/npm-static-prune.ts @@ -10,6 +10,7 @@ import { nearestPackageType, resolveBareModule } from "./resolve.js"; import { npmStaticPackageOfPath } from "./npm-static.js"; import { trackedReadFile } from "./input-tracker.js"; import { npmPackageNameOf } from "./workspace-registry.js"; +import { typeOnlyNamedImport } from "./type-only-imports.js"; export function isPrunedNpmReexport(program: ts.Program, stmt: ts.ExportDeclaration): boolean { return program.analysis.prunedNpmReexports.has(stmt); @@ -232,7 +233,9 @@ export function planNpmStaticReexports( (clause.namedBindings !== undefined && (ts.isNamespaceImport(clause.namedBindings) || (ts.isNamedImports(clause.namedBindings) && - clause.namedBindings.elements.length === 0))) + clause.namedBindings.elements.length === 0))) || + // `import { type A }` still loads the module, like `import {}`. + typeOnlyNamedImport(stmt) ) { request(dep, null); } else { @@ -244,12 +247,10 @@ export function planNpmStaticReexports( } } } else if (ts.isExportDeclaration(stmt)) { + // `export { type A } from` still loads the module under Node's + // type stripping; only `export type … from` erases. if ( stmt.isTypeOnly || - (stmt.exportClause !== undefined && - ts.isNamedExports(stmt.exportClause) && - stmt.exportClause.elements.length > 0 && - stmt.exportClause.elements.every((element) => element.isTypeOnly)) || stmt.moduleSpecifier === undefined || !ts.isStringLiteral(stmt.moduleSpecifier) ) diff --git a/packages/compiler/src/frontend/pipeline.ts b/packages/compiler/src/frontend/pipeline.ts index 2ec9553f6..944877d58 100644 --- a/packages/compiler/src/frontend/pipeline.ts +++ b/packages/compiler/src/frontend/pipeline.ts @@ -28,6 +28,7 @@ import type { FrontendServices } from "./services.js"; import { isImportDeclaration, isExportDeclaration, isStringLiteral } from "./ts7/adapter.js"; import { CONTRACT_TYPES_MODULE } from "./contract-types.js"; import { THREADS_MODULE } from "./threads-import.js"; +import { erasedTypeOnlyImport } from "./type-only-imports.js"; import { EXPERIMENTAL_MODULE } from "./experimental-import.js"; export interface ProgramLoadOptions { @@ -107,6 +108,10 @@ function detectAutoPackages( stmt.moduleSpecifier && isStringLiteral(stmt.moduleSpecifier) ) { + // `import type` and `export type … from` erase under Node's type + // stripping: Node never loads the package, so it is no dependency + // to compile (its declarations still type the program). + if (isImportDeclaration(stmt) ? erasedTypeOnlyImport(stmt) : stmt.isTypeOnly) continue; edges.push({ spec: stmt.moduleSpecifier.text, loc: locOf(stmt) }); } else if (mode === "lib") { // CJS packages spell their dep edges as top-level requires; the diff --git a/packages/compiler/src/frontend/program.ts b/packages/compiler/src/frontend/program.ts index 3a4ec1647..c805d47a7 100644 --- a/packages/compiler/src/frontend/program.ts +++ b/packages/compiler/src/frontend/program.ts @@ -119,6 +119,11 @@ import { import { trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js"; import { forkTargetPaths } from "./fork-target.js"; import { workerTargetPaths } from "./worker-target.js"; +import { + erasedTypeOnlyImport, + typeOnlyNamedImport, + typeOnlyReachedFiles, +} from "./type-only-imports.js"; import { moduleSourceCandidates } from "./module-source-candidates.js"; import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js"; @@ -1642,7 +1647,7 @@ function insideFunctionLike7(node: ts.Node): boolean { function nodeEsmSyntaxMarker7(sf: ts.SourceFile): ts.Node | null { for (const stmt of sf.statements) { if (ts.isImportDeclaration(stmt) && !erasedTypeOnlyImport(stmt)) return stmt; - if (ts.isExportDeclaration(stmt) && !stmt.isTypeOnly && !erasedTypeOnlyReexport(stmt)) { + if (ts.isExportDeclaration(stmt) && !stmt.isTypeOnly) { return stmt; } if (ts.isExportAssignment(stmt)) return stmt; @@ -2314,6 +2319,7 @@ export function makeCycleAdmission( const clause = e.stmt.importClause; if ( clause === undefined || + typeOnlyNamedImport(e.stmt) || (clause.name === undefined && (clause.namedBindings === undefined || (ts.isNamespaceImport(clause.namedBindings) && @@ -3579,21 +3585,41 @@ function preflight7(load: LoadResult): { npmStaticPackageOfPath(sf.fileName) !== null) && !unselectedPackageJsFile(sf.fileName), ); + // Files reached only through `import type` / `export type … from` are + // checker input, never program modules: Node does not load them, so + // their imports and syntax must not fence the program. + const resolveRuntimeEdge = ( + sf: ts.SourceFile, + spec: string, + resolutionKind?: "import" | "require", + ): ts.SourceFile | null => + resolveImport7(program, sf, spec, resolutionKind) ?? + npmStaticDepSf7(program, sf, spec, resolutionKind); + const typeOnlyFiles = typeOnlyReachedFiles( + program, + entry, + programFiles, + () => [ + ...forkTargetPaths(program, program.getImplementationSourceFiles()), + ...workerTargetPaths(program, program.getImplementationSourceFiles()), + ], + resolveRuntimeEdge, + ); + const runtimeFiles = + typeOnlyFiles.size === 0 ? programFiles : programFiles.filter((sf) => !typeOnlyFiles.has(sf)); const userFiles = npmStaticActive() ? planNpmStaticReexports( program, entry, - programFiles, + runtimeFiles, [ ...createRequireProgramRoots7(program), ...forkTargetPaths(program, program.getImplementationSourceFiles()), ...workerTargetPaths(program, program.getImplementationSourceFiles()), ], - (sf, spec, resolutionKind) => - resolveImport7(program, sf, spec, resolutionKind) ?? - npmStaticDepSf7(program, sf, spec, resolutionKind), + resolveRuntimeEdge, ) - : programFiles; + : runtimeFiles; program.getTypeChecker().prefetchSourceFileStructures(userFiles); // Unselected node_modules JS is not native program source even when @@ -3718,8 +3744,7 @@ function preflight7(load: LoadResult): { continue; } if (ts.isExportDeclaration(stmt)) { - if (stmt.isTypeOnly || erasedTypeOnlyReexport(stmt) || isPrunedNpmReexport(program, stmt)) - continue; + if (stmt.isTypeOnly || isPrunedNpmReexport(program, stmt)) continue; if (!stmt.moduleSpecifier) continue; const fromSpec = ts.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : ""; if (load.externalTypes.has(fromSpec)) { @@ -4954,42 +4979,6 @@ export function isCheckedJsSourceFile(sf: ts.SourceFile, projectCheckJs: boolean return checked; } -/** `import type …` declarations and named clauses whose every element is - * `type`-qualified are ERASED by tsc at emit — Node's module graph has no - * edge there, so module order, cycle detection, init calls, and the - * startup-refusal probe must not count them either (zod v4's core modules - * are "cyclic" only through `import type * as ns` namespaces — 27 phantom - * SC1016 sites against 1 real value-level cycle; and a type-only import - * of a module Node cannot resolve is NOT a startup crash — Node never - * resolves it). Originated as the provenance-sources pilot's flag-gated - * prototype (SCRIPTC_TYPE_ONLY_EDGES), promoted to always-on with the - * full-suite differential green. Side-effect imports (no clause) stay - * real edges. */ -function erasedTypeOnlyImport(stmt: ts.ImportDeclaration): boolean { - const clause = stmt.importClause; - if (clause === undefined) return false; // side-effect import: a real edge - if (clause.phaseModifier === ts.SyntaxKind.TypeKeyword) return true; - return ( - clause.name === undefined && - clause.namedBindings !== undefined && - ts.isNamedImports(clause.namedBindings) && - clause.namedBindings.elements.length > 0 && - clause.namedBindings.elements.every((e) => e.isTypeOnly) - ); -} - -/** The re-export twin: `export { type X } from "./m"` with every element - * `type`-qualified erases at emit exactly like `export type { X } from` - * (which stmt.isTypeOnly already covers) — no module edge. */ -function erasedTypeOnlyReexport(stmt: ts.ExportDeclaration): boolean { - return ( - stmt.exportClause !== undefined && - ts.isNamedExports(stmt.exportClause) && - stmt.exportClause.elements.length > 0 && - stmt.exportClause.elements.every((e) => e.isTypeOnly) - ); -} - export function orderedImportsOf( program: ts.Program, sf: ts.SourceFile, @@ -4997,11 +4986,7 @@ export function orderedImportsOf( const out: { stmt: ts.Statement; dep: ts.SourceFile | null }[] = []; for (const stmt of sf.statements) { if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt)) continue; - if ( - ts.isExportDeclaration(stmt) && - (stmt.isTypeOnly || erasedTypeOnlyReexport(stmt) || !stmt.moduleSpecifier) - ) - continue; + if (ts.isExportDeclaration(stmt) && (stmt.isTypeOnly || !stmt.moduleSpecifier)) continue; if (!ts.isImportDeclaration(stmt) && !ts.isExportDeclaration(stmt)) continue; if (ts.isImportDeclaration(stmt) && erasedTypeOnlyImport(stmt)) continue; if (!stmt.moduleSpecifier || !ts.isStringLiteral(stmt.moduleSpecifier)) continue; diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index 54fb8f70e..7570a6ce0 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -1656,16 +1656,38 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { // Declaration-only package types have no compiled implementation. // Primitive and container types retain their structural mappings; types // owned by the standard library or explicit host mappings are handled - // by their dedicated native rules. - const npmSym = widened.getAliasSymbol() ?? widened.getSymbol(); - const npmDecls = npmSym ? checker.declarationsOf(npmSym) : undefined; + // by their dedicated native rules. Pure type shapes — interfaces, type + // aliases, and object or mapped type literals with no value declaration + // merged in — describe data, not an implementation: a program value of + // such a type is one the program built itself (`import type` from a + // types-only package), so it maps structurally like a local declaration. + // Values the package itself would produce stay refused at their import. + const packageOnly = (sym: ts.Symbol | undefined): readonly ts.Node[] | null => { + const decls = sym ? checker.declarationsOf(sym) : undefined; + return decls && + decls.length > 0 && + decls.every((d) => { + const sf = d.getSourceFile(); + return sf.isDeclarationFile && !ctx.isStdlibFile(sf) && !ctx.isExternalTypeFile(sf); + }) + ? decls + : null; + }; + const pureTypeShape = (decls: readonly ts.Node[] | null): boolean => + decls === null || + decls.every( + (d) => + packageTypeFile(d.getSourceFile(), ctx) && + (ts.isInterfaceDeclaration(d) || + ts.isTypeAliasDeclaration(d) || + ts.isTypeLiteralNode(d) || + ts.isMappedTypeNode(d)), + ); + const aliasDecls = packageOnly(widened.getAliasSymbol()); + const ownDecls = packageOnly(widened.getSymbol()); if ( - npmDecls && - npmDecls.length > 0 && - npmDecls.every((d) => { - const sf = d.getSourceFile(); - return sf.isDeclarationFile && !ctx.isStdlibFile(sf) && !ctx.isExternalTypeFile(sf); - }) + (aliasDecls !== null || (widened.getAliasSymbol() === undefined && ownDecls !== null)) && + !(pureTypeShape(aliasDecls) && pureTypeShape(ownDecls)) ) { return null; } @@ -5167,6 +5189,17 @@ function isMappedShape(t: ts.Type): boolean { ); } +/** A declaration file an installed package ships (its own or an @types + * twin), outside the standard library and @types/node: the type surface + * of a package the program does not compile. Its pure type shapes — + * interfaces, aliases, type literals — describe data a program can build + * itself (`import type` from a types-only package such as type-fest). */ +function packageTypeFile(sf: ts.SourceFile, ctx: Pick): boolean { + return ( + sf.isDeclarationFile && /[\\/]node_modules[\\/]/.test(sf.fileName) && !ctx.isStdlibFile(sf) + ); +} + /** The record path's provenance fence. Declared shapes (object literals, * interfaces, type literals) must come from user code or an explicitly * mapped external type surface, never an arbitrary .d.ts — the empty @@ -5205,13 +5238,14 @@ function recordProvenanceOk(t: ts.Type, ctx: TypeMapperCtx): boolean { .every( (decl) => !decl.getSourceFile().isDeclarationFile || - ctx.isExternalTypeFile(decl.getSourceFile()), + ctx.isExternalTypeFile(decl.getSourceFile()) || + packageTypeFile(decl.getSourceFile(), ctx), ), ); } return !decls.some((d) => { const sf = d.getSourceFile(); - return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf); + return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf) && !packageTypeFile(sf, ctx); }); } @@ -5668,7 +5702,7 @@ function mapRecordTypeInner( computed && checker.declarationsOf(p).some((d) => { const sf = d.getSourceFile(); - return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf); + return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf) && !packageTypeFile(sf, ctx); }) ) { return null; @@ -5995,7 +6029,7 @@ export function describeRecordMemberBlocker(widened: ts.Type, ctx: TypeMapperCtx computed && checker.declarationsOf(p).some((d) => { const sf = d.getSourceFile(); - return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf); + return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf) && !packageTypeFile(sf, ctx); }) ) { return null; diff --git a/packages/compiler/src/frontend/type-only-imports.ts b/packages/compiler/src/frontend/type-only-imports.ts new file mode 100644 index 000000000..003d4ccf7 --- /dev/null +++ b/packages/compiler/src/frontend/type-only-imports.ts @@ -0,0 +1,143 @@ +/** Type-only module edges under Node's type stripping. + * + * Node runs TypeScript by erasing types in place, with the semantics of + * `verbatimModuleSyntax`: `import type …` and `export type … from` vanish, + * but `import { type A } from "./m"` and `export { type A } from "./m"` + * keep an empty clause (`import {} from "./m"`) and still load and + * evaluate `./m`. Only the erased forms are absent from Node's module + * graph. */ +import * as ts from "./ts7/adapter.js"; +import { moduleSourceCandidates } from "./module-source-candidates.js"; + +/** `import type …` (default, named, or namespace): erased by Node, so + * module order, cycle detection, init calls, package selection, and the + * startup-refusal probe must not count it (zod v4's core modules are + * "cyclic" only through `import type * as ns` namespaces, and a + * type-only import of a module Node cannot resolve is not a startup + * crash). Side-effect imports and inline `type` specifiers stay real + * edges. */ +export function erasedTypeOnlyImport(stmt: ts.ImportDeclaration): boolean { + return stmt.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword; +} + +/** `import { type A, type B } from "./m"`: a real module edge that binds + * nothing at runtime, exactly like a side-effect import. */ +export function typeOnlyNamedImport(stmt: ts.ImportDeclaration): boolean { + const clause = stmt.importClause; + return ( + clause !== undefined && + clause.phaseModifier !== ts.SyntaxKind.TypeKeyword && + clause.name === undefined && + clause.namedBindings !== undefined && + ts.isNamedImports(clause.namedBindings) && + clause.namedBindings.elements.length > 0 && + clause.namedBindings.elements.every((e) => e.isTypeOnly) + ); +} + +/** One module reference of a program file: its specifier and whether + * Node erases it. */ +interface ModuleReference { + spec: string; + erased: boolean; + kind?: "import" | "require"; +} + +function declarationReferencesOf(sf: ts.SourceFile): ModuleReference[] { + const refs: ModuleReference[] = []; + for (const stmt of sf.statements) { + if (ts.isImportDeclaration(stmt)) { + if (ts.isStringLiteral(stmt.moduleSpecifier)) + refs.push({ spec: stmt.moduleSpecifier.text, erased: erasedTypeOnlyImport(stmt) }); + } else if (ts.isExportDeclaration(stmt)) { + if (stmt.moduleSpecifier !== undefined && ts.isStringLiteral(stmt.moduleSpecifier)) + refs.push({ spec: stmt.moduleSpecifier.text, erased: stmt.isTypeOnly }); + } else if ( + ts.isImportEqualsDeclaration(stmt) && + ts.isExternalModuleReference(stmt.moduleReference) && + ts.isStringLiteralLike(stmt.moduleReference.expression) + ) { + refs.push({ + spec: stmt.moduleReference.expression.text, + erased: stmt.isTypeOnly, + kind: "require", + }); + } + } + return refs; +} + +/** Every call with a leading string literal counts as a loading edge — + * require(), import(), createRequire'd require functions, and loader + * helpers alike. Over-counting only keeps a file in the graph. */ +function callReferencesOf(program: ts.Program, sf: ts.SourceFile): ModuleReference[] { + const refs: ModuleReference[] = []; + for (const node of moduleSourceCandidates(program, sf).calls) { + const arg = node.arguments[0]; + if (arg === undefined || !ts.isStringLiteralLike(arg)) continue; + refs.push({ + spec: arg.text, + erased: false, + kind: node.expression.kind === ts.SyntaxKind.ImportKeyword ? "import" : "require", + }); + } + return refs; +} + +/** The program files Node never loads because the only references that + * reach them are erased type-only forms (directly or through other such + * files). A file referenced by nothing at all (a program root, or a file + * reached through a reference this walk does not model, such as an + * `import("./m")` type query) keeps its place, as do `extraRoots` (fork + * and worker targets). Empty when no erased reference resolves to a + * program file — the common case pays one statement scan per file. */ +export function typeOnlyReachedFiles( + program: ts.Program, + entry: ts.SourceFile, + files: readonly ts.SourceFile[], + extraRoots: () => readonly string[], + resolveEdge: ( + from: ts.SourceFile, + spec: string, + resolutionKind?: "import" | "require", + ) => ts.SourceFile | null, +): Set { + const available = new Set(files); + const declarationRefs = new Map(files.map((sf) => [sf, declarationReferencesOf(sf)] as const)); + const target = (sf: ts.SourceFile, ref: ModuleReference): ts.SourceFile | null => { + const dep = resolveEdge(sf, ref.spec, ref.kind); + return dep === null || dep === sf || !available.has(dep) ? null : dep; + }; + if ( + !files.some((sf) => + declarationRefs.get(sf)!.some((ref) => ref.erased && target(sf, ref) !== null), + ) + ) + return new Set(); + const valueEdges = new Map(); + const referenced = new Set(); + for (const sf of files) { + const deps: ts.SourceFile[] = []; + valueEdges.set(sf, deps); + for (const ref of [...declarationRefs.get(sf)!, ...callReferencesOf(program, sf)]) { + const dep = target(sf, ref); + if (dep === null) continue; + referenced.add(dep); + if (!ref.erased) deps.push(dep); + } + } + const roots = files.filter((sf) => sf === entry || !referenced.has(sf)); + for (const path of extraRoots()) { + const sf = program.getSourceFile(path); + if (sf !== undefined && available.has(sf)) roots.push(sf); + } + const reached = new Set(); + const queue = [...roots]; + while (queue.length > 0) { + const sf = queue.pop()!; + if (reached.has(sf)) continue; + reached.add(sf); + for (const dep of valueEdges.get(sf) ?? []) if (!reached.has(dep)) queue.push(dep); + } + return new Set(files.filter((sf) => !reached.has(sf))); +} diff --git a/tests/corpus/6120-type-only-import-graph/flags.ts b/tests/corpus/6120-type-only-import-graph/flags.ts new file mode 100644 index 000000000..5af639c0a --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/flags.ts @@ -0,0 +1,2 @@ +export type Flag = boolean; +console.log("flags evaluated"); diff --git a/tests/corpus/6120-type-only-import-graph/main.ts b/tests/corpus/6120-type-only-import-graph/main.ts new file mode 100644 index 000000000..251ce6809 --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/main.ts @@ -0,0 +1,21 @@ +// Node's type stripping erases `import type` and `export type … from`, so +// the modules and packages they name are never loaded: a package with no +// runtime entry, a module importing a builtin scriptc does not compile, and +// modules with load-time output. An inline `type` specifier keeps an empty +// import clause and still evaluates its module, as does a mixed clause. +import type { Frozen, Shape } from "types-only-pkg"; +import type { Label } from "./uses-vm.ts"; +import type * as Models from "./models.ts"; +import type { Reexported } from "./reexports.ts"; +import { type Mode, describe } from "./mixed.ts"; +import { type Flag } from "./flags.ts"; + +const shape: Shape = { width: 3, height: 4 }; +const frozen: Frozen = { width: 5, height: 6 }; +const label: Label = "area"; +const model: Models.Model = { id: 1 }; +const payload: Reexported = { ok: true }; +const mode: Mode = "fast"; +const flag: Flag = true; +console.log(label, shape.width * shape.height, model.id, payload.ok); +console.log(describe(mode), flag, frozen.width + frozen.height); diff --git a/tests/corpus/6120-type-only-import-graph/mixed.ts b/tests/corpus/6120-type-only-import-graph/mixed.ts new file mode 100644 index 000000000..ec5a08bbb --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/mixed.ts @@ -0,0 +1,8 @@ +export type { Payload } from "./payload.ts"; + +export type Mode = "fast" | "slow"; + +export function describe(mode: Mode): string { + return `mode=${mode}`; +} +console.log("mixed evaluated"); diff --git a/tests/corpus/6120-type-only-import-graph/models.ts b/tests/corpus/6120-type-only-import-graph/models.ts new file mode 100644 index 000000000..195cf9a17 --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/models.ts @@ -0,0 +1,4 @@ +export interface Model { + id: number; +} +console.log("models evaluated"); diff --git a/tests/corpus/6120-type-only-import-graph/node_modules/types-only-pkg/index.d.ts b/tests/corpus/6120-type-only-import-graph/node_modules/types-only-pkg/index.d.ts new file mode 100644 index 000000000..e9c1b5497 --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/node_modules/types-only-pkg/index.d.ts @@ -0,0 +1,6 @@ +export interface Shape { + width: number; + height: number; +} + +export type Frozen = { readonly [K in keyof T]: T[K] }; diff --git a/tests/corpus/6120-type-only-import-graph/node_modules/types-only-pkg/package.json b/tests/corpus/6120-type-only-import-graph/node_modules/types-only-pkg/package.json new file mode 100644 index 000000000..c2be952b9 --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/node_modules/types-only-pkg/package.json @@ -0,0 +1,5 @@ +{ + "name": "types-only-pkg", + "version": "1.0.0", + "types": "./index.d.ts" +} diff --git a/tests/corpus/6120-type-only-import-graph/payload.ts b/tests/corpus/6120-type-only-import-graph/payload.ts new file mode 100644 index 000000000..beb97c5ac --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/payload.ts @@ -0,0 +1,4 @@ +export interface Payload { + ok: boolean; +} +console.log("payload evaluated"); diff --git a/tests/corpus/6120-type-only-import-graph/reexports.ts b/tests/corpus/6120-type-only-import-graph/reexports.ts new file mode 100644 index 000000000..52e86f294 --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/reexports.ts @@ -0,0 +1,2 @@ +export type { Payload as Reexported } from "./payload.ts"; +console.log("reexports evaluated"); diff --git a/tests/corpus/6120-type-only-import-graph/tsconfig.json b/tests/corpus/6120-type-only-import-graph/tsconfig.json new file mode 100644 index 000000000..aee0ec940 --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/tsconfig.json @@ -0,0 +1,5 @@ +{ + "compilerOptions": { + "strict": true + } +} diff --git a/tests/corpus/6120-type-only-import-graph/uses-vm.ts b/tests/corpus/6120-type-only-import-graph/uses-vm.ts new file mode 100644 index 000000000..bed6646bf --- /dev/null +++ b/tests/corpus/6120-type-only-import-graph/uses-vm.ts @@ -0,0 +1,4 @@ +import * as vm from "node:vm"; + +export type Label = string; +console.log("uses-vm evaluated", vm.runInThisContext("1 + 1")); diff --git a/tests/corpus/6121-type-specifier-edges/a.ts b/tests/corpus/6121-type-specifier-edges/a.ts new file mode 100644 index 000000000..59d6385da --- /dev/null +++ b/tests/corpus/6121-type-specifier-edges/a.ts @@ -0,0 +1,10 @@ +import { b } from "./b.ts"; + +export interface AInfo { + tag: string; +} + +export function start(): string { + return `a+${b()}`; +} +console.log("a evaluated"); diff --git a/tests/corpus/6121-type-specifier-edges/b.ts b/tests/corpus/6121-type-specifier-edges/b.ts new file mode 100644 index 000000000..a71f62def --- /dev/null +++ b/tests/corpus/6121-type-specifier-edges/b.ts @@ -0,0 +1,7 @@ +import { type AInfo } from "./a.ts"; + +export function b(): string { + const info: AInfo = { tag: "b" }; + return info.tag; +} +console.log("b evaluated"); diff --git a/tests/corpus/6121-type-specifier-edges/config-barrel.ts b/tests/corpus/6121-type-specifier-edges/config-barrel.ts new file mode 100644 index 000000000..dc461f654 --- /dev/null +++ b/tests/corpus/6121-type-specifier-edges/config-barrel.ts @@ -0,0 +1,2 @@ +export { type Config } from "./config.ts"; +console.log("barrel evaluated"); diff --git a/tests/corpus/6121-type-specifier-edges/config.ts b/tests/corpus/6121-type-specifier-edges/config.ts new file mode 100644 index 000000000..1a42a9093 --- /dev/null +++ b/tests/corpus/6121-type-specifier-edges/config.ts @@ -0,0 +1,4 @@ +export interface Config { + name: string; +} +console.log("config evaluated"); diff --git a/tests/corpus/6121-type-specifier-edges/main.ts b/tests/corpus/6121-type-specifier-edges/main.ts new file mode 100644 index 000000000..23855b470 --- /dev/null +++ b/tests/corpus/6121-type-specifier-edges/main.ts @@ -0,0 +1,10 @@ +// An inline `type` specifier keeps its module request under Node's type +// stripping: `export { type X } from` and `import { type X } from` both +// evaluate the named module, once, in source order. A cycle closed only by +// such an import binds nothing at runtime and runs like a side-effect +// import. +import { type Config } from "./config-barrel.ts"; +import { start } from "./a.ts"; + +const config: Config = { name: "demo" }; +console.log("main", config.name, start()); diff --git a/tests/fixtures/npm-static/node_modules/@types/twinned/index.d.ts b/tests/fixtures/npm-static/node_modules/@types/twinned/index.d.ts new file mode 100644 index 000000000..ef7c0d6c6 --- /dev/null +++ b/tests/fixtures/npm-static/node_modules/@types/twinned/index.d.ts @@ -0,0 +1,5 @@ +export interface Greeting { + text: string; +} + +export default function wait(text: string): string; diff --git a/tests/fixtures/npm-static/node_modules/@types/twinned/package.json b/tests/fixtures/npm-static/node_modules/@types/twinned/package.json new file mode 100644 index 000000000..2bdbbfa6e --- /dev/null +++ b/tests/fixtures/npm-static/node_modules/@types/twinned/package.json @@ -0,0 +1,5 @@ +{ + "name": "@types/twinned", + "version": "1.0.0", + "types": "index.d.ts" +} diff --git a/tests/fixtures/npm-static/node_modules/twinned/index.js b/tests/fixtures/npm-static/node_modules/twinned/index.js new file mode 100644 index 000000000..0aa0a79f0 --- /dev/null +++ b/tests/fixtures/npm-static/node_modules/twinned/index.js @@ -0,0 +1,9 @@ +// A CommonJS package without its own declarations: its types live in the +// separate @types/twinned package, and it depends on the untyped ms. +'use strict'; + +const ms = require('ms'); + +module.exports = function wait(text) { + return 'twinned:' + text + ':' + ms(90000); +}; diff --git a/tests/fixtures/npm-static/node_modules/twinned/package.json b/tests/fixtures/npm-static/node_modules/twinned/package.json new file mode 100644 index 000000000..14cce5ab2 --- /dev/null +++ b/tests/fixtures/npm-static/node_modules/twinned/package.json @@ -0,0 +1,5 @@ +{ + "name": "twinned", + "version": "1.0.0", + "main": "index.js" +} diff --git a/tests/fixtures/npm-static/twinned-cli.ts b/tests/fixtures/npm-static/twinned-cli.ts new file mode 100644 index 000000000..e24383184 --- /dev/null +++ b/tests/fixtures/npm-static/twinned-cli.ts @@ -0,0 +1,5 @@ +// twinned's declarations come from @types/twinned; the package itself and +// its untyped ms dependency ship JavaScript only. +import wait from "twinned"; + +console.log(wait("ready")); diff --git a/tests/fixtures/npm-static/type-only-cli.ts b/tests/fixtures/npm-static/type-only-cli.ts new file mode 100644 index 000000000..9fd332331 --- /dev/null +++ b/tests/fixtures/npm-static/type-only-cli.ts @@ -0,0 +1,7 @@ +// `import type` erases under Node's type stripping: twinned is never +// loaded, so no package is selected or refused, and its declared +// interface types a value the program builds itself. +import type { Greeting } from "twinned"; + +const greeting: Greeting = { text: "hello" }; +console.log(greeting.text); diff --git a/tests/harness/npm-static.test.ts b/tests/harness/npm-static.test.ts index 9324d1c7f..398c35b8a 100644 --- a/tests/harness/npm-static.test.ts +++ b/tests/harness/npm-static.test.ts @@ -791,6 +791,21 @@ describe(`npm-static pilots${sanitize ? " (sanitized)" : ""}`, () => { ]); }, 120_000); + test("type-only imports select no package", async () => { + const entry = join(pilotRoot, "type-only-cli.ts"); + const { coverage } = analyze(entry); + expect(coverage.npmStatic ?? []).toEqual([]); + expect(coverage.preflightFailed).toBe(false); + expect(coverage.diagnostics).toEqual([]); + const binary = await buildStatic(entry, []); + const [nodeRes, nativeRes] = await Promise.all([ + runBinary("node", [entry]), + runBinary(binary, []), + ]); + expect(nativeRes.stdout.toString("utf8")).toBe(nodeRes.stdout.toString("utf8")); + expect(nativeRes.exitCode).toBe(nodeRes.exitCode); + }, 180_000); + test("ms supports invalid duration strings without runtime fences", () => { const { coverage } = analyze(join(pilotRoot, "ms-invalid-cli.ts"), { npmStatic: ["ms"] }); expect(coverage.npmStatic).toEqual([{ package: "ms", status: "static" }]); From e79380ce17172766b583dc616c43f98d52bd7492 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 19:39:21 -0700 Subject: [PATCH 07/47] Name the runtime package in npm refusals and add transitive --npm-static - A package typed only by an @types twin was judged under the twin's name and refused with "its import resolves to '@types/x/index.d.ts', not to runtime JavaScript". Selection now resolves the runtime package, and the refusal names it with the --npm-static option that compiles it anyway. - Refusals the declaration and shipped-JS heuristics make carry the same remedy as a diagnostic hint; a dependency of a named package suggests the transitive form. - `--npm-static=pkg...` (and `"pkg..."` in a library profile) selects the package and every package its files import, nested require() calls included, without the eligibility heuristics. Co-Authored-By: Claude Opus 5.5 --- docs/content/docs/cli.mdx | 2 +- docs/content/docs/dependencies.mdx | 4 +- packages/compiler/src/cli/usage.ts | 3 +- packages/compiler/src/coverage/report.ts | 2 + .../compiler/src/diagnostics/diagnostic.ts | 11 +- packages/compiler/src/executable/prepare.ts | 1 + packages/compiler/src/frontend/analysis.ts | 1 + packages/compiler/src/frontend/pipeline.ts | 134 +++++++++++++++--- tests/harness/npm-static.test.ts | 47 ++++++ 9 files changed, 179 insertions(+), 26 deletions(-) diff --git a/docs/content/docs/cli.mdx b/docs/content/docs/cli.mdx index a6f75c6d3..3180d1fa4 100644 --- a/docs/content/docs/cli.mdx +++ b/docs/content/docs/cli.mdx @@ -119,7 +119,7 @@ Verifies and loads the installed precompiled runtime objects and vendored librar
On Linux, when the program calls process.exit(), hand the release of its memory to a helper process so the parent sees the exit sooner. The kernel otherwise frees the whole address space before the exit is reported, which takes tens of milliseconds per gigabyte. Opt in only where the trade-offs are acceptable: for up to about 100 ms after the exit, the helper keeps the executable mapped (overwriting the binary in place fails with "text file busy"), its memory stays charged to the cgroup, and the teardown CPU time no longer appears in the parent's resource usage. Valid only for executable builds; it has no effect on other platforms.
--npm-static <pkg[,pkg…]|auto>
-
Name npm packages to compile even if they don't ship their own type declarations (repeatable). auto uses the default automatic selection. Packages that can't compile produce diagnostics. See npm Dependencies.
+
Name npm packages to compile even if they don't ship their own type declarations (repeatable). A trailing ..., as in fs-extra..., also names every package that package depends on. auto uses the default automatic selection. Packages that can't compile produce diagnostics. See npm Dependencies.
--provenance-sources
Experimental. Compile npm dependencies from the source at the commit their provenance attestation names. Packages without a usable attestation compile from their installed files.
diff --git a/docs/content/docs/dependencies.mdx b/docs/content/docs/dependencies.mdx index 80414ef2a..c611fa1d5 100644 --- a/docs/content/docs/dependencies.mdx +++ b/docs/content/docs/dependencies.mdx @@ -55,7 +55,7 @@ scriptc compiles a package automatically when it: - ships its own type declarations, and - ships readable, unminified JavaScript. -A package that doesn't meet these requirements, or that uses something scriptc can't compile, gets a package-specific diagnostic that explains why. The usual fixes are to switch to a version or alternative package that compiles, or to replace the call with code you write yourself. +A package that doesn't meet these requirements, or that uses something scriptc can't compile, gets a package-specific diagnostic that explains why. The usual fixes are to switch to a version or alternative package that compiles, or to replace the call with code you write yourself. A package whose declarations come from a separate `@types/` package doesn't ship its own; its diagnostic names the package and the `--npm-static` option that compiles it anyway. @@ -69,7 +69,7 @@ Some packages rely on separately installed declarations, such as an `@types/` pa $ scriptc build app.ts --npm-static=three -o app >/dev/null ``` -Naming a package skips the declaration requirement above, but the package still has to compile. `--npm-static=auto` uses the default automatic selection. The option accepts a comma-separated list and can be repeated. +Naming a package skips the declaration requirement above, but the package still has to compile. The option selects only the packages it names: a dependency of a named package that doesn't ship its own declarations is still refused. Add a trailing `...` to select a package together with every package it depends on, for example `--npm-static=fs-extra...`. `--npm-static=auto` uses the default automatic selection. The option accepts a comma-separated list and can be repeated. ## Unsupported code inside a package diff --git a/packages/compiler/src/cli/usage.ts b/packages/compiler/src/cli/usage.ts index a0388374b..cf099b5fd 100644 --- a/packages/compiler/src/cli/usage.ts +++ b/packages/compiler/src/cli/usage.ts @@ -57,7 +57,8 @@ Options: compile the named npm packages' shipped JS statically as program modules (repeatable; "auto" opts in every eligible direct import: own .d.ts, unminified JS, no build-transform - markers). Packages that fail preflight are refused with a + markers; "pkg..." also names every package pkg depends + on). Packages that fail preflight are refused with a diagnostic. Eligible dependencies compile automatically. --provenance-sources EXPERIMENTAL: compile npm dependencies from their diff --git a/packages/compiler/src/coverage/report.ts b/packages/compiler/src/coverage/report.ts index 9d0776d9a..e8d81ac01 100644 --- a/packages/compiler/src/coverage/report.ts +++ b/packages/compiler/src/coverage/report.ts @@ -61,6 +61,8 @@ export interface NpmStaticStatus { status: "static" | "refused"; /** The first refusal reason for a refused package. */ detail?: string; + /** How to act on the refusal, when there is a specific remedy. */ + hint?: string; } const GREEN = "\x1b[32m"; diff --git a/packages/compiler/src/diagnostics/diagnostic.ts b/packages/compiler/src/diagnostics/diagnostic.ts index 9a7b4a37a..1902f6b18 100644 --- a/packages/compiler/src/diagnostics/diagnostic.ts +++ b/packages/compiler/src/diagnostics/diagnostic.ts @@ -877,13 +877,20 @@ export function unsupportedPackageValueDiag(pkg: string, loc: SrcLoc): ScrDiagno ); } -export function npmStaticRefusalDiag(pkg: string, detail: string, loc: SrcLoc): ScrDiagnostic { +export function npmStaticRefusalDiag( + pkg: string, + detail: string, + loc: SrcLoc, + hint?: string, +): ScrDiagnostic { return { code: "SC2013", message: `cannot compile npm package '${pkg}' statically: ${detail}`, loc, milestone: "later", - hint: "use a dependency with supported source, or replace the unsupported operation; scriptc has no interpreter fallback", + hint: + hint ?? + "use a dependency with supported source, or replace the unsupported operation; scriptc has no interpreter fallback", }; } diff --git a/packages/compiler/src/executable/prepare.ts b/packages/compiler/src/executable/prepare.ts index f6012dd2a..ead13afb8 100644 --- a/packages/compiler/src/executable/prepare.ts +++ b/packages/compiler/src/executable/prepare.ts @@ -59,6 +59,7 @@ export function prepareExecutableModule( entry.package, entry.detail ?? "its static compilation was refused", fe.npmImportSites.get(entry.package) ?? { file: entryPath, start: 0, end: 0 }, + entry.hint, ), ), ); diff --git a/packages/compiler/src/frontend/analysis.ts b/packages/compiler/src/frontend/analysis.ts index b38a267fa..8435710c2 100644 --- a/packages/compiler/src/frontend/analysis.ts +++ b/packages/compiler/src/frontend/analysis.ts @@ -58,6 +58,7 @@ export function analyzeWithFrontend( entry.package, entry.detail ?? "its static compilation was refused", fe.npmImportSites.get(entry.package) ?? { file: entryPath, start: 0, end: 0 }, + entry.hint, ), ), ]; diff --git a/packages/compiler/src/frontend/pipeline.ts b/packages/compiler/src/frontend/pipeline.ts index 944877d58..20df75c9b 100644 --- a/packages/compiler/src/frontend/pipeline.ts +++ b/packages/compiler/src/frontend/pipeline.ts @@ -25,7 +25,15 @@ import { isJsSourceFileName } from "./tsc-codes.js"; import { isRelativeSpecifier, packageNameOfSpecifier } from "./workspace-registry.js"; import { lowerToIr, type LowerOptions, type LowerResult } from "./lowering/lowerer.js"; import type { FrontendServices } from "./services.js"; -import { isImportDeclaration, isExportDeclaration, isStringLiteral } from "./ts7/adapter.js"; +import { + isIdentifier, + isImportDeclaration, + isExportDeclaration, + isStringLiteral, + isStringLiteralLike, + SyntaxKind, +} from "./ts7/adapter.js"; +import { moduleSourceCandidates } from "./module-source-candidates.js"; import { CONTRACT_TYPES_MODULE } from "./contract-types.js"; import { THREADS_MODULE } from "./threads-import.js"; import { erasedTypeOnlyImport } from "./type-only-imports.js"; @@ -92,15 +100,36 @@ function detectAutoPackages( mode: "auto" | "lib" = "auto", judged?: Set, sites?: Map, + transitive: Set = new Set(), ): string[] { + const chosen: string[] = []; // package → the resolved types file AND the file whose import found it: // the runtime-JS probe below must resolve from the SAME importing file, // or a package visible only to a nested package.json realm (a pnpm // monorepo's packages/*/node_modules, unreachable from the entry's own // walk-up) answers "no runtime JS" for perfectly ordinary installs. - const seen = new Map(); - for (const sf of [...load.moduleOrder, load.entry]) { + const seen = new Map< + string, + { typesFile: string; fromFile: string; spec: string; owner: string | null } + >(); + // A transitive package's files outside the module order (reached through + // nested require() calls the graph walk does not model) still name its + // dependencies. + const scanned = new Set([...load.moduleOrder, load.entry]); + const transitiveFiles = + transitive.size === 0 + ? [] + : load.program.getImplementationSourceFiles().filter((sf) => { + const pkg = npmStaticPackageOfPath(sf.fileName); + return !scanned.has(sf) && pkg !== null && transitive.has(pkg); + }); + for (const sf of [...scanned, ...transitiveFiles]) { if (mode === "auto" && sf.fileName.includes("/node_modules/")) continue; + // `--npm-static=pkg...` opts pkg's whole dependency closure in: every + // package its compiled files import is selected the same explicit way, + // without the declaration eligibility bar. + const owner = npmStaticPackageOfPath(sf.fileName); + const viaTransitive = owner !== null && transitive.has(owner); const edges: { spec: string; loc: SrcLoc }[] = []; for (const stmt of sf.statements) { if ( @@ -113,12 +142,26 @@ function detectAutoPackages( // to compile (its declarations still type the program). if (isImportDeclaration(stmt) ? erasedTypeOnlyImport(stmt) : stmt.isTypeOnly) continue; edges.push({ spec: stmt.moduleSpecifier.text, loc: locOf(stmt) }); - } else if (mode === "lib") { + } else if (mode === "lib" && !viaTransitive) { // CJS packages spell their dep edges as top-level requires; the // import-statement scan alone would miss every one of them. for (const req of requiresOf(stmt)) edges.push({ spec: req.spec, loc: locOf(req.node) }); } } + // Transitive selection counts every literal require() and import() + // anywhere in the package, nested ones included. + if (viaTransitive) { + for (const call of moduleSourceCandidates(load.program, sf).calls) { + const arg = call.arguments[0]; + if ( + arg !== undefined && + isStringLiteralLike(arg) && + (call.expression.kind === SyntaxKind.ImportKeyword || + (isIdentifier(call.expression) && call.expression.text === "require")) + ) + edges.push({ spec: arg.text, loc: locOf(call) }); + } + } for (const { spec, loc } of edges) { if (load.externalTypes?.has(spec)) continue; // scriptc's own packages are not npm dependencies: contract types are @@ -142,28 +185,49 @@ function detectAutoPackages( if (judged?.has(packageNameOfSpecifier(spec))) continue; const npm = resolveNpmImport(sf.fileName, spec); if (npm !== null && isNodeTypesPath(npm.typesFile)) continue; - if (npm === null) { - if (mode !== "lib") continue; - const js = resolveBareModule(sf.fileName, spec, "js-only"); - if (js === null || judged!.has(js.packageName)) continue; - judged!.add(js.packageName); - sites!.set(js.packageName, loc); + // The runtime package Node loads. Types-first resolution answers an + // @types twin's declarations for a package that ships none, but + // selection and every refusal name the package that has the code. + const js = + mode === "lib" && (npm === null || npm.packageName.startsWith("@types/")) + ? resolveBareModule(sf.fileName, spec, "js-only") + : null; + const runtimePkg = js !== null && js.packageName !== npm?.packageName ? js.packageName : null; + if (npm === null || runtimePkg !== null) { + if (mode !== "lib" || runtimePkg === null || judged!.has(runtimePkg)) continue; + judged!.add(runtimePkg); + sites!.set(runtimePkg, loc); + if (viaTransitive) { + transitive.add(runtimePkg); + chosen.push(runtimePkg); + continue; + } statuses.push({ - package: js.packageName, + package: runtimePkg, status: "refused", - detail: "it ships no own .d.ts declaration surface", + detail: + npm === null + ? "it ships no own .d.ts declaration surface" + : `its declared types come from the separate ${npm.packageName} package, not the package itself`, + hint: npmStaticOptInHint(runtimePkg, owner), }); continue; } if (judged?.has(npm.packageName)) continue; + if (viaTransitive) { + judged!.add(npm.packageName); + sites!.set(npm.packageName, loc); + transitive.add(npm.packageName); + chosen.push(npm.packageName); + continue; + } if (!seen.has(npm.packageName)) { - seen.set(npm.packageName, { typesFile: npm.typesFile, fromFile: sf.fileName, spec }); + seen.set(npm.packageName, { typesFile: npm.typesFile, fromFile: sf.fileName, spec, owner }); sites?.set(npm.packageName, loc); } } } - const chosen: string[] = []; - for (const [pkg, { typesFile, fromFile, spec }] of seen) { + for (const [pkg, { typesFile, fromFile, spec, owner }] of seen) { judged?.add(pkg); // A package without a root entry (no "main", "exports" or index file) // can still serve the subpath the program imports. @@ -180,11 +244,23 @@ function detectAutoPackages( package: pkg, status: "refused", detail: mode === "lib" ? reason : `auto: ${reason}`, + // Naming a package bypasses the declaration and shipped-JS + // heuristics; it cannot supply JavaScript that does not resolve. + ...(mode === "lib" && jsEntry !== null ? { hint: npmStaticOptInHint(pkg, owner) } : {}), }); } return chosen; } +/** How to compile a package the declaration bar refused anyway: name it, + * or (for a dependency of an opted-in package) opt in that package's + * whole dependency closure. */ +function npmStaticOptInHint(pkg: string, importer: string | null): string { + return importer === null + ? `to compile it anyway, name it with --npm-static=${pkg} (or --npm-static=${pkg}... to include its dependencies)` + : `to compile it anyway, name it with --npm-static=${pkg}, or use --npm-static=${importer}... to include all of ${importer}'s dependencies`; +} + /** The opted-in packages a consumer-anchored tsc message NAMES: module * specifiers in `Module '"spec"'` phrasings, and resolved file paths in * `import("…")` type spellings — the two ways the checker points at an @@ -232,9 +308,23 @@ export function runFrontend( // selections bypass eligibility heuristics, but never compilation checks. const explicit: readonly string[] = npmStatic !== undefined && typeof npmStatic !== "string" ? npmStatic : []; - return loadFrontend(entryPath, trackedLoader, "lib", externalTypes, [ - ...new Set([...libraryNpmStatic, ...explicit]), - ]); + // A trailing "..." (`--npm-static=fs-extra...`) selects the package and + // its whole dependency closure, which the library fixpoint discovers. + const transitive = new Set(); + const names = [...libraryNpmStatic, ...explicit].map((name) => { + if (!name.endsWith("...") || name.length === 3) return name; + const base = name.slice(0, -3); + transitive.add(base); + return base; + }); + return loadFrontend( + entryPath, + trackedLoader, + "lib", + externalTypes, + [...new Set(names)], + transitive, + ); } catch (error) { for (const load of active) { // Preserve the original failure and attempt every remaining cleanup. @@ -254,6 +344,7 @@ function loadFrontend( npmStatic?: readonly string[] | "auto" | "lib", externalTypes?: Readonly>, libraryNpmStatic: readonly string[] = [], + transitive: Set = new Set(), ): Frontend { // Resolver package/workspace metadata is intentionally shared across the // several load attempts of ONE auto-detection fixpoint, but never across @@ -275,7 +366,10 @@ function loadFrontend( const scoutPreflight = checkPreflight(scout); requested = npmStatic === "lib" - ? [...libraryNpmStatic, ...detectAutoPackages(scout, statuses, "lib", judged, npmSites)] + ? [ + ...libraryNpmStatic, + ...detectAutoPackages(scout, statuses, "lib", judged, npmSites, transitive), + ] : detectAutoPackages(scout, statuses); // With no package to opt in, the scout already IS the final frontend: // same roots, resolution posture, preflight, and module order. Retain it @@ -333,7 +427,7 @@ function loadFrontend( // at least one new package for good). if (npmStatic === "lib") { for (;;) { - const grown = detectAutoPackages(load, statuses, "lib", judged, npmSites); + const grown = detectAutoPackages(load, statuses, "lib", judged, npmSites, transitive); if (grown.length === 0) break; requested = [...requested, ...grown]; load.dispose(); diff --git a/tests/harness/npm-static.test.ts b/tests/harness/npm-static.test.ts index 398c35b8a..e144f428b 100644 --- a/tests/harness/npm-static.test.ts +++ b/tests/harness/npm-static.test.ts @@ -787,10 +787,56 @@ describe(`npm-static pilots${sanitize ? " (sanitized)" : ""}`, () => { package: "ms", status: "refused", detail: "it ships no own .d.ts declaration surface", + hint: "to compile it anyway, name it with --npm-static=ms (or --npm-static=ms... to include its dependencies)", }, ]); }, 120_000); + // Types-first resolution answers @types/twinned, but the refusal names the + // package that has the code and the flag that compiles it. + test("an @types-typed package is refused under its runtime name with the opt-in remedy", () => { + const { coverage } = analyze(join(pilotRoot, "twinned-cli.ts")); + expect(coverage.npmStatic).toEqual([ + { + package: "twinned", + status: "refused", + detail: + "its declared types come from the separate @types/twinned package, not the package itself", + hint: "to compile it anyway, name it with --npm-static=twinned (or --npm-static=twinned... to include its dependencies)", + }, + ]); + const diagnostic = coverage.diagnostics.find((d) => d.code === "SC2013"); + expect(diagnostic?.message).toContain("'twinned'"); + expect(diagnostic?.hint).toContain("--npm-static=twinned"); + }, 120_000); + + test("a named package's untyped dependency points at the transitive opt-in", () => { + const { coverage } = analyze(join(pilotRoot, "twinned-cli.ts"), { npmStatic: ["twinned"] }); + expect(coverage.npmStatic).toContainEqual({ + package: "ms", + status: "refused", + detail: "it ships no own .d.ts declaration surface", + hint: "to compile it anyway, name it with --npm-static=ms, or use --npm-static=twinned... to include all of twinned's dependencies", + }); + }, 120_000); + + test("--npm-static=pkg... compiles the package's dependency closure", async () => { + const entry = join(pilotRoot, "twinned-cli.ts"); + const { coverage } = analyze(entry, { npmStatic: ["twinned..."] }); + expect(coverage.npmStatic).toEqual([ + { package: "twinned", status: "static" }, + { package: "ms", status: "static" }, + ]); + expect(coverage.preflightFailed).toBe(false); + const binary = await buildStatic(entry, ["twinned..."]); + const [nodeRes, nativeRes] = await Promise.all([ + runBinary("node", [entry]), + runBinary(binary, []), + ]); + expect(nativeRes.stdout.toString("utf8")).toBe(nodeRes.stdout.toString("utf8")); + expect(nativeRes.exitCode).toBe(nodeRes.exitCode); + }, 180_000); + test("type-only imports select no package", async () => { const entry = join(pilotRoot, "type-only-cli.ts"); const { coverage } = analyze(entry); @@ -937,6 +983,7 @@ describe(`npm-static pilots${sanitize ? " (sanitized)" : ""}`, () => { package: "typegapped", status: "refused", detail: "it ships no own .d.ts declaration surface", + hint: "to compile it anyway, name it with --npm-static=typegapped (or --npm-static=typegapped... to include its dependencies)", }, { package: "escape-string-regexp", status: "static" }, ]); From cf872eaba51a4fb060bdc4bf2f474a4431b5e5df Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 19:43:56 -0700 Subject: [PATCH 08/47] Convert only int32 loop counters from their low half A uint32 counter converted through `uitofp i32` folds an inlined callee's index conversion, but the zero extension it adds on x86-64 slowed loops that only convert the counter for a cold fallback. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/src/backend/llvm/expr-primitives.ts | 10 +++++----- packages/compiler/src/backend/llvm/integer-values.ts | 7 +------ 2 files changed, 6 insertions(+), 11 deletions(-) diff --git a/packages/compiler/src/backend/llvm/expr-primitives.ts b/packages/compiler/src/backend/llvm/expr-primitives.ts index 664689e91..e237f8f13 100644 --- a/packages/compiler/src/backend/llvm/expr-primitives.ts +++ b/packages/compiler/src/backend/llvm/expr-primitives.ts @@ -67,18 +67,18 @@ export function emitLiteralExpr( const uint32 = integerSlot.type === "i32" ? integer : B.tmp(); if (integerSlot.type !== "i32") B.line(`${uint32} = trunc ${integerSlot.type} ${integer} to i32`); - // A counter whose range fits 32 bits converts from its low half, so - // LLVM folds a later `fptosi` of the double (an inlined callee's + // An int32 counter (a dense array loop's) converts from its low half, + // so LLVM folds a later `fptosi` of the double (an inlined callee's // index) back to the integer. Otherwise a 64-bit induction value is // a safe integer, so its sign bit is clear and the signed conversion // is exact: one cvtsi2sd instead of x86-64's multi-instruction - // unsigned 64-bit conversion. + // unsigned 64-bit conversion. (A uint32 counter would fold through + // `uitofp i32` too, but the zero extension it adds on x86-64 cost + // more in loops that never convert the double than it saved.) const range = integerSlot.range; const signedConversion = integerSlot.signed === true || integerSlot.type === "i64"; if (range && range.min >= -2147483648 && range.max <= 2147483647) B.line(`${number} = sitofp i32 ${uint32} to double`); - else if (range && range.min >= 0 && range.max <= 4294967295) - B.line(`${number} = uitofp i32 ${uint32} to double`); else B.line( `${number} = ${signedConversion ? "sitofp" : "uitofp"} ${integerSlot.type} ${integer} to double`, diff --git a/packages/compiler/src/backend/llvm/integer-values.ts b/packages/compiler/src/backend/llvm/integer-values.ts index 53e07462e..63e279d04 100644 --- a/packages/compiler/src/backend/llvm/integer-values.ts +++ b/packages/compiler/src/backend/llvm/integer-values.ts @@ -93,16 +93,11 @@ export function integerNumber( // `x | 0`), while a 64-bit source is not known to convert exactly. So a // counter written `i = (i + 1) | 0` stays an integer instead of taking a // double round trip on every iteration. - // A uint32 (an array index counter) converts from its low half unsigned, - // which LLVM likewise folds back through a later `fptosi` to i64. const int32 = range.min >= -2147483648 && range.max <= 2147483647; - const unsigned = !int32 && range.min >= 0 && range.max <= 4294967295; host.B.line( int32 ? `${number} = sitofp i32 ${uint32} to double` - : unsigned - ? `${number} = uitofp i32 ${uint32} to double` - : `${number} = sitofp i64 ${name} to double`, + : `${number} = sitofp i64 ${name} to double`, ); return { name: number, type, uint32, integer: { name, type: "i64", signed: true, range } }; } From 1e5079a23ab3354f3d67cc76624774050104de30 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 19:44:08 -0700 Subject: [PATCH 09/47] Format the array length loop changes and record their order baselines Co-Authored-By: Claude Opus 5.5 --- .../backend/llvm/dense-array-loops.test.ts | 28 +++++++++++++---- .../src/backend/llvm/dense-array-loops.ts | 5 +--- .../src/ir/array-length-stability.test.ts | 30 +++++++++++++------ .../compiler/src/ir/integer-ranges.test.ts | 25 ++++++++++++++-- .../5993-array-length-loop-resizing.ts.json | 6 ++++ .../5994-array-length-sparse-loops.ts.json | 6 ++++ .../5995-array-dense-loop-boundaries.ts.json | 6 ++++ 7 files changed, 84 insertions(+), 22 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5993-array-length-loop-resizing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5994-array-length-sparse-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5995-array-dense-loop-boundaries.ts.json diff --git a/packages/compiler/src/backend/llvm/dense-array-loops.test.ts b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts index d9e18d7ef..405ad67e7 100644 --- a/packages/compiler/src/backend/llvm/dense-array-loops.test.ts +++ b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts @@ -1,6 +1,10 @@ import { expect, test } from "vitest"; import { BOOL, F64, arrayOf, type IrExpr, type IrLocal, type IrStmt } from "../../ir/ir.js"; -import { countedDenseShape, matchDenseArrayLoop, type DenseLoopShape } from "./dense-array-loops.js"; +import { + countedDenseShape, + matchDenseArrayLoop, + type DenseLoopShape, +} from "./dense-array-loops.js"; const loc = { file: "dense-array-loops.ts", start: 0, end: 0 }; const ARR = arrayOf(F64); @@ -16,9 +20,15 @@ const method = ( receiver: string, name: Extract["method"], args: IrExpr[] = [], -): IrExpr => ({ kind: "arrIntrinsic", method: name, receiver: arr(receiver), args, type: F64, loc }); -const read = (receiver: string, index = ref("i")): IrExpr => - method(receiver, "getNumber", [index]); +): IrExpr => ({ + kind: "arrIntrinsic", + method: name, + receiver: arr(receiver), + args, + type: F64, + loc, +}); +const read = (receiver: string, index = ref("i")): IrExpr => method(receiver, "getNumber", [index]); const write = (receiver: string, value: IrExpr, index = ref("i")): IrStmt => ({ kind: "arraySet", arr: arr(receiver), @@ -49,7 +59,11 @@ function loop(body: IrStmt[]): IrStmt & { kind: "for" } { body, }; } -const shape: DenseLoopShape = { counter: "i", length: arr("a"), range: { min: 0, max: 4294967294 } }; +const shape: DenseLoopShape = { + counter: "i", + length: arr("a"), + range: { min: 0, max: 4294967294 }, +}; const match = (body: IrStmt[], initialized = new Set(["a", "b"])) => matchDenseArrayLoop(loop(body), shape, locals, new Set(), initialized); @@ -73,7 +87,9 @@ test("loops that may resize, rebind or move storage keep the ordinary copy only" expect(match([{ kind: "exprStmt", expr: method("a", "push", [num(1)]), loc }])).toBeNull(); expect(match([write("a", num(0), ref("unknown"))])).toBeNull(); expect( - match([{ kind: "exprStmt", expr: { kind: "call", callee: "f", args: [], type: F64, loc }, loc }]), + match([ + { kind: "exprStmt", expr: { kind: "call", callee: "f", args: [], type: F64, loc }, loc }, + ]), ).toBeNull(); // A nested loop would be duplicated too. expect(match([{ kind: "exprStmt", expr: read("a"), loc }, loop([])])).toBeNull(); diff --git a/packages/compiler/src/backend/llvm/dense-array-loops.ts b/packages/compiler/src/backend/llvm/dense-array-loops.ts index 5009e6c82..271a5ddf8 100644 --- a/packages/compiler/src/backend/llvm/dense-array-loops.ts +++ b/packages/compiler/src/backend/llvm/dense-array-loops.ts @@ -137,10 +137,7 @@ export function matchDenseArrayLoop( if (s.kind === "assign" || s.kind === "varDecl") disturbed.add(s.localId); if (s.kind === "arraySet") { access(s.arr, s.index); - if ( - s.arr.kind === "varRef" && - (s.index.kind !== "varRef" || s.index.localId !== counter) - ) + if (s.arr.kind === "varRef" && (s.index.kind !== "varRef" || s.index.localId !== counter)) disturbed.add(s.arr.localId); } return everyStmtChild(s, expr, stmt); diff --git a/packages/compiler/src/ir/array-length-stability.test.ts b/packages/compiler/src/ir/array-length-stability.test.ts index 87e510a3f..44e461ca2 100644 --- a/packages/compiler/src/ir/array-length-stability.test.ts +++ b/packages/compiler/src/ir/array-length-stability.test.ts @@ -1,6 +1,14 @@ import { expect, test } from "vitest"; import { findUnaliasedLocalArrays, preservesArrayLength } from "./array-length-stability.js"; -import { BOOL, F64, arrayOf, type IrExpr, type IrFunction, type IrLocal, type IrStmt } from "./ir.js"; +import { + BOOL, + F64, + arrayOf, + type IrExpr, + type IrFunction, + type IrLocal, + type IrStmt, +} from "./ir.js"; const loc = { file: "array-length-stability.ts", start: 0, end: 0 }; const ARR = arrayOf(F64); @@ -11,7 +19,14 @@ const method = ( receiver: string, name: Extract["method"], args: IrExpr[] = [], -): IrExpr => ({ kind: "arrIntrinsic", method: name, receiver: arr(receiver), args, type: F64, loc }); +): IrExpr => ({ + kind: "arrIntrinsic", + method: name, + receiver: arr(receiver), + args, + type: F64, + loc, +}); const length = (receiver: string): IrExpr => method(receiver, "length"); const read = (receiver: string, index: IrExpr): IrExpr => method(receiver, "getNumber", [index]); const plus = (left: IrExpr, right: IrExpr): IrExpr => ({ @@ -74,9 +89,9 @@ test("resizing methods, length stores, calls and escapes refuse the proof", () = expect(preserves([{ kind: "arraySetLength", arr: arr("a"), length: num(0), loc }])).toBe(false); expect(preserves([{ kind: "arrayDelete", arr: arr("a"), index: ref("i"), loc }])).toBe(false); expect(preserves([stmt({ kind: "call", callee: "f", args: [], type: F64, loc })])).toBe(false); - expect( - preserves([stmt({ kind: "call", callee: "f", args: [arr("a")], type: F64, loc })]), - ).toBe(false); + expect(preserves([stmt({ kind: "call", callee: "f", args: [arr("a")], type: F64, loc })])).toBe( + false, + ); expect(preserves([{ kind: "varDecl", localId: "b", init: arr("a"), loc }])).toBe(false); expect(preserves([{ kind: "assign", localId: "a", value: arr("b"), loc }])).toBe(false); }); @@ -119,10 +134,7 @@ test("fresh local arrays read only as receivers have no alias", () => { expect(findUnaliasedLocalArrays(fn(body, ["out"])).size).toBe(0); const copied = [...body, { kind: "varDecl", localId: "b", init: arr("out"), loc } as IrStmt]; expect(findUnaliasedLocalArrays(fn(copied)).has("out")).toBe(false); - const passed = [ - ...body, - stmt({ kind: "call", callee: "g", args: [arr("out")], type: F64, loc }), - ]; + const passed = [...body, stmt({ kind: "call", callee: "g", args: [arr("out")], type: F64, loc })]; expect(findUnaliasedLocalArrays(fn(passed)).has("out")).toBe(false); const rebound = [...body, { kind: "assign", localId: "out", value: arr("a"), loc } as IrStmt]; expect(findUnaliasedLocalArrays(fn(rebound)).has("out")).toBe(false); diff --git a/packages/compiler/src/ir/integer-ranges.test.ts b/packages/compiler/src/ir/integer-ranges.test.ts index 0d0762d16..8e1c97f66 100644 --- a/packages/compiler/src/ir/integer-ranges.test.ts +++ b/packages/compiler/src/ir/integer-ranges.test.ts @@ -800,11 +800,25 @@ test("an array length bounds while and for counters even when the body resizes t // let i = 0; while (i < items.length) { observe(i); items.push(i); i++; } observe(i); const ARR = { kind: "array", elem: F64 } as const; const items: IrExpr = { loc, kind: "varRef", localId: "items", type: ARR }; - const length: IrExpr = { loc, kind: "arrIntrinsic", method: "length", receiver: items, args: [], type: F64 }; + const length: IrExpr = { + loc, + kind: "arrIntrinsic", + method: "length", + receiver: items, + args: [], + type: F64, + }; const push: IrStmt = { loc, kind: "exprStmt", - expr: { loc, kind: "arrIntrinsic", method: "push", receiver: items, args: [ref("i")], type: F64 }, + expr: { + loc, + kind: "arrIntrinsic", + method: "push", + receiver: items, + args: [ref("i")], + type: F64, + }, }; const bump: IrStmt = { loc, @@ -815,7 +829,12 @@ test("an array length bounds while and for counters even when the body resizes t after = ref("i"); const f = fn([ { loc, kind: "assign", localId: "i", value: num(0) }, - { loc, kind: "while", cond: condition("<", ref("i"), length), body: [observe(inside), push, bump] }, + { + loc, + kind: "while", + cond: condition("<", ref("i"), length), + body: [observe(inside), push, bump], + }, observe(after), ]); f.locals.push( diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5993-array-length-loop-resizing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5993-array-length-loop-resizing.ts.json new file mode 100644 index 000000000..e4cf027ce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5993-array-length-loop-resizing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5993-array-length-loop-resizing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5994-array-length-sparse-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5994-array-length-sparse-loops.ts.json new file mode 100644 index 000000000..6289e8a21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5994-array-length-sparse-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5994-array-length-sparse-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5995-array-dense-loop-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5995-array-dense-loop-boundaries.ts.json new file mode 100644 index 000000000..d0afcf505 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5995-array-dense-loop-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5995-array-dense-loop-boundaries.ts" + ], + "diags": [] +} From 0dc6e05e82f3a9d23238c7d71236cb236e4bcf90 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 20:47:16 -0700 Subject: [PATCH 10/47] Expect the tighter strided-loop bound in the self-hosted range cases The native range analysis now admits one fewer pass for a strict bound, so the failing condition of `for (x = 0; x < 100; x += 24)` reads at most 123 (the last pass enters at 99 at most). Co-Authored-By: Claude Opus 5.5 --- tests/harness/self-hosting-range-cases.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/harness/self-hosting-range-cases.ts b/tests/harness/self-hosting-range-cases.ts index 05d6a1fe6..ed2b24ca9 100644 --- a/tests/harness/self-hosting-range-cases.ts +++ b/tests/harness/self-hosting-range-cases.ts @@ -375,7 +375,8 @@ export function integerRangeCases(): RangeCase[] { ], }, ], - [proof(cursor, 0, 80), proof(decoded, 0, 4294967295), proof(head, 0, 124)], + // Passes enter at 0, 24, 48, 72 and 96 (at most 99), so the failing test reads at most 123. + [proof(cursor, 0, 80), proof(decoded, 0, 4294967295), proof(head, 0, 123)], (func) => { for (const id of ["cursor", "decoded"]) func.locals.push({ id, name: id, type: F64, mutable: true }); From e2c7eac01db6b7b3ae00f54b7bd9776748d4879e Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 21:01:15 -0700 Subject: [PATCH 11/47] Record order baselines for the type-only import fixtures Co-Authored-By: Claude Opus 5.5 --- .../corpus/6120-type-only-import-graph/main.ts.json | 8 ++++++++ .../corpus/6121-type-specifier-edges/main.ts.json | 10 ++++++++++ 2 files changed, 18 insertions(+) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6120-type-only-import-graph/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6121-type-specifier-edges/main.ts.json diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6120-type-only-import-graph/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6120-type-only-import-graph/main.ts.json new file mode 100644 index 000000000..979391c1c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6120-type-only-import-graph/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/6120-type-only-import-graph/mixed.ts", + "/tests/corpus/6120-type-only-import-graph/flags.ts", + "/tests/corpus/6120-type-only-import-graph/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6121-type-specifier-edges/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6121-type-specifier-edges/main.ts.json new file mode 100644 index 000000000..c0f3f653c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6121-type-specifier-edges/main.ts.json @@ -0,0 +1,10 @@ +{ + "order": [ + "/tests/corpus/6121-type-specifier-edges/config.ts", + "/tests/corpus/6121-type-specifier-edges/config-barrel.ts", + "/tests/corpus/6121-type-specifier-edges/b.ts", + "/tests/corpus/6121-type-specifier-edges/a.ts", + "/tests/corpus/6121-type-specifier-edges/main.ts" + ], + "diags": [] +} From b4e25cdba0708b1b2a4aacbd499ec3ff21871c8c Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 21:01:15 -0700 Subject: [PATCH 12/47] Leave an @types twin with no runtime package to the declaration bar in transitive selection Co-Authored-By: Claude Opus 5.5 --- packages/compiler/src/frontend/pipeline.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/packages/compiler/src/frontend/pipeline.ts b/packages/compiler/src/frontend/pipeline.ts index 20df75c9b..c769ed99e 100644 --- a/packages/compiler/src/frontend/pipeline.ts +++ b/packages/compiler/src/frontend/pipeline.ts @@ -214,7 +214,9 @@ function detectAutoPackages( continue; } if (judged?.has(npm.packageName)) continue; - if (viaTransitive) { + // An @types twin with no runtime package installed has nothing to + // compile (Node cannot load it either). + if (viaTransitive && !npm.packageName.startsWith("@types/")) { judged!.add(npm.packageName); sites!.set(npm.packageName, loc); transitive.add(npm.packageName); From 1c19d6613df8a52d64e4536724d84f6d7eaeec1f Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 21:01:16 -0700 Subject: [PATCH 13/47] Compile the deprecated punycode and constants builtin modules - node:punycode: encode, decode, toASCII, toUnicode, ucs2.decode, ucs2.encode and version, ported from the punycode.js 2.1.0 Node bundles (scr_url.c), with its RangeErrors. DEP0040 follows Node: a static ES import reports before any module evaluates and before the program can register a 'warning' listener; require() reports on the next tick, once for both spellings, not when a dependency under node_modules loads the module first, and not under process.noDeprecation. - node:constants: the frozen object Node builds from os.constants' dlopen, errno, priority and signals groups, fs.constants (node_constants.cc order and guards) and crypto.constants (scr_os.c); its bindings read it as a checked-dynamic value. These unblock tr46 (whatwg-url, node-fetch@2) and graceful-fs (fs-extra). Co-Authored-By: Claude Opus 5.5 --- docs/content/docs/limitations.mdx | 2 + .../builtin-apis/deprecated-modules.mdx | 1 + .../node-v24-compatibility-meta.json | 2 +- .../src/generated/node-v24-compatibility.json | 48 +-- .../generated/node-v24-backlog.json | 116 +++--- .../generated/node-v24-internal.json | 76 +++- internal/compatibility/static-support.json | 1 + .../ambient/scriptc-node-fallback.d.ts | 33 ++ .../compiler/src/backend/llvm/lib-dispatch.ts | 2 + .../compiler/src/backend/llvm/lib-shared.ts | 8 + .../compiler/src/frontend/builtin-modules.ts | 2 + .../frontend/lowering/lower-builtin-values.ts | 32 ++ .../src/frontend/lowering/lower-exprs.ts | 14 + .../src/frontend/lowering/lower-modules.ts | 1 + .../src/frontend/lowering/lower-stmts.ts | 4 +- .../compiler/src/frontend/lowering/lowerer.ts | 77 ++++ .../src/frontend/lowering/surfaces.ts | 17 + packages/compiler/src/ir/builtin-effects.ts | 7 + .../compiler/src/ir/builtin-signatures.ts | 17 + packages/compiler/src/ir/runtime-features.ts | 2 + packages/compiler/surface-manifest.json | 57 +++ .../corpus/6122-punycode-conversions.ts.json | 6 + .../6124-punycode-require-warnings.cjs.json | 6 + .../corpus/6125-constants-module.cjs.json | 6 + .../6126-punycode-dependency/main.cjs.json | 18 + packages/runtime/src/scr_async.h | 5 + packages/runtime/src/scr_async_dyn.c | 21 ++ packages/runtime/src/scr_os.c | 194 ++++++++++ packages/runtime/src/scr_os.h | 4 + packages/runtime/src/scr_url.c | 339 ++++++++++++++++++ packages/runtime/src/scr_url.h | 9 + tests/corpus/6122-punycode-conversions.ts | 45 +++ .../corpus/6124-punycode-require-warnings.cjs | 32 ++ tests/corpus/6125-constants-module.cjs | 26 ++ .../corpus/6126-punycode-dependency/main.cjs | 12 + .../node_modules/puny-dep/index.d.ts | 2 + .../node_modules/puny-dep/index.js | 8 + .../node_modules/puny-dep/package.json | 5 + 38 files changed, 1169 insertions(+), 88 deletions(-) create mode 100644 docs/content/limitations/builtin-apis/deprecated-modules.mdx create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6122-punycode-conversions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6124-punycode-require-warnings.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6125-constants-module.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6126-punycode-dependency/main.cjs.json create mode 100644 tests/corpus/6122-punycode-conversions.ts create mode 100644 tests/corpus/6124-punycode-require-warnings.cjs create mode 100644 tests/corpus/6125-constants-module.cjs create mode 100644 tests/corpus/6126-punycode-dependency/main.cjs create mode 100644 tests/corpus/6126-punycode-dependency/node_modules/puny-dep/index.d.ts create mode 100644 tests/corpus/6126-punycode-dependency/node_modules/puny-dep/index.js create mode 100644 tests/corpus/6126-punycode-dependency/node_modules/puny-dep/package.json diff --git a/docs/content/docs/limitations.mdx b/docs/content/docs/limitations.mdx index ed2c5b1ec..a66b2ffd6 100644 --- a/docs/content/docs/limitations.mdx +++ b/docs/content/docs/limitations.mdx @@ -74,6 +74,8 @@ title: "Limitations" ../limitations/builtin-apis/legacy-url-api.mdx +../limitations/builtin-apis/deprecated-modules.mdx + ../limitations/builtin-apis/filesystem-flags.mdx ../limitations/builtin-apis/copy.mdx diff --git a/docs/content/limitations/builtin-apis/deprecated-modules.mdx b/docs/content/limitations/builtin-apis/deprecated-modules.mdx new file mode 100644 index 000000000..bb630b8c3 --- /dev/null +++ b/docs/content/limitations/builtin-apis/deprecated-modules.mdx @@ -0,0 +1 @@ +- **Deprecated `punycode` and `constants` modules:** `punycode.encode()`, `decode()`, `toASCII()`, `toUnicode()`, `ucs2.decode()`, `ucs2.encode()`, and `version` compile, with the `DEP0040` warning Node.js reports when the module loads. A `require("punycode")` made from inside `node_modules` doesn't warn; a `require()` used inside a larger expression, such as `require("punycode").toASCII(name)`, doesn't warn either. The `punycode.ucs2` object itself is unsupported as a value. The `constants` module is the frozen object Node.js builds from `os.constants` and `fs.constants`, plus the `crypto.constants` of Node.js 24.22.0. diff --git a/docs/src/generated/node-v24-compatibility-meta.json b/docs/src/generated/node-v24-compatibility-meta.json index 93149c51c..a063052f3 100644 --- a/docs/src/generated/node-v24-compatibility-meta.json +++ b/docs/src/generated/node-v24-compatibility-meta.json @@ -2,6 +2,6 @@ "schemaVersion": 3, "nodeVersion": "24.22.0", "nodeCommit": "f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93", - "artifactVersion": "a1ff929d49885bd8c92e", + "artifactVersion": "7b345b86e2e5f616a7a0", "rowCount": 3880 } diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json index 352c211b5..62eb8283e 100644 --- a/docs/src/generated/node-v24-compatibility.json +++ b/docs/src/generated/node-v24-compatibility.json @@ -584,9 +584,9 @@ "apiEntries": 9, "static": { "supported": 0, - "partial": 0, + "partial": 8, "refused": 0, - "not-implemented": 9, + "not-implemented": 1, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -58489,7 +58489,7 @@ "inherited": false }, "static": { - "status": "not-implemented", + "status": "partial", "detail": "Derived from the exact API rows in this chapter.", "verification": "derived" } @@ -58512,9 +58512,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented for the call shapes accepted by the compiler lowering.", + "verification": "test-backed" } }, { @@ -58535,9 +58535,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented for the call shapes accepted by the compiler lowering.", + "verification": "test-backed" } }, { @@ -58558,9 +58558,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented for the call shapes accepted by the compiler lowering.", + "verification": "test-backed" } }, { @@ -58581,9 +58581,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented for the call shapes accepted by the compiler lowering.", + "verification": "test-backed" } }, { @@ -58627,9 +58627,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented for the call shapes accepted by the compiler lowering.", + "verification": "test-backed" } }, { @@ -58650,9 +58650,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented for the call shapes accepted by the compiler lowering.", + "verification": "test-backed" } }, { @@ -58673,9 +58673,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented for the call shapes accepted by the compiler lowering.", + "verification": "test-backed" } }, { diff --git a/internal/compatibility/generated/node-v24-backlog.json b/internal/compatibility/generated/node-v24-backlog.json index fff784adc..c4ce78314 100644 --- a/internal/compatibility/generated/node-v24-backlog.json +++ b/internal/compatibility/generated/node-v24-backlog.json @@ -7,8 +7,8 @@ "tierItemCount": 3456, "tiers": { "static": { - "audit-partial": 1091, - "verify-gap": 2238, + "audit-partial": 1098, + "verify-gap": 2231, "replace-refusal": 40, "classify": 2, "implement": 85 @@ -58534,12 +58534,16 @@ "priority": "low", "tiers": { "static": { - "status": "not-implemented", - "action": "verify-gap", - "verification": "registry-gap", - "confidence": "low", - "source": "compiler-unmatched:punycode", - "tests": [] + "status": "partial", + "action": "audit-partial", + "verification": "test-backed", + "confidence": "high", + "source": "surface-manifest:node-builtin.punycode.decode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] } } }, @@ -58559,12 +58563,16 @@ "priority": "low", "tiers": { "static": { - "status": "not-implemented", - "action": "verify-gap", - "verification": "registry-gap", - "confidence": "low", - "source": "compiler-unmatched:punycode", - "tests": [] + "status": "partial", + "action": "audit-partial", + "verification": "test-backed", + "confidence": "high", + "source": "surface-manifest:node-builtin.punycode.encode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] } } }, @@ -58584,12 +58592,16 @@ "priority": "low", "tiers": { "static": { - "status": "not-implemented", - "action": "verify-gap", - "verification": "registry-gap", - "confidence": "low", - "source": "compiler-unmatched:punycode", - "tests": [] + "status": "partial", + "action": "audit-partial", + "verification": "test-backed", + "confidence": "high", + "source": "surface-manifest:node-builtin.punycode.toASCII", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] } } }, @@ -58609,12 +58621,16 @@ "priority": "low", "tiers": { "static": { - "status": "not-implemented", - "action": "verify-gap", - "verification": "registry-gap", - "confidence": "low", - "source": "compiler-unmatched:punycode", - "tests": [] + "status": "partial", + "action": "audit-partial", + "verification": "test-backed", + "confidence": "high", + "source": "surface-manifest:node-builtin.punycode.toUnicode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] } } }, @@ -58659,12 +58675,16 @@ "priority": "low", "tiers": { "static": { - "status": "not-implemented", - "action": "verify-gap", - "verification": "registry-gap", - "confidence": "low", - "source": "compiler-unmatched:punycode", - "tests": [] + "status": "partial", + "action": "audit-partial", + "verification": "test-backed", + "confidence": "high", + "source": "surface-manifest:node-builtin.punycode.ucs2.decode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] } } }, @@ -58684,12 +58704,16 @@ "priority": "low", "tiers": { "static": { - "status": "not-implemented", - "action": "verify-gap", - "verification": "registry-gap", - "confidence": "low", - "source": "compiler-unmatched:punycode", - "tests": [] + "status": "partial", + "action": "audit-partial", + "verification": "test-backed", + "confidence": "high", + "source": "surface-manifest:node-builtin.punycode.ucs2.encode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] } } }, @@ -58709,12 +58733,16 @@ "priority": "low", "tiers": { "static": { - "status": "not-implemented", - "action": "verify-gap", - "verification": "registry-gap", - "confidence": "low", - "source": "compiler-unmatched:punycode", - "tests": [] + "status": "partial", + "action": "audit-partial", + "verification": "test-backed", + "confidence": "high", + "source": "surface-manifest:node-builtin.punycode.version", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] } } }, diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index 559bd48ca..58ffc3399 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -611,9 +611,9 @@ "apiEntries": 9, "static": { "supported": 0, - "partial": 0, + "partial": 8, "refused": 0, - "not-implemented": 9, + "not-implemented": 1, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -81908,8 +81908,13 @@ "inherited": false }, "static": { - "status": "not-implemented", - "evidence": "derived:descendants" + "status": "partial", + "evidence": "derived:descendants", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] }, "anchorSource": "chapter" }, @@ -81931,8 +81936,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:punycode" + "status": "partial", + "evidence": "surface-manifest:node-builtin.punycode.decode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] }, "anchorSource": "exact" }, @@ -81954,8 +81964,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:punycode" + "status": "partial", + "evidence": "surface-manifest:node-builtin.punycode.encode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] }, "anchorSource": "exact" }, @@ -81977,8 +81992,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:punycode" + "status": "partial", + "evidence": "surface-manifest:node-builtin.punycode.toASCII", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] }, "anchorSource": "exact" }, @@ -82000,8 +82020,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:punycode" + "status": "partial", + "evidence": "surface-manifest:node-builtin.punycode.toUnicode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] }, "anchorSource": "exact" }, @@ -82046,8 +82071,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:punycode" + "status": "partial", + "evidence": "surface-manifest:node-builtin.punycode.ucs2.decode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] }, "anchorSource": "exact" }, @@ -82069,8 +82099,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:punycode" + "status": "partial", + "evidence": "surface-manifest:node-builtin.punycode.ucs2.encode", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] }, "anchorSource": "exact" }, @@ -82092,8 +82127,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:punycode" + "status": "partial", + "evidence": "surface-manifest:node-builtin.punycode.version", + "tests": [ + "tests/corpus/6122-punycode-conversions.ts", + "tests/corpus/6124-punycode-require-warnings.cjs", + "tests/corpus/6126-punycode-dependency/main.cjs" + ] }, "anchorSource": "chapter" }, diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index d68011393..5332ddd4c 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -146,6 +146,7 @@ "node-builtin.process.rows": ["tests/corpus/2992-stream-rows.ts", "tests/harness/terminal-geometry.test.ts"], "node-builtin.process.columns": ["tests/corpus/1448-stream-columns.ts", "tests/harness/terminal-geometry.test.ts"], "node-builtin.process.exitCode": ["tests/corpus/2941-process-exit-code.ts", "tests/corpus/2942-process-exit-code-override.ts", "tests/corpus/2943-process-exit-code-invalid.ts", "tests/corpus/2944-process-exit-code-wrap.ts"], + "node-builtin.punycode": ["tests/corpus/6122-punycode-conversions.ts", "tests/corpus/6124-punycode-require-warnings.cjs", "tests/corpus/6126-punycode-dependency/main.cjs"], "node-builtin.querystring": ["tests/corpus/957-builtins-namespace.ts", "tests/corpus/2917-builtin-callable-widths.ts"], "node-builtin.readline": ["tests/corpus/1475-readline-closed-stdin.ts"], "node-builtin.stream": ["tests/corpus/1685-stream-readable-basics.ts", "tests/corpus/1746-stream-for-await.ts", "tests/corpus/1814-stream-pipeline.cjs", "tests/corpus/2629-stream-consumers.ts", "tests/corpus/2861-readable-iterator-close.ts"], diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index d87172f61..2c53bb523 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -3643,6 +3643,39 @@ declare module "node:querystring" { export * from "querystring"; } +/* node:punycode (deprecated, DEP0040) — punycode.js 2.1.0: decode and + * toUnicode throw its RangeErrors on malformed input; ucs2 converts + * between strings and UTF-16 code point arrays. */ +declare module "punycode" { + export function decode(string: string): string; + export function encode(string: string): string; + export function toUnicode(domain: string): string; + export function toASCII(domain: string): string; + export namespace ucs2 { + function decode(string: string): number[]; + function encode(codePoints: readonly number[]): string; + } + export const version: string; +} +declare module "node:punycode" { + export * from "punycode"; +} + +/* node:constants (deprecated, DEP0008) — one frozen object: os.constants' + * dlopen, errno, priority and signals groups, fs.constants, and + * crypto.constants. A platform's missing constant reads as undefined. */ +declare module "constants" { + const constants: { readonly [name: string]: number } & { + readonly defaultCoreCipherList: string; + readonly defaultCipherList: string; + }; + export = constants; +} +declare module "node:constants" { + import constants = require("constants"); + export = constants; +} + /* node:readline — the question/close slice: createInterface over exactly * { input: process.stdin, output: process.stdout }, question(query, cb) * (the query writes to stdout, the callback gets the next line's text), diff --git a/packages/compiler/src/backend/llvm/lib-dispatch.ts b/packages/compiler/src/backend/llvm/lib-dispatch.ts index 50804bf5a..92dbaea76 100644 --- a/packages/compiler/src/backend/llvm/lib-dispatch.ts +++ b/packages/compiler/src/backend/llvm/lib-dispatch.ts @@ -680,6 +680,8 @@ export function emitLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue { case "events": case "blob": case "record": + case "punycode": + case "constants": return host.emitGenericLibCall(e); case "test": return emitTestLibCall(host, e); diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 9232cbd03..700044da2 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -192,6 +192,7 @@ export const LIB_FN_SYMS: Record = { "os.cpusModel": "scr_os_cpus_model", "os.cpusField": "scr_os_cpus_field", "os.constants": "scr_os_constants", + "constants.object": "scr_node_constants", "os.release": "scr_os_release", "os.userName": "scr_os_user_name", "os.userShell": "scr_os_user_shell", @@ -631,6 +632,13 @@ export const LIB_FN_SYMS: Record = { "url.legacyFormat": "scr_url_legacy_format", "url.legacyResolve": "scr_url_legacy_resolve", "url.domainToASCII": "scr_url_domain_to_ascii", + "punycode.decode": "scr_punycode_decode", + "punycode.encode": "scr_punycode_encode", + "punycode.toASCII": "scr_punycode_to_ascii", + "punycode.toUnicode": "scr_punycode_to_unicode", + "punycode.ucs2Decode": "scr_punycode_ucs2_decode", + "punycode.ucs2Encode": "scr_str_from_code_point", + "punycode.warn": "scr_punycode_warn", "url.domainToUnicode": "scr_url_domain_to_unicode", "url.pathToFileURL": "scr_url_from_path", "url.pathToFileURLPlatform": "scr_url_from_path_platform", diff --git a/packages/compiler/src/frontend/builtin-modules.ts b/packages/compiler/src/frontend/builtin-modules.ts index b45dce6d7..3a1acb934 100644 --- a/packages/compiler/src/frontend/builtin-modules.ts +++ b/packages/compiler/src/frontend/builtin-modules.ts @@ -42,6 +42,8 @@ export const SUPPORTED_BUILTIN_MODULES = [ "module", "console", "process", + "punycode", + "constants", ] as const; /** Builtins Node itself serves ONLY under the node: prefix — diff --git a/packages/compiler/src/frontend/lowering/lower-builtin-values.ts b/packages/compiler/src/frontend/lowering/lower-builtin-values.ts index a9df9e662..c05430ad3 100644 --- a/packages/compiler/src/frontend/lowering/lower-builtin-values.ts +++ b/packages/compiler/src/frontend/lowering/lower-builtin-values.ts @@ -23,6 +23,7 @@ import { builtinModulesArrayLit, stdlibGlobalNameOf, } from "./surfaces.js"; +import { CRYPTO_CONSTANTS } from "./crypto-tables.js"; const PROTOTYPE_METHODS: Record = { Date: ["getTime", "valueOf", "toISOString", "toJSON"], @@ -680,3 +681,34 @@ export function lowerBuiltinLoaderValue(lowerer: Lowerer, loc: SrcLoc): IrExpr { loc, }; } + +/** The deprecated node:constants module object: the runtime merges + * os.constants' groups and fs.constants with crypto.constants, which a + * lifted function answers from the baked table the first time the object + * is built. */ +export function builtinConstantsObject(lowerer: Lowerer, loc: SrcLoc): IrExpr { + const name = "%builtin.constants.crypto"; + if (!lowerer.builtinCallableValueFns.has(name)) { + lowerer.builtinCallableValueFns.set(name, name); + const fields = Object.entries(CRYPTO_CONSTANTS).map(([key, value]) => ({ + key: strLit(key, loc), + value: box(builtinConstLit(value, loc)), + })); + lowerer.liftedFns.push({ + name, + params: [], + returnType: DYN, + locals: [], + body: [{ kind: "return", value: { kind: "dynObjLit", fields, type: DYN, loc }, loc }], + loc, + }); + } + const table: IrExpr = { + kind: "closure", + fnName: name, + captures: [], + type: { kind: "func", params: [], ret: DYN }, + loc, + }; + return { kind: "libCall", fn: "constants.object", args: [box(table)], type: DYN, loc }; +} diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index 08e12518b..88a4918d8 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -216,6 +216,7 @@ import { } from "./class-prototypes.js"; import { isClassCallback } from "./class-callbacks.js"; import { + builtinConstantsObject, builtinPrototypeMethod, lowerArrayIsArrayValue, lowerCheckedPredicateValue, @@ -1164,6 +1165,17 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { if (bi.module === "os" && bi.member === "constants") { return { kind: "libCall", fn: "os.constants", args: [], type: DYN, loc }; } + // `import { O_RDONLY } from "constants"`: the member of the frozen + // module object. + if (bi.module === "constants") { + return { + kind: "dynKeyGet", + value: builtinConstantsObject(lowerer, loc), + key: { kind: "strLit", value: bi.member, type: STRING, loc }, + type: DYN, + loc, + }; + } // tls.rootCertificates: a runtime-valued module constant (the // cached bundled-CA array) — the one member read that lowers // to a libCall instead of a baked literal. @@ -1206,6 +1218,7 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { // their access sites only. The CommonJS namespace binding // (`const lib = require("./lib.js")`) gets the same fence. const builtinNamespace = lowerer.builtinNamespaceModuleOf(expr); + if (builtinNamespace === "constants") return builtinConstantsObject(lowerer, loc); if (builtinNamespace !== null) { const type: IrType = { kind: "moduleNs", moduleId: `builtin:${builtinNamespace}` }; return { kind: "moduleNsRef", moduleId: type.moduleId, type, loc }; @@ -1495,6 +1508,7 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { return { kind: "moduleNsRef", moduleId: moduleNs.moduleId, type: moduleNs, loc }; } const builtinNs = lowerer.builtinNamespaceModuleOf(expr); + if (builtinNs === "constants") return builtinConstantsObject(lowerer, loc); if (builtinNs !== null) { const type: IrType = { kind: "moduleNs", moduleId: `builtin:${builtinNs}` }; return { kind: "moduleNsRef", moduleId: type.moduleId, type, loc }; diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index d18c4f547..b2f76cd24 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -2656,6 +2656,7 @@ export function lowerFileInit( loc: loc0, }); } + if (sf === lowerer.entry) header.push(...lowerer.punycodeLinkWarning()); for (const { stmt, dep } of orderedImportsOf(lowerer.program, sf)) { const npm = lowerer.npmInitActions.get(sf)?.get(stmt); if (npm !== undefined && npm.length > 0) { diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 367c147f8..27f4169c1 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -1557,7 +1557,9 @@ export function lowerVarStatement(lowerer: Lowerer, stmt: ts.VariableStatement): // Relative requires keep the fence: their module-init-at-position // semantics needs storage this model doesn't represent. if (canonicalBuiltinModule(spec) !== null) { - return []; + return canonicalBuiltinModule(spec) === "punycode" + ? [lowerer.punycodeRequireWarning(decl)] + : []; } lowerer.unsupported( "SC1090", diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 3217802ad..8e6f64143 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -128,6 +128,7 @@ import { resolve } from "node:path"; import { bindingSource } from "../binding-source.js"; import { tsgoPath } from "../dts-paths.js"; import * as ts from "../ts7/adapter.js"; +import { erasedTypeOnlyImport } from "../type-only-imports.js"; import { literalValues } from "../literal-values.js"; import { discriminantOwners, literalUnionArm, type UnionLiteral } from "../union-discriminants.js"; import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js"; @@ -3745,6 +3746,65 @@ export class Lowerer { for (const fp of parts) if (!indexOf.has(fp.sf)) visit(fp.sf); } + /** node:punycode's load at a require() call: the module body reports + * DEP0040 when it first runs, unless isInsideNodeModules() finds the + * requiring frame in a dependency, and process.emitWarning delivers the + * report on the next tick. Later loads are cache hits either way. */ + punycodeRequireWarning(node: ts.Node): IrStmt { + const loc = locOf(node); + const fromDependency = /[\\/]node_modules[\\/]/.test(node.getSourceFile().fileName); + return { + kind: "exprStmt", + expr: { + kind: "libCall", + fn: "punycode.warn", + args: [ + { kind: "boolLit", value: false, type: BOOL, loc }, + { kind: "boolLit", value: !fromDependency, type: BOOL, loc }, + ], + type: VOID, + loc, + }, + loc, + }; + } + + /** node:punycode's DEP0040 for a static ES import anywhere in the module + * graph: Node links builtins before any module evaluates, so the report + * comes first, before the program can register a 'warning' listener — + * whichever file imports it (a dependency's ES import has no requiring + * frame either). Prepended to the entry's %init. */ + punycodeLinkWarning(): IrStmt[] { + const imports = this.moduleOrder.some((sf) => + sf.statements.some( + (stmt) => + ((ts.isImportDeclaration(stmt) && !erasedTypeOnlyImport(stmt)) || + (ts.isExportDeclaration(stmt) && !stmt.isTypeOnly)) && + stmt.moduleSpecifier !== undefined && + ts.isStringLiteral(stmt.moduleSpecifier) && + canonicalBuiltinModule(stmt.moduleSpecifier.text) === "punycode", + ), + ); + if (!imports) return []; + const loc: SrcLoc = { file: this.entry.fileName, start: 0, end: 0 }; + return [ + { + kind: "exprStmt", + expr: { + kind: "libCall", + fn: "punycode.warn", + args: [ + { kind: "boolLit", value: true, type: BOOL, loc }, + { kind: "boolLit", value: true, type: BOOL, loc }, + ], + type: VOID, + loc, + }, + loc, + }, + ]; + } + /** The lowering of a CommonJS `require("./local")` occurrence: a call of * the required module's run-once %init at exactly this statement's * position — Node's inline evaluation, with the guard supplying the @@ -3754,6 +3814,7 @@ export class Lowerer { * their external dependencies by name). Null for everything else * (builtins load nothing; the rest kept its preflight fence). */ requireInitStmt(spec: string, node: ts.Node): IrStmt | null { + if (canonicalBuiltinModule(spec) === "punycode") return this.punycodeRequireWarning(node); // Project requires resolve within the program; another bare require can // be a program-module edge when it names an opted-in --npm-static package // (one package requiring another — the resolution answered its shipped @@ -11286,7 +11347,23 @@ export class Lowerer { return { module: "timers/promises", member: `scheduler.${access.name.text}` }; } } + // punycode.ucs2.decode / encode: methods of the module's ucs2 object, + // dispatched as module members. + if (access.name.text === "decode" || access.name.text === "encode") { + const owner = access.expression; + const imported = ts.isIdentifier(owner) + ? this.builtinImportOf(owner) + : ts.isPropertyAccessExpression(owner) + ? this.builtinMemberOf(owner) + : null; + if (imported?.module === "punycode" && imported.member === "ucs2") { + return { module: "punycode", member: `ucs2.${access.name.text}` }; + } + } const module = this.builtinNamespaceModuleOf(access.expression); + // node:constants is one checked-dynamic object: its members read + // through the object itself (builtinConstantsObject), not the tables. + if (module === "constants") return null; if (module !== null) return { module, member: access.name.text }; // The events module object IS the EventEmitter class, so the class's // defaultMaxListeners is the module property. diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index 4c74e8b6a..72d6c09f8 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -1801,6 +1801,22 @@ export const BUILTIN_MODULE_FNS: Record< valueParams: [{ mode: "required", type: STRING }], }, }, + // node:punycode (deprecated): punycode.js 2.1.0's conversions over + // strings (scr_url.c). ucs2.decode/encode are members of the module's + // ucs2 object, dispatched as module members (builtinMemberOf). The + // DEP0040 report rides the module's load sites (punycodeLoadWarning). + punycode: { + decode: { fn: "punycode.decode", params: [STRING], result: STRING }, + encode: { fn: "punycode.encode", params: [STRING], result: STRING }, + toASCII: { fn: "punycode.toASCII", params: [STRING], result: STRING }, + toUnicode: { fn: "punycode.toUnicode", params: [STRING], result: STRING }, + "ucs2.decode": { fn: "punycode.ucs2Decode", params: [STRING], result: arrayOf(F64) }, + "ucs2.encode": { fn: "punycode.ucs2Encode", params: [arrayOf(F64)], result: STRING }, + }, + // node:constants (deprecated) is one frozen object (Object.assign of + // os.constants' groups, fs.constants and crypto.constants): bindings of + // the module read it as a checked-dynamic value (builtinConstantsObject). + constants: {}, // node:readline: createInterface's options are entirely special-cased // (exactly { input: process.stdin, output?: process.stdout } — see // lowerBuiltinModuleCall); the entry carries the canonical shape. The @@ -1930,6 +1946,7 @@ export const BUILTIN_MODULE_CONSTS: Record< os: { EOL: "\n", devNull: "/dev/null" }, worker_threads: { isMainThread: true, threadId: 0 }, cluster: { isPrimary: true, isMaster: true, isWorker: false }, + punycode: { version: "2.1.0" }, // zlib's module-level copies of its constants (every member outside // BROTLI_*, Node's own loop over zlib.constants). zlib: Object.fromEntries( diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index 2381413f8..ee5ba8c7c 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -466,6 +466,13 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "str.encodeUri", "qs.escape", "qs.stringify", + // node:punycode's RangeErrors (encode/toASCII only past 32-bit deltas) + // and String.fromCodePoint's for ucs2.encode. + "punycode.decode", + "punycode.encode", + "punycode.toASCII", + "punycode.toUnicode", + "punycode.ucs2Encode", // The base64 globals: atob/btoa throw the catchable DOMException // InvalidCharacterError on malformed input; the zero-argument form // always throws Node's TypeError [ERR_MISSING_ARGS]. diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 5e219ecf6..e9f7778bc 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -559,6 +559,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ /** os.constants: the per-thread null-prototype constants object (dlopen, * errno, signals, priority, UV_UDP_REUSEADDR). Never throws. */ "os.constants": { argTypes: [], result: DYN }, + /** The deprecated node:constants object (scr_os.c): the os groups and + * fs.constants merged with the borrowed baked crypto.constants table, + * frozen, one per thread. */ + "constants.object": { argTypes: [DYN], result: DYN }, /** umask(2): arg < 0 reads without setting (umask has no read-only form * — set 0, restore); otherwise sets and answers the PREVIOUS mask. * Never throws. */ @@ -856,6 +860,19 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "url.legacyResolve": { argTypes: [DYN, DYN, BOOL], result: STRING }, "url.domainToASCII": { argTypes: [DYN, BOOL], result: STRING }, "url.domainToUnicode": { argTypes: [DYN, BOOL], result: STRING }, + /** node:punycode (scr_url.c): punycode.js 2.1.0's string conversions; + * decode/toUnicode (and, past 32-bit deltas, encode/toASCII) throw the + * module's RangeErrors, ucs2Encode String.fromCodePoint's. warn marks the + * module's first load (scr_async_dyn.c) and reports DEP0040 then unless + * the second argument is false: at once for a static ES import, on the + * next tick for a require() call. */ + "punycode.decode": { argTypes: [STRING], result: STRING }, + "punycode.encode": { argTypes: [STRING], result: STRING }, + "punycode.toASCII": { argTypes: [STRING], result: STRING }, + "punycode.toUnicode": { argTypes: [STRING], result: STRING }, + "punycode.ucs2Decode": { argTypes: [STRING], result: arrayOf(F64) }, + "punycode.ucs2Encode": { argTypes: [arrayOf(F64)], result: STRING }, + "punycode.warn": { argTypes: [BOOL, BOOL], result: VOID }, "url.fileURLToPathBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 }, "url.pathToFileURLChecked": { argTypes: [DYN, DYN], result: URL_T }, "url.fileURLToPathStr": { argTypes: [STRING], result: STRING }, diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index 80a9c9b57..ba97670ce 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -43,6 +43,8 @@ export interface RuntimeFeatures { } const DYN_ASYNC_LIB_FNS: ReadonlySet = new Set([ + // DEP0040 rides the dyn-async unit's warning machinery. + "punycode.warn", "fs.callbackValue", "fs.callbackCall", "fs.callbackGlob", diff --git a/packages/compiler/surface-manifest.json b/packages/compiler/surface-manifest.json index 63efde378..3ee171669 100644 --- a/packages/compiler/surface-manifest.json +++ b/packages/compiler/surface-manifest.json @@ -466,6 +466,13 @@ "status": "static", "note": "recognized module (bare and node:-prefixed specifiers)" }, + { + "id": "node-builtin.constants", + "kind": "node-builtin", + "name": "constants", + "status": "static", + "note": "recognized module (bare and node:-prefixed specifiers)" + }, { "id": "node-builtin.crypto", "kind": "node-builtin", @@ -2095,6 +2102,56 @@ "status": "static", "note": "shared version dictionary containing node and openssl; other components are absent unless defined by the program" }, + { + "id": "node-builtin.punycode", + "kind": "node-builtin", + "name": "punycode", + "status": "static", + "note": "recognized module (bare and node:-prefixed specifiers)" + }, + { + "id": "node-builtin.punycode.decode", + "kind": "node-builtin", + "name": "punycode.decode", + "status": "static" + }, + { + "id": "node-builtin.punycode.encode", + "kind": "node-builtin", + "name": "punycode.encode", + "status": "static" + }, + { + "id": "node-builtin.punycode.toASCII", + "kind": "node-builtin", + "name": "punycode.toASCII", + "status": "static" + }, + { + "id": "node-builtin.punycode.toUnicode", + "kind": "node-builtin", + "name": "punycode.toUnicode", + "status": "static" + }, + { + "id": "node-builtin.punycode.ucs2.decode", + "kind": "node-builtin", + "name": "punycode.ucs2.decode", + "status": "static" + }, + { + "id": "node-builtin.punycode.ucs2.encode", + "kind": "node-builtin", + "name": "punycode.ucs2.encode", + "status": "static" + }, + { + "id": "node-builtin.punycode.version", + "kind": "node-builtin", + "name": "punycode.version", + "status": "static", + "note": "constant value read" + }, { "id": "node-builtin.querystring", "kind": "node-builtin", diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6122-punycode-conversions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6122-punycode-conversions.ts.json new file mode 100644 index 000000000..b15e4fe13 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6122-punycode-conversions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6122-punycode-conversions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6124-punycode-require-warnings.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6124-punycode-require-warnings.cjs.json new file mode 100644 index 000000000..dfd4aa912 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6124-punycode-require-warnings.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6124-punycode-require-warnings.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6125-constants-module.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6125-constants-module.cjs.json new file mode 100644 index 000000000..ef8c7f2bf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6125-constants-module.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6125-constants-module.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6126-punycode-dependency/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6126-punycode-dependency/main.cjs.json new file mode 100644 index 000000000..5de83361a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6126-punycode-dependency/main.cjs.json @@ -0,0 +1,18 @@ +{ + "order": [ + "/tests/corpus/6126-punycode-dependency/main.cjs" + ], + "diags": [ + { + "code": "SC1010", + "message": "the 'puny-dep' module is not supported yet", + "loc": { + "file": "/tests/corpus/6126-punycode-dependency/main.cjs", + "start": 347, + "end": 376 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), statically compiled npm packages, and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + } + ] +} diff --git a/packages/runtime/src/scr_async.h b/packages/runtime/src/scr_async.h index a391d2a26..f41949f6e 100644 --- a/packages/runtime/src/scr_async.h +++ b/packages/runtime/src/scr_async.h @@ -212,6 +212,11 @@ void scr_process_on_warning(ScrDyn *fn); void scr_process_off_warning(ScrDyn *fn); void scr_process_emit_warning(ScrDyn *args); void scr_emit_warning(const char *name, const char *code, ScrStr *message); +/* node:punycode's first load (scr_async_dyn.c): later calls are module + * cache hits. The first reports DEP0040 when `report` (false for a require + * made from node_modules) — at once for a static ES import, which Node + * links before any module evaluates, otherwise on the next tick. */ +void scr_punycode_warn(bool immediate, bool report); /* scr_emit_warning once a 'warning' listener exists (scr_lib.c; set by the * listener registration): units that cannot link the dyn-async unit route * their warnings through it, and print the default report otherwise. */ diff --git a/packages/runtime/src/scr_async_dyn.c b/packages/runtime/src/scr_async_dyn.c index a14ae6e6a..7a27f16f3 100644 --- a/packages/runtime/src/scr_async_dyn.c +++ b/packages/runtime/src/scr_async_dyn.c @@ -813,6 +813,27 @@ void scr_warning_emit_deferred(ScrDyn *w) { scr_warning_defer(w, scr_warning_tick); } +static SCR_TL bool scr_punycode_loaded = false; + +void scr_punycode_warn(bool immediate, bool report) { + if (scr_punycode_loaded) return; + scr_punycode_loaded = true; + if (!report) return; + static const char text[] = + "The `punycode` module is deprecated. Please use a userland alternative instead."; + ScrStr *message = scr_str_new(text, sizeof text - 1); + ScrStr *code = scr_str_new("DEP0040", 7); + ScrDyn *w = scr_warning_new(message, "DeprecationWarning", code); + if (immediate) { + if (!scr_process_deprecation_flag_on(0)) scr_warning_dispatch(w); + } else { + scr_warning_emit_deferred(w); + } + scr_dyn_release(w); + scr_str_release(code); + scr_str_release(message); +} + /* The console members' warnings. Node's emitWarning emits on * process.nextTick, so these queue in order and each rides one raw tick * on the shared tick queue; any left at exit are dropped with it. */ diff --git a/packages/runtime/src/scr_os.c b/packages/runtime/src/scr_os.c index 0bc50fb3f..0df57d2e1 100644 --- a/packages/runtime/src/scr_os.c +++ b/packages/runtime/src/scr_os.c @@ -27,6 +27,8 @@ #include #include #endif +#include +#include #ifdef __linux__ #include #endif @@ -1286,3 +1288,195 @@ ScrDyn *scr_os_constants(void) { scr_atexit(scr_os_constants_clear); return scr_dyn_retain(os); } + +/* ── node:constants (deprecated, DEP0008) ────────────────────────────── + * Node's lib/constants.js: Object.assign({}, os.constants.dlopen, errno, + * priority, signals, fs.constants, crypto.constants), frozen, with an + * ordinary prototype. The fs group follows node_constants.cc's + * DefineFsConstants order and guards (libuv's UV_* values are fixed on + * POSIX); crypto_table (borrowed) is a compiler-emitted function that + * answers the baked crypto.constants table, called only on first use. One + * object per thread. */ +#define SCR_FS_CONSTANT(o, name) scr_os_constant((o), #name, (double)(name)) + +static void scr_fs_constants(ScrDyn *o) { + scr_os_constant(o, "UV_FS_SYMLINK_DIR", 1); + scr_os_constant(o, "UV_FS_SYMLINK_JUNCTION", 2); +#ifdef O_RDONLY + SCR_FS_CONSTANT(o, O_RDONLY); +#endif +#ifdef O_WRONLY + SCR_FS_CONSTANT(o, O_WRONLY); +#endif +#ifdef O_RDWR + SCR_FS_CONSTANT(o, O_RDWR); +#endif + scr_os_constant(o, "UV_DIRENT_UNKNOWN", 0); + scr_os_constant(o, "UV_DIRENT_FILE", 1); + scr_os_constant(o, "UV_DIRENT_DIR", 2); + scr_os_constant(o, "UV_DIRENT_LINK", 3); + scr_os_constant(o, "UV_DIRENT_FIFO", 4); + scr_os_constant(o, "UV_DIRENT_SOCKET", 5); + scr_os_constant(o, "UV_DIRENT_CHAR", 6); + scr_os_constant(o, "UV_DIRENT_BLOCK", 7); +#ifdef S_IFMT + SCR_FS_CONSTANT(o, S_IFMT); +#endif +#ifdef S_IFREG + SCR_FS_CONSTANT(o, S_IFREG); +#endif +#ifdef S_IFDIR + SCR_FS_CONSTANT(o, S_IFDIR); +#endif +#ifdef S_IFCHR + SCR_FS_CONSTANT(o, S_IFCHR); +#endif +#ifdef S_IFBLK + SCR_FS_CONSTANT(o, S_IFBLK); +#endif +#ifdef S_IFIFO + SCR_FS_CONSTANT(o, S_IFIFO); +#endif +#ifdef S_IFLNK + SCR_FS_CONSTANT(o, S_IFLNK); +#endif +#ifdef S_IFSOCK + SCR_FS_CONSTANT(o, S_IFSOCK); +#endif +#ifdef O_CREAT + SCR_FS_CONSTANT(o, O_CREAT); +#endif +#ifdef O_EXCL + SCR_FS_CONSTANT(o, O_EXCL); +#endif + /* libuv's Windows-only open flags are 0 everywhere else. */ + scr_os_constant(o, "UV_FS_O_FILEMAP", 0); + scr_os_constant(o, "UV_FS_O_TEMPORARY", 0); + scr_os_constant(o, "UV_FS_O_SHORT_LIVED", 0); + scr_os_constant(o, "UV_FS_O_SEQUENTIAL", 0); + scr_os_constant(o, "UV_FS_O_RANDOM", 0); +#ifdef O_NOCTTY + SCR_FS_CONSTANT(o, O_NOCTTY); +#endif +#ifdef O_TRUNC + SCR_FS_CONSTANT(o, O_TRUNC); +#endif +#ifdef O_APPEND + SCR_FS_CONSTANT(o, O_APPEND); +#endif +#ifdef O_DIRECTORY + SCR_FS_CONSTANT(o, O_DIRECTORY); +#endif +#ifdef O_NOATIME + SCR_FS_CONSTANT(o, O_NOATIME); +#endif +#ifdef O_NOFOLLOW + SCR_FS_CONSTANT(o, O_NOFOLLOW); +#endif +#ifdef O_SYNC + SCR_FS_CONSTANT(o, O_SYNC); +#endif +#ifdef O_DSYNC + SCR_FS_CONSTANT(o, O_DSYNC); +#endif +#ifdef O_SYMLINK + SCR_FS_CONSTANT(o, O_SYMLINK); +#endif +#ifdef O_DIRECT + SCR_FS_CONSTANT(o, O_DIRECT); +#endif +#ifdef O_NONBLOCK + SCR_FS_CONSTANT(o, O_NONBLOCK); +#endif +#ifdef S_IRWXU + SCR_FS_CONSTANT(o, S_IRWXU); +#endif +#ifdef S_IRUSR + SCR_FS_CONSTANT(o, S_IRUSR); +#endif +#ifdef S_IWUSR + SCR_FS_CONSTANT(o, S_IWUSR); +#endif +#ifdef S_IXUSR + SCR_FS_CONSTANT(o, S_IXUSR); +#endif +#ifdef S_IRWXG + SCR_FS_CONSTANT(o, S_IRWXG); +#endif +#ifdef S_IRGRP + SCR_FS_CONSTANT(o, S_IRGRP); +#endif +#ifdef S_IWGRP + SCR_FS_CONSTANT(o, S_IWGRP); +#endif +#ifdef S_IXGRP + SCR_FS_CONSTANT(o, S_IXGRP); +#endif +#ifdef S_IRWXO + SCR_FS_CONSTANT(o, S_IRWXO); +#endif +#ifdef S_IROTH + SCR_FS_CONSTANT(o, S_IROTH); +#endif +#ifdef S_IWOTH + SCR_FS_CONSTANT(o, S_IWOTH); +#endif +#ifdef S_IXOTH + SCR_FS_CONSTANT(o, S_IXOTH); +#endif +#ifdef F_OK + SCR_FS_CONSTANT(o, F_OK); +#endif +#ifdef R_OK + SCR_FS_CONSTANT(o, R_OK); +#endif +#ifdef W_OK + SCR_FS_CONSTANT(o, W_OK); +#endif +#ifdef X_OK + SCR_FS_CONSTANT(o, X_OK); +#endif + scr_os_constant(o, "UV_FS_COPYFILE_EXCL", 1); + scr_os_constant(o, "COPYFILE_EXCL", 1); + scr_os_constant(o, "UV_FS_COPYFILE_FICLONE", 2); + scr_os_constant(o, "COPYFILE_FICLONE", 2); + scr_os_constant(o, "UV_FS_COPYFILE_FICLONE_FORCE", 4); + scr_os_constant(o, "COPYFILE_FICLONE_FORCE", 4); +} +#undef SCR_FS_CONSTANT + +static SCR_TL ScrDyn *scr_node_constants_value; +static void scr_node_constants_clear(void) { + ScrDyn *value = scr_node_constants_value; + scr_node_constants_value = NULL; + scr_dyn_release(value); +} + +ScrDyn *scr_node_constants(const ScrDyn *crypto_table) { + if (scr_node_constants_value) return scr_dyn_retain(scr_node_constants_value); + ScrDyn *crypto = scr_dyn_call(crypto_table, NULL, 0, "constants"); + if (!crypto) return NULL; + ScrDyn *o = scr_dyn_new_obj(); + scr_os_dlopen_constants(o); + scr_os_errno_constants(o); + scr_os_constant(o, "PRIORITY_LOW", SCR_OS_PRIORITY_LOW); + scr_os_constant(o, "PRIORITY_BELOW_NORMAL", SCR_OS_PRIORITY_BELOW_NORMAL); + scr_os_constant(o, "PRIORITY_NORMAL", SCR_OS_PRIORITY_NORMAL); + scr_os_constant(o, "PRIORITY_ABOVE_NORMAL", SCR_OS_PRIORITY_ABOVE_NORMAL); + scr_os_constant(o, "PRIORITY_HIGH", SCR_OS_PRIORITY_HIGH); + scr_os_constant(o, "PRIORITY_HIGHEST", SCR_OS_PRIORITY_HIGHEST); + scr_os_signal_constants(o); + scr_fs_constants(o); + if (crypto && crypto->kind == SCR_DYN_OBJ) { + for (size_t i = 0; i < crypto->v.obj.len; i++) { + const ScrDynEntry *entry = &crypto->v.obj.entries[i]; + if (entry->accessor || !entry->value) continue; + scr_dyn_obj_set(o, entry->key, entry->key_len, scr_dyn_retain(entry->value)); + } + } + scr_dyn_release(crypto); + scr_dyn_release(scr_dyn_freeze(o)); + scr_node_constants_value = o; + scr_atexit(scr_node_constants_clear); + return scr_dyn_retain(o); +} diff --git a/packages/runtime/src/scr_os.h b/packages/runtime/src/scr_os.h index b40a8027a..6f8d9b616 100644 --- a/packages/runtime/src/scr_os.h +++ b/packages/runtime/src/scr_os.h @@ -34,6 +34,10 @@ ScrStr *scr_os_cpus_model(double i); double scr_os_cpus_field(double i, double field); /* os.constants: the per-thread null-prototype constants object (+1). */ ScrDyn *scr_os_constants(void); +/* The deprecated node:constants module object (scr_os.c): the os groups, + * fs.constants and the crypto table the borrowed function answers, merged + * and frozen (+1). */ +ScrDyn *scr_node_constants(const ScrDyn *crypto_table); double scr_os_available_parallelism(void); /* uv_available_parallelism: CPUs this process may use, >= 1 */ /* os.userInfo()'s field trio (pw_name / pw_shell / pw_dir — the passwd * home, not the $HOME cascade). +1 fresh; abort on lookup failure. */ diff --git a/packages/runtime/src/scr_url.c b/packages/runtime/src/scr_url.c index b6fdb9cd6..42a7ef607 100644 --- a/packages/runtime/src/scr_url.c +++ b/packages/runtime/src/scr_url.c @@ -1988,3 +1988,342 @@ ScrBytes *scr_url_checked_to_path_buffer(const ScrDyn *value, const ScrDyn *opti scr_url_release(url); return result; } + +/* ── node:punycode (deprecated, DEP0040) ─────────────────────────────── + * A port of the punycode.js 2.1.0 that Node 24 bundles as lib/punycode.js. + * It works on UTF-16 code units: ucs2.decode pairs surrogates and keeps + * lone ones, which is exactly a code-point walk over WTF-8 storage. + * Errors throw the module's RangeErrors ("Overflow: ...", "Illegal input + * >= 0x80 ...", "Invalid input"); decoded code points past U+10FFFF throw + * String.fromCodePoint's "Invalid code point N". All inputs are borrowed; + * results are +1, or NULL with the error pending. The DEP0040 report is + * scr_punycode_warn (scr_async_dyn.c). */ + +enum { + PC_MAX_INT = 2147483647, + PC_BASE = 36, + PC_TMIN = 1, + PC_TMAX = 26, + PC_SKEW = 38, + PC_DAMP = 700, + PC_INITIAL_BIAS = 72, + PC_INITIAL_N = 128 +}; + +static void pc_error(const char *message) { + scr_throw_error_msg(SCR_ERR_RANGE, message, strlen(message)); +} +#define PC_OVERFLOW "Overflow: input needs wider integers to process" +#define PC_NOT_BASIC "Illegal input >= 0x80 (not a basic code point)" +#define PC_INVALID "Invalid input" + +typedef struct { + uint32_t *data; + size_t len, cap; +} PcPoints; + +static void pc_push(PcPoints *p, uint32_t cp) { + if (p->len == p->cap) { + size_t cap = p->cap ? p->cap * 2 : 16; + uint32_t *grown = realloc(p->data, cap * sizeof *grown); + if (!grown) scr_trap("scriptc: out of memory\n"); + p->data = grown; + p->cap = cap; + } + p->data[p->len++] = cp; +} + +/* ucs2decode over WTF-8 storage: a pair is one 4-byte sequence, a lone + * surrogate one 3-byte sequence carrying its own value. */ +static void pc_code_points(const char *s, size_t n, PcPoints *out) { + const unsigned char *b = (const unsigned char *)s; + for (size_t i = 0; i < n;) { + uint32_t c = b[i]; + if (c < 0x80) { + i += 1; + } else if (c < 0xE0 && i + 1 < n) { + c = ((c & 0x1F) << 6) | (b[i + 1] & 0x3F); + i += 2; + } else if (c < 0xF0 && i + 2 < n) { + c = ((c & 0x0F) << 12) | ((uint32_t)(b[i + 1] & 0x3F) << 6) | (b[i + 2] & 0x3F); + i += 3; + } else if (i + 3 < n) { + c = ((c & 0x07) << 18) | ((uint32_t)(b[i + 1] & 0x3F) << 12) | + ((uint32_t)(b[i + 2] & 0x3F) << 6) | (b[i + 3] & 0x3F); + i += 4; + } else { + i += 1; + } + pc_push(out, c); + } +} + +static int64_t pc_adapt(int64_t delta, int64_t points, bool first) { + int64_t k = 0; + delta = first ? delta / PC_DAMP : delta >> 1; + delta += delta / points; + for (; delta > ((PC_BASE - PC_TMIN) * PC_TMAX) >> 1; k += PC_BASE) delta /= PC_BASE - PC_TMIN; + return k + (PC_BASE - PC_TMIN + 1) * delta / (delta + PC_SKEW); +} + +static int64_t pc_basic_to_digit(unsigned char c) { + if (c >= 0x30 && c < 0x3A) return 26 + (c - 0x30); + if (c >= 0x41 && c < 0x5B) return c - 0x41; + if (c >= 0x61 && c < 0x7B) return c - 0x61; + return PC_BASE; +} + +static char pc_digit_to_basic(int64_t digit) { + return (char)(digit + 22 + 75 * (digit < 26)); +} + +/* String.fromCodePoint(...points). */ +static ScrStr *pc_from_points(const PcPoints *p) { + for (size_t i = 0; i < p->len; i++) { + if (p->data[i] > 0x10FFFF) { + char message[48]; + int size = snprintf(message, sizeof message, "Invalid code point %u", (unsigned)p->data[i]); + scr_throw_error_msg(SCR_ERR_RANGE, message, (size_t)size); + return NULL; + } + } + char *out = malloc(p->len * 4 + 1); + if (!out) scr_trap("scriptc: out of memory\n"); + size_t offset = 0; + for (size_t i = 0; i < p->len; i++) { + uint32_t point = p->data[i]; + if (point >= 0xD800 && point <= 0xDBFF && i + 1 < p->len && p->data[i + 1] >= 0xDC00 && + p->data[i + 1] <= 0xDFFF) { + point = 0x10000 + ((point - 0xD800) << 10) + (p->data[i + 1] - 0xDC00); + i++; + } + offset += scr_wtf8_put(out + offset, point); + } + ScrStr *result = scr_str_new(out, offset); + free(out); + return result; +} + +/* punycode.decode over the bytes of one label. Any non-ASCII byte fails + * where its first code unit would: before the last delimiter it is not + * basic, after it it is no digit — so byte positions stand in for code + * unit positions until the first error. */ +static ScrStr *pc_decode(const char *s, size_t n) { + PcPoints output = {0}; + size_t basic = 0; + for (size_t k = n; k > 0; k--) { + if (s[k - 1] == '-') { + basic = k - 1; + break; + } + } + ScrStr *result = NULL; + for (size_t j = 0; j < basic; j++) { + if ((unsigned char)s[j] >= 0x80) { + pc_error(PC_NOT_BASIC); + goto done; + } + pc_push(&output, (unsigned char)s[j]); + } + int64_t i = 0, cp = PC_INITIAL_N, bias = PC_INITIAL_BIAS; + for (size_t index = basic > 0 ? basic + 1 : 0; index < n;) { + int64_t old = i; + for (int64_t w = 1, k = PC_BASE;; k += PC_BASE) { + if (index >= n) { + pc_error(PC_INVALID); + goto done; + } + int64_t digit = pc_basic_to_digit((unsigned char)s[index++]); + if (digit >= PC_BASE) { + pc_error(PC_INVALID); + goto done; + } + if (digit > (PC_MAX_INT - i) / w) { + pc_error(PC_OVERFLOW); + goto done; + } + i += digit * w; + int64_t t = k <= bias ? PC_TMIN : (k >= bias + PC_TMAX ? PC_TMAX : k - bias); + if (digit < t) break; + if (w > PC_MAX_INT / (PC_BASE - t)) { + pc_error(PC_OVERFLOW); + goto done; + } + w *= PC_BASE - t; + } + int64_t out = (int64_t)output.len + 1; + bias = pc_adapt(i - old, out, old == 0); + if (i / out > PC_MAX_INT - cp) { + pc_error(PC_OVERFLOW); + goto done; + } + cp += i / out; + i %= out; + pc_push(&output, 0); + memmove(output.data + i + 1, output.data + i, (output.len - 1 - (size_t)i) * sizeof *output.data); + output.data[i++] = (uint32_t)cp; + } + result = pc_from_points(&output); +done: + free(output.data); + return result; +} + +/* punycode.encode of one label's code points, appended to buf. */ +static bool pc_encode(const PcPoints *input, ScrJsonBuf *buf) { + int64_t cp = PC_INITIAL_N, delta = 0, bias = PC_INITIAL_BIAS; + size_t basic_length = 0; + for (size_t k = 0; k < input->len; k++) { + if (input->data[k] < 0x80) { + scr_jb_putc(buf, (char)input->data[k]); + basic_length++; + } + } + size_t handled = basic_length; + if (basic_length) scr_jb_putc(buf, '-'); + while (handled < input->len) { + int64_t m = PC_MAX_INT; + for (size_t k = 0; k < input->len; k++) + if (input->data[k] >= cp && input->data[k] < m) m = input->data[k]; + int64_t handled_plus_one = (int64_t)handled + 1; + if (m - cp > (PC_MAX_INT - delta) / handled_plus_one) { + pc_error(PC_OVERFLOW); + return false; + } + delta += (m - cp) * handled_plus_one; + cp = m; + for (size_t k = 0; k < input->len; k++) { + int64_t current = input->data[k]; + if (current < cp && ++delta > PC_MAX_INT) { + pc_error(PC_OVERFLOW); + return false; + } + if (current == cp) { + int64_t q = delta; + for (int64_t j = PC_BASE;; j += PC_BASE) { + int64_t t = j <= bias ? PC_TMIN : (j >= bias + PC_TMAX ? PC_TMAX : j - bias); + if (q < t) break; + scr_jb_putc(buf, pc_digit_to_basic(t + (q - t) % (PC_BASE - t))); + q = (q - t) / (PC_BASE - t); + } + scr_jb_putc(buf, pc_digit_to_basic(q)); + bias = pc_adapt(delta, handled_plus_one, handled == basic_length); + delta = 0; + handled++; + } + } + delta++; + cp++; + } + return true; +} + +ScrStr *scr_punycode_decode(const ScrStr *input) { return pc_decode(input->data, input->len); } + +ScrStr *scr_punycode_encode(const ScrStr *input) { + PcPoints points = {0}; + pc_code_points(input->data, input->len, &points); + ScrJsonBuf buf; + scr_jb_init(&buf); + bool ok = pc_encode(&points, &buf); + free(points.data); + ScrStr *result = scr_jb_finish(&buf); + if (ok) return result; + scr_str_release(result); + return NULL; +} + +ScrArr *scr_punycode_ucs2_decode(const ScrStr *input) { + PcPoints points = {0}; + pc_code_points(input->data, input->len, &points); + ScrArr *out = scr_arr_new(SCR_ELEM_F64, points.len); + for (size_t i = 0; i < points.len; i++) scr_arr_push_f64(out, (double)points.data[i]); + free(points.data); + return out; +} + +/* mapDomain: only the part after the first '@' maps (and only up to a + * second one — punycode.js keeps parts[0] and parts[1]); the RFC 3490 + * separators U+002E, U+3002, U+FF0E and U+FF61 all split labels, and the + * labels rejoin with '.'. */ +static ScrStr *pc_map_domain(const ScrStr *input, bool to_ascii) { + const char *s = input->data; + size_t n = input->len; + ScrJsonBuf buf; + scr_jb_init(&buf); + const char *at = memchr(s, '@', n); + if (at) { + scr_jb_write(&buf, s, (size_t)(at - s) + 1); + const char *rest = at + 1; + const char *second = memchr(rest, '@', n - (size_t)(rest - s)); + n = (second ? (size_t)(second - rest) : n - (size_t)(rest - s)); + s = rest; + } + size_t start = 0; + bool ok = true; + for (size_t i = 0; ok && i <= n;) { + size_t sep = 0; + if (i == n) sep = 1; + else if (s[i] == '.') sep = 1; + else if (i + 2 < n && (unsigned char)s[i] == 0xE3 && (unsigned char)s[i + 1] == 0x80 && + (unsigned char)s[i + 2] == 0x82) + sep = 3; + else if (i + 2 < n && (unsigned char)s[i] == 0xEF && + (((unsigned char)s[i + 1] == 0xBC && (unsigned char)s[i + 2] == 0x8E) || + ((unsigned char)s[i + 1] == 0xBD && (unsigned char)s[i + 2] == 0xA1))) + sep = 3; + if (!sep) { + i++; + continue; + } + const char *label = s + start; + size_t len = i - start; + bool ascii = true; + for (size_t k = 0; k < len; k++) ascii = ascii && (unsigned char)label[k] < 0x80; + if (to_ascii && !ascii) { + PcPoints points = {0}; + pc_code_points(label, len, &points); + scr_jb_puts(&buf, "xn--"); + ok = pc_encode(&points, &buf); + free(points.data); + } else if (!to_ascii && len >= 4 && memcmp(label, "xn--", 4) == 0) { + /* string.slice(4).toLowerCase(): ASCII letters fold; the one other + * code point whose lowercase is ASCII is KELVIN SIGN (U+212A → k). + * Any other non-ASCII stays non-ASCII and fails in decode either + * way, at the same position. */ + ScrJsonBuf lower; + scr_jb_init(&lower); + for (size_t k = 4; k < len; k++) { + unsigned char c = (unsigned char)label[k]; + if (c == 0xE2 && k + 2 < len && (unsigned char)label[k + 1] == 0x84 && + (unsigned char)label[k + 2] == 0xAA) { + scr_jb_putc(&lower, 'k'); + k += 2; + } else { + scr_jb_putc(&lower, (char)(c >= 'A' && c <= 'Z' ? c + 32 : c)); + } + } + ScrStr *folded = scr_jb_finish(&lower); + ScrStr *decoded = pc_decode(folded->data, folded->len); + scr_str_release(folded); + if (decoded) { + scr_jb_put_str(&buf, decoded); + scr_str_release(decoded); + } else { + ok = false; + } + } else { + scr_jb_write(&buf, label, len); + } + if (ok && i < n) scr_jb_putc(&buf, '.'); + i += sep; + start = i; + } + ScrStr *result = scr_jb_finish(&buf); + if (ok) return result; + scr_str_release(result); + return NULL; +} + +ScrStr *scr_punycode_to_ascii(const ScrStr *input) { return pc_map_domain(input, true); } +ScrStr *scr_punycode_to_unicode(const ScrStr *input) { return pc_map_domain(input, false); } diff --git a/packages/runtime/src/scr_url.h b/packages/runtime/src/scr_url.h index 134893054..05e5702bb 100644 --- a/packages/runtime/src/scr_url.h +++ b/packages/runtime/src/scr_url.h @@ -53,6 +53,15 @@ ScrDyn *scr_url_legacy_parse(const ScrDyn *url, const ScrDyn *parse_query, const ScrStr *scr_url_legacy_format(const ScrDyn *object, const ScrDyn *options, bool warn); ScrStr *scr_url_legacy_resolve(const ScrDyn *from, const ScrDyn *to, bool warn); ScrStr *scr_url_domain_to_ascii(const ScrDyn *domain, bool missing); +/* node:punycode (scr_url.c): punycode.js 2.1.0's encode/decode, toASCII/ + * toUnicode (mapDomain over RFC 3490 separators) and ucs2.decode (UTF-16 + * code points as an f64 array). Borrowed input; +1, or NULL with the + * module's RangeError pending. */ +ScrStr *scr_punycode_decode(const ScrStr *input); +ScrStr *scr_punycode_encode(const ScrStr *input); +ScrStr *scr_punycode_to_ascii(const ScrStr *input); +ScrStr *scr_punycode_to_unicode(const ScrStr *input); +ScrArr *scr_punycode_ucs2_decode(const ScrStr *input); ScrStr *scr_url_domain_to_unicode(const ScrDyn *domain, bool missing); ScrStr *scr_url_to_path(ScrUrl *u); /* +1, or throws */ ScrStr *scr_url_str_to_path(ScrStr *s); /* +1, or throws */ diff --git a/tests/corpus/6122-punycode-conversions.ts b/tests/corpus/6122-punycode-conversions.ts new file mode 100644 index 000000000..061987a78 --- /dev/null +++ b/tests/corpus/6122-punycode-conversions.ts @@ -0,0 +1,45 @@ +// @exit: 1 +// @no-node-shims +// node:punycode's conversions (punycode.js 2.1.0): encode/decode of bare +// labels, toASCII/toUnicode over domains and email addresses (only the part +// after '@' maps; every RFC 3490 separator splits labels), ucs2 code point +// arrays with astral pairs and lone surrogates, and the RangeErrors of +// malformed input. A static import links the module before anything runs, +// so its DEP0040 report precedes the program and no 'warning' listener the +// program registers sees it (the Node side runs without the preload shim, +// which would delay that report past the program's first turn). The report +// carries the process id, so the @exit directive keeps stderr out of the +// comparison. +import * as punycode from "node:punycode"; + +process.on("warning", (w) => console.log("listener", w.name)); + +const show = (label: string, f: () => unknown): void => { + try { + console.log(label, JSON.stringify(f())); + } catch (e) { + const err = e as Error; + console.log(label, "threw", err instanceof RangeError, err.name, err.message); + } +}; + +console.log(punycode.version); +for (const s of ["mañana", "bücher", "ü", "abc", "", "-> $1.00 <-", "ليهمابتكلموشعربي؟", "他们为什么不说中文", "😀x", "MaJiでKoiする5秒前"]) { + show(`encode ${s}`, () => punycode.encode(s)); + show(`roundtrip ${s}`, () => punycode.decode(punycode.encode(s))); +} +for (const s of ["maana-pta", "bcher-kva", "tda", "abc-", "-abc", "ABC-kva", "a-b-c-kva", "ü-kva", "kva-ü", "99999999999", "zzzzzzzzzzzzz", "a-", "-"]) { + show(`decode ${s}`, () => punycode.decode(s)); +} +for (const d of ["mañana.com", "bücher.de", "example.com", "", "a..b", "ex@mple@bücher.de", "user@bücher.de", "日本。jp", "a．b｡c", "ÄÖÜ.test", "a.b."]) { + show(`toASCII ${d}`, () => punycode.toASCII(d)); +} +for (const d of ["xn--maana-pta.com", "xn--bcher-kva.de", "XN--bcher-kva.de", "xn--BCHER-KVA.de", "example.com", "user@xn--bcher-kva.de", "xn--.x", "xn--ü.x", "xn--zzzzzzzzzzzzz.x", "xn--a-Kva.x"]) { + show(`toUnicode ${d}`, () => punycode.toUnicode(d)); +} +show("ucs2.decode", () => punycode.ucs2.decode("aé😀\ud800b\udc00")); +show("ucs2.encode", () => punycode.ucs2.encode([97, 0xe9, 0x1f600, 0xd800, 0xdc00, 98])); +show("ucs2.encode join", () => punycode.ucs2.encode([0xd83d, 0xde00]).length); +show("ucs2.encode range", () => punycode.ucs2.encode([0x110000])); +show("ucs2 roundtrip", () => punycode.ucs2.encode(punycode.ucs2.decode("x😀\udfffy")) === "x😀\udfffy"); +process.exitCode = 1; diff --git a/tests/corpus/6124-punycode-require-warnings.cjs b/tests/corpus/6124-punycode-require-warnings.cjs new file mode 100644 index 000000000..c3255e6b7 --- /dev/null +++ b/tests/corpus/6124-punycode-require-warnings.cjs @@ -0,0 +1,32 @@ +// DEP0040 for require("punycode"): reported once, on the next tick after +// the requiring turn, to the stderr report and the 'warning' listeners; +// require("node:punycode") is the same module and does not report again. +// process.noDeprecation drops the report and the listener call. The program +// re-runs itself per case and prints each child's output with process ids +// normalized. +"use strict"; +const { spawnSync } = require("child_process"); + +const mode = process.argv[2]; +if (mode === "direct") { + process.on("warning", (w) => console.log("listener", w.name, w.code, w.message)); + process.nextTick(() => console.log("earlier tick")); + console.log("before require"); + const direct = require("punycode"); + console.log("after require", direct.toASCII("bücher.de")); + const prefixed = require("node:punycode"); + console.log("prefixed", prefixed.toUnicode("xn--bcher-kva.de")); + setTimeout(() => console.log("timer"), 0); +} else if (mode === "silenced") { + process.on("warning", (w) => console.log("listener", w.code)); + process.noDeprecation = true; + const silencedModule = require("punycode"); + console.log("silenced", silencedModule.encode("ü")); +} else { + for (const child of ["direct", "silenced"]) { + const run = spawnSync(process.execPath, [process.argv[1], child], { encoding: "utf8" }); + console.log(`== ${child}: status ${run.status}`); + console.log(run.stdout); + console.log(run.stderr.replace(/\(node:\d+\)/g, "(node:)")); + } +} diff --git a/tests/corpus/6125-constants-module.cjs b/tests/corpus/6125-constants-module.cjs new file mode 100644 index 000000000..d7a547ac5 --- /dev/null +++ b/tests/corpus/6125-constants-module.cjs @@ -0,0 +1,26 @@ +// node:constants (deprecated in documentation only, so no warning): one +// frozen object merging os.constants' dlopen, errno, priority and signals +// groups with fs.constants and crypto.constants, in that order. Members +// read like the owning modules' constants, and a constant the platform +// lacks is absent (graceful-fs probes O_SYMLINK with hasOwnProperty). +const constants = require("constants"); +const nodeConstants = require("node:constants"); +const os = require("os"); + +console.log(typeof constants, Object.isFrozen(constants), constants === nodeConstants); +console.log(constants.O_RDONLY, constants.O_WRONLY, constants.O_RDWR); +console.log(constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC); +console.log(constants.S_IFMT, constants.S_IFREG, constants.S_IFDIR, constants.S_IRWXU); +console.log(constants.F_OK, constants.R_OK, constants.W_OK, constants.X_OK); +console.log(constants.COPYFILE_EXCL, constants.UV_FS_COPYFILE_FICLONE, constants.UV_DIRENT_DIR); +console.log(constants.SIGTERM === os.constants.signals.SIGTERM, constants.SIGINT); +console.log(constants.ENOENT === os.constants.errno.ENOENT, constants.EACCES); +console.log(constants.PRIORITY_HIGH, constants.PRIORITY_LOW, constants.RTLD_LAZY); +console.log(constants.TLS1_2_VERSION, constants.RSA_PKCS1_PADDING, typeof constants.defaultCoreCipherList); +console.log(constants.hasOwnProperty("O_SYMLINK") === ("O_SYMLINK" in constants)); +console.log(constants.hasOwnProperty("O_RDWR"), "SIGKILL" in constants, "UV_UDP_REUSEADDR" in constants); +console.log(constants.hasOwnProperty("NOT_A_CONSTANT"), "dlopen" in constants, "errno" in constants); +const keys = Object.keys(constants); +console.log(keys.indexOf("RTLD_LAZY") < keys.indexOf("E2BIG"), keys.indexOf("E2BIG") < keys.indexOf("PRIORITY_LOW")); +console.log(keys.indexOf("PRIORITY_LOW") < keys.indexOf("SIGHUP"), keys.indexOf("SIGHUP") < keys.indexOf("O_RDONLY")); +console.log(keys.indexOf("O_RDONLY") < keys.indexOf("OPENSSL_VERSION_NUMBER"), keys.includes("POINT_CONVERSION_HYBRID")); diff --git a/tests/corpus/6126-punycode-dependency/main.cjs b/tests/corpus/6126-punycode-dependency/main.cjs new file mode 100644 index 000000000..530503a71 --- /dev/null +++ b/tests/corpus/6126-punycode-dependency/main.cjs @@ -0,0 +1,12 @@ +// A dependency under node_modules that requires node:punycode: Node's +// isInsideNodeModules() rule skips DEP0040 for it, so nothing reaches stderr +// or the 'warning' listeners, and the program's own later require of the +// cached module does not report either. +"use strict"; +process.on("warning", (w) => console.log("listener", w.code)); +const toAscii = require("puny-dep"); +const punycode = require("punycode"); + +console.log(toAscii("mañana.com"), toAscii("example.org")); +console.log(punycode.toUnicode("xn--maana-pta.com")); +setTimeout(() => console.log("timer"), 0); diff --git a/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/index.d.ts b/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/index.d.ts new file mode 100644 index 000000000..89b712210 --- /dev/null +++ b/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/index.d.ts @@ -0,0 +1,2 @@ +declare function toAscii(domain: string): string; +export = toAscii; diff --git a/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/index.js b/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/index.js new file mode 100644 index 000000000..417c44889 --- /dev/null +++ b/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/index.js @@ -0,0 +1,8 @@ +// A dependency requiring node:punycode: Node's isInsideNodeModules() rule +// skips DEP0040 for it. +"use strict"; +const punycode = require("punycode"); + +module.exports = function toAscii(domain) { + return punycode.toASCII(domain); +}; diff --git a/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/package.json b/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/package.json new file mode 100644 index 000000000..71edeb25c --- /dev/null +++ b/tests/corpus/6126-punycode-dependency/node_modules/puny-dep/package.json @@ -0,0 +1,5 @@ +{ + "name": "puny-dep", + "version": "1.0.0", + "main": "index.js" +} From 062c77c05a7c57df3d3a19e38188124fc2307643 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 17 Oct 2026 20:12:17 -0700 Subject: [PATCH 14/47] Restore survivors from the recorded gray set instead of whitening scan walked every referenced component from its candidates, whitening each object it reached and restoring the subgraphs of the externally referenced ones, so garbage inside a live component was walked a second time and objects whitened before a later root restored them were walked a third. markGray already records every gray object in a pass of up to 64k objects, and the survivors are exactly what the externally referenced ones reach. So scan now sweeps the recorded entries of the referenced components once, restores from each one that is still gray and referenced, and drops survivors from the list as it sees them; what stays gray is the dead set, with no whitening walk. A pass too large to record still walks scan, but restores from its referenced candidates first. On test_cycle's growing chain this cuts the objects traced from 1.53M to 1.06M, and the work-bound check now passes at thresholds 2 and 7 with a growth cap of 1, where it failed before. Every walk also visits a dense cycle-capable array's elements itself, in a per-phase loop kept out of line so the per-edge visitors stay small, instead of calling scr_arr_trace_v's indirect visit per element. Arrays with sparse entries, properties or metadata keep the trace callback. The array descriptor's kind is what identifies them, so it is reserved. The new corpus program mixes dead and live structures in one pass, inner nodes held from outside, arrays with holes and sparse slots, and a live tree too large for a pass to record. Co-Authored-By: Claude Opus 5.5 --- .../corpus/5973-cycle-components.ts.json | 6 + packages/runtime/src/scr_cycle.c | 170 ++++++++++++++---- packages/runtime/src/scr_rc.h | 3 + tests/corpus/5973-cycle-components.ts | 101 +++++++++++ 4 files changed, 242 insertions(+), 38 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5973-cycle-components.ts.json create mode 100644 tests/corpus/5973-cycle-components.ts diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5973-cycle-components.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5973-cycle-components.ts.json new file mode 100644 index 000000000..e97b429fa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5973-cycle-components.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5973-cycle-components.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_cycle.c b/packages/runtime/src/scr_cycle.c index 08b43186c..c2be13a03 100644 --- a/packages/runtime/src/scr_cycle.c +++ b/packages/runtime/src/scr_cycle.c @@ -26,16 +26,19 @@ * count was already given up (which would over-decrement and free live * data). * - * The main graph phases keep a bounded depth-first walk and defer deeper - * traces to reusable worklists. Ordinary RC destruction and cross-generation - * releases are separate paths. White candidates are recorded during scan - * and filtered after outside roots settle, avoiding a separate gather walk. - * markGray also records the objects it grays and counts those still - * externally referenced (rc > 0 after the trial decrements), per pass and - * per component: the objects first reached from one candidate. A component - * with none is garbage, which is what scan would find, so the pass dooms it - * at once; scan runs only when some component is externally referenced, - * and only from there (see scr_cyc_pass). + * The graph phases keep a bounded depth-first walk and defer deeper traces + * to reusable worklists. Ordinary RC destruction and cross-generation + * releases are separate paths. markGray records the objects it grays (up + * to SCR_CYC_GRAY_LIST_MAX) and counts those still externally referenced + * (rc > 0 after the trial decrements), per pass and per component: the + * objects first reached from one candidate. A component with none is + * garbage, which is what scan would find, so the pass dooms it at once. + * For the others, scan blackens from each recorded object that is still + * externally referenced, which restores exactly the survivors, and what + * stays gray is the garbage: no walk whitens it. Only a pass too large to + * record walks scan from the candidates, whitening as it goes, and then + * filters the white set after outside roots settle, avoiding a separate + * gather walk. * * ── generations ────────────────────────────────────────────────────── * A pass costs O(objects reachable from its candidates), and a candidate @@ -379,7 +382,6 @@ static SCR_TL ScrVec scr_promote; static SCR_TL ScrVec scr_pending; static SCR_TL ScrVec scr_restore_pending; #endif -#define SCR_CYC_WALK_DEPTH 64 /* The gathered white set (freed after the walk completes). */ #ifndef SCR_WORKERS @@ -933,18 +935,53 @@ void scr_cyc_on_release(void *obj) { ((child) == NULL || SCR_RC(child) == SIZE_MAX \ || scr_cyc_gen(scr_cyc_hdr(child)) > scr_gen_limit) -/* Trace callbacks forward an integer depth through their opaque context; - * it is never dereferenced. The ABI already carries it through every edge. */ +/* The walks are depth-first and recursive up to SCR_CYC_WALK_DEPTH, where + * an object is queued instead (scr_pending, or scr_restore_pending for the + * restoration, which can run inside scan) and traced from the queue. Trace + * callbacks forward that integer depth through their opaque context; it is + * never dereferenced. */ +#define SCR_CYC_WALK_DEPTH 64 + +/* A walk visits a dense cycle-capable array's children itself: the present + * dense elements, which are all scr_arr_trace_v visits when the array has + * no sparse entries, properties or metadata (no `ext`). Each walk gets its + * own copy, out of line, so the per-edge visitors stay small. */ +#define SCR_CYC_ARRAY_WALK(name, visit) \ + static __attribute__((noinline)) void name(const ScrArr *arr, void *ctx) { \ + size_t end = arr->len < arr->cap ? arr->len : arr->cap; \ + size_t filled = arr->filled < end ? arr->filled : end; \ + for (size_t i = 0; i < filled; i++) visit((void *)(uintptr_t)arr->data[i], ctx); \ + for (size_t i = filled; i < end; i++) \ + if (arr->present[i] == SCR_ARR_VALUE) visit((void *)(uintptr_t)arr->data[i], ctx); \ + } + +/* Visit every child of `obj` with VISIT, through ARRAY_WALK for a dense + * cycle-capable array and through the type's trace otherwise. */ +#define SCR_CYC_CHILDREN(obj, type, ARRAY_WALK, VISIT, depth) \ + do { \ + if ((type)->kind == SCR_CYC_KIND_ARRAY && ((const ScrArr *)(obj))->ext == NULL) \ + ARRAY_WALK((const ScrArr *)(obj), (void *)(depth)); \ + else \ + (type)->trace((obj), (VISIT), (void *)(depth)); \ + } while (0) + +static void scr_mg_visit(void *child, void *ctx); +static void scr_sb_visit(void *child, void *ctx); +static void scr_scan_visit(void *child, void *ctx); +SCR_CYC_ARRAY_WALK(scr_mg_array, scr_mg_visit) +SCR_CYC_ARRAY_WALK(scr_sb_array, scr_sb_visit) +SCR_CYC_ARRAY_WALK(scr_scan_array, scr_scan_visit) + static inline __attribute__((always_inline)) void scr_mark_gray(void *obj, uintptr_t depth); static void scr_mg_visit(void *child, void *ctx) { if (child == NULL || SCR_RC(child) == SIZE_MAX) return; - if (scr_cyc_gen(scr_cyc_hdr(child)) > scr_gen_limit) { + ScrCycHdr *h = scr_cyc_hdr(child); + if (scr_cyc_gen(h) > scr_gen_limit) { scr_cyc_push_work(&scr_xgen_edges, scr_gray_holder); scr_cyc_push_work(&scr_xgen_edges, child); return; } size_t rc = --SCR_RC(child); - ScrCycHdr *h = scr_cyc_hdr(child); if (scr_cyc_color(h) == SCR_CYC_GRAY) { if (rc == 0) { scr_gray_referenced--; @@ -954,9 +991,11 @@ static void scr_mg_visit(void *child, void *ctx) { } scr_mark_gray(child, (uintptr_t)ctx); } +/* markGray reaches `obj` (its count already trial-decremented): gray it, + * number it with the walk's component, record it, count it while it is + * externally referenced, and walk its children. */ static inline __attribute__((always_inline)) void scr_mark_gray(void *obj, uintptr_t depth) { ScrCycHdr *h = scr_cyc_hdr(obj); - if (scr_cyc_color(h) == SCR_CYC_GRAY) return; scr_cyc_set_color(h, SCR_CYC_GRAY); /* A limited pass can gray candidates it did not take; they keep their * buffer position and are simply never counted as members. */ @@ -972,10 +1011,24 @@ static inline __attribute__((always_inline)) void scr_mark_gray(void *obj, uintp } void *holder = scr_gray_holder; scr_gray_holder = obj; - scr_cyc_type(h)->trace(obj, scr_mg_visit, (void *)(depth + 1)); + const ScrCycType *type = scr_cyc_type(h); + SCR_CYC_CHILDREN(obj, type, scr_mg_array, scr_mg_visit, depth + 1); scr_gray_holder = holder; } +/* markGray from one (black) candidate, through the queue. */ +static void scr_mark_gray_from(void *root) { + scr_mark_gray(root, 0); + while (scr_pending.n) { + void *obj = scr_pending.v[--scr_pending.n]; + const ScrCycType *type = scr_cyc_type(scr_cyc_hdr(obj)); + scr_gray_holder = obj; + SCR_CYC_CHILDREN(obj, type, scr_mg_array, scr_mg_visit, 1); + } +} +/* scan's restoration: blacken an externally referenced object and + * everything it reaches that is not black yet, giving back the trial + * decrements of the edges it follows. */ static void scr_scan_black(void *obj, uintptr_t depth); static void scr_sb_visit(void *child, void *ctx) { if (SCR_CYC_SKIP(child)) return; @@ -994,9 +1047,21 @@ static void scr_scan_black(void *obj, uintptr_t depth) { scr_cyc_push_work(&scr_restore_pending, obj); return; } - scr_cyc_type(h)->trace(obj, scr_sb_visit, (void *)(depth + 1)); + const ScrCycType *type = scr_cyc_type(h); + SCR_CYC_CHILDREN(obj, type, scr_sb_array, scr_sb_visit, depth + 1); +} +static void scr_restore_from(void *root) { + scr_scan_black(root, 0); + while (scr_restore_pending.n) { + void *obj = scr_restore_pending.v[--scr_restore_pending.n]; + const ScrCycType *type = scr_cyc_type(scr_cyc_hdr(obj)); + SCR_CYC_CHILDREN(obj, type, scr_sb_array, scr_sb_visit, 1); + } } +/* scan, walking: restore a gray object that is externally referenced, else + * whiten it, record it once (a later outside root can still restore it; + * settle filters the list) and walk its children. */ static void scr_scan(void *obj, uintptr_t depth); static void scr_scan_visit(void *child, void *ctx) { if (SCR_CYC_SKIP(child)) return; @@ -1006,22 +1071,17 @@ static void scr_scan(void *obj, uintptr_t depth) { ScrCycHdr *h = scr_cyc_hdr(obj); if (scr_cyc_color(h) != SCR_CYC_GRAY) return; if (SCR_RC(obj) > 0) { - scr_scan_black(obj, 0); - while (scr_restore_pending.n) { - void *next = scr_restore_pending.v[--scr_restore_pending.n]; - scr_cyc_type(scr_cyc_hdr(next))->trace(next, scr_sb_visit, NULL); - } + scr_restore_from(obj); return; } scr_cyc_set_color(h, SCR_CYC_WHITE); - /* Record each whitened object once. A later outside root can restore it; - * filter the list only after every scan finishes. No gather trace needed. */ scr_cyc_push_work(&scr_white, obj); if (depth == SCR_CYC_WALK_DEPTH) { scr_cyc_push_work(&scr_pending, obj); return; } - scr_cyc_type(h)->trace(obj, scr_scan_visit, (void *)(depth + 1)); + const ScrCycType *type = scr_cyc_type(h); + SCR_CYC_CHILDREN(obj, type, scr_scan_array, scr_scan_visit, depth + 1); } /* ── cross-generation edges ───────────────────────────────────────────── */ @@ -1337,12 +1397,7 @@ static size_t scr_cyc_pass(unsigned gen_limit) { size_t start = scr_white.n; scr_gray_comp = split ? ++comp : 0; scr_comp_referenced = 0; - scr_mark_gray(obj, 0); - while (scr_pending.n) { - void *next = scr_pending.v[--scr_pending.n]; - scr_gray_holder = next; - scr_cyc_type(scr_cyc_hdr(next))->trace(next, scr_mg_visit, NULL); - } + scr_mark_gray_from(obj); if (!split) continue; size_t end = scr_white.n; if (scr_comp_referenced == 0 && end < SCR_CYC_GRAY_LIST_MAX) { @@ -1361,8 +1416,39 @@ static size_t scr_cyc_pass(unsigned gen_limit) { if (scr_gray_referenced == 0 && scr_white.n < SCR_CYC_GRAY_LIST_MAX) return scr_cyc_pass_done(scr_cyc_settle(gen_limit, split && scr_live_ranges.n == 0)); - /* Keep only the doomed components' entries; scan appends what it - * whitens. */ + /* scan, from the recorded set when markGray recorded every gray object: + * the survivors are exactly what the externally referenced gray objects + * reach, so blackening from each of them in turn leaves the garbage gray + * without walking it again, and settle dooms what is still gray. Only + * the referenced components' entries need looking at; the doomed ones + * are settled already. */ + if (scr_white.n < SCR_CYC_GRAY_LIST_MAX) { + /* One sweep over the list, keeping the doomed components' entries and, + * of the referenced components', only those still gray: a survivor + * leaves the list as soon as it is seen black, and an object kept here + * that a later restoration blackens is skipped by settle. */ + size_t kept = 0, from = 0; + size_t nranges = split ? scr_live_ranges.n : 2; + for (size_t k = 0; k < nranges; k += 2) { + size_t start = split ? (uintptr_t)scr_live_ranges.v[k] : 0; + size_t end = split ? (uintptr_t)scr_live_ranges.v[k + 1] : scr_white.n; + if (start > from) memmove(scr_white.v + kept, scr_white.v + from, (start - from) * sizeof *scr_white.v); + kept += start - from; + for (size_t j = start; j < end; j++) { + void *obj = scr_white.v[j]; + if (scr_cyc_color(scr_cyc_hdr(obj)) != SCR_CYC_GRAY) continue; + if (SCR_RC(obj) > 0) scr_restore_from(obj); + else scr_white.v[kept++] = obj; + } + from = end; + } + if (scr_white.n > from) memmove(scr_white.v + kept, scr_white.v + from, (scr_white.n - from) * sizeof *scr_white.v); + scr_white.n = kept + (scr_white.n - from); + return scr_cyc_pass_done(scr_cyc_settle(gen_limit, false)); + } + + /* Otherwise scan walks from the candidates. Keep only the doomed + * components' entries; scan appends what it whitens. */ if (!split) { scr_white.n = 0; } else if (scr_live_ranges.n) { @@ -1376,16 +1462,24 @@ static size_t scr_cyc_pass(unsigned gen_limit) { memmove(scr_white.v + kept, scr_white.v + from, (scr_white.n - from) * sizeof *scr_white.v); scr_white.n = kept + (scr_white.n - from); } + /* Externally referenced candidates first: what they restore is never + * whitened only to be restored again. */ + for (size_t i = 0; i < scr_cands.n; i++) { + void *obj = scr_cands.v[i]; + if (scr_cyc_color(scr_cyc_hdr(obj)) == SCR_CYC_GRAY && SCR_RC(obj) > 0) scr_restore_from(obj); + } for (size_t i = 0; i < scr_cands.n; i++) { void *obj = scr_cands.v[i]; if (scr_cyc_color(scr_cyc_hdr(obj)) == SCR_CYC_GRAY) scr_scan(obj, 0); } while (scr_pending.n) { void *obj = scr_pending.v[--scr_pending.n]; - /* A later outside root may have restored this deferred white node and - * its descendants already. Never scan a black node's edges again. */ - if (scr_cyc_color(scr_cyc_hdr(obj)) == SCR_CYC_WHITE) - scr_cyc_type(scr_cyc_hdr(obj))->trace(obj, scr_scan_visit, NULL); + /* A later outside root may have restored this deferred white object and + * its descendants already. Never scan a black object's edges again. */ + ScrCycHdr *h = scr_cyc_hdr(obj); + if (scr_cyc_color(h) != SCR_CYC_WHITE) continue; + const ScrCycType *type = scr_cyc_type(h); + SCR_CYC_CHILDREN(obj, type, scr_scan_array, scr_scan_visit, 1); } return scr_cyc_pass_done(scr_cyc_settle(gen_limit, false)); diff --git a/packages/runtime/src/scr_rc.h b/packages/runtime/src/scr_rc.h index 7069839c7..d5d83a72a 100644 --- a/packages/runtime/src/scr_rc.h +++ b/packages/runtime/src/scr_rc.h @@ -92,6 +92,9 @@ typedef struct ScrCycType { * SCR_CYC_KIND_EMITTED (llvm/alloc.ts FIRST_EMITTED_CYC_KIND). */ enum { SCR_CYC_KIND_NONE = 0, + /* Also how the collector recognizes a cycle-capable ScrArr, whose dense + * elements it visits inline (scr_cycle.c SCR_CYC_CHILDREN): reserved for + * scr_array.c's descriptor. */ SCR_CYC_KIND_ARRAY, SCR_CYC_KIND_PROMISE, SCR_CYC_KIND_BOX, diff --git a/tests/corpus/5973-cycle-components.ts b/tests/corpus/5973-cycle-components.ts new file mode 100644 index 000000000..05e8ffed1 --- /dev/null +++ b/tests/corpus/5973-cycle-components.ts @@ -0,0 +1,101 @@ +// Collector passes whose candidates mix dead structures with live ones: the +// ring under construction when a pass runs, owners that keep an inner node +// of an otherwise dead ring, trees whose child arrays have holes and sparse +// slots, and a live structure too large for a pass to record. Each dead +// structure is reclaimed whole, and everything still reachable survives +// with its contents intact. The sanitized lane's RC audit fails if anything +// below leaks or is freed while reachable. + +class Node { + next: Node | null = null; + kids: (Node | undefined)[] = []; + owner: Node | null = null; + value: number; + constructor(value: number) { + this.value = value; + } +} + +function ring(size: number, base: number): Node { + const first = new Node(base); + let last = first; + for (let i = 1; i < size; i++) { + const node = new Node(base + i); + last.next = node; + last = node; + } + last.next = first; + return first; +} + +function tree(depth: number, owner: Node | null, value: number): Node { + const node = new Node(value); + node.owner = owner; + if (depth > 0) for (let i = 0; i < 3; i++) node.kids.push(tree(depth - 1, node, value * 3 + i)); + return node; +} + +function total(start: Node): number { + const seen = new Set(); + const stack: Node[] = [start]; + let sum = 0; + while (stack.length > 0) { + const node = stack.pop()!; + if (seen.has(node)) continue; + seen.add(node); + sum = (sum + node.value) % 1000003; + if (node.next) stack.push(node.next); + if (node.owner) stack.push(node.owner); + for (const kid of node.kids) if (kid) stack.push(kid); + } + return sum * 1000 + (seen.size % 1000); +} + +// Dead rings dropped while the next one is being built; a few are kept. +let rings = 0; +const kept: Node[] = []; +for (let round = 0; round < 3000; round++) { + const r = ring(5 + (round % 7), round); + rings = (rings + r.next!.value) % 1000003; + if (round % 500 === 0) kept.push(r); +} +console.log("rings", rings, kept.map(total).join(" ")); + +// Rings whose head is dropped while an owner keeps a node in the middle: +// the ring stays reachable through it and must survive whole. +const anchors: Node[] = []; +for (let round = 0; round < 400; round++) { + let mid = ring(30, round * 100); + for (let i = 0; i < 15; i++) mid = mid.next!; + if (round % 4 === 0) anchors.push(mid); +} +let anchored = 0; +for (const anchor of anchors) anchored = (anchored + total(anchor)) % 1000003; +console.log("anchored", anchors.length, anchored); + +// Trees with holes and sparse slots in their child arrays. +let trees = 0; +const shaped: Node[] = []; +for (let round = 0; round < 300; round++) { + const t = tree(4, null, round); + if (round % 3 === 0) t.kids.length = 6; + if (round % 5 === 0) t.kids[200] = tree(2, t, round + 7); + if (round % 7 === 0) t.kids[0]!.kids.length = 1; + trees = (trees + total(t)) % 1000003; + if (round % 60 === 0) shaped.push(t.kids[2]!); +} +console.log("trees", trees, shaped.map(total).join(" ")); + +// A live tree larger than one pass records, built and read while dead +// structures keep dying around it, then dropped. +const big = tree(10, null, 1); +let churn = 0; +for (let round = 0; round < 200; round++) { + const r = ring(50, round); + const branch = big.kids[round % 3]!.kids[(round >> 2) % 3]!; + branch.next = r; + churn = (churn + total(r)) % 1000003; + if (round % 50 === 0) churn = (churn + total(big)) % 1000003; + branch.next = null; +} +console.log("big", churn, total(big)); From d49fcf3c6674d20f1b86faa291c0555bb6a980de Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 06:26:10 -0700 Subject: [PATCH 15/47] Record CI costs for the array length loop corpus programs The shard harness requires measured costs for more than 90% of the corpus. Take the costs of programs 5993-5995 from this branch's green Linux shard logs the way scripts/ci-corpus-costs.mjs computes them. Co-Authored-By: Claude Opus 5.5 --- tests/harness/corpus-costs.json | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index 88b9415bd..dd3a0b00a 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -1913,6 +1913,9 @@ "5990-worker-uncloneable.mjs": 3283, "5991-worker-async-dispose.mjs": 5699, "5992-worker-thread-name-lifetime.mjs": 2687, + "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, @@ -4611,6 +4614,9 @@ "5990-worker-uncloneable.mjs": 22432, "5991-worker-async-dispose.mjs": 25768, "5992-worker-thread-name-lifetime.mjs": 28932, + "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, From 1c4a7f08075ab3fd1023b750af78aedebdedfea3 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 06:34:55 -0700 Subject: [PATCH 16/47] Renumber the cycle components corpus program to 5980 5973 is also taken by 5973-large-closure-environment.ts on opt/compile-closures. Move the program and its order baseline. Co-Authored-By: Claude Opus 5.5 --- ...973-cycle-components.ts.json => 5980-cycle-components.ts.json} | 0 .../corpus/{5973-cycle-components.ts => 5980-cycle-components.ts} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename packages/compiler/test/ts7/baselines/order-parity/tests/corpus/{5973-cycle-components.ts.json => 5980-cycle-components.ts.json} (100%) rename tests/corpus/{5973-cycle-components.ts => 5980-cycle-components.ts} (100%) diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5973-cycle-components.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json similarity index 100% rename from packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5973-cycle-components.ts.json rename to packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json diff --git a/tests/corpus/5973-cycle-components.ts b/tests/corpus/5980-cycle-components.ts similarity index 100% rename from tests/corpus/5973-cycle-components.ts rename to tests/corpus/5980-cycle-components.ts From 8e6986c561803a89fcee41e34fdcc00dd0899a7d Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:17:51 -0700 Subject: [PATCH 17/47] 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 dcdca2b8107994107418afb8ce641010ce5b7807 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:32:40 -0700 Subject: [PATCH 18/47] Read and write records through a binding that may hold a missing record Under noUncheckedIndexedAccess, `let e = map[k]; if (e === undefined) { e = {}; map[k] = e } e[c] = v` failed with SC9001 "recordKeySet receiver: expected record, got union". A runtime-optional binding read with a computed key reaches the record read and write lowerings as its `record | undefined` storage. Those lowerings now hold the receiver, the key and, for writes, the value in temporaries and throw Node's TypeError for an undefined receiver ("Cannot read properties of undefined (reading 'k')", "Cannot set properties of undefined (setting 'k')") after evaluating them in Node's order. Every other receiver builds the same IR as before. Co-Authored-By: Claude Opus 5.5 --- .../src/frontend/lowering/lower-exprs.ts | 229 ++++++++++++++++-- .../main.ts.json | 6 + .../main.ts | 70 ++++++ .../tsconfig.json | 6 + 4 files changed, 295 insertions(+), 16 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6101-record-get-or-create-unchecked/main.ts.json create mode 100644 tests/corpus/6101-record-get-or-create-unchecked/main.ts create mode 100644 tests/corpus/6101-record-get-or-create-unchecked/tsconfig.json diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index f0538bb71..5f5bc3ff3 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -16,6 +16,7 @@ import { STATS_TYPE_TESTS } from "./builtins/filesystem.js"; import { threadsImportOf } from "../threads-import.js"; import { experimentalImportOf, lifetimeRegionMemberOf } from "../experimental-import.js"; import { lowerInternTableProperty } from "./intern-tables.js"; +import { concatStrings } from "./containers/dynamic-receivers.js"; import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js"; import { InternalCompilerError } from "../../errors.js"; import { SYMBOL_T } from "../../ir/ir.js"; @@ -7077,6 +7078,194 @@ export function lowerRecordKeyRead( // The receiver lowers FIRST (both branches below read it, and JS // evaluates the receiver before the key). const obj = lowerer.lowerExpr(expr.expression); + const optional = optionalRecordReceiver(lowerer, obj); + if (optional) { + // A runtime-optional binding read with a computed key reaches here as + // its `record | undefined` storage. JavaScript evaluates the receiver, + // then the key, and only then throws for an undefined receiver, naming + // the key. Hold both in temporaries so that order and message survive. + const receiver = lowerer.declareHiddenLocal("%optionalRecord", obj.type); + const stmts: IrStmt[] = [{ kind: "varDecl", localId: receiver.id, init: obj, loc }]; + let keyRef: IrExpr | null = + litKey !== null ? { kind: "strLit", value: litKey, type: STRING, loc } : null; + const read = lowerRecordKeyReadFrom( + lowerer, + expr, + shapeId, + shape, + includeUndefined, + litKey, + optionalRecordPresent(optional, receiver, loc), + (key) => { + if (keyRef !== null) return key; + const held = lowerer.declareHiddenLocal("%optionalRecordKey", STRING); + stmts.push({ kind: "varDecl", localId: held.id, init: key, loc }); + keyRef = varRef(held.id, STRING, loc); + return keyRef; + }, + ); + if (keyRef === null) { + lowerer.unsupported( + "SC1090", + keyNode, + "this computed key through a binding that may hold a missing record (narrow the binding or the key first)", + ); + } + return { + kind: "seqExpr", + stmts, + result: optionalRecordGuard(optional, receiver, keyRef, "reading", read, loc), + type: read.type, + loc, + }; + } + return lowerRecordKeyReadFrom(lowerer, expr, shapeId, shape, includeUndefined, litKey, obj, null); +} + +/** The `record | undefined` storage of a runtime-optional binding whose + * only value arm is a record (the get-or-create local after its presence + * guard). Null for every other receiver. */ +function optionalRecordReceiver( + lowerer: Lowerer, + obj: IrExpr, +): { unionId: string; undefinedTag: number; presentTag: number; record: IrType } | null { + if (obj.type.kind !== "union") return null; + const def = lowerer.unions.get(obj.type.unionId); + if (!def || def.arms.length !== 2) return null; + const undefinedTag = lowerer.armTag(obj.type.unionId, UNDEFINED_T); + if (undefinedTag < 0) return null; + const presentTag = undefinedTag === 0 ? 1 : 0; + const record = def.arms[presentTag]!; + if (record.kind !== "record" || lowerer.shapes.get(record.shapeId)?.tuple) return null; + return { unionId: obj.type.unionId, undefinedTag, presentTag, record }; +} + +function optionalRecordPresent( + optional: NonNullable>, + receiver: IrLocal, + loc: SrcLoc, +): IrExpr { + return { + kind: "unionNarrow", + unionId: optional.unionId, + tag: optional.presentTag, + value: varRef(receiver.id, receiver.type, loc), + type: optional.record, + loc, + }; +} + +/** Node's TypeError for a keyed access on undefined ("Cannot read + * properties of undefined (reading 'k')", or "Cannot set ... (setting + * 'k')" for a write), naming the already-evaluated property key. */ +function optionalRecordThrow( + key: IrExpr, + verb: "reading" | "setting", + type: IrType, + loc: SrcLoc, +): IrExpr { + const message = concatStrings( + [ + strLit( + `Cannot ${verb === "reading" ? "read" : "set"} properties of undefined (${verb} '`, + loc, + ), + key, + strLit("')", loc), + ], + loc, + ); + return { + kind: "libCall", + fn: "error.nodeThrow", + args: [numLit(1, loc), strLit("", loc), message], + type, + loc, + }; +} + +function optionalRecordIsUndefined( + optional: NonNullable>, + receiver: IrLocal, + loc: SrcLoc, +): IrExpr { + return { + kind: "unionIsTag", + unionId: optional.unionId, + tag: optional.undefinedTag, + negated: false, + value: varRef(receiver.id, receiver.type, loc), + type: BOOL, + loc, + }; +} + +/** `present` when the held receiver is a record, otherwise the TypeError. */ +function optionalRecordGuard( + optional: NonNullable>, + receiver: IrLocal, + key: IrExpr, + verb: "reading" | "setting", + present: IrExpr, + loc: SrcLoc, +): IrExpr { + return { + kind: "ternary", + cond: optionalRecordIsUndefined(optional, receiver, loc), + then: optionalRecordThrow(key, verb, present.type, loc), + else_: present, + type: present.type, + loc, + }; +} + +/** A keyed write whose receiver may be the `record | undefined` storage of + * a runtime-optional binding: JavaScript evaluates the receiver, the key + * and the value, then throws for an undefined receiver. Other receivers + * build the write directly. */ +function optionalRecordWrite( + lowerer: Lowerer, + obj: IrExpr, + key: IrExpr, + value: IrExpr, + loc: SrcLoc, + build: (receiver: IrExpr, key: IrExpr, value: IrExpr) => IrStmt, +): IrStmt { + const optional = optionalRecordReceiver(lowerer, obj); + if (!optional) return build(obj, key, value); + const receiver = lowerer.declareHiddenLocal("%optionalRecord", obj.type); + const body: IrStmt[] = [{ kind: "varDecl", localId: receiver.id, init: obj, loc }]; + const hold = (e: IrExpr, name: string): IrExpr => { + if (e.kind === "strLit" || e.kind === "numLit") return e; + const held = lowerer.declareHiddenLocal(name, e.type); + body.push({ kind: "varDecl", localId: held.id, init: e, loc }); + return varRef(held.id, e.type, loc); + }; + const heldKey = hold(key, "%optionalRecordKey"); + const heldValue = hold(value, "%optionalRecordValue"); + body.push({ + kind: "if", + cond: optionalRecordIsUndefined(optional, receiver, loc), + then: [{ kind: "exprStmt", expr: optionalRecordThrow(heldKey, "setting", VOID, loc), loc }], + else_: null, + loc, + }); + body.push(build(optionalRecordPresent(optional, receiver, loc), heldKey, heldValue)); + return { kind: "block", body, loc }; +} + +function lowerRecordKeyReadFrom( + lowerer: Lowerer, + expr: ts.ElementAccessExpression, + shapeId: string, + shape: IrRecordShape, + includeUndefined: boolean, + litKey: string | null, + obj: IrExpr, + holdKey: ((key: IrExpr) => IrExpr) | null, +): IrExpr { + const loc = locOf(expr); + const keyNode = expr.argumentExpression; // A record-mapped CHECKER type over a VALUE living in the checked-dynamic tree (a JS // file-scope object-literal global): the checked-dynamic keyed read — // dynKeyGet against the runtime keys (a missing key answers the checked-dynamic tree @@ -7177,6 +7366,7 @@ export function lowerRecordKeyRead( if (key.type.kind !== "string") { lowerer.unsupported("SC1090", keyNode, "indexing records with non-string or non-number keys"); } + if (holdKey) key = holdKey(key); if (shape.fields.length === 0 && shape.indexValue === undefined) { const result = dynUndefinedExpr(loc); return { @@ -8161,14 +8351,21 @@ export function lowerElementWrite(lowerer: Lowerer, expr: ts.BinaryExpression): if (field) { const obj = lowerer.lowerExpr(target.expression); const value = lowerer.lowerExprExpecting(expr.right, field.type); - return { - kind: "recordSet", + return optionalRecordWrite( + lowerer, obj, - shapeId: receiverIr.shapeId, - field: litKey, + strLit(litKey, locOf(target.argumentExpression)), value, - loc: locOf(expr), - }; + locOf(expr), + (receiver, _key, held) => ({ + kind: "recordSet", + obj: receiver, + shapeId: receiverIr.shapeId, + field: litKey, + value: held, + loc: locOf(expr), + }), + ); } } if (!shape.indexValue) { @@ -8211,14 +8408,14 @@ export function lowerElementWrite(lowerer: Lowerer, expr: ts.BinaryExpression): const value = lowerer.coerceInto(expr.right, lowerer.lowerExpr(expr.right), common); if (!typeEquals(value.type, common)) lowerer.badType(expr.right, lowerer.typeOf(expr.right)); - return { + return optionalRecordWrite(lowerer, obj, key, value, locOf(expr), (receiver, k, v) => ({ kind: "recordKeySet", - obj, + obj: receiver, shapeId: receiverIr.shapeId, - key, - value, + key: k, + value: v, loc: locOf(expr), - }; + })); } // A LITERAL key naming no declared field is a pure overflow insert // — no collision to validate. Runtime keys must be able to collide @@ -8264,15 +8461,15 @@ export function lowerElementWrite(lowerer: Lowerer, expr: ts.BinaryExpression): shape.indexValue, expr.right, ); - return { + return optionalRecordWrite(lowerer, obj, key, value, locOf(expr), (receiver, k, v) => ({ kind: "recordKeySet", - obj, + obj: receiver, shapeId: receiverIr.shapeId, - key, - value, + key: k, + value: v, ...(overflowOnly ? { overflowOnly: true as const } : {}), loc: locOf(expr), - }; + })); } } // Keyed write `d[k] = v` on a CHECKED-DYNAMIC receiver (a JS `any` diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6101-record-get-or-create-unchecked/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6101-record-get-or-create-unchecked/main.ts.json new file mode 100644 index 000000000..dcb5b192f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6101-record-get-or-create-unchecked/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6101-record-get-or-create-unchecked/main.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6101-record-get-or-create-unchecked/main.ts b/tests/corpus/6101-record-get-or-create-unchecked/main.ts new file mode 100644 index 000000000..a2b4ef705 --- /dev/null +++ b/tests/corpus/6101-record-get-or-create-unchecked/main.ts @@ -0,0 +1,70 @@ +// Get-or-create over nested index-signature records under +// noUncheckedIndexedAccess: after the presence guard the binding is still +// stored with its undefined arm, and reads, writes and absence probes with +// computed keys go through it (an internal compiler error before). +type ExportMap = Record>; + +function build(rows: { k: string; c: string; v: string }[]): ExportMap { + const map: ExportMap = {}; + for (const r of rows) { + let entry = map[r.k]; + if (entry === undefined) { + entry = {}; + map[r.k] = entry; + } + entry[r.c] = r.v; + } + return map; +} +console.log( + JSON.stringify( + build([ + { k: "a", c: "x", v: "1" }, + { k: "a", c: "y", v: "2" }, + { k: "b", c: "x", v: "3" }, + ]), + ), +); + +function touch(map: ExportMap, k: string): string { + let e = map[k]; + if (e === undefined) { + e = { [k]: "init" }; + map[k] = e; + } + const before = e[k] ?? "none"; + e[k] = e[k] + "!"; + return before + (k in e ? "+" : "-"); +} +const m: ExportMap = {}; +console.log(touch(m, "a"), touch(m, "a"), touch(m, "b"), JSON.stringify(m)); + +function tally(counts: Record>, group: string, item: string): void { + let row = counts[group]; + if (!row) { + row = {}; + counts[group] = row; + } + row[item] = (row[item] ?? 0) + 1; +} +const counts: Record> = {}; +for (const [g, i] of [ + ["fruit", "apple"], + ["fruit", "pear"], + ["veg", "kale"], + ["fruit", "apple"], +]) { + tally(counts, g!, i!); +} +console.log(JSON.stringify(counts)); + +// Module scope. +const top: ExportMap = {}; +const key = process.argv.length > 99 ? "unused" : "k"; +let slot = top[key]; +if (slot === undefined) { + slot = {}; + top[key] = slot; +} +slot[key] = "v"; +console.log(JSON.stringify(top), slot[key], slot["other"] ?? "missing"); diff --git a/tests/corpus/6101-record-get-or-create-unchecked/tsconfig.json b/tests/corpus/6101-record-get-or-create-unchecked/tsconfig.json new file mode 100644 index 000000000..f2e1c10cd --- /dev/null +++ b/tests/corpus/6101-record-get-or-create-unchecked/tsconfig.json @@ -0,0 +1,6 @@ +{ + "compilerOptions": { + "strict": true, + "noUncheckedIndexedAccess": true + } +} From ce87ba722dc84fa3be14c8bfb0a615f0d52261c3 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:32:46 -0700 Subject: [PATCH 19/47] Read missing record keys as undefined before every absence guard MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `let e = map[k]; if (e === undefined) { e = {}; map[k] = e } e[c] = v` on a `Record>` compiled, then aborted with "record has no key (typed slot…)" where Node prints the result. Without noUncheckedIndexedAccess a keyed record read keeps its typed trap unless the next statement tests the binding for absence, and only `if (!e)` counted. Comparisons with the missing value now count too (`=== undefined`, `== null`, `!== void 0`, `typeof e === "undefined"` and their mirrored forms) for index-signature record reads whose checker type lacks undefined. Module-scope declarations get the same treatment: their pre-registered global takes the undefined arm before any body reads it, and the initializer lowers as the absence probe. Array reads, annotated bindings and noUncheckedIndexedAccess programs compile as before. Co-Authored-By: Claude Opus 5.5 --- .../src/frontend/lowering/lower-stmts.ts | 141 ++++++++++++++---- .../compiler/src/frontend/lowering/lowerer.ts | 30 ++++ .../corpus/6100-record-get-or-create.ts.json | 6 + tests/corpus/6100-record-get-or-create.ts | 119 +++++++++++++++ 4 files changed, 269 insertions(+), 27 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6100-record-get-or-create.ts.json create mode 100644 tests/corpus/6100-record-get-or-create.ts diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index ad4fd5312..7eb86d6d9 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -4334,16 +4334,21 @@ export function lowerVarDecl( if (wrapped) return { kind: "assign", localId: g.id, value: wrapped, loc: locOf(decl) }; return null; } - const raw = lowerVariableInitializer( - lowerer, - decl.initializer, - g.type.kind === "dyn" && - (isNativeBuiltinValueInitializer(lowerer, decl.initializer) || - ts.isArrayLiteralExpression(decl.initializer) || - ts.isObjectLiteralExpression(decl.initializer)) - ? DYN - : undefined, - ); + const guardedRead = isGuardedRecordRead(lowerer, decl) + ? lowerAbsenceProbe(lowerer, decl.initializer) + : null; + const raw = + guardedRead ?? + lowerVariableInitializer( + lowerer, + decl.initializer, + g.type.kind === "dyn" && + (isNativeBuiltinValueInitializer(lowerer, decl.initializer) || + ts.isArrayLiteralExpression(decl.initializer) || + ts.isObjectLiteralExpression(decl.initializer)) + ? DYN + : undefined, + ); if ( isJsSourceFile(decl.getSourceFile()) && !decl.type && @@ -5139,29 +5144,111 @@ export function jsBindingHasOpenWrites(lowerer: Lowerer, decl: ts.VariableDeclar } function immediatelyGuardedAbsenceProbe(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean { - if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer) return false; + const guard = immediateAbsenceGuard(lowerer, decl); + // `if (!x)`: the falsy test sees a missing value. + if (guard === "falsy") return true; + // `if (x === undefined)` and its spellings compare the binding with the + // missing value itself, so the read must be able to produce it. Only + // index-signature record reads take this form: array reads already + // carry their undefined arm, and their ordinary lowering keeps its + // bounds proofs. + return guard === "compare" && isIndexSignatureRecordRead(lowerer, decl); +} + +/** A file-scope or block-scope `let e = map[k]` over an index-signature + * record whose next statement guards `e` for absence (`if (e === + * undefined)`, `if (!e)`, ...): the get-or-create idiom. Its read keeps the + * missing key as undefined even without noUncheckedIndexedAccess. */ +export function isGuardedRecordRead(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean { + return immediateAbsenceGuard(lowerer, decl) !== null && isIndexSignatureRecordRead(lowerer, decl); +} + +function isIndexSignatureRecordRead(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean { + if (!decl.initializer) return false; + let init = decl.initializer; + while (ts.isParenthesizedExpression(init)) init = init.expression; + if (!ts.isElementAccessExpression(init)) return false; + // Under noUncheckedIndexedAccess the checker already spells the missing + // arm, and the ordinary read carries it. + const read = lowerer.typeOf(init); + if ( + (read.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0 || + (read.isUnionType() && + ts.constituentTypes(read).some((t) => (t.flags & ts.TypeFlags.Undefined) !== 0)) + ) + return false; + const receiver = lowerer.mapTypeOf(lowerer.typeOf(init.expression)); + const shape = receiver?.kind === "record" ? lowerer.shapes.get(receiver.shapeId) : undefined; + return !!shape && !shape.tuple && !!shape.indexValue && shape.indexValue.kind !== "dyn"; +} + +/** How the statement right after an unannotated declaration tests the + * declared binding for absence: `if (!x)` ("falsy"), or a comparison with + * the missing value — `x === undefined`, `x == null`, `x !== void 0`, + * `typeof x === "undefined"` and their mirrored and negated spellings + * ("compare"). Null for anything else. */ +function immediateAbsenceGuard( + lowerer: Lowerer, + decl: ts.VariableDeclaration, +): "falsy" | "compare" | null { + if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer) return null; const statement = decl.parent?.parent; - if (!statement || !ts.isVariableStatement(statement)) return false; + if (!statement || !ts.isVariableStatement(statement)) return null; const container = statement.parent; const statements = ts.isBlock(container) || ts.isSourceFile(container) ? container.statements : null; - if (!statements) return false; + if (!statements) return null; const index = statements.indexOf(statement); const next = index >= 0 ? statements[index + 1] : undefined; - if (!next || !ts.isIfStatement(next)) return false; - let condition = next.expression; - while (ts.isParenthesizedExpression(condition)) condition = condition.expression; - if ( - !ts.isPrefixUnaryExpression(condition) || - condition.operator !== ts.SyntaxKind.ExclamationToken - ) - return false; - let operand = condition.operand; - while (ts.isParenthesizedExpression(operand)) operand = operand.expression; - return ( - ts.isIdentifier(operand) && - lowerer.resolveValueSymbol(operand) === lowerer.resolveValueSymbol(decl.name) - ); + if (!next || !ts.isIfStatement(next)) return null; + const binding = lowerer.resolveValueSymbol(decl.name); + const peel = (node: ts.Expression): ts.Expression => { + while (ts.isParenthesizedExpression(node)) node = node.expression; + return node; + }; + const isBinding = (node: ts.Expression): boolean => { + const operand = peel(node); + return ts.isIdentifier(operand) && lowerer.resolveValueSymbol(operand) === binding; + }; + const condition = peel(next.expression); + if (ts.isPrefixUnaryExpression(condition)) + return condition.operator === ts.SyntaxKind.ExclamationToken && isBinding(condition.operand) + ? "falsy" + : null; + if (!ts.isBinaryExpression(condition)) return null; + const op = condition.operatorToken.kind; + const strict = + op === ts.SyntaxKind.EqualsEqualsEqualsToken || + op === ts.SyntaxKind.ExclamationEqualsEqualsToken; + const loose = + op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken; + if (!strict && !loose) return null; + const isUndefined = (node: ts.Expression): boolean => { + const operand = peel(node); + if (ts.isVoidExpression(operand)) return true; + return ( + ts.isIdentifier(operand) && + operand.text === "undefined" && + (lowerer.typeOf(operand).flags & ts.TypeFlags.Undefined) !== 0 + ); + }; + const isNull = (node: ts.Expression): boolean => peel(node).kind === ts.SyntaxKind.NullKeyword; + const missing = (node: ts.Expression): boolean => isUndefined(node) || (loose && isNull(node)); + const isTypeofBinding = (node: ts.Expression): boolean => { + const operand = peel(node); + return ts.isTypeOfExpression(operand) && isBinding(operand.expression); + }; + const isUndefinedTag = (node: ts.Expression): boolean => { + const operand = peel(node); + return ts.isStringLiteralLike(operand) && operand.text === "undefined"; + }; + const { left, right } = condition; + return (isBinding(left) && missing(right)) || + (missing(left) && isBinding(right)) || + (isTypeofBinding(left) && isUndefinedTag(right)) || + (isUndefinedTag(left) && isTypeofBinding(right)) + ? "compare" + : null; } function falsyExitRuntimeOptionalLocals(lowerer: Lowerer, stmt: ts.IfStatement): IrLocal[] { diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 12deec7ad..aca306900 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -525,6 +525,7 @@ import { lowerForOf, lowerForStatement, matchGroupsPatternSource, + isGuardedRecordRead, } from "./lower-stmts.js"; import { type FieldTarget, @@ -3908,6 +3909,33 @@ export class Lowerer { } } + /** A file-scope get-or-create read (`let e = map[k]; if (e === + * undefined) ...` over an index-signature record) keeps a missing key as + * undefined (isGuardedRecordRead). Its pre-registered global takes the + * undefined arm before any body reads it; the declaration lowers its + * initializer as the matching absence probe. */ + analyzeGuardedRecordReadGlobals(parts: FileParts[]): void { + for (const { sf } of parts) { + for (const statement of sf.statements) { + if (!ts.isVariableStatement(statement)) continue; + for (const decl of statement.declarationList.declarations) { + if (!ts.isIdentifier(decl.name) || !isGuardedRecordRead(this, decl)) continue; + const global = this.globalOf(decl.name); + const symbol = this.resolveValueSymbol(decl.name); + if (!global || !symbol || global.tdz || this.runtimeOptionalBindingTypes.has(symbol)) + continue; + const widened = + global.type.kind === "union" + ? this.withUndefinedArmOf(global.type) + : this.withUndefinedArm(global.type); + if (!widened || typeEquals(widened, global.type)) continue; + global.type = widened; + this.runtimeOptionalBindingTypes.set(symbol, widened); + } + } + } + } + analyzeRuntimeOptionalArrayReads(parts: FileParts[]): void { const provenance = RuntimeOptionalProvenance.fromEnvironment(); // The site whose value the current promotion follows (debug only). @@ -6058,6 +6086,7 @@ export class Lowerer { this.collectProgram(parts); this.analyzeRuntimeOptionalArrayReads(parts); this.analyzeDateJsonResults(parts); + this.analyzeGuardedRecordReadGlobals(parts); // Decorated classes analyze AFTER the whole collection pass: a // decorator's return type may name a subclass declared below the // class, and reference lowering needs each class's rebindability @@ -6443,6 +6472,7 @@ export class Lowerer { this.collectProgram(parts); this.analyzeRuntimeOptionalArrayReads(parts); this.analyzeDateJsonResults(parts); + this.analyzeGuardedRecordReadGlobals(parts); // Decorated classes analyze post-collection here too: the %init seeds // lower the decoration calls, whose edges (decorator bodies, construct // thunks) reachable emit must see. diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6100-record-get-or-create.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6100-record-get-or-create.ts.json new file mode 100644 index 000000000..b7c18a8a4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6100-record-get-or-create.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6100-record-get-or-create.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6100-record-get-or-create.ts b/tests/corpus/6100-record-get-or-create.ts new file mode 100644 index 000000000..807cb303e --- /dev/null +++ b/tests/corpus/6100-record-get-or-create.ts @@ -0,0 +1,119 @@ +// Get-or-create over nested index-signature records without +// noUncheckedIndexedAccess: a missing key reads as undefined when the next +// statement tests the binding for absence, in every spelling of that test, +// at module scope and inside functions. A write with a computed key through +// a binding that may hold a missing element throws Node's TypeError after +// the key and the value evaluated. +type ExportMap = Record>; + +interface Target { + subpath: string; + condition: string; + target: string; +} + +function build(targets: Target[]): { exports: ExportMap; unmapped: string[] } { + const exports: ExportMap = {}; + const unmapped: string[] = []; + for (const t of targets) { + if (t.target === "") { + unmapped.push(t.subpath); + continue; + } + let entry = exports[t.subpath]; + if (entry === undefined) { + entry = {}; + exports[t.subpath] = entry; + } + entry[t.condition] = `./${t.target}`; + entry["types"] = `./${t.target}`; + } + return { exports: exports, unmapped: unmapped }; +} + +const result = build([ + { subpath: ".", condition: "import", target: "src/index.ts" }, + { subpath: ".", condition: "require", target: "src/index.ts" }, + { subpath: "./x", condition: "default", target: "" }, + { subpath: "./y", condition: "node", target: "src/y.ts" }, +]); +console.log(JSON.stringify(result.exports), result.unmapped.join(",")); + +function group(words: string[]): Record { + const byInitial: Record = {}; + for (const w of words) { + const k = w.slice(0, 1); + let list = byInitial[k]; + if (list == null) { + list = []; + byInitial[k] = list; + } + list.push(w); + } + return byInitial; +} +console.log(JSON.stringify(group(["apple", "avocado", "banana", "blueberry", "cherry"]))); + +function count(words: string[]): Record { + const counts: Record = {}; + for (const w of words) { + const n = counts[w]; + if (typeof n === "undefined") counts[w] = 1; + else counts[w] = n + 1; + } + return counts; +} +console.log(JSON.stringify(count(["a", "b", "a", "c", "a"]))); + +function lookup(table: Record, key: string): string { + const hit = table[key]; + if (hit !== undefined) return hit; + return `<${key} missing>`; +} +console.log(lookup({ a: "A" }, "a"), lookup({ a: "A" }, "b")); + +function rows(table: Record>, key: string, col: string): number { + const row = table[key]; + if (row != undefined) return row[col] ?? -1; + return -2; +} +console.log(rows({ r: { c: 3 } }, "r", "c"), rows({ r: { c: 3 } }, "r", "d"), rows({}, "x", "c")); + +// Module scope. +const nested: Record> = {}; +const key = process.argv.length > 99 ? "unused" : "k"; +let slot = nested[key]; +if (slot === undefined) { + slot = {}; + nested[key] = slot; +} +slot[key] = 1; +slot["fixed"] = 2; +console.log(JSON.stringify(nested)); + +const names: Record = { present: "yes" }; +const missing = names[key]; +if (!missing) console.log("falsy guard:", missing); +const present = names["present"]; +if (present === void 0) console.log("unreachable"); +else console.log("present:", present); + +// A write with a computed key through a binding that may hold a missing +// array element throws Node's TypeError naming the key, after evaluating +// the key and the value. +function probe(tables: Record[]): void { + const firstTable = tables[0]; + const lastTable = tables[5]; + const pick = (k: string): string => { + console.log("key", k); + return k; + }; + firstTable[pick("b")] = pick("second"); + console.log(JSON.stringify(firstTable)); + try { + lastTable[pick("c")] = pick("value"); + } catch (e) { + console.log((e as Error).name, (e as Error).message); + } +} +probe([{ a: "first" }]); From 95712ea5906d7eefafa973ec44ed2c783ef80ff6 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:32:52 -0700 Subject: [PATCH 20/47] Keep refused local classes out of speculative type queries Whole-program analyses that query types before reachability is known (the computed-key write census for JavaScript method dispatch, and the runtime-optional array analysis) can name a function-local class whose collection is refused. No statement owns that refusal there, so it escaped as an uncaught PoisonError from collectClassShapeInner and crashed the compiler (the ts-api-utils probe, @typescript-eslint/typescript-estree, and small TypeScript programs). These analyses now run under Lowerer.speculativeTypeQueries: a refused local class is unmappable for the query and its diagnostics are dropped, and the class's own declaration collects it again and reports them if the program reaches it. Collection and body lowering keep their poison handling. Co-Authored-By: Claude Opus 5.5 --- .../src/frontend/lowering/lower-classes.ts | 2 +- .../compiler/src/frontend/lowering/lowerer.ts | 62 ++++++++++++++++--- .../6102-local-class-type-query.js.json | 6 ++ .../local-class-type-query-brand.ts.json | 6 ++ .../local-class-type-query.ts.json | 6 ++ tests/corpus/6102-local-class-type-query.js | 42 +++++++++++++ .../local-class-type-query-brand.ts | 14 +++++ tests/diagnostics/local-class-type-query.ts | 14 +++++ .../local-class-type-query-brand.ts.txt | 6 ++ .../local-class-type-query.ts.txt | 6 ++ 10 files changed, 156 insertions(+), 8 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6102-local-class-type-query.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query-brand.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query.ts.json create mode 100644 tests/corpus/6102-local-class-type-query.js create mode 100644 tests/diagnostics/local-class-type-query-brand.ts create mode 100644 tests/diagnostics/local-class-type-query.ts create mode 100644 tests/harness/__snapshots__/local-class-type-query-brand.ts.txt create mode 100644 tests/harness/__snapshots__/local-class-type-query.ts.txt diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 06739166c..bfb7e06b8 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -6385,7 +6385,7 @@ export function collectInheritedJsFieldWrites( * hierarchy identifies the original declarations through aliases as well. */ export function collectVirtualJsMethods(lowerer: Lowerer, files: readonly ts.SourceFile[]): void { const families: [ts.MethodDeclaration, ts.MethodDeclaration][] = []; - collectClassMethodMutations(lowerer, files); + lowerer.speculativeTypeQueries(() => collectClassMethodMutations(lowerer, files)); const visit = (node: ts.Node): void => { if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) { const accessors = node.members.filter( diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index aca306900..147a6232b 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -2825,7 +2825,8 @@ export class Lowerer { return null; } const className = this.classNamer(decl); - if (!this.collectingExprClasses.has(decl)) this.lowerClassExpressionInfo(decl); + if (!this.collectingExprClasses.has(decl) && !this.collectLocalClassForType(decl)) + return null; return { kind: "object", className }; }, mixinIntersectionInstance: (widened) => mixinIntersectionInstanceType(this, widened), @@ -6084,9 +6085,11 @@ export class Lowerer { for (const fp of parts) this.checker.prefetchSourceFile(fp.sf); } this.collectProgram(parts); - this.analyzeRuntimeOptionalArrayReads(parts); - this.analyzeDateJsonResults(parts); - this.analyzeGuardedRecordReadGlobals(parts); + this.speculativeTypeQueries(() => { + this.analyzeRuntimeOptionalArrayReads(parts); + this.analyzeDateJsonResults(parts); + this.analyzeGuardedRecordReadGlobals(parts); + }); // Decorated classes analyze AFTER the whole collection pass: a // decorator's return type may name a subclass declared below the // class, and reference lowering needs each class's rebindability @@ -6470,9 +6473,11 @@ export class Lowerer { collectionEdges.add(name); }; this.collectProgram(parts); - this.analyzeRuntimeOptionalArrayReads(parts); - this.analyzeDateJsonResults(parts); - this.analyzeGuardedRecordReadGlobals(parts); + this.speculativeTypeQueries(() => { + this.analyzeRuntimeOptionalArrayReads(parts); + this.analyzeDateJsonResults(parts); + this.analyzeGuardedRecordReadGlobals(parts); + }); // Decorated classes analyze post-collection here too: the %init seeds // lower the decoration calls, whose edges (decorator bodies, construct // thunks) reachable emit must see. @@ -9615,6 +9620,49 @@ export class Lowerer { return lowerClassExpressionInfo(this, expr); } + /** Depth of the whole-program analyses that query types across every + * file before reachability is known (speculativeTypeQueries). */ + private speculativeTypeQueryDepth = 0; + + /** Runs a whole-program analysis whose type queries are speculative: they + * visit every file, reached or not, and no statement or declaration owns + * a refusal they trigger (collectLocalClassForType). */ + speculativeTypeQueries(analysis: () => void): void { + this.speculativeTypeQueryDepth++; + try { + analysis(); + } finally { + this.speculativeTypeQueryDepth--; + } + } + + /** Collects a function-local class because a type query named its + * instance type. Collection and body lowering own a refusal of that + * class: the poison reaches the declaration or statement that asked, as + * before. A speculative whole-program analysis owns none, so there the + * class is unmappable for the query and its diagnostics are dropped; + * lowering the class's own declaration collects it again and reports + * them if the program reaches it. */ + collectLocalClassForType(decl: ts.ClassLikeDeclaration): boolean { + if (this.speculativeTypeQueryDepth === 0 || this.fnStack.length > 0) { + this.lowerClassExpressionInfo(decl); + return true; + } + const sink: ScrDiagnostic[] = []; + const previousSink = this.diagSink; + this.diagSink = sink; + try { + this.lowerClassExpressionInfo(decl); + } catch (e) { + if (e instanceof PoisonError) return false; + throw e; + } finally { + this.diagSink = previousSink; + } + for (const d of sink) this.pushDiag(d); + return true; + } + lowerClassExpression(expr: ts.ClassLikeDeclaration): IrExpr { return lowerClassExpression(this, expr); } diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6102-local-class-type-query.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6102-local-class-type-query.js.json new file mode 100644 index 000000000..86c6ba9e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6102-local-class-type-query.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6102-local-class-type-query.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query-brand.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query-brand.ts.json new file mode 100644 index 000000000..e17ea3bf5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query-brand.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/local-class-type-query-brand.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query.ts.json new file mode 100644 index 000000000..3c89fba9f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/local-class-type-query.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6102-local-class-type-query.js b/tests/corpus/6102-local-class-type-query.js new file mode 100644 index 000000000..92fe35725 --- /dev/null +++ b/tests/corpus/6102-local-class-type-query.js @@ -0,0 +1,42 @@ +// A whole-program analysis that queries types before reachability is known +// (the computed-key write census here) can name a function-local class whose +// collection is refused. That query has no owner for the refusal: the class +// stays unmapped for it, and the refusal belongs to the class's own +// declaration, which this program never executes (it used to crash the +// compiler with an uncaught PoisonError). +function main(run) { + if (!run) return "skipped"; + const Project = class { + constructor() { + this.name = "p"; + } + close() { + if (this.missingFilesMap) { + this.missingFilesMap.clear(); + this.missingFilesMap = void 0; + } + } + add(k) { + (this.missingFilesMap || (this.missingFilesMap = new Map())).set(k, 1); + } + }; + const holder = { p: new Project() }; + const key = String(run); + holder.p[key] = "q"; + return holder.p.name; +} + +class Counter { + constructor() { + this.counts = {}; + } + bump(key) { + this.counts[key] = (this.counts[key] || 0) + 1; + return this.counts[key]; + } +} + +const counter = new Counter(); +const word = process.argv.length > 99 ? "unused" : "word"; +counter.bump(word); +console.log(main(0), counter.bump(word)); diff --git a/tests/diagnostics/local-class-type-query-brand.ts b/tests/diagnostics/local-class-type-query-brand.ts new file mode 100644 index 000000000..566304627 --- /dev/null +++ b/tests/diagnostics/local-class-type-query-brand.ts @@ -0,0 +1,14 @@ +// The same speculative element-type query, reaching a function-local class +// with a private brand through the function's returned array. +function make() { + class Box { + #v = 1; + read(): number { + return this.#v; + } + } + return [new Box()]; +} +const xs = make(); +const x = xs[0]; +console.log(x === undefined ? -1 : x.read()); diff --git a/tests/diagnostics/local-class-type-query.ts b/tests/diagnostics/local-class-type-query.ts new file mode 100644 index 000000000..217653ff2 --- /dev/null +++ b/tests/diagnostics/local-class-type-query.ts @@ -0,0 +1,14 @@ +// A whole-program analysis queries the element type of `items` before any +// body lowers. The function-local class it names is refused: the refusal is +// reported once, at the class (it used to crash the compiler with an uncaught +// PoisonError). +function make() { + class Box { + static count = 0; + v = 1; + } + return new Box(); +} +const items = [make()]; +const first = items[0]; +console.log(first ? first.v : 0); diff --git a/tests/harness/__snapshots__/local-class-type-query-brand.ts.txt b/tests/harness/__snapshots__/local-class-type-query-brand.ts.txt new file mode 100644 index 000000000..6db3418a8 --- /dev/null +++ b/tests/harness/__snapshots__/local-class-type-query-brand.ts.txt @@ -0,0 +1,6 @@ +local-class-type-query-brand.ts:4:3 - error SC1090: function-local classes with private brands are not supported yet + + 3 | function make() { + 4 | class Box { + | ^~~~~~~~~~~ + 5 | #v = 1; \ No newline at end of file diff --git a/tests/harness/__snapshots__/local-class-type-query.ts.txt b/tests/harness/__snapshots__/local-class-type-query.ts.txt new file mode 100644 index 000000000..87489fcd5 --- /dev/null +++ b/tests/harness/__snapshots__/local-class-type-query.ts.txt @@ -0,0 +1,6 @@ +local-class-type-query.ts:6:3 - error SC1090: function-local classes with statics, decorators, or generic members are not supported yet + + 5 | function make() { + 6 | class Box { + | ^~~~~~~~~~~ + 7 | static count = 0; \ No newline at end of file From 15096a47ed9ebdfda61983675dcdc4f623784dcb Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:32:58 -0700 Subject: [PATCH 21/47] Answer typeof on builtin import bindings by the export's kind `const { inspect } = require("util"); typeof inspect` printed "string", as did `import { inspect } from "node:util"` in an ES module and `typeof promises` from `fs`. JavaScript sources represent builtin values without their own lowering as identity tokens (strings), and typeof answered from that representation. typeof on a builtin import binding in a JavaScript source now answers "function" for exported functions and classes and "object" for exported objects; the binding read has no effects. TypeScript sources compile as before. Co-Authored-By: Claude Opus 5.5 --- .../src/frontend/lowering/lower-exprs.ts | 24 +++++++++++++++++++ .../6103-typeof-builtin-bindings.cjs.json | 6 +++++ .../6104-typeof-builtin-bindings.mjs.json | 6 +++++ tests/corpus/6103-typeof-builtin-bindings.cjs | 15 ++++++++++++ tests/corpus/6104-typeof-builtin-bindings.mjs | 11 +++++++++ 5 files changed, 62 insertions(+) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6103-typeof-builtin-bindings.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6104-typeof-builtin-bindings.mjs.json create mode 100644 tests/corpus/6103-typeof-builtin-bindings.cjs create mode 100644 tests/corpus/6104-typeof-builtin-bindings.mjs diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index 5f5bc3ff3..3062ff06b 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -678,6 +678,30 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { if (!sym) { return { kind: "strLit", value: "undefined", type: STRING, loc }; } + // `const { inspect } = require("util")` / `import { inspect } from + // "node:util"`: a binding of a builtin module's exported function, + // class or object. JavaScript sources represent such a value without + // its own lowering as an identity token (a string), so the operand's + // representation cannot answer. Node's answer follows the export's + // kind, and the binding read has no effects. + const imported = isJsSourceFile(tested.getSourceFile()) + ? lowerer.builtinImportOf(tested) + : null; + if ( + imported && + builtinModuleConstOf(lowerer, imported.module, imported.member) === undefined + ) { + const t = lowerer.typeOf(tested); + if ( + lowerer.checker.getCallSignatures(t).length > 0 || + lowerer.checker.getConstructSignatures(t).length > 0 + ) { + return { kind: "strLit", value: "function", type: STRING, loc }; + } + if ((t.flags & ts.TypeFlags.Object) !== 0) { + return { kind: "strLit", value: "object", type: STRING, loc }; + } + } if (lowerer.isStdlibSymbol(sym)) { const t = lowerer.typeOf(expr.expression); if ( diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6103-typeof-builtin-bindings.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6103-typeof-builtin-bindings.cjs.json new file mode 100644 index 000000000..008914d85 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6103-typeof-builtin-bindings.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6103-typeof-builtin-bindings.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6104-typeof-builtin-bindings.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6104-typeof-builtin-bindings.mjs.json new file mode 100644 index 000000000..b6a8a48e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6104-typeof-builtin-bindings.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6104-typeof-builtin-bindings.mjs" + ], + "diags": [] +} diff --git a/tests/corpus/6103-typeof-builtin-bindings.cjs b/tests/corpus/6103-typeof-builtin-bindings.cjs new file mode 100644 index 000000000..ecef94dd3 --- /dev/null +++ b/tests/corpus/6103-typeof-builtin-bindings.cjs @@ -0,0 +1,15 @@ +// typeof on bindings destructured from Node builtin modules: Node answers by +// the export's kind ("function" for functions and classes, "object" for +// namespace objects), never by how the binding is represented. +const { inspect, format, promisify, deprecate, isDeepStrictEqual } = require("util"); +const { join, resolve } = require("path"); +const { readFileSync, promises } = require("fs"); +const { EventEmitter } = require("events"); +const { createHash } = require("crypto"); +const util = require("node:util"); +const { inspect: aliased } = util; +console.log(typeof inspect, typeof format, typeof promisify, typeof deprecate, typeof isDeepStrictEqual); +console.log(typeof join, typeof resolve, typeof readFileSync, typeof promises); +console.log(typeof EventEmitter, typeof createHash, typeof aliased, typeof util.inspect); +console.log(typeof inspect === "function" ? "callable" : "not callable"); +console.log(join("a", "b"), format("%s=%d", "x", 1), inspect({ a: [1, 2] })); diff --git a/tests/corpus/6104-typeof-builtin-bindings.mjs b/tests/corpus/6104-typeof-builtin-bindings.mjs new file mode 100644 index 000000000..dd2976775 --- /dev/null +++ b/tests/corpus/6104-typeof-builtin-bindings.mjs @@ -0,0 +1,11 @@ +// typeof on named, default-destructured and namespace-destructured builtin +// bindings in an ES module: Node answers by the export's kind. +import util, { inspect as namedInspect, format } from "node:util"; +import * as path from "node:path"; +import { createHash } from "node:crypto"; +import { promises } from "node:fs"; +const { inspect, promisify } = util; +const { join } = path; +console.log(typeof inspect, typeof promisify, typeof namedInspect, typeof format); +console.log(typeof join, typeof createHash, typeof util.inspect, typeof promises); +console.log(namedInspect("s"), format("%d", 2), join("x", "y")); From 5a6efaf01049ca33d8ab46604e7b1b279ca604ab Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:33:04 -0700 Subject: [PATCH 22/47] Bind top-level this in CommonJS modules to the module's exports object Top-level `this` in a CommonJS JavaScript file, also inside top-level arrow functions, read as undefined; Node binds it to the module's original exports object. It is now a per-module object created when the module starts: typeof, truthiness, identity and passing it along (the UMD wrapper `(function (root) { ... })(this)`, CoffeeScript's `.call(this)`) behave as in Node. Exports stay the static export table, so a property access through top-level `this` is a named refusal rather than a write no requirer would see. ES modules keep undefined. The UMD host test `typeof module !== "undefined" && module.exports` read `module.exports` through the module handle as undefined inside functions, so such modules took the non-CommonJS branch (this is what broke ipaddr.js). `module.exports` used only for its truthiness now answers true when every `module.exports =` in the file assigns an object or function. Co-Authored-By: Claude Opus 5.5 --- .../src/frontend/lowering/lower-exprs.ts | 4 + .../src/frontend/lowering/lower-modules.ts | 11 ++ .../frontend/lowering/lower-node-module.ts | 134 +++++++++++++++++- .../compiler/src/frontend/lowering/lowerer.ts | 15 +- .../6105-cjs-top-level-this/main.js.json | 7 + .../corpus/6106-esm-top-level-this.mjs.json | 6 + tests/corpus/6105-cjs-top-level-this/lib.js | 11 ++ tests/corpus/6105-cjs-top-level-this/main.js | 12 ++ .../6105-cjs-top-level-this/package.json | 1 + tests/corpus/6106-esm-top-level-this.mjs | 4 + 10 files changed, 203 insertions(+), 2 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6105-cjs-top-level-this/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6106-esm-top-level-this.mjs.json create mode 100644 tests/corpus/6105-cjs-top-level-this/lib.js create mode 100644 tests/corpus/6105-cjs-top-level-this/main.js create mode 100644 tests/corpus/6105-cjs-top-level-this/package.json create mode 100644 tests/corpus/6106-esm-top-level-this.mjs diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index 3062ff06b..6dc85f251 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -195,6 +195,7 @@ import { tryLowerExpression } from "./expressions/try-lower-expression.js"; import { fenceNodeModuleMutation, isNodeModuleValue, + lowerCjsTopLevelThis, lowerNodeModuleIdentifier, lowerNodeModuleProperty, lowerRequireCacheElement, @@ -1648,6 +1649,9 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { // constant. TypeScript keeps the fence (noImplicitThis makes it a // compile-time story there). if (isJsSourceFile(expr.getSourceFile())) { + // Module scope of a CommonJS file: `this` is module.exports. + const exportsThis = lowerCjsTopLevelThis(lowerer, expr); + if (exportsThis) return exportsThis; return { kind: "libCall", fn: "dyn.this", args: [], type: DYN, loc }; } lowerer.unsupported("SC1080", expr); diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index d18c4f547..7ff595117 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -2656,6 +2656,17 @@ export function lowerFileInit( loc: loc0, }); } + // Top-level `this` of a CommonJS module: its object exists before the + // module's first statement (lowerCjsTopLevelThis). + const exportsThis = lowerer.cjsExportsThis.get(sf); + if (exportsThis) { + header.push({ + kind: "assign", + localId: exportsThis.id, + value: { kind: "dynObjLit", fields: [], type: DYN, loc: loc0 }, + loc: loc0, + }); + } for (const { stmt, dep } of orderedImportsOf(lowerer.program, sf)) { const npm = lowerer.npmInitActions.get(sf)?.get(stmt); if (npm !== undefined && npm.length > 0) { diff --git a/packages/compiler/src/frontend/lowering/lower-node-module.ts b/packages/compiler/src/frontend/lowering/lower-node-module.ts index ad3f86dee..c15749601 100644 --- a/packages/compiler/src/frontend/lowering/lower-node-module.ts +++ b/packages/compiler/src/frontend/lowering/lower-node-module.ts @@ -8,10 +8,11 @@ import * as win32 from "node:path/win32"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import type { FileParts } from "./lower-modules.js"; -import { isNodeEsmFile, locOf } from "../program.js"; +import { isCjsJsFile, isNodeEsmFile, locOf } from "../program.js"; import { runtimePathForTarget } from "../runtime-resolve.js"; import { BOOL, + DYN, F64, type IrExpr, type IrStmt, @@ -224,6 +225,135 @@ function nodeModuleType(lowerer: Lowerer, node: ts.Expression): boolean { return rendered === "ScriptcModule" || rendered === "NodeModule" || rendered === "NodeJS.Module"; } +/** `module.exports` used only for its truthiness (the UMD test `typeof + * module !== "undefined" && module.exports`): the exports object starts as + * a fresh object, so it stays truthy unless the module replaces it with a + * value that can be falsy. True when every `module.exports = value` in the + * file assigns an object or function. */ +function moduleExportsAlwaysTruthy(lowerer: Lowerer, expr: ts.PropertyAccessExpression): boolean { + if (!truthinessOnly(expr)) return false; + const sf = expr.getSourceFile(); + if (isNodeEsmFile(sf, lowerer.program)) return false; + let truthy = true; + ts.walkPreorder(sf, (node) => { + if ( + !ts.isBinaryExpression(node) || + node.operatorToken.kind < ts.SyntaxKind.FirstAssignment || + node.operatorToken.kind > ts.SyntaxKind.LastAssignment + ) + return undefined; + let target = node.left; + while (ts.isParenthesizedExpression(target)) target = target.expression; + if ( + !ts.isPropertyAccessExpression(target) || + target.name.text !== "exports" || + !isCjsModuleGlobal(lowerer, target.expression) + ) + return undefined; + const type = lowerer.typeOf(node.right); + const objectLike = (t: ts.Type): boolean => + t.isUnionType() + ? ts.constituentTypes(t).every(objectLike) + : (t.flags & ts.TypeFlags.Object) !== 0 || (t.flags & ts.TypeFlags.NonPrimitive) !== 0; + if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !objectLike(type)) { + truthy = false; + return "stop"; + } + return undefined; + }); + return truthy; +} + +/** Whether only the truthiness of `node` can be observed: a condition, a + * `!` operand, or a `&&`/`||` operand of an expression that is itself used + * only for its truthiness. */ +function truthinessOnly(node: ts.Expression): boolean { + let child: ts.Node = node; + for (let parent = node.parent; ; child = parent, parent = parent.parent) { + if (ts.isParenthesizedExpression(parent)) continue; + if (ts.isPrefixUnaryExpression(parent)) + return parent.operator === ts.SyntaxKind.ExclamationToken; + if ( + ts.isBinaryExpression(parent) && + (parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || + parent.operatorToken.kind === ts.SyntaxKind.BarBarToken) + ) + continue; + if (ts.isIfStatement(parent) || ts.isWhileStatement(parent) || ts.isDoStatement(parent)) + return parent.expression === child; + if (ts.isForStatement(parent)) return parent.condition === child; + if (ts.isConditionalExpression(parent)) return parent.condition === child; + return false; + } +} + +/** `this` at the top level of a CommonJS module (directly, or inside + * arrow functions there): Node calls the module wrapper with `this` bound + * to the module's original exports object. */ +export function isCjsTopLevelThis(lowerer: Lowerer, node: ts.Node): boolean { + if (node.kind !== ts.SyntaxKind.ThisKeyword) return false; + for (let p: ts.Node | undefined = node.parent; p && !ts.isSourceFile(p); p = p.parent) { + if (ts.isArrowFunction(p)) continue; + if ( + ts.isFunctionLike(p) || + ts.isClassDeclaration(p) || + ts.isClassExpression(p) || + ts.isClassStaticBlockDeclaration(p) + ) + return false; + } + return isCjsJsFile(node.getSourceFile(), lowerer.program); +} + +export function usesCjsTopLevelThis(lowerer: Lowerer, sf: ts.SourceFile): boolean { + if (!isCjsJsFile(sf, lowerer.program)) return false; + let found = false; + ts.walkPreorder(sf, (node) => { + if ( + node !== sf && + !ts.isArrowFunction(node) && + (ts.isFunctionLike(node) || + ts.isClassDeclaration(node) || + ts.isClassExpression(node) || + ts.isClassStaticBlockDeclaration(node)) + ) + return "skip"; + if (node.kind === ts.SyntaxKind.ThisKeyword) { + found = true; + return "stop"; + } + return undefined; + }); + return found; +} + +/** The value of top-level `this` in a CommonJS module: the module's own + * object standing for its original exports, created when the module starts + * (lowerFileInit). Exports themselves are the static export table, so a + * property access through `this` would read or write an object no requirer + * sees; it keeps a named refusal instead. Typeof, truthiness, identity and + * passing the value along (the UMD wrapper `(function (root) { ... })(this)`) + * behave as in Node. */ +export function lowerCjsTopLevelThis(lowerer: Lowerer, expr: ts.Expression): IrExpr | null { + if (!isCjsTopLevelThis(lowerer, expr)) return null; + const global = lowerer.cjsExportsThis.get(expr.getSourceFile()); + if (!global) return null; + let receiver: ts.Node = expr; + while (ts.isParenthesizedExpression(receiver.parent)) receiver = receiver.parent; + const access = receiver.parent; + if ( + (ts.isPropertyAccessExpression(access) || ts.isElementAccessExpression(access)) && + access.expression === receiver + ) { + lowerer.unsupported( + "SC1090", + access, + "property access through top-level 'this' in a CommonJS module (it is module.exports; spell exports.)", + ); + } + return varRef(global.id, DYN, locOf(expr)); +} + function optionalModule( lowerer: Lowerer, node: ts.Expression, @@ -309,6 +439,8 @@ export function lowerNodeModuleProperty( if (!direct && !nodeModuleType(lowerer, expr.expression)) return null; if (expr.questionDotToken) return null; const member = expr.name.text; + if (member === "exports" && direct && moduleExportsAlwaysTruthy(lowerer, expr)) + return boolLit(true, locOf(expr)); if (member === "exports" || member === "require") return null; let moduleRef = direct ? cjsModuleRef(lowerer, expr.expression) diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 147a6232b..e4736fe2f 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -264,7 +264,7 @@ import { appendForkModules, appendWorkerModules, } from "./lower-modules.js"; -import { prepareCjsModuleGraph } from "./lower-node-module.js"; +import { prepareCjsModuleGraph, usesCjsTopLevelThis } from "./lower-node-module.js"; import { registerBuiltinEventTargetClasses } from "./lower-event-target.js"; import { type ClassInfo, @@ -1845,6 +1845,9 @@ export class Lowerer { * carry undefined at runtime. Identifier reads keep the union tag so * typeof and later boundaries observe the real value. */ readonly runtimeOptionalGlobals = new Set(); + /** Per CommonJS file using top-level `this`: the global holding the + * object that stands for its original exports (lowerCjsTopLevelThis). */ + readonly cjsExportsThis = new Map(); /** Bindings whose unchecked string arithmetic can produce either a number * (NaN for an absent read) or a string. Preserve that result union at bare * reads instead of applying the checker-bare string narrowing adapter. */ @@ -3656,6 +3659,16 @@ export class Lowerer { const id = `%g.${tag}%loaded`; this.moduleGuardOf.set(fp.sf, id); this.globalsList.push({ id, name: "%loaded", type: BOOL, mutable: true }); + if (usesCjsTopLevelThis(this, fp.sf)) { + const exportsThis: IrGlobal = { + id: `%g.${tag}%exportsThis`, + name: "%exportsThis", + type: DYN, + mutable: true, + }; + this.globalsList.push(exportsThis); + this.cjsExportsThis.set(fp.sf, exportsThis); + } } // A module is intrinsically async when an await/for-await occurs diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6105-cjs-top-level-this/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6105-cjs-top-level-this/main.js.json new file mode 100644 index 000000000..ef768b4ce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6105-cjs-top-level-this/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/6105-cjs-top-level-this/lib.js", + "/tests/corpus/6105-cjs-top-level-this/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6106-esm-top-level-this.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6106-esm-top-level-this.mjs.json new file mode 100644 index 000000000..ad427bd7f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6106-esm-top-level-this.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6106-esm-top-level-this.mjs" + ], + "diags": [] +} diff --git a/tests/corpus/6105-cjs-top-level-this/lib.js b/tests/corpus/6105-cjs-top-level-this/lib.js new file mode 100644 index 000000000..7addc1840 --- /dev/null +++ b/tests/corpus/6105-cjs-top-level-this/lib.js @@ -0,0 +1,11 @@ +// A required CommonJS module sees its own exports object as `this`, and the +// UMD test for a CommonJS host takes the module.exports branch. +const kind = typeof this; +let host = "global"; +if (typeof module !== "undefined" && module.exports) host = "commonjs"; +(function (root) { + console.log("lib wrapper root:", typeof root, root ? "truthy" : "falsy"); +})(this); +exports.describe = function () { + return kind + " " + host; +}; diff --git a/tests/corpus/6105-cjs-top-level-this/main.js b/tests/corpus/6105-cjs-top-level-this/main.js new file mode 100644 index 000000000..1da910171 --- /dev/null +++ b/tests/corpus/6105-cjs-top-level-this/main.js @@ -0,0 +1,12 @@ +// Top-level `this` in a CommonJS module is module.exports (an object), also +// inside arrow functions at module scope. +const lib = require("./lib.js"); +const self = this; +const arrow = () => this; +console.log(typeof this, self === this, arrow() === this, this ? "truthy" : "falsy"); +console.log(lib.describe()); +(function () { + console.log("call(this):", typeof this); +}).call(this); +if ((typeof module !== "undefined" && module !== null) && module.exports) console.log("commonjs host"); +else console.log("browser host"); diff --git a/tests/corpus/6105-cjs-top-level-this/package.json b/tests/corpus/6105-cjs-top-level-this/package.json new file mode 100644 index 000000000..a3c15a7a6 --- /dev/null +++ b/tests/corpus/6105-cjs-top-level-this/package.json @@ -0,0 +1 @@ +{ "type": "commonjs" } diff --git a/tests/corpus/6106-esm-top-level-this.mjs b/tests/corpus/6106-esm-top-level-this.mjs new file mode 100644 index 000000000..6079ecc1e --- /dev/null +++ b/tests/corpus/6106-esm-top-level-this.mjs @@ -0,0 +1,4 @@ +// Top-level `this` in an ES module stays undefined, also inside arrow +// functions at module scope. +const arrow = () => this; +console.log(typeof this, this === undefined, typeof arrow()); From 4128e6f6f5feccdc738c0d70097c68a433aa2bb1 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:46:38 -0700 Subject: [PATCH 23/47] 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 1090c05dfe6be947af2e821f74e17ab16d872da9 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 08:57:56 -0700 Subject: [PATCH 24/47] Compile chalk 5 through the dynamic object model chalk's callable builder (a function whose prototype chain is set with Object.setPrototypeOf, with style getters from Object.defineProperties) already ran on the checked-dynamic model. What failed was the code around it. Each fix is general and sits on a path that used to end in a refusal or a runtime fence, or is confined to JavaScript files: - package.json "imports" inside a --npm-static package resolve to the shipped JS with the "node" condition hoisted, like the tsgo fs shadow; - JavaScript object literals that the file reshapes at run time (keyed writes with runtime keys, delete, Object.defineProperty/ies) map to the checked-dynamic type, with the literals nested in them; - a JavaScript class whose only member is a constructor that returns a value and never reads `this` answers that value from `new` (the return used to be discarded silently); - `const { env } = process` binds the data member in JavaScript; - `o && x` / `o || x` with an always-truthy object, array or function left operand; - Number.parseInt/parseFloat over checked-dynamic values apply ToString; - Function.prototype as a value is one compiler-emitted function; - calls of String.prototype-only names (bold, italics, ...) on untyped receivers call the receiver's own or inherited member; a string receiver throws the refusal at run time. Programs without these patterns compile to identical bytes: the runtime benchmark workloads, the self-hosted compiler (LLVM and executable) and the TypeScript corpus IR were compared against the baseline. Co-Authored-By: Claude Opus 5.5 --- .../src/frontend/lowering/builtins/numbers.ts | 18 +- .../src/frontend/lowering/builtins/process.ts | 35 ++ .../lowering/js-dynamic-objects.test.ts | 38 ++ .../frontend/lowering/js-dynamic-objects.ts | 312 +++++++++++++++++ .../src/frontend/lowering/lower-calls.ts | 57 ++- .../src/frontend/lowering/lower-classes.ts | 3 + .../src/frontend/lowering/lower-exprs.ts | 56 +++ .../src/frontend/lowering/lower-stmts.ts | 33 +- .../compiler/src/frontend/lowering/lowerer.ts | 3 + packages/compiler/src/frontend/npm-static.ts | 4 + .../compiler/src/frontend/resolve.test.ts | 54 +++ packages/compiler/src/frontend/resolve.ts | 12 + packages/compiler/src/frontend/type-mapper.ts | 14 + .../main.ts.json | 7 + .../tests/corpus/js-callable-builder.js.json | 6 + .../js-class-constructor-returns/main.ts.json | 7 + .../js-function-prototype-value.js.json | 6 + .../corpus/js-number-parse-dynamic.js.json | 6 + .../corpus/js-process-destructure.mjs.json | 6 + .../corpus/js-reshaped-object-literal.js.json | 6 + .../corpus/truthy-object-logical.ts.json | 6 + .../fixtures/npm/cases/chalk5/main.ts.json | 6 + .../js-builder-string-method-names/builder.js | 22 ++ .../js-builder-string-method-names/main.ts | 14 + tests/corpus/js-callable-builder.js | 110 ++++++ .../js-class-constructor-returns/factory.js | 35 ++ .../js-class-constructor-returns/main.ts | 11 + tests/corpus/js-function-prototype-value.js | 17 + tests/corpus/js-number-parse-dynamic.js | 8 + tests/corpus/js-process-destructure.mjs | 12 + tests/corpus/js-reshaped-object-literal.js | 42 +++ tests/corpus/truthy-object-logical.ts | 31 ++ tests/fixtures/npm/cases/chalk5/main.ts | 64 ++++ .../cases/chalk5/node_modules/chalk/license | 9 + .../chalk5/node_modules/chalk/package.json | 83 +++++ .../node_modules/chalk/source/index.d.ts | 325 ++++++++++++++++++ .../chalk5/node_modules/chalk/source/index.js | 225 ++++++++++++ .../node_modules/chalk/source/utilities.js | 33 ++ .../source/vendor/ansi-styles/index.d.ts | 236 +++++++++++++ .../chalk/source/vendor/ansi-styles/index.js | 223 ++++++++++++ .../source/vendor/supports-color/browser.d.ts | 1 + .../source/vendor/supports-color/browser.js | 34 ++ .../source/vendor/supports-color/index.d.ts | 55 +++ .../source/vendor/supports-color/index.js | 190 ++++++++++ tests/fixtures/npm/cases/chalk5/package.json | 1 + tests/harness/chalk.test.ts | 97 ++++++ 46 files changed, 2569 insertions(+), 4 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/js-dynamic-objects.test.ts create mode 100644 packages/compiler/src/frontend/lowering/js-dynamic-objects.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-builder-string-method-names/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-builder.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-constructor-returns/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-function-prototype-value.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-number-parse-dynamic.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-process-destructure.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reshaped-object-literal.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/truthy-object-logical.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json create mode 100644 tests/corpus/js-builder-string-method-names/builder.js create mode 100644 tests/corpus/js-builder-string-method-names/main.ts create mode 100644 tests/corpus/js-callable-builder.js create mode 100644 tests/corpus/js-class-constructor-returns/factory.js create mode 100644 tests/corpus/js-class-constructor-returns/main.ts create mode 100644 tests/corpus/js-function-prototype-value.js create mode 100644 tests/corpus/js-number-parse-dynamic.js create mode 100644 tests/corpus/js-process-destructure.mjs create mode 100644 tests/corpus/js-reshaped-object-literal.js create mode 100644 tests/corpus/truthy-object-logical.ts create mode 100644 tests/fixtures/npm/cases/chalk5/main.ts create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/license create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/package.json create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.d.ts create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.js create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/utilities.js create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.d.ts create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.js create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.d.ts create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.js create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.d.ts create mode 100644 tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.js create mode 100644 tests/fixtures/npm/cases/chalk5/package.json create mode 100644 tests/harness/chalk.test.ts diff --git a/packages/compiler/src/frontend/lowering/builtins/numbers.ts b/packages/compiler/src/frontend/lowering/builtins/numbers.ts index 08d6cb349..4f86e6f74 100644 --- a/packages/compiler/src/frontend/lowering/builtins/numbers.ts +++ b/packages/compiler/src/frontend/lowering/builtins/numbers.ts @@ -2,7 +2,7 @@ import * as ts from "../../ts7/adapter.js"; import { type Lowerer, own } from "../lowerer.js"; import { lowerCheckedPredicateValue } from "../lower-builtin-values.js"; import { locOf } from "../../program.js"; -import { BOOL, F64, type IrExpr, type IrLibFn } from "../../../ir/ir.js"; +import { BOOL, F64, STRING, type IrExpr, type IrLibFn } from "../../../ir/ir.js"; import { lowerBuiltinValuePreservingUndefined, lowerOptionalNumberPredicate } from "./arguments.js"; import { tryLowerExpression } from "../expressions/try-lower-expression.js"; import { lowerStaticNumberGlobal } from "../lower-calls.js"; @@ -88,6 +88,22 @@ export function lowerNumberStaticCall( const parsed = lowerStaticNumberGlobal(lowerer, member, call, call.arguments, loc); if (parsed !== null) return parsed; } + // A checked-dynamic argument (`Number.parseInt(env.FORCE_COLOR, 10)` + // over a JavaScript dictionary read): the parsers' own ToString, + // exactly the global parseFloat's dyn form. + if (probed?.type.kind === "dyn") { + const text: IrExpr = { + kind: "libCall", + fn: "dyn.toStringCoerce", + args: [probed], + type: STRING, + loc, + }; + if (member === "parseFloat") + return { kind: "libCall", fn: "num.parseFloat", args: [text], type: F64, loc }; + const radix = lowerer.lowerExprExpecting(call.arguments[1]!, F64); + return { kind: "libCall", fn: "num.parseInt", args: [text, radix], type: F64, loc }; + } const argText = probed !== null ? lowerer.fmt(probed.type) diff --git a/packages/compiler/src/frontend/lowering/builtins/process.ts b/packages/compiler/src/frontend/lowering/builtins/process.ts index 97bf1e963..94c2cdba7 100644 --- a/packages/compiler/src/frontend/lowering/builtins/process.ts +++ b/packages/compiler/src/frontend/lowering/builtins/process.ts @@ -233,6 +233,41 @@ export function lowerProcessStreamProperty( * read in source order). Method members referenced without a call are * rejected specifically. Null for non-process receivers (the chain keeps * trying other property lowerings). */ +/** The value of a DATA member of the process global taken off by + * destructuring (`const { env, argv } = process` in JavaScript, the + * supports-color opening): the same values the spelled `process.env` / + * `process.argv` reads produce, typed by the binding. Null for members + * this does not cover (methods keep the destructuring fence). */ +export function processDataMemberValue( + lowerer: Lowerer, + member: string, + binding: ts.Node, + loc: SrcLoc, +): IrExpr | null { + switch (member) { + case "env": { + const mapped = lowerer.mapTypeOf(lowerer.typeOf(binding)); + if (mapped?.kind !== "record") return null; + const helper = envSnapshotHelper(lowerer, mapped.shapeId, loc); + return helper === null ? null : { kind: "call", callee: helper, args: [], type: mapped, loc }; + } + case "argv": + return { kind: "libCall", fn: "process.argv", args: [], type: arrayOf(STRING), loc }; + case "platform": + return { kind: "libCall", fn: "process.platform", args: [], type: STRING, loc }; + case "arch": + return { kind: "libCall", fn: "process.arch", args: [], type: STRING, loc }; + case "pid": + return { kind: "libCall", fn: "process.pid", args: [], type: F64, loc }; + case "execPath": + return { kind: "libCall", fn: "process.execPath", args: [], type: STRING, loc }; + case "versions": + return { kind: "libCall", fn: "process.versions", args: [], type: DYN, loc }; + default: + return null; + } +} + export function lowerProcessProperty( lowerer: Lowerer, expr: ts.PropertyAccessExpression, diff --git a/packages/compiler/src/frontend/lowering/js-dynamic-objects.test.ts b/packages/compiler/src/frontend/lowering/js-dynamic-objects.test.ts new file mode 100644 index 000000000..23ebdfaa9 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/js-dynamic-objects.test.ts @@ -0,0 +1,38 @@ +import { afterAll, expect, test } from "vitest"; +import * as ts from "../ts7/adapter.js"; +import { closeSourceParser, parseSourceFile } from "../ts7/source-parser-node.js"; +import { isValueReturningConstructorClass } from "./js-dynamic-objects.js"; + +afterAll(closeSourceParser); + +function classify(source: string): boolean { + const file = parseSourceFile("classes.js", source, "js"); + let decl: ts.ClassDeclaration | undefined; + ts.walkPreorder(file, (node) => { + if (!decl && ts.isClassDeclaration(node)) decl = node; + }); + if (!decl) throw new Error("fixture has no class"); + return isValueReturningConstructorClass(decl); +} + +test("a constructor-only class returning a value is claimed", () => { + expect(classify(`class Chalk { constructor(options) { return chalkFactory(options); } }`)).toBe( + true, + ); + expect(classify(`class C { constructor(a) { if (a) return { a }; return [a]; } ; }`)).toBe(true); + expect(classify(`class C { constructor() { const f = () => 1; return { f }; } }`)).toBe(true); +}); + +test("classes that keep their instance layout are left alone", () => { + // No value return, or only nested functions return. + expect(classify(`class C { constructor() { return; } }`)).toBe(false); + expect(classify(`class C { constructor() { function f() { return 1; } f(); } }`)).toBe(false); + expect(classify(`class C { constructor() { const f = () => { return 1; }; f(); } }`)).toBe(false); + // Other members, heritage, or a constructor that observes `this`. + expect(classify(`class C { constructor() { return {}; } m() {} }`)).toBe(false); + expect(classify(`class C { x = 1; constructor() { return {}; } }`)).toBe(false); + expect(classify(`class C extends B { constructor() { super(); return {}; } }`)).toBe(false); + expect(classify(`class C { constructor() { this.a = 1; return {}; } }`)).toBe(false); + expect(classify(`class C { constructor() { const g = () => this; return { g }; } }`)).toBe(false); + expect(classify(`class C {}`)).toBe(false); +}); diff --git a/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts new file mode 100644 index 000000000..1d7ab6eee --- /dev/null +++ b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts @@ -0,0 +1,312 @@ +/* JavaScript declarations whose values only the checked-dynamic + * representation can hold faithfully. TypeScript infers a fixed object + * type for each of them, but the program changes the value's shape or + * identity at run time, so a static layout would answer stale members + * (or throw on a value that no longer fits): + * + * - a non-empty object literal bound to a variable that the same file + * grows or reshapes dynamically: a keyed write with a runtime key + * (`o[k] = v`), a `delete`, or `Object.defineProperty(o, ...)` / + * `Object.defineProperties(o, ...)` (ansi-styles' `assembleStyles`). + * The object literals nested in its property values belong to the same + * value graph and are marked with it; + * - a class whose only member is a constructor that returns a value and + * never reads `this` (chalk's `class Chalk { constructor(options) { + * return chalkFactory(options); } }`): `new C()` answers whatever the + * constructor returns, so its instance type has no fixed layout. + * + * The type mapper answers the checked-dynamic type for the instance and + * object-literal types these declarations own (TypeMapperCtx + * .jsDynamicDeclaration). The scan is syntactic, runs over JavaScript + * files only, and an empty answer leaves every mapping unchanged, so + * TypeScript programs and JavaScript that never uses these patterns + * compile exactly as before. */ +import * as ts from "../ts7/adapter.js"; +import { isJsSourceFile, locOf } from "../program.js"; +import { BOOL, DYN, type IrExpr, type IrStmt } from "../../ir/ir.js"; +import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js"; +import type { Lowerer } from "./lowerer.js"; +import type { ParamShape } from "./call-signatures.js"; +import { newFnCtx } from "./function-context.js"; + +const SCANNED_KINDS: ReadonlySet = new Set([ + ts.SyntaxKind.VariableDeclaration, + ts.SyntaxKind.ClassDeclaration, + ts.SyntaxKind.BinaryExpression, + ts.SyntaxKind.DeleteExpression, + ts.SyntaxKind.CallExpression, +]); + +function unparenthesized(node: ts.Expression): ts.Expression { + while (ts.isParenthesizedExpression(node)) node = node.expression; + return node; +} + +function isLiteralKey(node: ts.Expression): boolean { + const key = unparenthesized(node); + return ( + ts.isStringLiteral(key) || ts.isNumericLiteral(key) || ts.isNoSubstitutionTemplateLiteral(key) + ); +} + +function isAssignmentOperator(kind: ts.SyntaxKind): boolean { + return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment; +} + +/** `class C { constructor(...) { ...; return value; } }` with nothing else: + * no heritage, decorators or other members, a constructor body that + * returns a value at its own level and never mentions `this`/`super`. */ +export function isValueReturningConstructorClass(decl: ts.ClassDeclaration): boolean { + if (decl.heritageClauses !== undefined && decl.heritageClauses.length > 0) return false; + if (decl.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.Decorator)) return false; + let ctor: ts.ConstructorDeclaration | undefined; + for (const member of decl.members) { + if (ts.isSemicolonClassElement(member)) continue; + if (!ts.isConstructorDeclaration(member) || ctor !== undefined) return false; + ctor = member; + } + if (ctor?.body === undefined) return false; + let returnsValue = false; + let observesThis = false; + const visit = (node: ts.Node): void => { + if (observesThis) return; + if (node.kind === ts.SyntaxKind.ThisKeyword || node.kind === ts.SyntaxKind.SuperKeyword) { + observesThis = true; + return; + } + // Arrow functions share the constructor's `this`; other functions + // have their own `this` and their own returns. + if (ts.isFunctionLike(node) && !ts.isArrowFunction(node)) return; + if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) return; + if (ts.isReturnStatement(node) && node.expression !== undefined && !insideArrow(node, ctor!)) + returnsValue = true; + node.forEachChild(visit); + }; + ctor.body.forEachChild(visit); + for (const parameter of ctor.parameters) parameter.forEachChild(visit); + return returnsValue && !observesThis; +} + +function insideArrow(node: ts.Node, ctor: ts.ConstructorDeclaration): boolean { + for (let p = node.parent; p !== undefined && p !== ctor; p = p.parent) { + if (ts.isArrowFunction(p)) return true; + } + return false; +} + +function markNested(literal: ts.ObjectLiteralExpression, out: Set): void { + if (out.has(literal)) return; + out.add(literal); + for (const property of literal.properties) { + if (!ts.isPropertyAssignment(property)) continue; + const value = unparenthesized(property.initializer); + if (ts.isObjectLiteralExpression(value)) markNested(value, out); + } +} + +export function jsDynamicDeclarations( + files: readonly ts.SourceFile[], + checker: ts.TypeChecker, +): Set { + const out = new Set(); + for (const file of files) { + if (!isJsSourceFile(file) || file.isDeclarationFile) continue; + const literals = new Map(); + const reshaped = new Set(); + const receiver = (expression: ts.Expression | undefined): void => { + if (expression === undefined) return; + const target = unparenthesized(expression); + if (!ts.isIdentifier(target)) return; + const symbol = checker.getSymbolAtLocation(target); + if (symbol !== undefined) reshaped.add(symbol); + }; + ts.walkPreorder( + file, + (node) => { + if (ts.isVariableDeclaration(node)) { + if (!ts.isIdentifier(node.name) || node.initializer === undefined) return; + const init = unparenthesized(node.initializer); + // An empty literal's binding is already checked-dynamic + // (jsOpenObjectType), and its type describes no layout. + if (!ts.isObjectLiteralExpression(init) || init.properties.length === 0) return; + const symbol = checker.getSymbolAtLocation(node.name); + if (symbol !== undefined) literals.set(symbol, init); + return; + } + if (ts.isClassDeclaration(node)) { + if (isValueReturningConstructorClass(node)) out.add(node); + return; + } + if (ts.isBinaryExpression(node)) { + if (!isAssignmentOperator(node.operatorToken.kind)) return; + const left = unparenthesized(node.left); + if (ts.isElementAccessExpression(left) && !isLiteralKey(left.argumentExpression)) + receiver(left.expression); + return; + } + if (ts.isDeleteExpression(node)) { + const operand = unparenthesized(node.expression); + if (ts.isElementAccessExpression(operand) || ts.isPropertyAccessExpression(operand)) + receiver(operand.expression); + return; + } + if (ts.isCallExpression(node)) { + const callee = unparenthesized(node.expression); + if ( + ts.isPropertyAccessExpression(callee) && + ts.isIdentifier(callee.expression) && + callee.expression.text === "Object" && + (callee.name.text === "defineProperty" || callee.name.text === "defineProperties") + ) + receiver(node.arguments[0]); + } + }, + SCANNED_KINDS, + ); + for (const symbol of reshaped) { + const literal = literals.get(symbol); + if (literal !== undefined) markNested(literal, out); + } + } + return out; +} + +/** `new C(args)` for a value-returning constructor class (above): the + * constructor body runs as an ordinary JavaScript function whose result + * is the construction's value. A returned object or function is Node's + * answer; a fall-through or primitive return would answer the bare + * instance, which has no static home here, and throws the deferred + * refusal instead. Null when the callee is not such a class. */ +export function lowerValueReturningConstructorNew( + lowerer: Lowerer, + expr: ts.NewExpression, +): IrExpr | null { + const isDynamic = lowerer.typeCtx.jsDynamicDeclaration; + if (isDynamic === undefined) return null; + const callee = unparenthesized(expr.expression); + if (!ts.isIdentifier(callee)) return null; + let symbol = lowerer.resolveValueSymbol(callee); + if (symbol !== null && (symbol.flags & ts.SymbolFlags.Alias) !== 0) + symbol = lowerer.checker.getAliasedSymbol(symbol); + const decl = symbol + ? lowerer.checker + .declarationsOf(symbol) + .find((node): node is ts.ClassDeclaration => ts.isClassDeclaration(node) && isDynamic(node)) + : undefined; + if (decl === undefined) return null; + const loc = locOf(expr); + const ctor = decl.members.find(ts.isConstructorDeclaration)!; + const simple = ctor.parameters.every( + (p) => ts.isIdentifier(p.name) && p.dotDotDotToken === undefined && p.initializer === undefined, + ); + if (!simple || !ts.isSourceFile(decl.parent)) { + lowerer.unsupported( + "SC1090", + expr, + "constructing a class whose constructor returns a value, with parameter defaults, rest or patterns, or declared inside a function", + ); + } + const args = expr.arguments ?? []; + if (args.some(ts.isSpreadElement)) { + lowerer.unsupported( + "SC1090", + expr, + "spread arguments when constructing a class whose constructor returns a value", + ); + } + const key = `ctorValue:${decl.getSourceFile().fileName}:${decl.getStart()}`; + let name = lowerer.valueHelpers.get(key); + if (name === undefined) { + name = `%ctorValue.${lowerer.valueHelpers.size}`; + lowerer.valueHelpers.set(key, name); + const savedClass = lowerer.currentClass; + lowerer.currentClass = null; + lowerer.fnStack.push(newFnCtx(false, null, null, DYN)); + try { + const shapes: ParamShape[] = ctor.parameters.map(() => ({ type: DYN, mode: "required" })); + const declared = lowerer.declareParams(ctor.parameters, shapes); + const body: IrStmt[] = [ + ...declared.prologue, + ...lowerer.lowerStmts(ctor.body!.statements), + { + kind: "runtimeFence", + code: "SC1090", + message: `constructors that return no object (the bare instance of '${decl.name?.text ?? "class"}' has no representation here) are not supported yet [SC1090 at ${decl.getSourceFile().fileName}:${ts.getLineAndCharacterOfPosition(decl.getSourceFile(), ctor.getStart()).line + 1}]`, + loc: locOf(ctor), + }, + ]; + lowerer.liftedFns.push({ + name, + params: declared.params, + returnType: DYN, + locals: lowerer.ctx.locals, + body, + loc: locOf(ctor), + }); + } finally { + lowerer.fnStack.pop(); + lowerer.currentClass = savedClass; + } + } + const lowered = ctor.parameters.map((_, i) => + args[i] !== undefined ? lowerer.lowerExprExpecting(args[i]!, DYN) : dynUndefinedExpr(loc), + ); + // Surplus arguments still evaluate, left to right, after the others. + const surplus: IrStmt[] = args + .slice(ctor.parameters.length) + .map((arg) => ({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc: locOf(arg) })); + const result = lowerer.declareHiddenLocal("%constructed", DYN); + const value: IrExpr = { kind: "varRef", localId: result.id, type: DYN, loc }; + const sf = expr.getSourceFile(); + const line = ts.getLineAndCharacterOfPosition(sf, expr.getStart()).line + 1; + const objectLike: IrExpr = { + kind: "logical", + op: "||", + left: { kind: "dynTest", test: "function", value, type: BOOL, loc }, + right: { + kind: "logical", + op: "&&", + left: { kind: "dynTest", test: "object", value, type: BOOL, loc }, + right: { kind: "dynTest", test: "null", negated: true, value, type: BOOL, loc }, + type: BOOL, + loc, + }, + type: BOOL, + loc, + }; + const args0: IrStmt[] = []; + const argLocals = lowered.map((arg) => { + const local = lowerer.declareHiddenLocal("%constructArg", DYN); + args0.push({ kind: "varDecl", localId: local.id, init: arg, loc }); + return { kind: "varRef", localId: local.id, type: DYN, loc } as IrExpr; + }); + return { + kind: "seqExpr", + stmts: [ + ...args0, + ...surplus, + { + kind: "varDecl", + localId: result.id, + init: { kind: "call", callee: name, args: argLocals, type: DYN, loc }, + loc, + }, + ], + result: { + kind: "ternary", + cond: objectLike, + then: value, + else_: nodeThrowExpr( + 0, + "SC1090", + `constructors that return no object are not supported yet [SC1090 at ${sf.fileName}:${line}]`, + DYN, + loc, + ), + type: DYN, + loc, + }, + type: DYN, + loc, + }; +} diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 56c639397..04034c2e0 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -3463,13 +3463,41 @@ function lowerDynReceiverMethodCall( // its name overlaps a primitive prototype (`colors.bold(...)`): the // source value was compiled from that object shape, while genuinely // untyped/any receivers retain the runtime-kind ambiguity and fence. - if (DYN_PROTO_METHOD_NAMES.has(access.name.text) && !ownCallable) return null; + // A name only String.prototype declares (`bold`, `italics`, `link`, + // ...) on a checker-untyped receiver: every other dyn kind answers its + // own or inherited member exactly like a non-prototype name (chalk's + // `chalk.red.bold(...)` reads a prototype getter of a function), so + // only a string receiver keeps the refusal, deferred to run time. + const stringOnlyName = + checkerUntyped && !ownCallable && DYN_STRING_PROTO_ONLY_NAMES.has(access.name.text); + if (DYN_PROTO_METHOD_NAMES.has(access.name.text) && !ownCallable && !stringOnlyName) return null; // Optional forms (`obj.cb?.()`, `obj?.cb()`) belong to the chain // machinery's short-circuit semantics — not modeled here yet. if (call.questionDotToken || access.questionDotToken) return null; const loc = locOf(call); const receiverLocal = lowerer.declareHiddenLocal("%dynCallReceiver", DYN); const receiver: IrExpr = { kind: "varRef", localId: receiverLocal.id, type: DYN, loc }; + // The string refusal throws in place of the member read (a seqExpr + // statement cannot leave the expression). + const stringRefusal = (read: IrExpr): IrExpr => { + if (!stringOnlyName) return read; + const sf = call.getSourceFile(); + const line = ts.getLineAndCharacterOfPosition(sf, call.getStart(sf)).line + 1; + return { + kind: "ternary", + cond: { kind: "dynTest", test: "string", value: receiver, type: BOOL, loc }, + then: nodeThrowExpr( + 0, + "SC1090", + `method calls like '${access.getText()}' on a string are not supported yet [SC1090 at ${sf.fileName}:${line}]`, + DYN, + loc, + ), + else_: read, + type: DYN, + loc, + }; + }; const member: IrExpr = { kind: "dynKeyGet", key: { kind: "strLit", value: access.name.text, type: STRING, loc: locOf(access) }, @@ -3481,7 +3509,7 @@ function lowerDynReceiverMethodCall( const callee = varRef(calleeLocal.id, DYN, loc); const stmts: IrStmt[] = [ { kind: "varDecl", localId: receiverLocal.id, init: recv, loc }, - { kind: "varDecl", localId: calleeLocal.id, init: member, loc }, + { kind: "varDecl", localId: calleeLocal.id, init: stringRefusal(member), loc }, ]; if (call.arguments.some(ts.isSpreadElement)) { const spread = lowerSpreadArgsCall(lowerer, call, callee, loc); @@ -3590,6 +3618,31 @@ const DYN_PROTO_METHOD_NAMES = new Set([ "toPrecision", ]); +/** The DYN_PROTO_METHOD_NAMES that only String.prototype declares among + * the dyn-representable kinds' prototypes. */ +const DYN_STRING_PROTO_ONLY_NAMES = new Set([ + "anchor", + "big", + "blink", + "bold", + "codePointAt", + "fixed", + "fontcolor", + "fontsize", + "isWellFormed", + "italics", + "link", + "localeCompare", + "normalize", + "small", + "strike", + "sub", + "sup", + "toLocaleLowerCase", + "toLocaleUpperCase", + "toWellFormed", +]); + /** The SHARED prototype names scr_dyn_invoke dispatches at runtime (the * subset of DYN_PROTO_METHOD_NAMES with a receiver-kind dispatch): the * runtime runs the real method for the receiver's kind, throws Node's diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 06739166c..b5d0e4ac8 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -1,3 +1,4 @@ +import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js"; import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js"; import { checkedIterableSpread } from "./checked-iterable-spread.js"; import { lowerReadlineUiNew } from "./builtins/readline.js"; @@ -8422,6 +8423,8 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { undefined, lowerer.checker.getSymbolAtLocation(expr.expression), ); + const valueReturning = lowerValueReturningConstructorNew(lowerer, expr); + if (valueReturning) return valueReturning; const instanceConstructor = lowerInstanceConstructorNew(lowerer, expr); if (instanceConstructor) return instanceConstructor; const objectFactory = lowerObjectFactoryNew(lowerer, expr); diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index d2d990e16..977062d45 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -4974,6 +4974,34 @@ export function lowerIntrinsicProperty( return { kind: "libCall", fn: "dyn.arrayPrototype", args: [], type: DYN, loc: locOf(expr) }; if (lowerer.stdlibGlobalMember(expr, "Object") === "prototype") return { kind: "libCall", fn: "dyn.objectPrototype", args: [], type: DYN, loc: locOf(expr) }; + // Function.prototype as a VALUE (a prototype-chain link: + // `Object.setPrototypeOf(F.prototype, Function.prototype)`): one + // anonymous function answering undefined, length 0 — a zero-capture + // closure of a compiler helper, so every read is the same function + // (closure identity) and shares its property table. Reads through it + // find the function members the checked runtime models for every + // function (apply, constructor, name, length). Member forms keep their + // own lowerings. + if (lowerer.stdlibGlobalMember(expr, "Function") === "prototype") { + const loc = locOf(expr); + const name = "%dyn.functionPrototype"; + if (!lowerer.liftedFns.some((fn) => fn.name === name)) + lowerer.liftedFns.push({ + name, + params: [], + locals: [], + returnType: DYN, + body: [{ kind: "return", value: dynUndefinedExpr(loc), loc }], + loc, + }); + return { + kind: "dynFrom", + value: { kind: "closure", fnName: name, captures: [], type: funcOf([], DYN), loc }, + fnName: "", + type: DYN, + loc, + }; + } if (lowerer.stdlibGlobalMember(expr, "Array") === "isArray") return lowerArrayIsArrayValue(lowerer, locOf(expr)); if (lowerer.stdlibGlobalMember(expr, "Array") === "from") @@ -11203,6 +11231,34 @@ function lowerLogicalPair(lowerer: Lowerer, expr: ts.BinaryExpression, left: IrE // same lift the union-operand path above takes, arriving here // with two plain arm values instead. const target = lowerer.mapTypeOf(lowerer.typeOf(expr)); + // An always-truthy left operand (a record, object, array or function + // value: every JS object is truthy): `o && x` evaluates `o` for its + // effects and answers `x`; `o || x` answers `o` and never evaluates + // `x`. supports-color's `stream && stream.isTTY` is the shape. Ahead + // of the union lift below exactly where that lift would store the + // object in a result union with no arm for it; a union holding the + // operand keeps the lift. + if ( + REF_TRUTHY_KINDS.has(kind) && + (target?.kind !== "union" || + (op === ts.SyntaxKind.AmpersandAmpersandToken && + lowerer.armTag(target.unionId, left.type) < 0)) + ) { + const and = op === ts.SyntaxKind.AmpersandAmpersandToken; + const answer = and ? right : left; + const answerT = target ?? answer.type; + if (answerT.kind !== "void") { + const value = lowerer.coerceInto(and ? expr.right : expr.left, answer, answerT); + if (!and) return value; + return { + kind: "seqExpr", + stmts: [{ kind: "exprStmt", expr: left, loc }], + result: value, + type: answerT, + loc, + }; + } + } if (target?.kind === "union") { lowerer.requireTruthyUnion(target.unionId, expr); return { diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index cffe4c661..9e3375e6d 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -10,6 +10,7 @@ import { InternalCompilerError } from "../../errors.js"; * flow (if/while/for/for-of/do, switch, try/catch, abrupt completions), * explicit resource management, and blocked-binding poisoning. */ import * as ts from "../ts7/adapter.js"; +import { processDataMemberValue } from "./builtins/process.js"; import { bindingSource } from "../binding-source.js"; import type { Lowerer } from "./lowerer.js"; import { @@ -3131,6 +3132,9 @@ function stdlibGlobalTokenDestructure( token: string; alias: string | null; g: IrGlobal | undefined; + /** A data member's value (`const { env } = process`), bound instead + * of a token. */ + value?: IrExpr; }[] = []; for (const el of decl.name.elements) { if (el.name === undefined) continue; @@ -3166,8 +3170,9 @@ function stdlibGlobalTokenDestructure( "destructuring with computed keys that do not fold to one property name", ); } - let token: string; + let token = ""; let alias: string | null = null; + let value: IrExpr | null = null; if (globalName === "globalThis") { // The member must BE a stdlib global (user script vars are // properties of `typeof globalThis` too — their values are real @@ -3187,6 +3192,13 @@ function stdlibGlobalTokenDestructure( token = `[builtin console.${propName}]`; } else if (TOKEN_OPAQUE_GLOBALS.has(globalName)) { token = `[builtin ${globalName}.${propName}]`; + } else if ( + globalName === "process" && + ts.isIdentifier(el.name) && + (value = processDataMemberValue(lowerer, propName, el.name, locOf(el))) !== null + ) { + // A data member reads its value once, exactly like the spelled + // `process.` read the destructuring performs. } else { lowerer.unsupported( "SC1031", @@ -3203,6 +3215,10 @@ function stdlibGlobalTokenDestructure( ); } const g = lowerer.globalsBySymbol.get(symbol); + if (value !== null) { + binds.push({ name: el.name, token, alias, g, value }); + continue; + } if (g !== undefined && g.type.kind !== "string" && g.type.kind !== "dyn") { lowerer.unsupported( "SC1031", @@ -3215,6 +3231,21 @@ function stdlibGlobalTokenDestructure( const out: IrStmt[] = []; for (const b of binds) { const loc = locOf(b.name); + if (b.value !== undefined) { + if (b.g !== undefined) { + out.push({ + kind: "assign", + localId: b.g.id, + value: lowerer.coerceInto(b.name, b.value, b.g.type), + ...(b.g.tdz ? { initializes: true as const } : {}), + loc, + }); + } else { + const local = lowerer.declareLocal(b.name, b.name.text, b.value.type, isLet); + out.push({ kind: "varDecl", localId: local.id, init: b.value, loc }); + } + continue; + } const token: IrExpr = { kind: "strLit", value: b.token, type: STRING, loc }; if (b.alias !== null) { const symbol = lowerer.checker.getSymbolAtLocation(b.name); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 087b4e628..4193be2bb 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -1,3 +1,4 @@ +import { jsDynamicDeclarations } from "./js-dynamic-objects.js"; import { lifetimeRegionType, lowerLifetimeRegionCall, @@ -2860,6 +2861,8 @@ export class Lowerer { this.fileTag.set(sf, sf === entry ? "" : `%m${i}.`); }); if (this.moduleOrder.length === 0) this.fileTag.set(entry, ""); + const jsDynamic = jsDynamicDeclarations(this.moduleOrder, this.checker); + if (jsDynamic.size > 0) this.typeCtx.jsDynamicDeclaration = (decl) => jsDynamic.has(decl); this.registerBuiltinErrorClasses(); registerBuiltinEmitterClass(this); registerBuiltinStreamClasses(this); diff --git a/packages/compiler/src/frontend/npm-static.ts b/packages/compiler/src/frontend/npm-static.ts index 1f83a12d4..d2f4ea3e8 100644 --- a/packages/compiler/src/frontend/npm-static.ts +++ b/packages/compiler/src/frontend/npm-static.ts @@ -190,6 +190,10 @@ export function npmStaticTransformPkgJson(pkg: Record): void { for (const value of Object.values(obj)) transform(value); }; if (pkg["exports"] !== undefined) transform(pkg["exports"]); + // The "imports" field maps "#" specifiers with the same condition objects + // (chalk 5's `"#supports-color": { node, default }`), so Node's "node" + // target hoists there too. + if (pkg["imports"] !== undefined) transform(pkg["imports"]); } /** npmStaticTransformPkgJson over a package.json TEXT (the fs shadow's diff --git a/packages/compiler/src/frontend/resolve.test.ts b/packages/compiler/src/frontend/resolve.test.ts index 0d135b3c2..0dd09e73d 100644 --- a/packages/compiler/src/frontend/resolve.test.ts +++ b/packages/compiler/src/frontend/resolve.test.ts @@ -11,6 +11,7 @@ import { setProjectPathMappings, setProjectRealm, } from "./resolve.js"; +import { setNpmStaticPackages } from "./npm-static.js"; const fixturesRoot = join(import.meta.dirname, "../../../..", "tests/fixtures"); @@ -60,3 +61,56 @@ test("source-only workspace packages are project modules while JavaScript packag clearResolveCaches(); } }); + +test("package imports inside a --npm-static package answer the shipped JavaScript", async () => { + // chalk 5's shape: a declaration twin beside every runtime file, and a + // `{ node, default }` imports entry whose node target is what Node runs. + const dir = realpathSync(await mkdtemp(join(tmpdir(), "scriptc-resolve-imports-"))); + try { + const pkg = join(dir, "node_modules", "colors"); + const vendor = join(pkg, "source", "vendor"); + await mkdir(join(vendor, "styles"), { recursive: true }); + await mkdir(join(vendor, "detect"), { recursive: true }); + await Promise.all([ + writeFile( + join(pkg, "package.json"), + JSON.stringify({ + name: "colors", + version: "1.0.0", + type: "module", + exports: "./source/index.js", + imports: { + "#styles": "./source/vendor/styles/index.js", + "#detect": { + node: "./source/vendor/detect/index.js", + default: "./source/vendor/detect/browser.js", + }, + }, + }), + ), + writeFile(join(pkg, "source", "index.js"), 'import styles from "#styles";\n'), + writeFile(join(pkg, "source", "index.d.ts"), "export {};\n"), + writeFile(join(vendor, "styles", "index.js"), "export default {};\n"), + writeFile(join(vendor, "styles", "index.d.ts"), "export {};\n"), + writeFile(join(vendor, "detect", "index.js"), "export default 1;\n"), + writeFile(join(vendor, "detect", "index.d.ts"), "export {};\n"), + writeFile(join(vendor, "detect", "browser.js"), "export default 0;\n"), + writeFile(join(vendor, "detect", "browser.d.ts"), "export {};\n"), + ]); + const from = join(pkg, "source", "index.js"); + + clearResolveCaches(); + setNpmStaticPackages([]); + expect(resolveProjectModule(from, "#styles")).toBe(join(vendor, "styles", "index.d.ts")); + + clearResolveCaches(); + setNpmStaticPackages(["colors"]); + expect(resolveProjectModule(from, "#styles")).toBe(join(vendor, "styles", "index.js")); + expect(resolveProjectModule(from, "#detect")).toBe(join(vendor, "detect", "index.js")); + expect(resolveProjectModule(from, "#missing")).toBeNull(); + } finally { + setNpmStaticPackages([]); + clearResolveCaches(); + await rm(dir, { recursive: true, force: true }); + } +}); diff --git a/packages/compiler/src/frontend/resolve.ts b/packages/compiler/src/frontend/resolve.ts index db440c199..463400475 100644 --- a/packages/compiler/src/frontend/resolve.ts +++ b/packages/compiler/src/frontend/resolve.ts @@ -617,6 +617,18 @@ export function resolveProjectImport(fromFile: string, specifier: string): strin // Node's validity rule: only the bare "#" is never resolvable ("#/..." // matches "#/*"-pattern keys on current Node). if (specifier === "#") return null; + // Inside an opted-in --npm-static package, an imports entry resolves + // the way the tsgo host's fs shadow does: the transformed document + // (the "node" condition hoisted), the runtime JS conditions, and the + // shipped JS rather than a declaration twin (see resolveRelativeModule). + if (npmStaticPackageOfPath(resolve(fromFile)) !== null) { + const transformed = JSON.parse(JSON.stringify(pkg)) as PkgJson & Record; + npmStaticTransformPkgJson(transformed); + const jsTarget = resolvePackageImports(transformed.imports, specifier, JS_ONLY_CONDITIONS); + if (jsTarget === null || !jsTarget.startsWith("./")) return null; + const jsPath = join(pkgDir, jsTarget); + return normalizeResolvedAnswer(loadAsJsFile(jsPath) ?? loadAsJsDirectory(jsPath)); + } target = resolvePackageImports(pkg.imports, specifier, EXPORT_CONDITIONS); // An imports target that is not "./"-relative is PACKAGE_RESOLVE'd as // a bare specifier (Node's PACKAGE_IMPORTS_EXPORTS_RESOLVE): the diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index 52964e1bd..1e1bedc39 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -996,6 +996,10 @@ export type TypeParamTsResolver = (t: ts.Type) => ts.Type | null; * one new field here, not a new parameter at every call site. */ export interface TypeMapperCtx { checker: ts.TypeChecker; + /** JavaScript declarations whose instance or object-literal types only + * the checked-dynamic representation holds (js-dynamic-objects.ts). + * Absent when the program has none: every mapping is unchanged. */ + jsDynamicDeclaration?: (decl: ts.Node) => boolean; /** Set while mapping a generic callable member's erased type * (erasedGenericMemberType): the signature's own type parameters * resolve to `unknown` instead of refusing the mapping. */ @@ -1368,6 +1372,16 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { const intrinsic = type.getSymbol(); if (intrinsic?.name === "globalThis" && checker.declarationsOf(intrinsic).length === 0) return DYN; + if (ctx.jsDynamicDeclaration !== undefined && intrinsic !== undefined) { + const objectLiteral = (intrinsic.flags & ts.SymbolFlags.ObjectLiteral) !== 0; + const classInstance = + (intrinsic.flags & ts.SymbolFlags.Class) !== 0 && type.isClassOrInterface(); + if ( + (objectLiteral || classInstance) && + checker.declarationsOf(intrinsic).some((decl) => ctx.jsDynamicDeclaration!(decl)) + ) + return DYN; + } { const moduleId = ctx.moduleNamespaceId?.(type) ?? null; if (moduleId !== null) return { kind: "moduleNs", moduleId }; diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-builder-string-method-names/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-builder-string-method-names/main.ts.json new file mode 100644 index 000000000..d1f487f89 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-builder-string-method-names/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/js-builder-string-method-names/builder.js", + "/tests/corpus/js-builder-string-method-names/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-builder.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-builder.js.json new file mode 100644 index 000000000..8f1025c47 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-builder.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-callable-builder.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-constructor-returns/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-constructor-returns/main.ts.json new file mode 100644 index 000000000..e05f1760c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-constructor-returns/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/js-class-constructor-returns/factory.js", + "/tests/corpus/js-class-constructor-returns/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-function-prototype-value.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-function-prototype-value.js.json new file mode 100644 index 000000000..b0fa827e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-function-prototype-value.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-function-prototype-value.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-number-parse-dynamic.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-number-parse-dynamic.js.json new file mode 100644 index 000000000..608e24d40 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-number-parse-dynamic.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-number-parse-dynamic.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-process-destructure.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-process-destructure.mjs.json new file mode 100644 index 000000000..87d43324e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-process-destructure.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-process-destructure.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reshaped-object-literal.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reshaped-object-literal.js.json new file mode 100644 index 000000000..939240b2c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reshaped-object-literal.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-reshaped-object-literal.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/truthy-object-logical.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/truthy-object-logical.ts.json new file mode 100644 index 000000000..96661c630 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/truthy-object-logical.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/truthy-object-logical.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json new file mode 100644 index 000000000..065c96347 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/chalk5/main.ts" + ], + "diags": [] +} diff --git a/tests/corpus/js-builder-string-method-names/builder.js b/tests/corpus/js-builder-string-method-names/builder.js new file mode 100644 index 000000000..36824c317 --- /dev/null +++ b/tests/corpus/js-builder-string-method-names/builder.js @@ -0,0 +1,22 @@ +// Prototype getters named like String.prototype's HTML methods (bold, +// italics, link, big): each read builds a callable that wraps its input. +const wrap = (tag) => ({ + get() { + const parent = this; + const builder = (text) => builder.prefix(text); + builder.prefix = (text) => parent.prefix(`<${tag}>` + text + ``); + Object.setPrototypeOf(builder, proto); + return builder; + }, +}); +const proto = Object.defineProperties(() => {}, { + bold: wrap("b"), + italics: wrap("i"), + link: wrap("a"), + big: wrap("big"), + red: wrap("red"), +}); +const root = (text) => text; +root.prefix = (text) => text; +Object.setPrototypeOf(root, proto); +export default root; diff --git a/tests/corpus/js-builder-string-method-names/main.ts b/tests/corpus/js-builder-string-method-names/main.ts new file mode 100644 index 000000000..5cab8e4ca --- /dev/null +++ b/tests/corpus/js-builder-string-method-names/main.ts @@ -0,0 +1,14 @@ +// A TypeScript caller reaching JavaScript builders whose member names +// collide with String.prototype methods: the receiver is a function, so +// each call reads the function's inherited getter, not the string method. +import builder from "./builder.js"; + +// TypeScript infers no members for the builder's prototype getters. +const tags: any = builder; + +console.log(tags.bold("strong")); +console.log(tags.red.bold("nested")); +console.log(tags.italics.link("deep").length); +console.log(tags.big.red.italics("three")); +const chain = tags.link; +console.log(chain.bold("from a binding")); diff --git a/tests/corpus/js-callable-builder.js b/tests/corpus/js-callable-builder.js new file mode 100644 index 000000000..3697d788d --- /dev/null +++ b/tests/corpus/js-callable-builder.js @@ -0,0 +1,110 @@ +// A chalk-style builder: every style read through a function's runtime +// prototype chain runs a getter that creates a new callable builder, +// links it to a shared prototype with Object.setPrototypeOf, and caches +// it on the receiver with Object.defineProperty. +const GENERATOR = Symbol("GENERATOR"); +const STYLER = Symbol("STYLER"); +const IS_EMPTY = Symbol("IS_EMPTY"); +const codes = { red: [31, 39], green: [32, 39], bold: [1, 22], underline: [4, 24] }; +let getterRuns = 0; + +const styles = Object.create(null); +for (const [name, [open, close]] of Object.entries(codes)) { + styles[name] = { + get() { + getterRuns++; + const builder = createBuilder(this, createStyler(`<${open}>`, ``, this[STYLER]), this[IS_EMPTY]); + Object.defineProperty(this, name, { value: builder }); + return builder; + }, + }; +} +styles.visible = { + get() { + const builder = createBuilder(this, this[STYLER], true); + Object.defineProperty(this, "visible", { value: builder }); + return builder; + }, +}; + +const proto = Object.defineProperties(() => {}, { + ...styles, + level: { + enumerable: true, + get() { + return this[GENERATOR].level; + }, + set(level) { + this[GENERATOR].level = level; + }, + }, +}); + +function createStyler(open, close, parent) { + if (parent === undefined) return { open, close, openAll: open, closeAll: close, parent }; + return { open, close, openAll: parent.openAll + open, closeAll: close + parent.closeAll, parent }; +} + +function createBuilder(self, styler, isEmpty) { + const builder = (...args) => applyStyle(builder, args.length === 1 ? "" + args[0] : args.join(" ")); + Object.setPrototypeOf(builder, proto); + builder[GENERATOR] = self; + builder[STYLER] = styler; + builder[IS_EMPTY] = isEmpty; + return builder; +} + +function applyStyle(self, text) { + if (self.level <= 0 || !text) return self[IS_EMPTY] ? "" : text; + let styler = self[STYLER]; + if (styler === undefined) return text; + const { openAll, closeAll } = styler; + if (text.includes(" strings.join(" "); + chalk.level = options && options.level !== undefined ? options.level : 1; + Object.setPrototypeOf(chalk, createChalk.prototype); + return chalk; +} +Object.setPrototypeOf(createChalk.prototype, Function.prototype); +Object.defineProperties(createChalk.prototype, styles); + +const chalk = createChalk(); +console.log(chalk.red("x")); +console.log(chalk.red.bold("nested")); +console.log(chalk.green("a " + chalk.red("b") + " c")); +console.log(chalk.underline.green.bold("three", "args", 3)); +console.log(JSON.stringify(chalk.red("")), chalk.visible("v"), chalk.red.visible("rv")); +console.log(chalk("plain", "call"), typeof chalk, typeof chalk.red, typeof chalk.red.bold); +console.log(chalk.red === chalk.red, chalk.red.bold === chalk.red.bold, getterRuns); +console.log(Object.getPrototypeOf(chalk) === createChalk.prototype); +console.log(Object.getPrototypeOf(chalk.red) === proto, Object.getPrototypeOf(chalk.red.bold) === proto); +console.log(Object.getPrototypeOf(createChalk.prototype) === Function.prototype); +console.log(chalk.apply(null, ["via", "apply"])); +console.log(Object.keys(chalk).join(","), Object.hasOwn(chalk, "red"), "red" in chalk); + +const red = chalk.red; +chalk.level = 0; +console.log(red("off"), red.level, chalk.level, JSON.stringify(red.visible("hidden"))); +red.level = 2; +console.log(chalk.level, chalk.green.level, red("on")); +const quiet = createChalk({ level: 0 }); +console.log(quiet.red.bold("quiet"), quiet.level, chalk.level); diff --git a/tests/corpus/js-class-constructor-returns/factory.js b/tests/corpus/js-class-constructor-returns/factory.js new file mode 100644 index 000000000..9fe0b84c4 --- /dev/null +++ b/tests/corpus/js-class-constructor-returns/factory.js @@ -0,0 +1,35 @@ +// Classes whose constructor returns a value: `new` answers that value. +const make = (options = {}) => { + const fn = (...parts) => parts.join(options.separator ?? " "); + fn.level = options.level ?? 1; + return fn; +}; + +export class Joiner { + constructor(options) { + return make(options); + } +} + +export class Record { + constructor(name, size) { + const value = { name, size, kind: "record" }; + if (size > 10) return { ...value, large: true }; + return value; + } +} + +let constructed = 0; +export class Counted { + constructor() { + constructed++; + return { id: constructed }; + } +} + +const j = new Joiner({ separator: "-", level: 3 }); +console.log(typeof j, j("a", "b", "c"), j.level); +const plain = new Joiner(); +console.log(plain("x", "y"), plain.level); +console.log(JSON.stringify(new Record("box", 4)), JSON.stringify(new Record("crate", 40))); +console.log(new Counted().id, new Counted().id, constructed); diff --git a/tests/corpus/js-class-constructor-returns/main.ts b/tests/corpus/js-class-constructor-returns/main.ts new file mode 100644 index 000000000..800016329 --- /dev/null +++ b/tests/corpus/js-class-constructor-returns/main.ts @@ -0,0 +1,11 @@ +// The same classes constructed from TypeScript: the values come from the +// constructors' returns. +import { Counted, Joiner, Record } from "./factory.js"; + +// TypeScript types `new` by the class; the values are what the constructors return. +const joiner: any = new Joiner({ separator: "+" }); +console.log(joiner("1", "2")); +const record = new Record("tube", 11); +console.log(JSON.stringify(record)); +const counted: any = new Counted(); +console.log(counted.id); diff --git a/tests/corpus/js-function-prototype-value.js b/tests/corpus/js-function-prototype-value.js new file mode 100644 index 000000000..3efe4540e --- /dev/null +++ b/tests/corpus/js-function-prototype-value.js @@ -0,0 +1,17 @@ +// Function.prototype as a value: a callable answering undefined, with an +// empty name and length 0, usable as a prototype-chain link. +const fp = Function.prototype; +console.log(typeof fp, fp === Function.prototype, JSON.stringify(fp.name), fp.length); +console.log(fp(), fp(1, 2, 3)); + +function Base() {} +Object.setPrototypeOf(Base.prototype, Function.prototype); +console.log(Object.getPrototypeOf(Base.prototype) === Function.prototype); + +const callable = (...args) => args.length; +Object.setPrototypeOf(callable, Base.prototype); +console.log(callable(1, 2), Object.getPrototypeOf(callable) === Base.prototype); +console.log(callable.apply(null, [1, 2, 3]), callable.call(null, 1)); + +const plain = Object.setPrototypeOf({ own: 1 }, Function.prototype); +console.log(typeof plain, plain.own, Object.getPrototypeOf(plain) === Function.prototype); diff --git a/tests/corpus/js-number-parse-dynamic.js b/tests/corpus/js-number-parse-dynamic.js new file mode 100644 index 000000000..e4b050046 --- /dev/null +++ b/tests/corpus/js-number-parse-dynamic.js @@ -0,0 +1,8 @@ +// Number.parseInt / Number.parseFloat over checked-dynamic values apply +// the parsers' own ToString, as supports-color does with FORCE_COLOR. +const env = JSON.parse('{"FORCE_COLOR":"2","DEPTH":" 3.5px","EMPTY":"","HEX":"ff"}'); +console.log(Number.parseInt(env.FORCE_COLOR, 10), Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3)); +console.log(Number.parseInt(env.MISSING, 10), Number.parseInt(env.EMPTY, 10), Number.parseInt(env.HEX, 16)); +console.log(Number.parseFloat(env.DEPTH), Number.parseFloat(env.MISSING)); +const values = JSON.parse("[12, true, null]"); +console.log(Number.parseInt(values[0], 10), Number.parseInt(values[1], 36), Number.parseInt(values[2], 36)); diff --git a/tests/corpus/js-process-destructure.mjs b/tests/corpus/js-process-destructure.mjs new file mode 100644 index 000000000..81660e22c --- /dev/null +++ b/tests/corpus/js-process-destructure.mjs @@ -0,0 +1,12 @@ +// Data members of the process object taken off by destructuring. +import process from "node:process"; + +const { env, argv, platform } = process; +console.log(env.SCRIPTC_TEST_ENV, "SCRIPTC_TEST_ENV" in env, "SCRIPTC_NOT_SET_ANYWHERE" in env); +console.log(Array.isArray(argv), typeof argv[0], platform === process.platform); + +function readFlags() { + const { env: environment, pid } = process; + return [typeof environment.SCRIPTC_TEST_ENV, pid === process.pid]; +} +console.log(readFlags().join(" ")); diff --git a/tests/corpus/js-reshaped-object-literal.js b/tests/corpus/js-reshaped-object-literal.js new file mode 100644 index 000000000..c184cc388 --- /dev/null +++ b/tests/corpus/js-reshaped-object-literal.js @@ -0,0 +1,42 @@ +// An object literal the program reshapes at run time (runtime-keyed +// writes, defineProperty, delete): every read sees the live object, not +// the layout TypeScript inferred for the literal (ansi-styles' +// assembleStyles shape). +const styles = { + modifier: { reset: [0, 0], bold: [1, 22] }, + color: { red: [31, 39], green: [32, 39] }, +}; + +function assemble() { + const codes = new Map(); + for (const [groupName, group] of Object.entries(styles)) { + for (const [styleName, style] of Object.entries(group)) { + styles[styleName] = { open: `<${style[0]}>`, close: `` }; + group[styleName] = styles[styleName]; + codes.set(style[0], style[1]); + } + Object.defineProperty(styles, groupName, { value: group, enumerable: false }); + } + Object.defineProperty(styles, "codes", { value: codes, enumerable: false }); + styles.color.close = ""; + styles.color.ansi = (code) => `[${code}]`; + Object.defineProperties(styles, { + double: { value: (n) => n * 2, enumerable: false }, + }); + return styles; +} + +const ansi = assemble(); +console.log(Object.keys(ansi).join(",")); +console.log(ansi.red.open, ansi.color.red.close, ansi.color.close, ansi.color.ansi(5)); +console.log(ansi.codes.get(31), ansi.codes.size, ansi.double(21)); +console.log(ansi.modifier.bold === ansi.bold, Object.keys(ansi.color).join(",")); +for (const [name, style] of Object.entries(ansi)) console.log(name, style.open, style.close); + +const table = { a: 1, b: 2, c: 3 }; +const drop = (key) => { + delete table[key]; +}; +drop("b"); +table["d" + 1] = 4; +console.log(JSON.stringify(table), Object.keys(table).length, "b" in table); diff --git a/tests/corpus/truthy-object-logical.ts b/tests/corpus/truthy-object-logical.ts new file mode 100644 index 000000000..0b84b760b --- /dev/null +++ b/tests/corpus/truthy-object-logical.ts @@ -0,0 +1,31 @@ +// `&&` and `||` whose left operand is an object, array or function value: +// every object is truthy, so `o && x` evaluates `o` and answers `x`, and +// `o || x` answers `o` without evaluating `x`. +interface Stream { + isTTY: boolean; + columns: number; +} +let reads = 0; +const stream = (): Stream => { + reads++; + return { isTTY: reads % 2 === 1, columns: 80 }; +}; +function tty(s: Stream): boolean { + return s && s.isTTY; +} +console.log(tty({ isTTY: true, columns: 1 }), tty({ isTTY: false, columns: 2 })); +const width = stream() && stream().columns; +console.log(width, reads); +const list = [3, 1, 2]; +const first = list && list.length; +console.log(first); +const fn = (n: number): number => n * 2; +const doubled = fn && fn(21); +console.log(doubled); +let evaluated = false; +const fallback = (): Stream => { + evaluated = true; + return { isTTY: false, columns: 0 }; +}; +const chosen = stream() || fallback(); +console.log(chosen.columns, evaluated, reads); diff --git a/tests/fixtures/npm/cases/chalk5/main.ts b/tests/fixtures/npm/cases/chalk5/main.ts new file mode 100644 index 000000000..6a33a1466 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/main.ts @@ -0,0 +1,64 @@ +// chalk 5 (the real package, pinned in node_modules): the callable +// builder whose styles are prototype getters on a function chain, every +// color model, nested styles, chalk.level and new Chalk({ level }) at all +// four levels. chalk.test.ts runs the same program under FORCE_COLOR and +// the --color flags. +import chalk, { Chalk, chalkStderr, supportsColor, modifierNames, foregroundColorNames, backgroundColorNames, colorNames } from "chalk"; + +const show = (label: string, value: string): void => { + console.log(label + " " + JSON.stringify(value)); +}; + +console.log("default level " + String(chalk.level) + " stderr " + String(chalkStderr.level)); +console.log("supportsColor " + JSON.stringify(supportsColor)); +console.log(modifierNames.join(",")); +console.log(foregroundColorNames.length + " " + backgroundColorNames.length + " " + colorNames.length); + +show("red", chalk.red("red")); +show("red.bold", chalk.red.bold("bold red")); +show("nested", chalk.blue("a " + chalk.red("b") + " c")); +show("multi-arg", chalk.green("one", "two", 3)); +show("number", chalk.yellow(42 as unknown as string)); +show("empty", chalk.red("")); +show("newline", chalk.magenta.underline("line1\nline2\r\nline3")); +show("bg", chalk.bgCyan.black("bg")); +show("bright", chalk.redBright.bgBlueBright("bright")); +show("modifiers", chalk.italic.inverse.strikethrough.overline("mods")); +show("hidden-visible", chalk.hidden("h") + "|" + chalk.visible("v")); +show("rgb", chalk.rgb(10, 20, 30)("rgb")); +show("hex", chalk.hex("#ff8800").bold("hex")); +show("hex-short", chalk.bgHex("#0f0")("bg hex")); +show("ansi256", chalk.ansi256(201)("ansi256")); +show("bgAnsi256", chalk.bgAnsi256(17).white("bgAnsi256")); +show("callable", chalk("plain", "args")); +show("gray-grey", chalk.gray("x") + chalk.grey("y")); + +for (const level of [0, 1, 2, 3] as const) { + const c = new Chalk({ level }); + show(`L${level} red.bold`, c.red.bold("x")); + show(`L${level} hex`, c.hex("#123456")("x")); + show(`L${level} rgb`, c.rgb(255, 255, 255).bgRgb(0, 0, 0)("x")); + show(`L${level} ansi256`, c.ansi256(100).bgAnsi256(200)("x")); + show(`L${level} visible`, c.visible.red("v")); + show(`L${level} nested`, c.green("g" + c.yellow("y") + "g")); +} + +const mutable = new Chalk({ level: 3 }); +const red = mutable.red; +show("before", red("r")); +mutable.level = 0; +show("after level 0", red("r") + "|" + mutable.blue("b")); +console.log("level via builder " + String(red.level)); +red.level = 2; +console.log("shared level " + String(mutable.level)); +show("restored", mutable.cyan("c")); + +try { + new Chalk({ level: 5 as 0 }); +} catch (error) { + console.log("error " + (error as Error).message); +} + +chalk.level = 1; +show("global after set", chalk.red.bold("x")); +console.log("global level " + String(chalk.level)); diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/license b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/license new file mode 100644 index 000000000..fa7ceba3e --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/package.json b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/package.json new file mode 100644 index 000000000..c9e0dc52b --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/package.json @@ -0,0 +1,83 @@ +{ + "name": "chalk", + "version": "5.6.2", + "description": "Terminal string styling done right", + "license": "MIT", + "repository": "chalk/chalk", + "funding": "https://github.com/chalk/chalk?sponsor=1", + "type": "module", + "main": "./source/index.js", + "exports": "./source/index.js", + "imports": { + "#ansi-styles": "./source/vendor/ansi-styles/index.js", + "#supports-color": { + "node": "./source/vendor/supports-color/index.js", + "default": "./source/vendor/supports-color/browser.js" + } + }, + "types": "./source/index.d.ts", + "sideEffects": false, + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "scripts": { + "test": "xo && c8 ava && tsd", + "bench": "matcha benchmark.js" + }, + "files": [ + "source", + "!source/index.test-d.ts" + ], + "keywords": [ + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "string", + "ansi", + "style", + "styles", + "tty", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "log", + "logging", + "command-line", + "text" + ], + "devDependencies": { + "@types/node": "^16.11.10", + "ava": "^3.15.0", + "c8": "^7.10.0", + "color-convert": "^2.0.1", + "execa": "^6.0.0", + "log-update": "^5.0.0", + "matcha": "^0.7.0", + "tsd": "^0.19.0", + "xo": "^0.57.0", + "yoctodelay": "^2.0.0" + }, + "xo": { + "rules": { + "unicorn/prefer-string-slice": "off", + "@typescript-eslint/consistent-type-imports": "off", + "@typescript-eslint/consistent-type-exports": "off", + "@typescript-eslint/consistent-type-definitions": "off", + "unicorn/expiring-todo-comments": "off" + } + }, + "c8": { + "reporter": [ + "text", + "lcov" + ], + "exclude": [ + "source/vendor" + ] + } +} diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.d.ts b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.d.ts new file mode 100644 index 000000000..8295d9252 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.d.ts @@ -0,0 +1,325 @@ +// TODO: Make it this when TS suports that. +// import {ModifierName, ForegroundColor, BackgroundColor, ColorName} from '#ansi-styles'; +// import {ColorInfo, ColorSupportLevel} from '#supports-color'; +import { + ModifierName, + ForegroundColorName, + BackgroundColorName, + ColorName, +} from './vendor/ansi-styles/index.js'; +import {ColorInfo, ColorSupportLevel} from './vendor/supports-color/index.js'; + +export interface Options { + /** + Specify the color support for Chalk. + + By default, color support is automatically detected based on the environment. + + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + readonly level?: ColorSupportLevel; +} + +/** +Return a new Chalk instance. +*/ +export const Chalk: new (options?: Options) => ChalkInstance; // eslint-disable-line @typescript-eslint/naming-convention + +export interface ChalkInstance { + (...text: unknown[]): string; + + /** + The color support for Chalk. + + By default, color support is automatically detected based on the environment. + + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + level: ColorSupportLevel; + + /** + Use RGB values to set text color. + + @example + ``` + import chalk from 'chalk'; + + chalk.rgb(222, 173, 237); + ``` + */ + rgb: (red: number, green: number, blue: number) => this; + + /** + Use HEX value to set text color. + + @param color - Hexadecimal value representing the desired color. + + @example + ``` + import chalk from 'chalk'; + + chalk.hex('#DEADED'); + ``` + */ + hex: (color: string) => this; + + /** + Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color. + + @example + ``` + import chalk from 'chalk'; + + chalk.ansi256(201); + ``` + */ + ansi256: (index: number) => this; + + /** + Use RGB values to set background color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgRgb(222, 173, 237); + ``` + */ + bgRgb: (red: number, green: number, blue: number) => this; + + /** + Use HEX value to set background color. + + @param color - Hexadecimal value representing the desired color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgHex('#DEADED'); + ``` + */ + bgHex: (color: string) => this; + + /** + Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgAnsi256(201); + ``` + */ + bgAnsi256: (index: number) => this; + + /** + Modifier: Reset the current style. + */ + readonly reset: this; + + /** + Modifier: Make the text bold. + */ + readonly bold: this; + + /** + Modifier: Make the text have lower opacity. + */ + readonly dim: this; + + /** + Modifier: Make the text italic. *(Not widely supported)* + */ + readonly italic: this; + + /** + Modifier: Put a horizontal line below the text. *(Not widely supported)* + */ + readonly underline: this; + + /** + Modifier: Put a horizontal line above the text. *(Not widely supported)* + */ + readonly overline: this; + + /** + Modifier: Invert background and foreground colors. + */ + readonly inverse: this; + + /** + Modifier: Print the text but make it invisible. + */ + readonly hidden: this; + + /** + Modifier: Puts a horizontal line through the center of the text. *(Not widely supported)* + */ + readonly strikethrough: this; + + /** + Modifier: Print the text only when Chalk has a color level above zero. + + Can be useful for things that are purely cosmetic. + */ + readonly visible: this; + + readonly black: this; + readonly red: this; + readonly green: this; + readonly yellow: this; + readonly blue: this; + readonly magenta: this; + readonly cyan: this; + readonly white: this; + + /* + Alias for `blackBright`. + */ + readonly gray: this; + + /* + Alias for `blackBright`. + */ + readonly grey: this; + + readonly blackBright: this; + readonly redBright: this; + readonly greenBright: this; + readonly yellowBright: this; + readonly blueBright: this; + readonly magentaBright: this; + readonly cyanBright: this; + readonly whiteBright: this; + + readonly bgBlack: this; + readonly bgRed: this; + readonly bgGreen: this; + readonly bgYellow: this; + readonly bgBlue: this; + readonly bgMagenta: this; + readonly bgCyan: this; + readonly bgWhite: this; + + /* + Alias for `bgBlackBright`. + */ + readonly bgGray: this; + + /* + Alias for `bgBlackBright`. + */ + readonly bgGrey: this; + + readonly bgBlackBright: this; + readonly bgRedBright: this; + readonly bgGreenBright: this; + readonly bgYellowBright: this; + readonly bgBlueBright: this; + readonly bgMagentaBright: this; + readonly bgCyanBright: this; + readonly bgWhiteBright: this; +} + +/** +Main Chalk object that allows to chain styles together. + +Call the last one as a method with a string argument. + +Order doesn't matter, and later styles take precedent in case of a conflict. + +This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`. +*/ +declare const chalk: ChalkInstance; + +export const supportsColor: ColorInfo; + +export const chalkStderr: typeof chalk; +export const supportsColorStderr: typeof supportsColor; + +export { + ModifierName, ForegroundColorName, BackgroundColorName, ColorName, + modifierNames, foregroundColorNames, backgroundColorNames, colorNames, +// } from '#ansi-styles'; +} from './vendor/ansi-styles/index.js'; + +export { + ColorInfo, + ColorSupport, + ColorSupportLevel, +// } from '#supports-color'; +} from './vendor/supports-color/index.js'; + +// TODO: Remove these aliases in the next major version +/** +@deprecated Use `ModifierName` instead. + +Basic modifier names. +*/ +export type Modifiers = ModifierName; + +/** +@deprecated Use `ForegroundColorName` instead. + +Basic foreground color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ForegroundColor = ForegroundColorName; + +/** +@deprecated Use `BackgroundColorName` instead. + +Basic background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type BackgroundColor = BackgroundColorName; + +/** +@deprecated Use `ColorName` instead. + +Basic color names. The combination of foreground and background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type Color = ColorName; + +/** +@deprecated Use `modifierNames` instead. + +Basic modifier names. +*/ +export const modifiers: readonly Modifiers[]; + +/** +@deprecated Use `foregroundColorNames` instead. + +Basic foreground color names. +*/ +export const foregroundColors: readonly ForegroundColor[]; + +/** +@deprecated Use `backgroundColorNames` instead. + +Basic background color names. +*/ +export const backgroundColors: readonly BackgroundColor[]; + +/** +@deprecated Use `colorNames` instead. + +Basic color names. The combination of foreground and background color names. +*/ +export const colors: readonly Color[]; + +export default chalk; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.js new file mode 100644 index 000000000..8bc993da5 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.js @@ -0,0 +1,225 @@ +import ansiStyles from '#ansi-styles'; +import supportsColor from '#supports-color'; +import { // eslint-disable-line import/order + stringReplaceAll, + stringEncaseCRLFWithFirstIndex, +} from './utilities.js'; + +const {stdout: stdoutColor, stderr: stderrColor} = supportsColor; + +const GENERATOR = Symbol('GENERATOR'); +const STYLER = Symbol('STYLER'); +const IS_EMPTY = Symbol('IS_EMPTY'); + +// `supportsColor.level` → `ansiStyles.color[name]` mapping +const levelMapping = [ + 'ansi', + 'ansi', + 'ansi256', + 'ansi16m', +]; + +const styles = Object.create(null); + +const applyOptions = (object, options = {}) => { + if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) { + throw new Error('The `level` option should be an integer from 0 to 3'); + } + + // Detect level if not set manually + const colorLevel = stdoutColor ? stdoutColor.level : 0; + object.level = options.level === undefined ? colorLevel : options.level; +}; + +export class Chalk { + constructor(options) { + // eslint-disable-next-line no-constructor-return + return chalkFactory(options); + } +} + +const chalkFactory = options => { + const chalk = (...strings) => strings.join(' '); + applyOptions(chalk, options); + + Object.setPrototypeOf(chalk, createChalk.prototype); + + return chalk; +}; + +function createChalk(options) { + return chalkFactory(options); +} + +Object.setPrototypeOf(createChalk.prototype, Function.prototype); + +for (const [styleName, style] of Object.entries(ansiStyles)) { + styles[styleName] = { + get() { + const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]); + Object.defineProperty(this, styleName, {value: builder}); + return builder; + }, + }; +} + +styles.visible = { + get() { + const builder = createBuilder(this, this[STYLER], true); + Object.defineProperty(this, 'visible', {value: builder}); + return builder; + }, +}; + +const getModelAnsi = (model, level, type, ...arguments_) => { + if (model === 'rgb') { + if (level === 'ansi16m') { + return ansiStyles[type].ansi16m(...arguments_); + } + + if (level === 'ansi256') { + return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_)); + } + + return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_)); + } + + if (model === 'hex') { + return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_)); + } + + return ansiStyles[type][model](...arguments_); +}; + +const usedModels = ['rgb', 'hex', 'ansi256']; + +for (const model of usedModels) { + styles[model] = { + get() { + const {level} = this; + return function (...arguments_) { + const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]); + return createBuilder(this, styler, this[IS_EMPTY]); + }; + }, + }; + + const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1); + styles[bgModel] = { + get() { + const {level} = this; + return function (...arguments_) { + const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]); + return createBuilder(this, styler, this[IS_EMPTY]); + }; + }, + }; +} + +const proto = Object.defineProperties(() => {}, { + ...styles, + level: { + enumerable: true, + get() { + return this[GENERATOR].level; + }, + set(level) { + this[GENERATOR].level = level; + }, + }, +}); + +const createStyler = (open, close, parent) => { + let openAll; + let closeAll; + if (parent === undefined) { + openAll = open; + closeAll = close; + } else { + openAll = parent.openAll + open; + closeAll = close + parent.closeAll; + } + + return { + open, + close, + openAll, + closeAll, + parent, + }; +}; + +const createBuilder = (self, _styler, _isEmpty) => { + // Single argument is hot path, implicit coercion is faster than anything + // eslint-disable-next-line no-implicit-coercion + const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' ')); + + // We alter the prototype because we must return a function, but there is + // no way to create a function with a different prototype + Object.setPrototypeOf(builder, proto); + + builder[GENERATOR] = self; + builder[STYLER] = _styler; + builder[IS_EMPTY] = _isEmpty; + + return builder; +}; + +const applyStyle = (self, string) => { + if (self.level <= 0 || !string) { + return self[IS_EMPTY] ? '' : string; + } + + let styler = self[STYLER]; + + if (styler === undefined) { + return string; + } + + const {openAll, closeAll} = styler; + if (string.includes('\u001B')) { + while (styler !== undefined) { + // Replace any instances already present with a re-opening code + // otherwise only the part of the string until said closing code + // will be colored, and the rest will simply be 'plain'. + string = stringReplaceAll(string, styler.close, styler.open); + + styler = styler.parent; + } + } + + // We can move both next actions out of loop, because remaining actions in loop won't have + // any/visible effect on parts we add here. Close the styling before a linebreak and reopen + // after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92 + const lfIndex = string.indexOf('\n'); + if (lfIndex !== -1) { + string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex); + } + + return openAll + string + closeAll; +}; + +Object.defineProperties(createChalk.prototype, styles); + +const chalk = createChalk(); +export const chalkStderr = createChalk({level: stderrColor ? stderrColor.level : 0}); + +export { + modifierNames, + foregroundColorNames, + backgroundColorNames, + colorNames, + + // TODO: Remove these aliases in the next major version + modifierNames as modifiers, + foregroundColorNames as foregroundColors, + backgroundColorNames as backgroundColors, + colorNames as colors, +} from './vendor/ansi-styles/index.js'; + +export { + stdoutColor as supportsColor, + stderrColor as supportsColorStderr, +}; + +export default chalk; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/utilities.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/utilities.js new file mode 100644 index 000000000..4366dee0d --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/utilities.js @@ -0,0 +1,33 @@ +// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`. +export function stringReplaceAll(string, substring, replacer) { + let index = string.indexOf(substring); + if (index === -1) { + return string; + } + + const substringLength = substring.length; + let endIndex = 0; + let returnValue = ''; + do { + returnValue += string.slice(endIndex, index) + substring + replacer; + endIndex = index + substringLength; + index = string.indexOf(substring, endIndex); + } while (index !== -1); + + returnValue += string.slice(endIndex); + return returnValue; +} + +export function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) { + let endIndex = 0; + let returnValue = ''; + do { + const gotCR = string[index - 1] === '\r'; + returnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\r\n' : '\n') + postfix; + endIndex = index + 1; + index = string.indexOf('\n', endIndex); + } while (index !== -1); + + returnValue += string.slice(endIndex); + return returnValue; +} diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.d.ts b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.d.ts new file mode 100644 index 000000000..58f133abe --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.d.ts @@ -0,0 +1,236 @@ +export interface CSPair { // eslint-disable-line @typescript-eslint/naming-convention + /** + The ANSI terminal control sequence for starting this style. + */ + readonly open: string; + + /** + The ANSI terminal control sequence for ending this style. + */ + readonly close: string; +} + +export interface ColorBase { + /** + The ANSI terminal control sequence for ending this color. + */ + readonly close: string; + + ansi(code: number): string; + + ansi256(code: number): string; + + ansi16m(red: number, green: number, blue: number): string; +} + +export interface Modifier { + /** + Resets the current color chain. + */ + readonly reset: CSPair; + + /** + Make text bold. + */ + readonly bold: CSPair; + + /** + Emitting only a small amount of light. + */ + readonly dim: CSPair; + + /** + Make text italic. (Not widely supported) + */ + readonly italic: CSPair; + + /** + Make text underline. (Not widely supported) + */ + readonly underline: CSPair; + + /** + Make text overline. + + Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash. + */ + readonly overline: CSPair; + + /** + Inverse background and foreground colors. + */ + readonly inverse: CSPair; + + /** + Prints the text, but makes it invisible. + */ + readonly hidden: CSPair; + + /** + Puts a horizontal line through the center of the text. (Not widely supported) + */ + readonly strikethrough: CSPair; +} + +export interface ForegroundColor { + readonly black: CSPair; + readonly red: CSPair; + readonly green: CSPair; + readonly yellow: CSPair; + readonly blue: CSPair; + readonly cyan: CSPair; + readonly magenta: CSPair; + readonly white: CSPair; + + /** + Alias for `blackBright`. + */ + readonly gray: CSPair; + + /** + Alias for `blackBright`. + */ + readonly grey: CSPair; + + readonly blackBright: CSPair; + readonly redBright: CSPair; + readonly greenBright: CSPair; + readonly yellowBright: CSPair; + readonly blueBright: CSPair; + readonly cyanBright: CSPair; + readonly magentaBright: CSPair; + readonly whiteBright: CSPair; +} + +export interface BackgroundColor { + readonly bgBlack: CSPair; + readonly bgRed: CSPair; + readonly bgGreen: CSPair; + readonly bgYellow: CSPair; + readonly bgBlue: CSPair; + readonly bgCyan: CSPair; + readonly bgMagenta: CSPair; + readonly bgWhite: CSPair; + + /** + Alias for `bgBlackBright`. + */ + readonly bgGray: CSPair; + + /** + Alias for `bgBlackBright`. + */ + readonly bgGrey: CSPair; + + readonly bgBlackBright: CSPair; + readonly bgRedBright: CSPair; + readonly bgGreenBright: CSPair; + readonly bgYellowBright: CSPair; + readonly bgBlueBright: CSPair; + readonly bgCyanBright: CSPair; + readonly bgMagentaBright: CSPair; + readonly bgWhiteBright: CSPair; +} + +export interface ConvertColor { + /** + Convert from the RGB color space to the ANSI 256 color space. + + @param red - (`0...255`) + @param green - (`0...255`) + @param blue - (`0...255`) + */ + rgbToAnsi256(red: number, green: number, blue: number): number; + + /** + Convert from the RGB HEX color space to the RGB color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToRgb(hex: string): [red: number, green: number, blue: number]; + + /** + Convert from the RGB HEX color space to the ANSI 256 color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToAnsi256(hex: string): number; + + /** + Convert from the ANSI 256 color space to the ANSI 16 color space. + + @param code - A number representing the ANSI 256 color. + */ + ansi256ToAnsi(code: number): number; + + /** + Convert from the RGB color space to the ANSI 16 color space. + + @param red - (`0...255`) + @param green - (`0...255`) + @param blue - (`0...255`) + */ + rgbToAnsi(red: number, green: number, blue: number): number; + + /** + Convert from the RGB HEX color space to the ANSI 16 color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToAnsi(hex: string): number; +} + +/** +Basic modifier names. +*/ +export type ModifierName = keyof Modifier; + +/** +Basic foreground color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ForegroundColorName = keyof ForegroundColor; + +/** +Basic background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type BackgroundColorName = keyof BackgroundColor; + +/** +Basic color names. The combination of foreground and background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ColorName = ForegroundColorName | BackgroundColorName; + +/** +Basic modifier names. +*/ +export const modifierNames: readonly ModifierName[]; + +/** +Basic foreground color names. +*/ +export const foregroundColorNames: readonly ForegroundColorName[]; + +/** +Basic background color names. +*/ +export const backgroundColorNames: readonly BackgroundColorName[]; + +/* +Basic color names. The combination of foreground and background color names. +*/ +export const colorNames: readonly ColorName[]; + +declare const ansiStyles: { + readonly modifier: Modifier; + readonly color: ColorBase & ForegroundColor; + readonly bgColor: ColorBase & BackgroundColor; + readonly codes: ReadonlyMap; +} & ForegroundColor & BackgroundColor & Modifier & ConvertColor; + +export default ansiStyles; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.js new file mode 100644 index 000000000..eaa7bed6c --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.js @@ -0,0 +1,223 @@ +const ANSI_BACKGROUND_OFFSET = 10; + +const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`; + +const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`; + +const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`; + +const styles = { + modifier: { + reset: [0, 0], + // 21 isn't widely supported and 22 does the same thing + bold: [1, 22], + dim: [2, 22], + italic: [3, 23], + underline: [4, 24], + overline: [53, 55], + inverse: [7, 27], + hidden: [8, 28], + strikethrough: [9, 29], + }, + color: { + black: [30, 39], + red: [31, 39], + green: [32, 39], + yellow: [33, 39], + blue: [34, 39], + magenta: [35, 39], + cyan: [36, 39], + white: [37, 39], + + // Bright color + blackBright: [90, 39], + gray: [90, 39], // Alias of `blackBright` + grey: [90, 39], // Alias of `blackBright` + redBright: [91, 39], + greenBright: [92, 39], + yellowBright: [93, 39], + blueBright: [94, 39], + magentaBright: [95, 39], + cyanBright: [96, 39], + whiteBright: [97, 39], + }, + bgColor: { + bgBlack: [40, 49], + bgRed: [41, 49], + bgGreen: [42, 49], + bgYellow: [43, 49], + bgBlue: [44, 49], + bgMagenta: [45, 49], + bgCyan: [46, 49], + bgWhite: [47, 49], + + // Bright color + bgBlackBright: [100, 49], + bgGray: [100, 49], // Alias of `bgBlackBright` + bgGrey: [100, 49], // Alias of `bgBlackBright` + bgRedBright: [101, 49], + bgGreenBright: [102, 49], + bgYellowBright: [103, 49], + bgBlueBright: [104, 49], + bgMagentaBright: [105, 49], + bgCyanBright: [106, 49], + bgWhiteBright: [107, 49], + }, +}; + +export const modifierNames = Object.keys(styles.modifier); +export const foregroundColorNames = Object.keys(styles.color); +export const backgroundColorNames = Object.keys(styles.bgColor); +export const colorNames = [...foregroundColorNames, ...backgroundColorNames]; + +function assembleStyles() { + const codes = new Map(); + + for (const [groupName, group] of Object.entries(styles)) { + for (const [styleName, style] of Object.entries(group)) { + styles[styleName] = { + open: `\u001B[${style[0]}m`, + close: `\u001B[${style[1]}m`, + }; + + group[styleName] = styles[styleName]; + + codes.set(style[0], style[1]); + } + + Object.defineProperty(styles, groupName, { + value: group, + enumerable: false, + }); + } + + Object.defineProperty(styles, 'codes', { + value: codes, + enumerable: false, + }); + + styles.color.close = '\u001B[39m'; + styles.bgColor.close = '\u001B[49m'; + + styles.color.ansi = wrapAnsi16(); + styles.color.ansi256 = wrapAnsi256(); + styles.color.ansi16m = wrapAnsi16m(); + styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET); + styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET); + styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET); + + // From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js + Object.defineProperties(styles, { + rgbToAnsi256: { + value(red, green, blue) { + // We use the extended greyscale palette here, with the exception of + // black and white. normal palette only has 4 greyscale shades. + if (red === green && green === blue) { + if (red < 8) { + return 16; + } + + if (red > 248) { + return 231; + } + + return Math.round(((red - 8) / 247) * 24) + 232; + } + + return 16 + + (36 * Math.round(red / 255 * 5)) + + (6 * Math.round(green / 255 * 5)) + + Math.round(blue / 255 * 5); + }, + enumerable: false, + }, + hexToRgb: { + value(hex) { + const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16)); + if (!matches) { + return [0, 0, 0]; + } + + let [colorString] = matches; + + if (colorString.length === 3) { + colorString = [...colorString].map(character => character + character).join(''); + } + + const integer = Number.parseInt(colorString, 16); + + return [ + /* eslint-disable no-bitwise */ + (integer >> 16) & 0xFF, + (integer >> 8) & 0xFF, + integer & 0xFF, + /* eslint-enable no-bitwise */ + ]; + }, + enumerable: false, + }, + hexToAnsi256: { + value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)), + enumerable: false, + }, + ansi256ToAnsi: { + value(code) { + if (code < 8) { + return 30 + code; + } + + if (code < 16) { + return 90 + (code - 8); + } + + let red; + let green; + let blue; + + if (code >= 232) { + red = (((code - 232) * 10) + 8) / 255; + green = red; + blue = red; + } else { + code -= 16; + + const remainder = code % 36; + + red = Math.floor(code / 36) / 5; + green = Math.floor(remainder / 6) / 5; + blue = (remainder % 6) / 5; + } + + const value = Math.max(red, green, blue) * 2; + + if (value === 0) { + return 30; + } + + // eslint-disable-next-line no-bitwise + let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red)); + + if (value === 2) { + result += 60; + } + + return result; + }, + enumerable: false, + }, + rgbToAnsi: { + value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)), + enumerable: false, + }, + hexToAnsi: { + value: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)), + enumerable: false, + }, + }); + + return styles; +} + +const ansiStyles = assembleStyles(); + +export default ansiStyles; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.d.ts b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.d.ts new file mode 100644 index 000000000..0e8a9ccb8 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.d.ts @@ -0,0 +1 @@ +export {default} from './index.js'; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.js new file mode 100644 index 000000000..fbb6ce0fc --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.js @@ -0,0 +1,34 @@ +/* eslint-env browser */ + +const level = (() => { + if (!('navigator' in globalThis)) { + return 0; + } + + if (globalThis.navigator.userAgentData) { + const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium'); + if (brand && brand.version > 93) { + return 3; + } + } + + if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) { + return 1; + } + + return 0; +})(); + +const colorSupport = level !== 0 && { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3, +}; + +const supportsColor = { + stdout: colorSupport, + stderr: colorSupport, +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.d.ts b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.d.ts new file mode 100644 index 000000000..db44a7851 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.d.ts @@ -0,0 +1,55 @@ +import type {WriteStream} from 'node:tty'; + +export type Options = { + /** + Whether `process.argv` should be sniffed for `--color` and `--no-color` flags. + + @default true + */ + readonly sniffFlags?: boolean; +}; + +/** +Levels: +- `0` - All colors disabled. +- `1` - Basic 16 colors support. +- `2` - ANSI 256 colors support. +- `3` - Truecolor 16 million colors support. +*/ +export type ColorSupportLevel = 0 | 1 | 2 | 3; + +/** +Detect whether the terminal supports color. +*/ +export type ColorSupport = { + /** + The color level. + */ + level: ColorSupportLevel; + + /** + Whether basic 16 colors are supported. + */ + hasBasic: boolean; + + /** + Whether ANSI 256 colors are supported. + */ + has256: boolean; + + /** + Whether Truecolor 16 million colors are supported. + */ + has16m: boolean; +}; + +export type ColorInfo = ColorSupport | false; + +export function createSupportsColor(stream?: WriteStream, options?: Options): ColorInfo; + +declare const supportsColor: { + stdout: ColorInfo; + stderr: ColorInfo; +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.js new file mode 100644 index 000000000..265d7f858 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.js @@ -0,0 +1,190 @@ +import process from 'node:process'; +import os from 'node:os'; +import tty from 'node:tty'; + +// From: https://github.com/sindresorhus/has-flag/blob/main/index.js +/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) { +function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) { + const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--'); + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf('--'); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); +} + +const {env} = process; + +let flagForceColor; +if ( + hasFlag('no-color') + || hasFlag('no-colors') + || hasFlag('color=false') + || hasFlag('color=never') +) { + flagForceColor = 0; +} else if ( + hasFlag('color') + || hasFlag('colors') + || hasFlag('color=true') + || hasFlag('color=always') +) { + flagForceColor = 1; +} + +function envForceColor() { + if ('FORCE_COLOR' in env) { + if (env.FORCE_COLOR === 'true') { + return 1; + } + + if (env.FORCE_COLOR === 'false') { + return 0; + } + + return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); + } +} + +function translateLevel(level) { + if (level === 0) { + return false; + } + + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3, + }; +} + +function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) { + const noFlagForceColor = envForceColor(); + if (noFlagForceColor !== undefined) { + flagForceColor = noFlagForceColor; + } + + const forceColor = sniffFlags ? flagForceColor : noFlagForceColor; + + if (forceColor === 0) { + return 0; + } + + if (sniffFlags) { + if (hasFlag('color=16m') + || hasFlag('color=full') + || hasFlag('color=truecolor')) { + return 3; + } + + if (hasFlag('color=256')) { + return 2; + } + } + + // Check for Azure DevOps pipelines. + // Has to be above the `!streamIsTTY` check. + if ('TF_BUILD' in env && 'AGENT_NAME' in env) { + return 1; + } + + if (haveStream && !streamIsTTY && forceColor === undefined) { + return 0; + } + + const min = forceColor || 0; + + if (env.TERM === 'dumb') { + return min; + } + + if (process.platform === 'win32') { + // Windows 10 build 10586 is the first Windows release that supports 256 colors. + // Windows 10 build 14931 is the first release that supports 16m/TrueColor. + const osRelease = os.release().split('.'); + if ( + Number(osRelease[0]) >= 10 + && Number(osRelease[2]) >= 10_586 + ) { + return Number(osRelease[2]) >= 14_931 ? 3 : 2; + } + + return 1; + } + + if ('CI' in env) { + if (['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some(key => key in env)) { + return 3; + } + + if (['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') { + return 1; + } + + return min; + } + + if ('TEAMCITY_VERSION' in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + + if (env.COLORTERM === 'truecolor') { + return 3; + } + + if (env.TERM === 'xterm-kitty') { + return 3; + } + + if (env.TERM === 'xterm-ghostty') { + return 3; + } + + if (env.TERM === 'wezterm') { + return 3; + } + + if ('TERM_PROGRAM' in env) { + const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); + + switch (env.TERM_PROGRAM) { + case 'iTerm.app': { + return version >= 3 ? 3 : 2; + } + + case 'Apple_Terminal': { + return 2; + } + // No default + } + } + + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + + if ('COLORTERM' in env) { + return 1; + } + + return min; +} + +export function createSupportsColor(stream, options = {}) { + const level = _supportsColor(stream, { + streamIsTTY: stream && stream.isTTY, + ...options, + }); + + return translateLevel(level); +} + +const supportsColor = { + stdout: createSupportsColor({isTTY: tty.isatty(1)}), + stderr: createSupportsColor({isTTY: tty.isatty(2)}), +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5/package.json b/tests/fixtures/npm/cases/chalk5/package.json new file mode 100644 index 000000000..3804daa8d --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/package.json @@ -0,0 +1 @@ +{ "name": "chalk5-case", "private": true, "type": "module" } diff --git a/tests/harness/chalk.test.ts b/tests/harness/chalk.test.ts new file mode 100644 index 000000000..4d99bf3ee --- /dev/null +++ b/tests/harness/chalk.test.ts @@ -0,0 +1,97 @@ +/* chalk 5 compiled from its published JavaScript (tests/fixtures/npm/cases/ + * chalk5): the program runs under Node and as a native binary with each + * color-detection input supports-color reads — FORCE_COLOR values and the + * --color/--no-color flags — and stdout, stderr and the exit status must + * match byte for byte. npm.test.ts runs the same case once in the + * harness's own environment. */ +import { execFile } from "node:child_process"; +import { mkdirSync } from "node:fs"; +import { dirname, join } from "node:path"; +import { promisify } from "node:util"; +import { beforeAll, describe, expect, test } from "vitest"; +import { compile } from "@scriptc/compiler"; + +const execFileAsync = promisify(execFile); +const repoRoot = join(import.meta.dirname, "../.."); +const entry = join(repoRoot, "tests/fixtures/npm/cases/chalk5/main.ts"); +const outDir = join(repoRoot, "node_modules/.cache/scriptc-tests/chalk5"); +const sanitize = process.env["SCRIPTC_SAN"] === "1"; + +interface RunResult { + stdout: string; + stderr: string; + exitCode: number; +} + +async function run(cmd: string, args: string[], env: NodeJS.ProcessEnv): Promise { + try { + const pending = execFileAsync(cmd, args, { cwd: dirname(entry), env, encoding: "utf8" }); + pending.child.stdin?.end(); + const { stdout, stderr } = await pending; + return { stdout, stderr, exitCode: 0 }; + } catch (err) { + const e = err as { code?: unknown; stdout?: string; stderr?: string }; + if (typeof e.stdout !== "string" || typeof e.stderr !== "string") throw err; + return { + stdout: e.stdout, + stderr: e.stderr, + exitCode: typeof e.code === "number" ? e.code : -1, + }; + } +} + +/** The harness environment without the color inputs, plus `force`. */ +function colorEnv(force: string | undefined): NodeJS.ProcessEnv { + const env = { ...process.env }; + delete env["FORCE_COLOR"]; + delete env["NO_COLOR"]; + delete env["NODE_DISABLE_COLORS"]; + if (force !== undefined) env["FORCE_COLOR"] = force; + return env; +} + +const cases: { name: string; force: string | undefined; argv: string[] }[] = [ + { name: "FORCE_COLOR unset", force: undefined, argv: [] }, + ...["0", "1", "2", "3", "true", "false", ""].map((force) => ({ + name: `FORCE_COLOR=${JSON.stringify(force)}`, + force, + argv: [], + })), + ...[ + ["--no-color"], + ["--color"], + ["--color=256"], + ["--color=16m"], + ["--color", "--", "--no-color"], + ].map((argv) => ({ name: argv.join(" "), force: undefined, argv })), + { name: "FORCE_COLOR=3 --no-color", force: "3", argv: ["--no-color"] }, +]; + +let binary = ""; + +beforeAll(async () => { + mkdirSync(outDir, { recursive: true }); + const result = await compile(entry, { outPath: join(outDir, "program"), outDir, sanitize }); + if (!result.ok) + throw new Error(result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")); + binary = result.binaryPath; +}, 300_000); + +describe("chalk 5 color detection matches Node", () => { + for (const c of cases) { + test( + c.name, + async () => { + const env = colorEnv(c.force); + const [node, native] = await Promise.all([ + run(process.execPath, [entry, ...c.argv], env), + run(binary, c.argv, env), + ]); + expect(native.stdout).toBe(node.stdout); + expect(native.stderr).toBe(node.stderr); + expect(native.exitCode).toBe(node.exitCode); + }, + 60_000, + ); + } +}); From d3dba4c07f56b0b719ca37d811d23418708379cf Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 10:59:27 -0500 Subject: [PATCH 25/47] 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 26/47] 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 577b0135a971413c885396f99945acb4639585d5 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 09:12:27 -0700 Subject: [PATCH 27/47] Add execution tiers to the IR and a report-only tier analysis Stage S2 of the two-tier design. IrFunction gains a tier (absent means static); lowering assigns it from function bodies, placing functions that use the dyn vocabulary in the dynamic tier, and the validator enforces invariant I1: a static function performs no dynamic operation, only boundary operations (dynFrom, dynCheck, kind tests) and moves. Serialized IR keeps the field out in this stage and loaders derive it again, so every IR, LLVM and executable artifact is unchanged. Every committed refusal and runtime fence becomes a recorded demotion request attributed to the binding, field, function instance, class or module the dynamic tier would take over, while the compiler still refuses and fences as before. `scriptc coverage` reports dynamic-tier statements (statementsDynamic), `--explain-dynamic[=]` prints the demotion chains, and `--tier=auto|static-only` is wired through build, run and coverage for stage S6; both modes compile identically today. Co-Authored-By: Claude Opus 5.5 --- docs/content/docs/cli.mdx | 6 + docs/content/docs/coverage.mdx | 13 +- packages/compiler/src/cli/command.ts | 43 +- packages/compiler/src/cli/usage.ts | 12 + packages/compiler/src/compile-types.ts | 10 + packages/compiler/src/coverage/report.ts | 148 ++++- .../compiler/src/coverage/verdict-cache.ts | 5 + packages/compiler/src/diagnostics/envelope.ts | 36 +- packages/compiler/src/executable/prepare.ts | 1 + packages/compiler/src/frontend/analysis.ts | 3 + .../compiler/src/frontend/lowering/lowerer.ts | 67 ++ .../compiler/src/frontend/tier-analysis.ts | 629 ++++++++++++++++++ packages/compiler/src/index.ts | 18 + packages/compiler/src/ir/ir.ts | 8 + packages/compiler/src/ir/serialize.ts | 24 +- packages/compiler/src/ir/tiers.test.ts | 142 ++++ packages/compiler/src/ir/tiers.ts | 157 +++++ packages/compiler/src/ir/validate.test.ts | 6 +- packages/compiler/src/ir/validate.ts | 12 + packages/compiler/src/library/prepare.ts | 2 + tests/coverage-fixtures/tier-demotions.ts | 25 + .../__snapshots__/coverage-divergences.txt | 1 + .../__snapshots__/coverage-dynamic-mix.txt | 1 + .../coverage-explain-dynamic.txt | 16 + .../harness/__snapshots__/coverage-js-gap.txt | 1 + .../harness/__snapshots__/coverage-mixed.txt | 1 + .../__snapshots__/coverage-npm-packages.txt | 1 + .../__snapshots__/coverage-tier-demotions.txt | 13 + .../__snapshots__/coverage-width-copies.txt | 1 + tests/harness/coverage.test.ts | 107 ++- 30 files changed, 1494 insertions(+), 15 deletions(-) create mode 100644 packages/compiler/src/frontend/tier-analysis.ts create mode 100644 packages/compiler/src/ir/tiers.test.ts create mode 100644 packages/compiler/src/ir/tiers.ts create mode 100644 tests/coverage-fixtures/tier-demotions.ts create mode 100644 tests/harness/__snapshots__/coverage-explain-dynamic.txt create mode 100644 tests/harness/__snapshots__/coverage-tier-demotions.txt diff --git a/docs/content/docs/cli.mdx b/docs/content/docs/cli.mdx index a6f75c6d3..e8596fc3d 100644 --- a/docs/content/docs/cli.mdx +++ b/docs/content/docs/cli.mdx @@ -127,6 +127,12 @@ Verifies and loads the installed precompiled runtime objects and vendored librar
--external-types <specifier=file.d.ts>
Coverage only. Map an exact bare module specifier to a local declaration file supplied by an embedder. Repeat the option for multiple modules. The declaration supplies checker types so application coverage can continue; runtime imports and values remain explicit SC1010 blockers. Relative paths resolve from the current working directory. Accepted files end in .d.ts, .d.mts, or .d.cts.
+
--tier <auto|static-only>
+
The tier policy for code that has no static lowering. auto is the default. static-only guarantees that the program contains no dynamic-tier demotions: every such construct stays a compile error in TypeScript and a deferred runtime error in JavaScript, which is how both modes behave today. Use it in CI to keep a program fully static. Library mode is always static-only. See Dynamic tier.
+ +
--explain-dynamic[=<name>]
+
Coverage only. After the report, list the functions that already operate on values typed only at runtime and the bindings, fields, functions, classes and modules that unsupported constructs would move to the dynamic tier, each with the diagnostic behind it. With a name such as x, Point, or Point.x, show only the matching units. See Dynamic tier.
+
--sanitize
Build an executable with AddressSanitizer and a reference-count audit at exit, the same checks scriptc's own test suite uses. Requires a C compiler and is available only for host builds. Not supported with --emit=asm or --emit=obj.
diff --git a/docs/content/docs/coverage.mdx b/docs/content/docs/coverage.mdx index 2d26e684b..805d7f612 100644 --- a/docs/content/docs/coverage.mdx +++ b/docs/content/docs/coverage.mdx @@ -36,6 +36,7 @@ When a program has unsupported operations, the report adds a group for each root statements analyzedExecutable statements in application code, excluding dependency implementation code. compile staticallyStatements that compile to native instructions. + in dynamic tierOf those, the statements in functions that operate on values typed only at runtime, such as any values and untyped JavaScript. Shown when there are any. See Dynamic tier. blockersUnsupported operations with counts, diagnostic codes, reasons, locations, and hints. in unreached codeBlockers in code the entry never reaches. A build never compiles that code, so these cannot fail it. differs from NodeSites that compile but can behave differently from Node.js. See Node divergences. @@ -51,6 +52,16 @@ If a function's signature can't compile, the statements in its body count as not + + +## Dynamic tier + +Code that operates on values whose types are known only at runtime, such as `any` values, the result of an untyped `JSON.parse`, or untyped JavaScript, compiles into dynamic-tier functions. They are native code too, but they check types and look up properties at runtime, so they are slower than code with static types. The report's `in dynamic tier` line counts their statements. + +`--explain-dynamic` lists those functions and the operation that makes each one dynamic. It also lists the units an unsupported construct would move to the dynamic tier: the binding, field, class, function, or module that has no static representation for the construct, with the diagnostic behind each one. These are the constructs the dynamic tier is planned to compile; today they remain blockers in TypeScript and deferred runtime errors in JavaScript. Add a name, such as `--explain-dynamic=Point`, to show only the matching units. With `--print=diagnostics`, the document gains a `tiers` object with the same information. + +`--tier=static-only` keeps every unsupported construct a blocker instead of moving it to the dynamic tier; code that already operates on runtime-typed values compiles as before. Today `auto`, the default, behaves the same way. + ## Diagnostic codes Coverage and `scriptc build` report the same diagnostic codes. Common ones include: @@ -160,7 +171,7 @@ For editors, CI annotations, and other tools, `scriptc coverage --print=diagnost stats - Coverage only, absent after a preflight failure: the report's statement counts. statementsDynamic is always 0 and remains for schema compatibility. + Coverage only, absent after a preflight failure: the report's statement counts. statementsStatic counts every statement that compiles to native code; statementsDynamic is the part of those in dynamic-tier functions. category diff --git a/packages/compiler/src/cli/command.ts b/packages/compiler/src/cli/command.ts index d729de866..6810cc8fb 100644 --- a/packages/compiler/src/cli/command.ts +++ b/packages/compiler/src/cli/command.ts @@ -7,8 +7,10 @@ import { coverageEnvelope, coveragePasses, renderCoverage, + renderExplainDynamic, type CoverageFailOn, } from "../coverage/report.js"; +import { TIER_MODES, type TierMode } from "../frontend/tier-analysis.js"; import { buildEnvelope } from "../diagnostics/envelope.js"; import { renderWarnings } from "../diagnostics/render.js"; import { isNativeOptimization } from "../backend/optimization.js"; @@ -45,8 +47,15 @@ function parseCli( ): ReturnType< typeof parseArgs<{ options: typeof CLI_OPTIONS; allowPositionals: true; allowNegative: true }> > { + // `--explain-dynamic` takes an optional value: alone it lists every unit. + const normalized = args.map((arg) => (arg === "--explain-dynamic" ? "--explain-dynamic=" : arg)); try { - return parseArgs({ args, options: CLI_OPTIONS, allowPositionals: true, allowNegative: true }); + return parseArgs({ + args: normalized, + options: CLI_OPTIONS, + allowPositionals: true, + allowNegative: true, + }); } catch (err) { // parseArgs appends a paragraph about `--` and positionals to the // unknown-option message; the first sentence is the part that names @@ -91,6 +100,8 @@ async function main(args: string[], host: CliHost): Promise { externalTypeArgs.length > 0 || values.out !== undefined || values["emit-ir"] || + values.tier !== undefined || + values["explain-dynamic"] !== undefined || !values["keep-llvm"] ) { fail( @@ -152,10 +163,12 @@ async function main(args: string[], host: CliHost): Promise { values["windows-subsystem"] !== undefined || values["detached-exit"] || (values["npm-static"] ?? []).length > 0 || - externalTypeArgs.length > 0 + externalTypeArgs.length > 0 || + values.tier !== undefined || + values["explain-dynamic"] !== undefined ) { fail( - "scriptc build --lib takes no --backend/--emit/--print/--optimization/--strip/--windows-subsystem/--detached-exit/--npm-static/--ffi/--external-types: the profile pins the emission and optimization, npm imports are judged automatically, outbound FFI belongs to executable builds, and external type mappings belong to coverage", + "scriptc build --lib takes no --backend/--emit/--print/--optimization/--strip/--windows-subsystem/--detached-exit/--npm-static/--ffi/--external-types/--tier/--explain-dynamic: the profile pins the emission and optimization, npm imports are judged automatically, outbound FFI belongs to executable builds, external type mappings belong to coverage, and library artifacts are static-tier only", ); } const profilePath = resolve(profileArg); @@ -223,6 +236,15 @@ async function main(args: string[], host: CliHost): Promise { fail(`--fail-on is a coverage option (a build already fails on blockers)\n\n${USAGE}`); } const failOn = failOnRaw as CoverageFailOn | undefined; + const tierRaw = values.tier; + if (tierRaw !== undefined && !(TIER_MODES as readonly string[]).includes(tierRaw)) { + fail(`unknown --tier value "${tierRaw}" (supported: ${TIER_MODES.join(", ")})\n\n${USAGE}`); + } + const tier = tierRaw as TierMode | undefined; + const explainDynamic = values["explain-dynamic"]; + if (explainDynamic !== undefined && command !== "coverage") { + fail(`--explain-dynamic is a coverage option\n\n${USAGE}`); + } if (printNativeLinkInfo && command !== "build") { fail(`--print=native-link-info is a build option\n\n${USAGE}`); } @@ -340,6 +362,8 @@ async function main(args: string[], host: CliHost): Promise { ...(npmStatic !== undefined ? { npmStatic } : {}), ...(ffiProfilePath !== undefined ? { ffiProfilePath } : {}), ...(Object.keys(externalTypes).length > 0 ? { externalTypes } : {}), + ...(tier !== undefined ? { tier } : {}), + ...(explainDynamic !== undefined ? { explainDynamic: true } : {}), }); if (printDiagnostics) { // Keep stdout pure JSON for tooling. @@ -354,6 +378,18 @@ async function main(args: string[], host: CliHost): Promise { process.stdout.write( renderCoverage(coverage, { color, sourceTexts, root: process.cwd() }) + "\n", ); + if (explainDynamic !== undefined && coverage.tiers !== undefined) { + process.stdout.write( + "\n" + + renderExplainDynamic(coverage.tiers, { + color, + sourceTexts, + root: process.cwd(), + query: explainDynamic, + }) + + "\n", + ); + } } return coveragePasses(coverage, failOn) ? 0 : 1; } @@ -386,6 +422,7 @@ async function main(args: string[], host: CliHost): Promise { ...(npmStatic !== undefined ? { npmStatic } : {}), ...(ffiProfilePath !== undefined ? { ffiProfilePath } : {}), ...(printNativeLinkInfo ? { nativeLinkInfo: true } : {}), + ...(tier !== undefined ? { tier } : {}), }); if (!result.ok) { if (printDiagnostics) { diff --git a/packages/compiler/src/cli/usage.ts b/packages/compiler/src/cli/usage.ts index a0388374b..97c56c274 100644 --- a/packages/compiler/src/cli/usage.ts +++ b/packages/compiler/src/cli/usage.ts @@ -69,6 +69,16 @@ Options: local declaration file. The declaration supplies types for analysis; the host module remains an explicit external-boundary blocker (repeatable) + --tier + tier policy (default: auto). static-only keeps every + construct without a static lowering a compile error, so + the program has no dynamic-tier demotions. Both modes + currently compile identically + --explain-dynamic[=] + coverage only: list the functions that operate on dynamic + values and the bindings, fields, functions, classes and + modules the dynamic tier would take over, with the + refusal behind each; a name shows only that unit's chain -h, --help show this help -v, --version print the version `; @@ -90,6 +100,8 @@ export const CLI_OPTIONS = { "npm-static": { type: "string", multiple: true }, "provenance-sources": { type: "boolean", default: false }, "external-types": { type: "string", multiple: true }, + tier: { type: "string" }, + "explain-dynamic": { type: "string" }, lib: { type: "boolean", default: false }, profile: { type: "string" }, help: { type: "boolean", short: "h", default: false }, diff --git a/packages/compiler/src/compile-types.ts b/packages/compiler/src/compile-types.ts index de2c1a335..f069df247 100644 --- a/packages/compiler/src/compile-types.ts +++ b/packages/compiler/src/compile-types.ts @@ -3,6 +3,7 @@ import type { NativeLinkInfo } from "./backend/native-link-info.js"; import type { NativeOptimization } from "./backend/optimization.js"; import type { ScrDiagnostic } from "./diagnostics/diagnostic.js"; import type { CoverageInput } from "./coverage/report.js"; +import type { TierMode } from "./frontend/tier-analysis.js"; export type CompileOutputKind = "ir" | "llvm" | "asm" | "obj" | "exe"; @@ -45,6 +46,10 @@ export interface CompileBaseOptions { /** Attach the machine-readable external link recipe to an object result. * Valid only with outputKind "obj"; it never invokes a linker. */ nativeLinkInfo?: boolean; + /** `--tier` (frontend/tier-analysis.ts). "static-only" keeps every demotion + * request a refusal (design invariant I2). Until demotion lands both modes + * compile exactly as before. */ + tier?: TierMode; } /** Executable compile options. This remains the compatibility type for the @@ -161,6 +166,11 @@ export interface AnalyzeOptions { * to analyze project code, but imported runtime values remain explicit * SC1010 blockers rather than being counted as executable. */ externalTypes?: Readonly>; + /** `--tier` (see CompileBaseOptions.tier). */ + tier?: TierMode; + /** `--explain-dynamic`: attach the tier-assignment report + * (CoverageInput.tiers). Such analyses bypass the verdict cache. */ + explainDynamic?: boolean; } export interface AnalyzeResult { diff --git a/packages/compiler/src/coverage/report.ts b/packages/compiler/src/coverage/report.ts index 9d0776d9a..730704f6f 100644 --- a/packages/compiler/src/coverage/report.ts +++ b/packages/compiler/src/coverage/report.ts @@ -17,10 +17,13 @@ import { type DiagnosticsEnvelope, type LocatedDiagnostic, type SourcePosition, + type TierUnitPosition, + type TiersEnvelope, } from "../diagnostics/envelope.js"; import { renderDiagnostics } from "../diagnostics/render.js"; import type { LowerStats } from "../frontend/lowering/lowerer.js"; import type { ProvenanceSources } from "../frontend/provenance-registry.js"; +import type { DemotionUnit, TierReport } from "../frontend/tier-analysis.js"; export interface CoverageInput { file: string; @@ -51,6 +54,9 @@ export interface CoverageInput { /** --provenance-sources: diagnostics of elided pure-annotated dead * consts (off the build; the provenance section names them). */ provenanceElided?: ScrDiagnostic[]; + /** --explain-dynamic: the report-only tier assignment (which bindings, + * fields, functions, classes and modules the dynamic tier would take). */ + tiers?: TierReport; /** True when tsc preflight failed — no coverage can be computed. */ preflightFailed: boolean; } @@ -180,6 +186,12 @@ export function renderCoverage(input: CoverageInput, opts: CoverageRenderOptions out.push(` statements analyzed ${total}`); out.push(` compile statically ${ok} ${c(pctColor, c(BOLD, `(${pct}%)`))}`); + const dynamic = dynamicStatements(input); + if (dynamic > 0) { + out.push( + ` in dynamic tier ${dynamic} ${c(DIM, "(operate on values typed only at runtime; --explain-dynamic lists them)")}`, + ); + } if (skipped > 0) { out.push( @@ -432,13 +444,147 @@ export function coverageEnvelope( stats: { statementsTotal: total, statementsStatic: ok, - statementsDynamic: 0, + statementsDynamic: dynamicStatements(input), statementsFailed: failed, functionsSkipped: skipped, percentStatic: total === 0 ? 100 : Math.floor((ok / total) * 100), }, }), + ...(input.tiers !== undefined ? { tiers: tiersEnvelope(input.tiers, locator) } : {}), groups, diagnostics: located, }; } + +/** Reached statements in dynamic-tier functions, never more than the + * compiled statements they are part of. */ +function dynamicStatements(input: CoverageInput): number { + const compiled = input.stats.statementsTotal - input.stats.statementsFailed; + return Math.max(0, Math.min(input.stats.statementsDynamic ?? 0, compiled)); +} + +function tiersEnvelope(tiers: TierReport, locator: SourceLocator): TiersEnvelope { + const at = (loc: { file: string; start: number }): SourcePosition => ({ + file: loc.file, + ...locator.position(loc.file, loc.start), + }); + const unit = (u: DemotionUnit): TierUnitPosition => ({ + kind: u.kind, + name: u.name, + ...(u.owner !== undefined ? { owner: u.owner } : {}), + ...at(u.loc), + }); + return { + mode: tiers.mode, + statementsDynamic: tiers.statementsDynamic, + dynamicFunctions: tiers.dynamicFunctions.map((fn) => ({ + name: fn.name, + ...at(fn.loc), + operation: fn.operation, + operationAt: at(fn.operationLoc), + statements: fn.statements, + })), + requests: tiers.requests.map((r) => ({ + unit: unit(r.unit), + enclosing: unit(r.enclosing), + seed: r.seed, + scope: r.scope, + code: r.code, + message: r.message, + ...at(r.loc), + })), + units: tiers.units.map((u) => ({ ...unit(u), requests: u.requests, sites: u.sites })), + }; +} + +/** IR function names as a user reads them: `%init.3` is a module's top + * level, `%Point.norm` the method `Point.norm`; generated helpers keep + * their `%`-prefixed names. */ +function functionDisplayName(name: string): string { + if (name.startsWith("%init.")) return ""; + if (/^%[A-Za-z_$][\w$]*\.[A-Za-z_$#][\w$]*$/.test(name)) return name.slice(1); + return name; +} + +function unitLabel(u: DemotionUnit, root: string | undefined): string { + if (u.kind === "module") return `module ${displayPath(u.name, root)}`; + if (u.kind === "binding" && u.owner !== undefined) return `binding ${u.name} in ${u.owner}`; + return `${u.kind} ${u.name}`; +} + +function unitMatches(u: DemotionUnit, query: string): boolean { + return ( + u.name === query || + u.name.endsWith(`.${query}`) || + u.name.split(" ")[0] === query || + `${u.owner ?? ""}:${u.name}` === query + ); +} + +/** `scriptc coverage --explain-dynamic[=]`: the dynamic tier today + * and the demotion chains the report-only analysis computed. With a query, + * only units whose name matches it (`x`, `Point.x`, `parse:x`). */ +export function renderExplainDynamic( + tiers: TierReport, + opts: CoverageRenderOptions & { query?: string } = {}, +): string { + const c = (code: string, s: string) => (opts.color ? code + s + RESET : s); + const locator = new SourceLocator(opts.sourceTexts); + const where = (loc: { file: string; start: number }) => { + const p = locator.position(loc.file, loc.start); + return `${displayPath(loc.file, opts.root)}:${p.line}:${p.column}`; + }; + const query = opts.query !== undefined && opts.query !== "" ? opts.query : undefined; + const out: string[] = []; + out.push( + ` ${c(BOLD, "dynamic tier")} ${c(DIM, `(tier assignment, report-only; --tier=${tiers.mode})`)}`, + ); + if (query === undefined) { + const fns = tiers.dynamicFunctions; + out.push( + ` ${fns.length} function${fns.length === 1 ? "" : "s"} already operate${fns.length === 1 ? "s" : ""} on dynamic values ${c(DIM, `(${tiers.statementsDynamic} statement${tiers.statementsDynamic === 1 ? "" : "s"})`)}`, + ); + for (const fn of fns) { + out.push( + ` ${functionDisplayName(fn.name)} ${c(DIM, `${where(fn.loc)}: ${fn.operation} at ${where(fn.operationLoc)}`)}`, + ); + } + } + const live = tiers.requests.filter((r) => r.scope !== "unreached" && r.seed !== "excluded"); + const excluded = tiers.requests.filter((r) => r.seed === "excluded").length; + const unreached = tiers.requests.filter((r) => r.scope === "unreached").length; + if (query === undefined) { + out.push(""); + out.push( + ` ${live.length} demotion request${live.length === 1 ? "" : "s"} ${c(DIM, "(refusals and fences the dynamic tier would replace)")}` + + (unreached > 0 ? c(DIM, `, ${unreached} more in unreached code`) : "") + + (excluded > 0 ? c(DIM, `, ${excluded} excluded by policy`) : ""), + ); + } + const units = tiers.units.filter((u) => query === undefined || unitMatches(u, query)); + if (query !== undefined && units.length === 0) { + out.push(` no demoted unit matches '${query}'`); + return out.join("\n"); + } + for (const u of units) { + const counts = [ + u.requests > 0 ? `${u.requests} request${u.requests === 1 ? "" : "s"}` : "", + u.sites > 0 ? `${u.sites} site${u.sites === 1 ? "" : "s"} inside` : "", + ] + .filter((s) => s !== "") + .join(", "); + out.push(` ${unitLabel(u, opts.root)} ${c(DIM, `${where(u.loc)} (${counts})`)}`); + if (query === undefined && u.requests === 0) continue; + for (const r of live) { + if (r.unit.kind !== u.kind || r.unit.name !== u.name || r.unit.loc.start !== u.loc.start) + continue; + if (r.unit.loc.file !== u.loc.file) continue; + out.push( + ` ${c(DIM, "<-")} ${r.code} ${r.seed} at ${where(r.loc)}: ${capMessage(r.message)}`, + ); + if (r.enclosing.name !== r.unit.name || r.enclosing.kind !== r.unit.kind) + out.push(` ${c(DIM, "->")} ${unitLabel(r.enclosing, opts.root)} turns dynamic`); + } + } + return out.join("\n"); +} diff --git a/packages/compiler/src/coverage/verdict-cache.ts b/packages/compiler/src/coverage/verdict-cache.ts index 841e2b57b..250259685 100644 --- a/packages/compiler/src/coverage/verdict-cache.ts +++ b/packages/compiler/src/coverage/verdict-cache.ts @@ -89,6 +89,9 @@ export function verdictKey( opts: AnalyzeOptions, cache: VerdictCacheOptions, ): string | null { + // The tier report carries source locations the semantic replay does not + // move; explaining analyses always lower. + if (opts.explainDynamic === true) return null; let ffi = ""; if (opts.ffiProfilePath !== undefined) { try { @@ -120,6 +123,8 @@ export function verdictKey( opts.ffiProfilePath ?? "", ffi, external.join("\n"), + // Demotion (stage S6) makes the tier mode part of the verdict. + ...(opts.tier === "static-only" ? ["tier=static-only"] : []), ].join("\0"), ); } diff --git a/packages/compiler/src/diagnostics/envelope.ts b/packages/compiler/src/diagnostics/envelope.ts index 39b193dd0..4c7c158d9 100644 --- a/packages/compiler/src/diagnostics/envelope.ts +++ b/packages/compiler/src/diagnostics/envelope.ts @@ -81,6 +81,34 @@ export interface DiagnosticGroup { sites: SourcePosition[]; } +export interface TierUnitPosition extends SourcePosition { + kind: "binding" | "field" | "function" | "class" | "module"; + name: string; + owner?: string; +} + +/** `scriptc coverage --explain-dynamic --print=diagnostics`: the tier + * assignment of frontend/tier-analysis.ts with source positions. */ +export interface TiersEnvelope { + mode: "auto" | "static-only"; + statementsDynamic: number; + dynamicFunctions: (SourcePosition & { + name: string; + operation: string; + operationAt: SourcePosition; + statements: number; + })[]; + requests: (SourcePosition & { + unit: TierUnitPosition; + enclosing: TierUnitPosition; + seed: string; + scope: string; + code: string; + message: string; + })[]; + units: (TierUnitPosition & { requests: number; sites: number })[]; +} + export interface DiagnosticsEnvelope { schema: typeof DIAGNOSTICS_SCHEMA; schemaVersion: typeof DIAGNOSTICS_SCHEMA_VERSION; @@ -97,8 +125,10 @@ export interface DiagnosticsEnvelope { stats?: { statementsTotal: number; statementsStatic: number; - /** Always 0: every compiled statement is native. Kept so schema - * version 1 consumers keep reading the same fields. */ + /** The compiled statements (counted in statementsStatic, which covers + * every statement that compiles to native code) that belong to + * dynamic-tier functions: code operating on values whose types are only + * known at runtime. */ statementsDynamic: number; statementsFailed: number; functionsSkipped: number; @@ -106,6 +136,8 @@ export interface DiagnosticsEnvelope { }; /** build only: the produced artifact path. */ artifact?: string; + /** coverage --explain-dynamic only: the report-only tier assignment. */ + tiers?: TiersEnvelope; groups: DiagnosticGroup[]; diagnostics: LocatedDiagnostic[]; } diff --git a/packages/compiler/src/executable/prepare.ts b/packages/compiler/src/executable/prepare.ts index f6012dd2a..7becd2358 100644 --- a/packages/compiler/src/executable/prepare.ts +++ b/packages/compiler/src/executable/prepare.ts @@ -69,6 +69,7 @@ export function prepareExecutableModule( lowered = fe.lower({ targetPlatform: buildPlatform, ...(ffi !== null ? { ffiImports: ffi.functions } : {}), + ...(opts.tier !== undefined ? { tierMode: opts.tier } : {}), }); timing("lower"); } catch (e) { diff --git a/packages/compiler/src/frontend/analysis.ts b/packages/compiler/src/frontend/analysis.ts index b38a267fa..87c7d22ca 100644 --- a/packages/compiler/src/frontend/analysis.ts +++ b/packages/compiler/src/frontend/analysis.ts @@ -90,6 +90,8 @@ export function analyzeWithFrontend( coverage: true, targetPlatform: buildPlatform, ...(ffi !== null ? { ffiImports: ffi.functions } : {}), + ...(opts.tier !== undefined ? { tierMode: opts.tier } : {}), + ...(opts.explainDynamic === true ? { tierReport: { preflight } } : {}), }); const provenance = provenanceSources(); return { @@ -109,6 +111,7 @@ export function analyzeWithFrontend( ...(provenance !== null ? { provenance } : {}), ...(lowered.statsByFile ? { statsByFile: lowered.statsByFile } : {}), ...(lowered.provenanceElided ? { provenanceElided: lowered.provenanceElided } : {}), + ...(lowered.tiers !== undefined ? { tiers: lowered.tiers } : {}), preflightFailed: false, }, sourceTexts: fe.sourceTexts(), diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index b4520d3be..c535d603f 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -110,6 +110,13 @@ import { ClassDynamicDispatch, trackClassFieldCreation } from "./class-dynamic-d import { ClassProtocols } from "./class-protocols.js"; import { earlyReadVarSymbols } from "./var-hoisting.js"; import { recordTextCodecClass } from "../../ir/ir.js"; +import { assignLegacyTiers, type DynamicFunction } from "../../ir/tiers.js"; +import { + analyzeTiers, + dynamicStatementCount, + type TierMode, + type TierReport, +} from "../tier-analysis.js"; import { DeferredModuleInitializers } from "./deferred-module-initializers.js"; import { finalizeClassMethodValues } from "./class-method-values.js"; import type { ClassSymbolKey } from "./symbol-fields.js"; @@ -627,6 +634,9 @@ export interface LowerStats { /** Functions whose signature couldn't be analyzed (bodies not counted). */ functionsSkipped: number; + /** Coverage only: reached statements that compile into dynamic-tier + * functions (tier-analysis.ts), a subset of the compiled statements. */ + statementsDynamic?: number; } /** Every identifier a binding name binds: the identifier itself, or all @@ -701,6 +711,11 @@ export interface LowerResult { /** Compile-time-detectable behavior differences from Node (SC6xxx * divergence warnings) in the program's own modules. Never failures. */ divergences?: ScrDiagnostic[]; + /** Functions lowering placed in the dynamic tier (ir/tiers.ts), present + * when there are any. */ + dynamicFunctions?: DynamicFunction[]; + /** LowerOptions.tierReport: the report-only tier assignment. */ + tiers?: TierReport; } export interface LowerOptions { @@ -750,6 +765,12 @@ export interface LowerOptions { /** The mapped entries plus relative declaration dependencies, attributed * to their owning external specifier. */ externalTypeSpecifiersByFile?: ReadonlyMap; + /** `--tier` (tier-analysis.ts); "auto" when absent. */ + tierMode?: TierMode; + /** Coverage only: compute the tier-assignment report (`--explain-dynamic`). + * `preflight` holds the import and package refusals coverage reports + * beside the lowering's own blockers; they request module demotions. */ + tierReport?: { preflight: readonly ScrDiagnostic[] }; } interface RuntimeFenceFallback { @@ -825,6 +846,8 @@ export interface LowererMode { externalTypes?: ReadonlyMap; /** LowerOptions.externalTypeSpecifiersByFile, shared by every pass. */ externalTypeSpecifiersByFile?: ReadonlyMap; + /** LowerOptions.tierMode, shared by every pass. */ + tierMode?: TierMode; } function directExternalTypeSpecifiersByFile( @@ -916,6 +939,7 @@ export function lowerToIr( const externalTypes = options.externalTypes ?? new Map(); const externalTypeSpecifiersByFile = options.externalTypeSpecifiersByFile ?? directExternalTypeSpecifiersByFile(externalTypes); + const tierMode = options.tierMode ?? "auto"; const validation = new Lowerer(program, entry, moduleOrder, { frontendServices: options.frontendServices, projectCheckJs: options.projectCheckJs ?? false, @@ -927,6 +951,7 @@ export function lowerToIr( workerTargets, externalTypes, externalTypeSpecifiersByFile, + tierMode, }); const ffiValidation = validateFfiImports(validation); timing("ffi-validate"); @@ -949,6 +974,7 @@ export function lowerToIr( workerTargets, externalTypes, externalTypeSpecifiersByFile, + tierMode, ffiBindingSymbols: ffiValidation.symbolsByName, }); for (const d of extraModuleCycleDiags) reachableEmit.pushDiag(d); @@ -979,6 +1005,7 @@ export function lowerToIr( ffiBindingSymbols: ffiValidation.symbolsByName, externalTypes, externalTypeSpecifiersByFile, + tierMode, }); for (const d of extraModuleCycleDiags) emit.pushDiag(d); for (const d of ffiValidation.diagnostics) emit.pushDiag(d); @@ -1037,18 +1064,42 @@ export function lowerToIr( ffiBindingSymbols: ffiValidation.symbolsByName, externalTypes, externalTypeSpecifiersByFile, + tierMode, }); const rem = remainder.run(); + timing("coverage-remainder"); + // Tiers (tier-analysis.ts): reached statements in dynamic-tier functions, + // and with tierReport the report-only demotion analysis. + const dynamicFunctions = resultLowerer.dynamicBodies; + const tiers = + options.tierReport === undefined + ? undefined + : analyzeTiers(program, { + mode: tierMode, + dynamicFunctions, + reached: [...options.tierReport.preflight, ...result.diagnostics], + deferred: result.runtimeFences, + unreached: [...rem.diagnostics, ...rem.runtimeFences], + }); + // A dynamic function's own statements can include ones that failed. + const statementsDynamic = Math.min( + tiers?.statementsDynamic ?? dynamicStatementCount(program, dynamicFunctions), + result.stats.statementsTotal - result.stats.statementsFailed, + ); + if (tiers !== undefined) tiers.statementsDynamic = statementsDynamic; + timing("tier-analysis", { dynamic: dynamicFunctions.length }); // Unreached JS statements whose fences deferred to runtime count as // failed statements in the remainder's stats, so their diagnostics must // travel with them: a failed statement is never left unexplained. return { ...result, + stats: { ...result.stats, statementsDynamic }, unreached: { diagnostics: rem.diagnostics, stats: rem.stats, ...(rem.runtimeFences.length > 0 ? { runtimeFences: rem.runtimeFences } : {}), }, + ...(tiers !== undefined ? { tiers } : {}), }; } @@ -2664,6 +2715,14 @@ export class Lowerer { /** Coverage remainder mode: the reachability gate inverts (see wantBody) * and no module is built. */ readonly remainder: boolean; + /** `--tier` (tier-analysis.ts). Stage S2 is report-only: both modes + * refuse and fence exactly as before. Stage S6 demotes the units of + * committed refusals in "auto" and keeps them refusals in "static-only". */ + readonly tierMode: TierMode; + /** Functions finishModule placed in the dynamic tier (ir/tiers.ts). */ + dynamicFunctions: DynamicFunction[] = []; + /** Their IR, for coverage's dynamic statement count. */ + dynamicBodies: IrFunction[] = []; /** Deferred collection diagnostics (failed signatures/class shapes) by * declaration symbol: an unreached declaration must not fail the build, * so its diagnostics wait until a reference makes them relevant. */ @@ -2750,6 +2809,7 @@ export class Lowerer { this.frontendServices = mode.frontendServices; this.reachable = mode.reachable ?? null; this.remainder = mode.remainder ?? false; + this.tierMode = mode.tierMode ?? "auto"; this.alreadyFlushed = mode.alreadyFlushed ?? new Set(); this.targetPlatform = mode.targetPlatform ?? process.platform; this.startupCrash = mode.startupCrash ?? null; @@ -6336,11 +6396,18 @@ export class Lowerer { }; if (module) sanitizeUnregisteredClassTypes(module, (name) => this.classes.has(name)); if (module) checkCycleBindingAccesses(this, module); + // Execution tiers from the final bodies (ir/tiers.ts). Assigned with or + // without a module: coverage reports the dynamic tier of programs that + // still have blockers. + this.dynamicFunctions = assignLegacyTiers(functions); + if (this.dynamicFunctions.length > 0) + this.dynamicBodies = functions.filter((fn) => fn.tier === "dynamic"); return { module, diagnostics: this.diags, runtimeFences: this.runtimeFences, stats: this.stats, + ...(this.dynamicFunctions.length > 0 ? { dynamicFunctions: this.dynamicFunctions } : {}), ...(this.statsByFile.size > 0 ? { statsByFile: this.statsByFile } : {}), ...(this.provenanceElided.length > 0 ? { provenanceElided: this.provenanceElided } : {}), }; diff --git a/packages/compiler/src/frontend/tier-analysis.ts b/packages/compiler/src/frontend/tier-analysis.ts new file mode 100644 index 000000000..ded7c5225 --- /dev/null +++ b/packages/compiler/src/frontend/tier-analysis.ts @@ -0,0 +1,629 @@ +/* Tier assignment, report-only (two-tier design, stage S2). + * + * The design assigns every binding, field, function instance, class and + * module a tier. Static is today's compiler; dynamic code operates on + * dynamic values. Demotion from static to dynamic is monotone and is seeded + * by `any`, untyped JavaScript, types and operations without a static + * lowering, reflection a static layout cannot answer, and dynamic modules + * (DESIGN.md §6). + * + * Stage S2 computes what WOULD be demoted without demoting anything: + * + * 1. Existing dynamic code. Functions whose bodies already use the `dyn` + * vocabulary are the dynamic tier today (ir/tiers.ts assigns them). The + * source statements whose lowering performs a dynamic operation are the + * coverage report's statementsDynamic. + * 2. Demotion requests. Every refusal or runtime fence the lowerer commits + * (today's poison sites: the SC1xxx/SC2xxx families) and every refused + * import or package becomes a request, attributed to the unit whose + * static representation could not express the construct. The lowerer + * still refuses or fences exactly as before; the requests are recorded + * from the committed diagnostics, so speculative probes that roll back + * record nothing. Under `--tier=static-only` every request stays today's + * refusal; stage S6 turns requests into demotions in the default mode. + * 3. Demoted units. A request demotes its unit, and the function instance + * containing the site turns dynamic (it would hold dynamic operations, + * invariant I1). Units are deduplicated; each keeps its requests, which + * is the chain `--explain-dynamic` prints. + * + * Attribution is syntactic and approximate: the site's innermost node, the + * operand it acts on, and that operand's declaration. Stage S6 replaces it + * with requests the failing lowering names exactly. */ +import type { ScrDiagnostic } from "../diagnostics/diagnostic.js"; +import type { IrFunction, SrcLoc } from "../ir/ir.js"; +import { dynamicOperationSites, type DynamicFunction } from "../ir/tiers.js"; +import * as ts from "./ts7/adapter.js"; + +/** `--tier`: "auto" (the default) will demote; "static-only" keeps every + * demotion request a refusal (design invariant I2). Identical in S2. */ +export type TierMode = "auto" | "static-only"; + +export const TIER_MODES: readonly TierMode[] = ["auto", "static-only"]; + +export type DemotionUnitKind = "binding" | "field" | "function" | "class" | "module"; + +export interface DemotionUnit { + kind: DemotionUnitKind; + /** Display name: `x`, `Point.x`, `parse`, `Parser.next`, `Point`, or the + * module's file path. */ + name: string; + /** Bindings: the function declaring a local, absent for module scope. */ + owner?: string; + /** The unit's declaration (the site itself when none is known). */ + loc: SrcLoc; +} + +/** Why a unit is demoted (DESIGN.md §6.2): a type with no static + * representation, an operation with no static lowering, reflection on a + * class, a use of a binding whose declaration was refused, a module or + * package that cannot be static, or a construct excluded by policy (no + * demotion: it stays a refusal). */ +export type DemotionSeed = "type" | "operation" | "reflection" | "cascade" | "module" | "excluded"; + +export type DemotionScope = "reached" | "deferred" | "unreached"; + +export interface DemotionRequest { + unit: DemotionUnit; + /** The function instance (or module top level) containing the site. */ + enclosing: DemotionUnit; + seed: DemotionSeed; + scope: DemotionScope; + code: string; + message: string; + loc: SrcLoc; +} + +export interface DemotedUnit extends DemotionUnit { + /** Requests naming this unit directly. */ + requests: number; + /** Requests whose sites this function instance or module contains. */ + sites: number; +} + +export interface TierDynamicFunction extends DynamicFunction { + /** Source statements with a dynamic operation in this function. */ + statements: number; +} + +export interface TierReport { + mode: TierMode; + /** Reached source statements that perform a dynamic operation. */ + statementsDynamic: number; + dynamicFunctions: TierDynamicFunction[]; + requests: DemotionRequest[]; + /** Units the requests would demote (reached and deferred scopes), + * deduplicated, by kind then source order. */ + units: DemotedUnit[]; +} + +/* ── statements of dynamic functions ─────────────────────────────────── */ + +function isClassLike(node: ts.Node): boolean { + return ts.isClassDeclaration(node) || ts.isClassExpression(node); +} + +/** The innermost node spanning exactly or containing [start, end). */ +function nodeAt(sf: ts.SourceFile, start: number, end: number): ts.Node { + let node: ts.Node = sf; + for (;;) { + let next: ts.Node | undefined; + node.forEachChild((child) => { + if (child.getStart(sf) <= start && end <= child.getEnd()) { + next = child; + return true; + } + return undefined; + }); + if (next === undefined) return node; + node = next; + } +} + +/** The source statement an IR location belongs to: the innermost + * statement containing it, or an arrow function's expression body. Null + * for synthetic locations. */ +function statementAt(program: ts.Program, loc: SrcLoc): ts.Node | null { + if (loc.start === 0 && loc.end === 0) return null; + const sf = program.getSourceFile(loc.file); + if (sf === undefined) return null; + let node: ts.Node | undefined = nodeAt(sf, loc.start, loc.end); + while (node !== undefined && !ts.isSourceFile(node)) { + const parent: ts.Node | undefined = node.parent; + if (parent !== undefined && ts.isArrowFunction(parent) && parent.body === node) return node; + if (ts.isStatement(node) && !ts.isBlock(node)) return node; + node = parent; + } + return null; +} + +/** Dynamic statements are the source statements whose lowering performs a + * dynamic operation (in the function itself or in a generated helper it + * calls). They count once however many functions and operations they + * involve. A function's tier is the unit of I1, but static operations + * inside a dynamic function stay static, so the statement is the honest + * measure of how much code is dynamic. */ +function dynamicFunctionReports( + program: ts.Program, + bodies: readonly IrFunction[], +): { functions: TierDynamicFunction[]; statements: number } { + const byLoc = new Map(); + const all = new Set(); + const functions: TierDynamicFunction[] = []; + for (const fn of bodies) { + const sites = dynamicOperationSites(fn); + if (sites.length === 0) continue; + const own = new Set(); + for (const site of sites) { + const key = `${site.loc.file}\0${site.loc.start}\0${site.loc.end}`; + let statement = byLoc.get(key); + if (statement === undefined) { + statement = statementAt(program, site.loc); + byLoc.set(key, statement); + } + if (statement === null) continue; + own.add(statement); + all.add(statement); + } + functions.push({ + name: fn.name, + loc: fn.loc, + operation: sites[0]!.operation, + operationLoc: sites[0]!.loc, + statements: own.size, + }); + } + return { functions, statements: all.size }; +} + +/* ── demotion requests ───────────────────────────────────────────────── */ + +const TYPE_CODES = new Set([ + "SC2001", + "SC2002", + "SC2003", + "SC2005", + "SC2006", + "SC2007", + "SC2008", + "SC2009", + "SC2011", + "SC1063", + "SC1100", + "SC1101", +]); +const MODULE_CODES = new Set([ + "SC1010", + "SC1012", + "SC1013", + "SC1014", + "SC1015", + "SC1016", + "SC2013", +]); +/** Runtime code generation (`eval`, `new Function`): excluded by policy, + * since the dynamic tier compiles ahead of time (DESIGN.md §12 class X). */ +const EXCLUDED_CODES = new Set(["SC2010"]); +const EXCLUDED_SURFACE = /^'(?:new Function|Function|eval)'/; + +/** Refusals and fences that name a static-tier gap. Type errors, + * environment and target refusals, divergences and internal errors are + * not demotion requests. */ +export function isDemotionCode(code: string): boolean { + return /^SC[12]\d{3}$/.test(code); +} + +function isFunctionLikeOrFile(node: ts.Node): boolean { + return ( + ts.isSourceFile(node) || + ts.isFunctionLikeDeclaration(node) || + ts.isClassStaticBlockDeclaration(node) + ); +} + +function nameText(name: ts.Node | undefined): string | null { + if (name === undefined) return null; + if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name)) return name.text; + if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text; + return null; +} + +function className(node: ts.Node | undefined): string { + if (node === undefined) return ""; + if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) && node.name !== undefined) + return node.name.text; + const parent = node.parent; + if (parent !== undefined && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) + return parent.name.text; + return ""; +} + +/** The display name of a function-like node, as a user would look it up. */ +function functionName(node: ts.Node): string { + if (ts.isSourceFile(node)) return ""; + if (ts.isClassStaticBlockDeclaration(node)) return `${className(node.parent)}.`; + if (ts.isConstructorDeclaration(node)) return `${className(node.parent)}.constructor`; + const own = ts.isFunctionLikeDeclaration(node) ? nameText(node.name) : null; + const parent = node.parent; + if (parent !== undefined && isClassLike(parent) && own !== null) + return `${className(parent)}.${own}`; + if (own !== null) return own; + if (parent !== undefined) { + if (ts.isVariableDeclaration(parent) || ts.isPropertyAssignment(parent)) { + const bound = nameText(parent.name); + if (bound !== null) return bound; + } + if ( + ts.isPropertyDeclaration(parent) && + parent.parent !== undefined && + isClassLike(parent.parent) + ) { + const field = nameText(parent.name); + if (field !== null) return `${className(parent.parent)}.${field}`; + } + if (ts.isBinaryExpression(parent) && parent.right === node) { + const left = parent.left; + if (ts.isIdentifier(left)) return left.text; + if (ts.isPropertyAccessExpression(left)) return left.getText(); + } + } + const sf = node.getSourceFile(); + const pos = ts.getLineAndCharacterOfPosition(sf, node.getStart(sf)); + return ``; +} + +function locOfNode(node: ts.Node): SrcLoc { + const sf = node.getSourceFile(); + return { file: sf.fileName, start: node.getStart(sf), end: node.getEnd() }; +} + +function enclosingFunction(node: ts.Node): ts.Node { + let current: ts.Node | undefined = node.parent; + while (current !== undefined && !isFunctionLikeOrFile(current)) current = current.parent; + return current ?? node.getSourceFile(); +} + +function functionUnit(node: ts.Node, instance: string | null): DemotionUnit { + // Top-level code runs in the module's initializer function. + if (ts.isSourceFile(node)) + return { + kind: "function", + name: "", + loc: { file: node.fileName, start: 0, end: 0 }, + }; + const name = functionName(node); + return { + kind: "function", + name: instance === null ? name : `${name} ${instance}`, + loc: locOfNode(node), + }; +} + +/** Generic instances append their instantiation context to diagnostics + * (Lowerer.pushDiag: ` (instantiating 'f' with )`); the instance, not + * the source function, is the unit. Returns the type-argument text. */ +function instanceOf(message: string): string | null { + const at = message.lastIndexOf(" (instantiating "); + if (at < 0 || !message.endsWith(")")) return null; + const context = message.slice(at + 2, -1); + const withAt = context.indexOf(" with "); + return withAt < 0 ? context : context.slice(withAt + 6); +} + +/** Strip wrappers and walk receivers down to the value an operation acts + * on: `a.b.c(…)` → `a`, `(x as T)[k]` → `x`. Records whether the chain + * passes through `.prototype`. */ +function rootOf(expr: ts.Node): { root: ts.Node; viaPrototype: boolean } { + let node = expr; + let viaPrototype = false; + for (;;) { + if ( + ts.isParenthesizedExpression(node) || + ts.isAsExpression(node) || + ts.isNonNullExpression(node) || + ts.isAssertionExpression(node) || + ts.isSatisfiesExpression(node) || + ts.isSpreadElement(node) || + ts.isAwaitExpression(node) + ) { + node = node.expression!; + } else if (ts.isPropertyAccessExpression(node)) { + if (node.name.text === "prototype") viaPrototype = true; + node = node.expression; + } else if (ts.isElementAccessExpression(node) || ts.isCallExpression(node)) { + node = node.expression; + } else if ( + ts.isDeleteExpression(node) || + ts.isTypeOfExpression(node) || + ts.isVoidExpression(node) + ) { + node = node.expression; + } else { + return { root: node, viaPrototype }; + } + } +} + +const REFLECTION_NAMESPACES = new Set(["Object", "Reflect"]); + +/** The expression an operation at `node` acts on. Reflection calls + * (`Object.defineProperty(x, …)`, `Reflect.set(x, …)`) act on their first + * argument; `new C()` and `x instanceof C` on the class value. */ +function subjectOf(node: ts.Node): ts.Node { + let current = node; + // A refused callee or member name: the whole call or access is the site. + const parent = current.parent; + if (parent !== undefined && ts.isPropertyAccessExpression(parent) && parent.name === current) + current = parent; + if (ts.isCallExpression(current)) { + const callee = current.expression; + if ( + ts.isPropertyAccessExpression(callee) && + ts.isIdentifier(callee.expression) && + REFLECTION_NAMESPACES.has(callee.expression.text) && + current.arguments.length > 0 + ) { + return current.arguments[0]!; + } + return callee; + } + if (ts.isNewExpression(current)) return current.expression; + if (ts.isBinaryExpression(current)) { + if (current.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) return current.right; + if (current.operatorToken.kind === ts.SyntaxKind.EqualsToken) return current.left; + } + return current; +} + +/** The declaration owning a type-refused node: the binding, parameter, + * field or function whose declared type has no static representation. */ +function typeOwnerOf(node: ts.Node): ts.Node | null { + let current: ts.Node | undefined = node; + while (current !== undefined && !ts.isSourceFile(current)) { + if ( + ts.isVariableDeclaration(current) || + ts.isParameter(current) || + ts.isBindingElement(current) || + ts.isPropertyDeclaration(current) || + ts.isPropertySignature(current) || + ts.isCatchClause(current) + ) { + return current; + } + if (ts.isFunctionLikeDeclaration(current) || isClassLike(current)) return current; + if (ts.isStatement(current)) return null; + current = current.parent; + } + return null; +} + +function isModuleObjectName(node: ts.Node): boolean { + return ts.isIdentifier(node) && (node.text === "exports" || node.text === "module"); +} + +class UnitResolver { + constructor(private readonly checker: ts.TypeChecker) {} + + /** The unit a declaration node denotes. */ + declarationUnit(decl: ts.Node): DemotionUnit | null { + if (isClassLike(decl)) return { kind: "class", name: className(decl), loc: locOfNode(decl) }; + if (ts.isFunctionLikeDeclaration(decl)) return functionUnit(decl, null); + if (ts.isPropertyDeclaration(decl) || ts.isPropertySignature(decl)) { + const field = nameText(decl.name) ?? ""; + const owner = decl.parent; + const ownerName = owner !== undefined && isClassLike(owner) ? className(owner) : null; + return { + kind: ownerName === null ? "binding" : "field", + name: ownerName === null ? field : `${ownerName}.${field}`, + loc: locOfNode(decl), + }; + } + if (ts.isCatchClause(decl)) { + const binding = decl.variableDeclaration; + if (binding === undefined) return null; + return this.declarationUnit(binding); + } + if (ts.isVariableDeclaration(decl) || ts.isParameter(decl) || ts.isBindingElement(decl)) { + const name = nameText(decl.name) ?? decl.name?.getText() ?? ""; + const scope = enclosingFunction(decl); + const unit: DemotionUnit = { kind: "binding", name, loc: locOfNode(decl) }; + if (ts.isParameter(decl) && ts.isFunctionLikeDeclaration(decl.parent)) + unit.owner = functionName(decl.parent); + else if (!ts.isSourceFile(scope)) unit.owner = functionName(scope); + return unit; + } + return null; + } + + /** The unit an operand expression denotes. */ + valueUnit(expr: ts.Node): { unit: DemotionUnit; reflection: boolean } | null { + const { root, viaPrototype } = rootOf(expr); + const sf = root.getSourceFile(); + if (root.kind === ts.SyntaxKind.ThisKeyword) { + const owner = enclosingFunction(root); + if (ts.isSourceFile(owner)) + return { + unit: { kind: "module", name: sf.fileName, loc: locOfNode(sf) }, + reflection: false, + }; + const cls = owner.parent; + if (cls !== undefined && isClassLike(cls)) { + // `this.f` names a field; `this` itself is the instance. + const access = root.parent; + if ( + access !== undefined && + ts.isPropertyAccessExpression(access) && + access.expression === root + ) { + return { + unit: { + kind: "field", + name: `${className(cls)}.${access.name.text}`, + loc: locOfNode(access), + }, + reflection: false, + }; + } + return { + unit: { kind: "class", name: className(cls), loc: locOfNode(cls) }, + reflection: viaPrototype, + }; + } + return null; + } + if (!ts.isIdentifier(root)) return null; + let symbol = this.checker.getSymbolAtLocation(root); + if (symbol !== undefined && (symbol.flags & ts.SymbolFlags.Alias) !== 0) + symbol = this.checker.getAliasedSymbol(symbol); + const decls = symbol === undefined ? [] : this.checker.declarationsOf(symbol); + const decl = decls.find((d) => !d.getSourceFile().isDeclarationFile); + if (decl === undefined) { + // CommonJS `exports`/`module` as values: the module object. + if (isModuleObjectName(root)) + return { + unit: { kind: "module", name: sf.fileName, loc: locOfNode(sf) }, + reflection: false, + }; + return null; + } + if (ts.isSourceFile(decl)) + return { + unit: { kind: "module", name: decl.fileName, loc: locOfNode(decl) }, + reflection: false, + }; + const unit = this.declarationUnit(decl); + if (unit === null) return null; + // `C.prototype.m = …`, `Object.defineProperty(C.prototype, …)`: the + // class (or the constructor function's prototype object). + if (viaPrototype && (unit.kind === "class" || unit.kind === "function")) + return { unit: { ...unit, kind: "class" }, reflection: true }; + return { unit, reflection: unit.kind === "class" }; + } +} + +function seedOf(code: string, message: string): DemotionSeed { + if (EXCLUDED_CODES.has(code) || EXCLUDED_SURFACE.test(message)) return "excluded"; + if (code === "SC2004") return "cascade"; + if (MODULE_CODES.has(code)) return "module"; + if (TYPE_CODES.has(code)) return "type"; + return "operation"; +} + +/** One request for a committed refusal or fence diagnostic. */ +function requestFor( + program: ts.Program, + resolver: UnitResolver, + diag: ScrDiagnostic, + scope: DemotionScope, +): DemotionRequest | null { + if (!isDemotionCode(diag.code)) return null; + let seed = seedOf(diag.code, diag.message); + const base = { code: diag.code, message: diag.message, loc: diag.loc, scope }; + const sf = program.getSourceFile(diag.loc.file); + if (sf === undefined) { + const unit: DemotionUnit = { kind: "module", name: diag.loc.file, loc: diag.loc }; + return { ...base, unit, enclosing: unit, seed }; + } + const moduleUnit: DemotionUnit = { kind: "module", name: sf.fileName, loc: locOfNode(sf) }; + const node = nodeAt(sf, diag.loc.start, diag.loc.end); + const instance = instanceOf(diag.message); + const owner = ts.isSourceFile(node) ? sf : enclosingFunction(node); + const enclosing = functionUnit(owner, instance); + if (seed === "module" || ts.isSourceFile(node)) + return { ...base, unit: moduleUnit, enclosing, seed }; + let unit: DemotionUnit | null = null; + if (seed === "type") { + const decl = typeOwnerOf(node); + if (decl !== null) unit = resolver.declarationUnit(decl); + } + if (unit === null) { + const value = resolver.valueUnit(subjectOf(node)); + if (value !== null) { + unit = value.unit; + if (value.reflection && seed === "operation") seed = "reflection"; + } + } + return { ...base, unit: unit ?? enclosing, enclosing, seed }; +} + +function unitKey(unit: DemotionUnit): string { + return `${unit.kind}\0${unit.name}\0${unit.owner ?? ""}\0${unit.loc.file}\0${unit.loc.start}`; +} + +const KIND_ORDER: readonly DemotionUnitKind[] = ["module", "class", "field", "function", "binding"]; + +function demotedUnits(requests: readonly DemotionRequest[]): DemotedUnit[] { + const units = new Map(); + const entry = (unit: DemotionUnit): DemotedUnit => { + const key = unitKey(unit); + let found = units.get(key); + if (found === undefined) units.set(key, (found = { ...unit, requests: 0, sites: 0 })); + return found; + }; + for (const request of requests) { + if (request.scope === "unreached" || request.seed === "excluded") continue; + entry(request.unit).requests++; + entry(request.enclosing).sites++; + } + return [...units.values()].sort( + (a, b) => + KIND_ORDER.indexOf(a.kind) - KIND_ORDER.indexOf(b.kind) || + a.loc.file.localeCompare(b.loc.file) || + a.loc.start - b.loc.start || + a.name.localeCompare(b.name), + ); +} + +export interface TierAnalysisInput { + mode: TierMode; + /** The dynamic-tier IR functions of the reached program. */ + dynamicFunctions: readonly IrFunction[]; + reached: readonly ScrDiagnostic[]; + deferred: readonly ScrDiagnostic[]; + unreached: readonly ScrDiagnostic[]; +} + +/** Coverage's statementsDynamic (see dynamicFunctionReports). */ +export function dynamicStatementCount( + program: ts.Program, + dynamicFunctions: readonly IrFunction[], +): number { + return dynamicFunctionReports(program, dynamicFunctions).statements; +} + +export function analyzeTiers(program: ts.Program, input: TierAnalysisInput): TierReport { + const resolver = new UnitResolver(program.getTypeChecker()); + const requests: DemotionRequest[] = []; + const add = (diags: readonly ScrDiagnostic[], scope: DemotionScope): void => { + for (const diag of diags) { + let request: DemotionRequest | null; + try { + request = requestFor(program, resolver, diag, scope); + } catch { + // Attribution is best effort; a report never fails an analysis. + if (!isDemotionCode(diag.code)) continue; + const unit: DemotionUnit = { kind: "module", name: diag.loc.file, loc: diag.loc }; + request = { + unit, + enclosing: unit, + seed: seedOf(diag.code, diag.message), + scope, + code: diag.code, + message: diag.message, + loc: diag.loc, + }; + } + if (request !== null) requests.push(request); + } + }; + add(input.reached, "reached"); + add(input.deferred, "deferred"); + add(input.unreached, "unreached"); + const dynamic = dynamicFunctionReports(program, input.dynamicFunctions); + return { + mode: input.mode, + statementsDynamic: dynamic.statements, + dynamicFunctions: dynamic.functions, + requests, + units: demotedUnits(requests), + }; +} diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts index c3009665a..56b787e18 100644 --- a/packages/compiler/src/index.ts +++ b/packages/compiler/src/index.ts @@ -172,11 +172,22 @@ export { } from "./diagnostics/render.js"; export { renderCoverage, + renderExplainDynamic, coverageEnvelope, coveragePasses, type CoverageInput, type CoverageFailOn, } from "./coverage/report.js"; +export { + TIER_MODES, + type DemotedUnit, + type DemotionRequest, + type DemotionSeed, + type DemotionUnit, + type DemotionUnitKind, + type TierMode, + type TierReport, +} from "./frontend/tier-analysis.js"; export { buildEnvelope, DIAGNOSTICS_SCHEMA_VERSION, @@ -208,6 +219,13 @@ export { } from "./compat/fetch-profile.js"; export { LIB_FN_SIGS } from "./ir/builtin-signatures.js"; export { validateModule } from "./ir/validate.js"; +export { + assignLegacyTiers, + dynamicOperationOf, + functionTier, + type DynamicFunction, + type IrTier, +} from "./ir/tiers.js"; export { deserializeModule, deserializeModuleBytes, diff --git a/packages/compiler/src/ir/ir.ts b/packages/compiler/src/ir/ir.ts index 9591c684a..9a4a12189 100644 --- a/packages/compiler/src/ir/ir.ts +++ b/packages/compiler/src/ir/ir.ts @@ -1656,6 +1656,14 @@ export interface IrFunction { sourceName?: string; /** Ordinary authored function declarations/expressions own a prototype. */ ownsPrototype?: true; + /** The function's execution tier (ir/tiers.ts). Absent means static: the + * function may use dynamic values only through boundary operations + * (dynFrom, dynCheck, kind tests) and moves, which the validator enforces + * (invariant I1). "dynamic" admits the dynamic operation vocabulary + * (dynKeyGet, dynCall, dyn.* builtins, ...). Lowering assigns the field + * from the body (assignLegacyTiers); stage S2 of the two-tier design + * keeps it out of serialized IR, so loaders derive it again. */ + tier?: "dynamic"; body: IrStmt[]; loc: SrcLoc; } diff --git a/packages/compiler/src/ir/serialize.ts b/packages/compiler/src/ir/serialize.ts index 54e210ea3..1d0e5364e 100644 --- a/packages/compiler/src/ir/serialize.ts +++ b/packages/compiler/src/ir/serialize.ts @@ -7,6 +7,7 @@ * text parts and decoded from bytes one function at a time; neither direction * materializes the complete document as a single string. */ import type { IrExpr, IrFunction, IrModule, IrStmt } from "./ir.js"; +import { deriveModuleTiers } from "./tiers.js"; // Version 16 removes embedded-engine types, operations, and module metadata. // Older modules can require runtime support that no longer exists. @@ -42,6 +43,19 @@ function encodeNumber(_key: string, value: unknown): unknown { return value; } +/** Stage S2 of the two-tier design keeps function tiers out of IR + * artifacts, so a report-only release changes no serialized byte; loaders + * derive them again (deriveModuleTiers). No IR node other than a function + * carries a `tier` key. */ +function encodeWithoutTier(key: string, value: unknown): unknown { + return key === "tier" ? undefined : encodeNumber(key, value); +} + +function encodeFunction(fn: IrFunction): string | undefined { + if (fn.tier !== undefined) return JSON.stringify(fn, encodeWithoutTier); + return ordinaryNumbers(fn) ? JSON.stringify(fn) : JSON.stringify(fn, encodeNumber); +} + /** The compact encoding as ordered parts: the module header up to the * function array, one part per function (with separate comma parts), and the * header's remainder. Concatenating the parts yields exactly @@ -58,9 +72,7 @@ export function serializeModuleParts(mod: IrModule): string[] { for (let index = 0; index < mod.functions.length; index++) { const fn = mod.functions[index]!; if (index > 0) parts.push(","); - parts.push( - (ordinaryNumbers(fn) ? JSON.stringify(fn) : JSON.stringify(fn, encodeNumber)) ?? "null", - ); + parts.push(encodeFunction(fn) ?? "null"); } parts.push("]" + header.slice(offset + slot.length)); return parts; @@ -70,7 +82,7 @@ export function serializeModuleParts(mod: IrModule): string[] { * readable default. Both return one string, so modules whose encoding * exceeds the host's string limit must use `serializeModuleParts`. */ export function serializeModule(mod: IrModule, compact = false): string { - if (!compact) return JSON.stringify(mod, encodeNumber, 2); + if (!compact) return JSON.stringify(mod, encodeWithoutTier, 2); return serializeModuleParts(mod).join(""); } @@ -96,7 +108,7 @@ function checkedVersion(mod: IrModule): IrModule { } export function deserializeModule(json: string): IrModule { - return checkedVersion(JSON.parse(json, decodeNumber) as IrModule); + return deriveModuleTiers(checkedVersion(JSON.parse(json, decodeNumber) as IrModule)); } /** A node as it reads back from the compact encoding: a fresh object, as @@ -249,5 +261,5 @@ export function deserializeModuleBytes(bytes: Buffer): IrModule { ); } mod.functions = functions; - return mod; + return deriveModuleTiers(mod); } diff --git a/packages/compiler/src/ir/tiers.test.ts b/packages/compiler/src/ir/tiers.test.ts new file mode 100644 index 000000000..c5f1ad4b8 --- /dev/null +++ b/packages/compiler/src/ir/tiers.test.ts @@ -0,0 +1,142 @@ +import { expect, test } from "vitest"; +import { BOOL, DYN, F64, STRING, VOID, type IrExpr, type IrFunction, type IrModule } from "./ir.js"; +import { + deserializeModule, + deserializeModuleBytes, + serializeModule, + serializeModuleParts, +} from "./serialize.js"; +import { + assignLegacyTiers, + dynamicOperationOf, + firstDynamicOperation, + functionTier, +} from "./tiers.js"; +import { validateModule } from "./validate.js"; + +const loc = { file: "tiers.ts", start: 0, end: 0 }; +const dynParam = { kind: "varRef", localId: "v", type: DYN, loc } as const satisfies IrExpr; + +function fn(name: string, value: IrExpr): IrFunction { + return { + name, + params: [{ localId: "v", name: "v", type: DYN }], + returnType: value.type, + locals: [{ id: "v", name: "v", type: DYN, mutable: false }], + body: [{ kind: "return", value, loc }], + loc, + }; +} + +function moduleOf(...functions: IrFunction[]): IrModule { + const main: IrFunction = { + name: "%main", + params: [], + returnType: VOID, + locals: [], + body: [], + loc, + }; + return { irVersion: 16, sourceFile: "tiers.ts", functions: [main, ...functions], entry: "%main" }; +} + +const keyGet: IrExpr = { + kind: "dynKeyGet", + key: { kind: "strLit", value: "name", type: STRING, loc }, + value: dynParam, + type: DYN, + loc, +}; + +test("dynamic operations and boundary operations are told apart", () => { + expect(dynamicOperationOf(keyGet)).toBe("dynKeyGet"); + expect( + dynamicOperationOf({ + kind: "libCall", + fn: "dyn.add", + args: [dynParam, dynParam], + type: DYN, + loc, + }), + ).toBe("dyn.add"); + expect( + dynamicOperationOf({ + kind: "call", + callee: "%dyn.class.property.12", + args: [dynParam], + type: DYN, + loc, + }), + ).toBe("%dyn.class.property"); + // Boundary operations: conversions and kind tests. + expect(dynamicOperationOf({ kind: "dynCheck", value: dynParam, type: F64, loc })).toBeNull(); + expect( + dynamicOperationOf({ + kind: "dynFrom", + value: { kind: "numLit", value: 1, type: F64, loc }, + type: DYN, + loc, + }), + ).toBeNull(); + expect( + dynamicOperationOf({ kind: "dynTest", test: "string", value: dynParam, type: BOOL, loc }), + ).toBeNull(); + expect( + dynamicOperationOf({ kind: "libCall", fn: "dyn.typedRefIs", args: [dynParam], type: DYN, loc }), + ).toBeNull(); + // Moves and calls of ordinary functions. + expect(dynamicOperationOf(dynParam)).toBeNull(); + expect( + dynamicOperationOf({ kind: "call", callee: "helper", args: [dynParam], type: DYN, loc }), + ).toBeNull(); +}); + +test("lowering's classification puts exactly the functions with dynamic operations in the dynamic tier", () => { + const reader = fn("reader", keyGet); + const mover = fn("mover", dynParam); + const dynamic = assignLegacyTiers([reader, mover]); + expect(dynamic.map((d) => [d.name, d.operation])).toEqual([["reader", "dynKeyGet"]]); + expect(functionTier(reader)).toBe("dynamic"); + expect(functionTier(mover)).toBe("static"); + expect(firstDynamicOperation(mover)).toBeNull(); +}); + +test("the validator enforces I1: static functions perform no dynamic operation", () => { + const reader = fn("reader", keyGet); + const errors = validateModule(moduleOf(reader)); + expect(errors.map((e) => e.message)).toEqual([ + "in reader: static-tier function performs the dynamic operation dynKeyGet", + ]); + reader.tier = "dynamic"; + expect(validateModule(moduleOf(reader))).toEqual([]); + // A logical operator over dynamic values applies ToBoolean to them. + const either = fn("either", { + kind: "logical", + op: "||", + left: dynParam, + right: dynParam, + type: DYN, + loc, + }); + expect(validateModule(moduleOf(either)).map((e) => e.message)).toEqual([ + "in either: static-tier function performs the dynamic operation logical", + ]); +}); + +test("serialized IR carries no tiers in stage S2, and loading derives them again", () => { + const reader = fn("reader", keyGet); + const mod = moduleOf(reader); + const untiered = serializeModule(mod, true); + assignLegacyTiers(mod.functions); + expect(reader.tier).toBe("dynamic"); + expect(serializeModule(mod, true)).toBe(untiered); + expect(serializeModuleParts(mod).join("")).toBe(untiered); + expect(serializeModule(mod)).not.toContain('"tier"'); + for (const loaded of [ + deserializeModule(untiered), + deserializeModuleBytes(Buffer.from(untiered)), + ]) { + expect(loaded.functions.map(functionTier)).toEqual(["static", "dynamic"]); + expect(validateModule(loaded)).toEqual([]); + } +}); diff --git a/packages/compiler/src/ir/tiers.ts b/packages/compiler/src/ir/tiers.ts new file mode 100644 index 000000000..201bc2a58 --- /dev/null +++ b/packages/compiler/src/ir/tiers.ts @@ -0,0 +1,157 @@ +/* Execution tiers (two-tier design, stage S2: report-only). + * + * Every IR function belongs to one of two tiers: + * + * - static: today's compiler. Exact layouts, direct calls, unboxed values. + * A static function may hold dynamic (`dyn`) values, pass them to calls, + * return them and store them, and it may cross the boundary with the + * boundary operations below, but it never operates on a dynamic value. + * - dynamic: code that operates on dynamic values with JavaScript semantics + * (property reads and writes, generic operators, calls of dynamic values, + * dynamic object and array construction). + * + * Invariant I1 (validate.ts): a static function contains no dynamic + * operation. Only boundary operations and moves may mix the tiers. Calls + * of generated `%dyn.*` helpers count as dynamic operations: they are the + * dynamic dispatch the lowering placed out of line. Calls of other dynamic + * functions are boundaries (the design's "call to a dynamic function"). + * + * Boundary operations: + * - `dynFrom` (static to dynamic, the design's `toJs`) and `caughtToDyn`; + * - `dynCheck` (dynamic to static, the design's `fromJs`); + * - kind tests that only inspect a dynamic value's tag (`dynTest`, the + * `dyn.*Is` and `dyn.typeof` builtins): the tag test of a conversion; + * - calls of non-`dyn.*` builtins whose signatures take or return `dyn` + * (typed APIs implemented through dyn, leak L6 of the design). They stay + * boundaries until stage S1 gives them typed signatures. + * + * Classification of existing code. The `dyn` vocabulary is today's + * dynamic tier (`ScrDyn`): `any`, untyped JavaScript, unschematized + * `JSON.parse`, and the generated dynamic dispatch helpers already lower to + * it. Lowering therefore assigns tiers from function bodies: a function + * containing a dynamic operation is dynamic, every other function is static + * (`assignLegacyTiers`). Demotion (stage S6) will add tier decisions that + * do not follow from a body; until then the classification is exact, and + * the validator guards it against later passes and hand-written IR. + * + * Serialization. Stage S2 must not change any artifact, so serialized IR + * omits `tier` (serialize.ts) and loaders derive it again with the same + * classification. The next IR version serializes the field. */ +import type { IrExpr, IrFunction, IrModule, SrcLoc } from "./ir.js"; +import { everyStmtList, type IrVisitor } from "./traverse.js"; + +export type IrTier = "static" | "dynamic"; + +export function functionTier(fn: IrFunction): IrTier { + return fn.tier === "dynamic" ? "dynamic" : "static"; +} + +/** `dyn.*` builtins that only inspect a dynamic value's kind: the tag test + * half of a dynamic-to-static conversion. */ +const DYN_KIND_TESTS: ReadonlySet = new Set([ + "dyn.typedRefIs", + "dyn.typedRefKeyIs", + "dyn.classIs", + "dyn.nativeSetIs", + "dyn.nativeMapIs", + "dyn.nativeUrlIs", + "dyn.nativeDateIs", + "dyn.nativeRegexIs", + "dyn.dataViewIs", + "dyn.typeof", +]); + +const DYN_HELPER_PREFIX = "%dyn."; + +/** `%dyn.class.property.12` → `%dyn.class.property`. */ +function dynHelperFamily(name: string): string { + return name.replace(/(\.\d+)+$/, ""); +} + +/** The dynamic operation an expression performs, named for reports + * (`dynKeyGet`, `dyn.keySet`, ...), or null for static operations, boundary + * operations and moves. Only the node itself is inspected. */ +export function dynamicOperationOf(e: IrExpr): string | null { + switch (e.kind) { + case "dynCall": + case "dynInvoke": + case "dynObjLit": + case "dynArrLit": + case "dynKeyGet": + case "dynHasKey": + case "dynScalarEq": + case "dynDestrCheck": + case "dynIterN": + return e.kind; + case "logical": + // `a || b` over dyn operands applies ToBoolean to a dynamic value. + return e.type.kind === "dyn" ? "logical" : null; + case "libCall": + return e.fn.startsWith("dyn.") && !DYN_KIND_TESTS.has(e.fn) ? e.fn : null; + case "call": + // Generated `%dyn.*` helpers are dynamic operations lowered out of + // line (class dynamic dispatch, dynamic HOF adapters). + return e.callee.startsWith(DYN_HELPER_PREFIX) ? dynHelperFamily(e.callee) : null; + default: + return null; + } +} + +export interface DynamicOperationSite { + operation: string; + loc: SrcLoc; +} + +function collectDynamicOperations(fn: IrFunction, first: boolean): DynamicOperationSite[] { + const found: DynamicOperationSite[] = []; + const visitor: IrVisitor = { + expr: (e) => { + const operation = dynamicOperationOf(e); + if (operation === null) return true; + found.push({ operation, loc: e.loc }); + return !first; + }, + stmt: () => true, + }; + everyStmtList(fn.body, visitor); + return found; +} + +/** The first dynamic operation in a function body, in traversal order. */ +export function firstDynamicOperation(fn: IrFunction): DynamicOperationSite | null { + return collectDynamicOperations(fn, true)[0] ?? null; +} + +/** Every dynamic operation in a function body (coverage reports). */ +export function dynamicOperationSites(fn: IrFunction): DynamicOperationSite[] { + return collectDynamicOperations(fn, false); +} + +/** A function the classification placed in the dynamic tier, with the + * operation that put it there. */ +export interface DynamicFunction { + name: string; + loc: SrcLoc; + operation: string; + operationLoc: SrcLoc; +} + +/** Assign every function its tier from its body (see the header). Returns + * the dynamic functions in module order. */ +export function assignLegacyTiers(functions: readonly IrFunction[]): DynamicFunction[] { + const dynamic: DynamicFunction[] = []; + for (const fn of functions) { + const site = firstDynamicOperation(fn); + if (site === null) continue; + fn.tier = "dynamic"; + dynamic.push({ name: fn.name, loc: fn.loc, operation: site.operation, operationLoc: site.loc }); + } + return dynamic; +} + +/** Loaders call this on deserialized modules (stage S2 serializes no + * tiers). */ +export function deriveModuleTiers(mod: IrModule): IrModule { + assignLegacyTiers(mod.functions); + return mod; +} diff --git a/packages/compiler/src/ir/validate.test.ts b/packages/compiler/src/ir/validate.test.ts index b7caf8c41..8086cc176 100644 --- a/packages/compiler/src/ir/validate.test.ts +++ b/packages/compiler/src/ir/validate.test.ts @@ -20,6 +20,7 @@ import { type IrUnionDef, } from "./ir.js"; import { deserializeModule, serializeModule } from "./serialize.js"; +import { assignLegacyTiers } from "./tiers.js"; import { validateModule } from "./validate.js"; const loc = { file: "numeric-read.ts", start: 0, end: 0 }; @@ -399,7 +400,7 @@ test.each(["sortPrimitive", "toSortedPrimitive"] as const)( ); function expressionModule(expr: IrExpr, unions: IrUnionDef[]): IrModule { - return { + const mod: IrModule = { irVersion: 16, sourceFile: loc.file, entry: "main", @@ -415,6 +416,9 @@ function expressionModule(expr: IrExpr, unions: IrUnionDef[]): IrModule { }, ], }; + // Lowering assigns tiers from function bodies (ir/tiers.ts). + assignLegacyTiers(mod.functions); + return mod; } test("numeric byte tokens and DataView stores validate their storage before emission", () => { diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts index f7d30a1bb..1bac14de6 100644 --- a/packages/compiler/src/ir/validate.ts +++ b/packages/compiler/src/ir/validate.ts @@ -59,6 +59,7 @@ import { import { DYN_CLASS_PROPERTIES } from "./ir.js"; import { unionWideningTags } from "./analysis.js"; import { alwaysReturns } from "./control-flow.js"; +import { dynamicOperationOf, functionTier } from "./tiers.js"; import { LIB_FN_SIGS } from "./builtin-signatures.js"; import { REGEX_INTRINSIC_SIGS, STR_INTRINSIC_SIGS } from "./intrinsic-signatures.js"; @@ -1007,6 +1008,14 @@ function validateFunction( const locals = new Map(fn.locals.map((l) => [l.id, l])); const err = (message: string, loc: SrcLoc) => errors.push({ message: `in ${fn.name}: ${message}`, loc }); + // Invariant I1 (ir/tiers.ts): a static function reaches dynamic values + // only through boundary operations and moves. + const staticTier = functionTier(fn) === "static"; + const checkTier = (e: IrExpr): void => { + const operation = dynamicOperationOf(e); + if (operation !== null) + err(`static-tier function performs the dynamic operation ${operation}`, e.loc); + }; const asyncCaches = [ ["asyncCacheGlobal", fn.asyncCacheGlobal], @@ -1251,6 +1260,8 @@ function validateFunction( continue; } if (e.kind === "logical") { + // checkExpr already checked the root's tier. + if (staticTier && e !== root) checkTier(e); if ( e.type.kind !== "f64" && e.type.kind !== "string" && @@ -1294,6 +1305,7 @@ function validateFunction( } function checkExpr(e: IrExpr): void { + if (staticTier) checkTier(e); switch (e.kind) { case "numLit": case "strLit": diff --git a/packages/compiler/src/library/prepare.ts b/packages/compiler/src/library/prepare.ts index 94f20198a..298bb43bb 100644 --- a/packages/compiler/src/library/prepare.ts +++ b/packages/compiler/src/library/prepare.ts @@ -553,6 +553,8 @@ export function prepareLibrary( try { lowered = fe.lower({ targetPlatform: buildPlatform, + // Library artifacts are static-tier only (two-tier design I2). + tierMode: "static-only", ...(cbImports.length > 0 ? { ffiImports: cbImports } : {}), ...(cbImports.length > 0 ? { libraryCallbacks: true } : {}), // The profile-mapped exports are called from OUTSIDE the graph: diff --git a/tests/coverage-fixtures/tier-demotions.ts b/tests/coverage-fixtures/tier-demotions.ts new file mode 100644 index 000000000..52f2058f1 --- /dev/null +++ b/tests/coverage-fixtures/tier-demotions.ts @@ -0,0 +1,25 @@ +// The report-only tier assignment of `scriptc coverage --explain-dynamic`. +class Point { + constructor( + public x: number, + public y: number, + ) {} +} + +// Reflection on a class: the dynamic tier would give Point a prototype object. +(Point.prototype as any).norm = function () { + return 0; +}; + +// Already dynamic: a property read on an `any` value. +function readName(text: string): string { + const data: any = JSON.parse(text); + return String(data.name); +} + +// An operation without a static lowering, on a parameter. +function precise(n: number): string { + return n.toPrecision(3); +} + +console.log(readName('{"name":"a"}'), precise(1.5), new Point(1, 2).x); diff --git a/tests/harness/__snapshots__/coverage-divergences.txt b/tests/harness/__snapshots__/coverage-divergences.txt index 67c9b57e3..2f811f892 100644 --- a/tests/harness/__snapshots__/coverage-divergences.txt +++ b/tests/harness/__snapshots__/coverage-divergences.txt @@ -2,6 +2,7 @@ scriptc coverage tests/coverage-fixtures/divergences.ts statements analyzed 18 compile statically 18 (100%) + in dynamic tier 1 (operate on values typed only at runtime; --explain-dynamic lists them) fully static — all analyzed statements compile to native code. diff --git a/tests/harness/__snapshots__/coverage-dynamic-mix.txt b/tests/harness/__snapshots__/coverage-dynamic-mix.txt index a3e714bde..2ad84f0af 100644 --- a/tests/harness/__snapshots__/coverage-dynamic-mix.txt +++ b/tests/harness/__snapshots__/coverage-dynamic-mix.txt @@ -2,6 +2,7 @@ scriptc coverage tests/coverage-fixtures/dynamic-mix.ts statements analyzed 8 compile statically 7 (87%) + in dynamic tier 2 (operate on values typed only at runtime; --explain-dynamic lists them) blockers: ×1 SC2012 '.toPrecision()' on numbers cannot compile statically diff --git a/tests/harness/__snapshots__/coverage-explain-dynamic.txt b/tests/harness/__snapshots__/coverage-explain-dynamic.txt new file mode 100644 index 000000000..1c86a808c --- /dev/null +++ b/tests/harness/__snapshots__/coverage-explain-dynamic.txt @@ -0,0 +1,16 @@ + dynamic tier (tier assignment, report-only; --tier=auto) + 4 functions already operate on dynamic values (1 statement) + readName tests/coverage-fixtures/tier-demotions.ts:15:1: %dyn.error.stringConstructor at tests/coverage-fixtures/tier-demotions.ts:17:10 + %dyn.error.stringConstructor.0 tests/coverage-fixtures/tier-demotions.ts:17:10: dynCall at tests/coverage-fixtures/tier-demotions.ts:17:10 + %dyn.class.property.0 tests/coverage-fixtures/tier-demotions.ts:17:17: %dyn.class.readPropertiesOrEmpty at tests/coverage-fixtures/tier-demotions.ts:17:17 + %method.value:%%Error.toString tests/coverage-fixtures/tier-demotions.ts:17:10: dyn.this at tests/coverage-fixtures/tier-demotions.ts:17:10 + + 2 demotion requests (refusals and fences the dynamic tier would replace) + class Point tests/coverage-fixtures/tier-demotions.ts:2:1 (1 request) + <- SC1090 reflection at tests/coverage-fixtures/tier-demotions.ts:10:1: assignment to non-variables are not supported yet + -> function turns dynamic + function tests/coverage-fixtures/tier-demotions.ts:1:1 (1 site inside) + function precise tests/coverage-fixtures/tier-demotions.ts:21:1 (1 site inside) + binding n in precise tests/coverage-fixtures/tier-demotions.ts:21:18 (1 request) + <- SC2012 operation at tests/coverage-fixtures/tier-demotions.ts:22:10: '.toPrecision()' on numbers cannot compile statically + -> function precise turns dynamic \ No newline at end of file diff --git a/tests/harness/__snapshots__/coverage-js-gap.txt b/tests/harness/__snapshots__/coverage-js-gap.txt index 3150216b6..3b6fa678c 100644 --- a/tests/harness/__snapshots__/coverage-js-gap.txt +++ b/tests/harness/__snapshots__/coverage-js-gap.txt @@ -2,5 +2,6 @@ scriptc coverage tests/coverage-fixtures/js-gap/gap.js statements analyzed 5 compile statically 5 (100%) + in dynamic tier 3 (operate on values typed only at runtime; --explain-dynamic lists them) fully static — all analyzed statements compile to native code. \ No newline at end of file diff --git a/tests/harness/__snapshots__/coverage-mixed.txt b/tests/harness/__snapshots__/coverage-mixed.txt index 88b61c39b..c3b348f9c 100644 --- a/tests/harness/__snapshots__/coverage-mixed.txt +++ b/tests/harness/__snapshots__/coverage-mixed.txt @@ -2,6 +2,7 @@ scriptc coverage tests/coverage-fixtures/mixed.ts statements analyzed 13 compile statically 12 (92%) + in dynamic tier 1 (operate on values typed only at runtime; --explain-dynamic lists them) blockers: ×1 SC1031 object destructuring of non-record values (the source is array-typed) diff --git a/tests/harness/__snapshots__/coverage-npm-packages.txt b/tests/harness/__snapshots__/coverage-npm-packages.txt index 0ba05286a..475b10e45 100644 --- a/tests/harness/__snapshots__/coverage-npm-packages.txt +++ b/tests/harness/__snapshots__/coverage-npm-packages.txt @@ -2,6 +2,7 @@ scriptc coverage tests/corpus/native-npm-imports/main.ts statements analyzed 14 compile statically 14 (100%) + in dynamic tier 3 (operate on values typed only at runtime; --explain-dynamic lists them) npm package compilation: mathkit static diff --git a/tests/harness/__snapshots__/coverage-tier-demotions.txt b/tests/harness/__snapshots__/coverage-tier-demotions.txt new file mode 100644 index 000000000..7b52f9d63 --- /dev/null +++ b/tests/harness/__snapshots__/coverage-tier-demotions.txt @@ -0,0 +1,13 @@ +scriptc coverage tests/coverage-fixtures/tier-demotions.ts + + statements analyzed 5 + compile statically 3 (60%) + in dynamic tier 1 (operate on values typed only at runtime; --explain-dynamic lists them) + + blockers: + ×1 SC1090 assignment to non-variables + at tests/coverage-fixtures/tier-demotions.ts:10:1 + hint: this form is valid TypeScript but does not compile yet — rewrite it with a supported equivalent of the construct the message names (https://scriptc.dev/limitations lists the boundary) + ×1 SC2012 '.toPrecision()' on numbers cannot compile statically + at tests/coverage-fixtures/tier-demotions.ts:22:10 + hint: use a supported API or rewrite this operation for native compilation \ No newline at end of file diff --git a/tests/harness/__snapshots__/coverage-width-copies.txt b/tests/harness/__snapshots__/coverage-width-copies.txt index dd99d4bb5..46e8e949d 100644 --- a/tests/harness/__snapshots__/coverage-width-copies.txt +++ b/tests/harness/__snapshots__/coverage-width-copies.txt @@ -2,6 +2,7 @@ scriptc coverage tests/coverage-fixtures/width-copies.ts statements analyzed 14 compile statically 14 (100%) + in dynamic tier 1 (operate on values typed only at runtime; --explain-dynamic lists them) fully static — all analyzed statements compile to native code. diff --git a/tests/harness/coverage.test.ts b/tests/harness/coverage.test.ts index d4582d151..6148b13ac 100644 --- a/tests/harness/coverage.test.ts +++ b/tests/harness/coverage.test.ts @@ -3,7 +3,13 @@ import { globSync, mkdtempSync, readFileSync, rmSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { expect, test } from "vitest"; -import { analyze, coverageEnvelope, coveragePasses, renderCoverage } from "@scriptc/compiler"; +import { + analyze, + coverageEnvelope, + coveragePasses, + renderCoverage, + renderExplainDynamic, +} from "@scriptc/compiler"; import { shardSelect, shardSuffix } from "./shard.js"; const repoRoot = join(import.meta.dirname, "../.."); @@ -230,6 +236,105 @@ test("CLI: build --print=diagnostics reports failures and divergence warnings as } }); +test("coverage counts the statements of dynamic-tier functions", async () => { + expect(analyze(join(repoRoot, "tests/corpus/400-fib.ts")).coverage.stats.statementsDynamic).toBe( + 0, + ); + const { coverage, sourceTexts } = analyze(fixture("tier-demotions.ts")); + expect(coverage.stats.statementsDynamic).toBe(1); + expect(coverage.tiers).toBeUndefined(); + expect(coverageEnvelope(coverage, { compilerVersion: "test", sourceTexts }).stats).toMatchObject({ + statementsTotal: 5, + statementsStatic: 3, + statementsDynamic: 1, + statementsFailed: 2, + }); + await expect(report(fixture("tier-demotions.ts"))).toMatchFileSnapshot( + "__snapshots__/coverage-tier-demotions.txt", + ); +}); + +test("--explain-dynamic attributes each refusal to the unit the dynamic tier would take", async () => { + const { coverage, sourceTexts } = analyze(fixture("tier-demotions.ts"), { explainDynamic: true }); + const tiers = coverage.tiers!; + expect(tiers.mode).toBe("auto"); + expect(tiers.statementsDynamic).toBe(1); + expect(tiers.dynamicFunctions.map((fn) => fn.name)).toContain("readName"); + const requests = [...tiers.requests].sort((a, b) => a.loc.start - b.loc.start); + expect( + requests.map((r) => [r.code, r.seed, r.scope, r.unit.kind, r.unit.name, r.enclosing.name]), + ).toEqual([ + ["SC1090", "reflection", "reached", "class", "Point", ""], + ["SC2012", "operation", "reached", "binding", "n", "precise"], + ]); + expect(tiers.units.map((u) => [u.kind, u.name, u.requests, u.sites])).toEqual([ + ["class", "Point", 1, 0], + ["function", "", 0, 1], + ["function", "precise", 0, 1], + ["binding", "n", 1, 0], + ]); + const envelope = coverageEnvelope(coverage, { compilerVersion: "test", sourceTexts }); + expect(envelope.tiers?.requests[0]).toMatchObject({ unit: { kind: expect.any(String) } }); + const relative = JSON.parse(JSON.stringify(tiers).replaceAll(repoRoot + "/", "")) as typeof tiers; + await expect(renderExplainDynamic(relative)).toMatchFileSnapshot( + "__snapshots__/coverage-explain-dynamic.txt", + ); + expect(renderExplainDynamic(relative, { query: "Point" })).toContain("class Point"); + expect(renderExplainDynamic(relative, { query: "Point" })).not.toContain("binding n"); + expect(renderExplainDynamic(relative, { query: "nothing" })).toContain( + "no demoted unit matches 'nothing'", + ); +}); + +test("CLI: --tier and --explain-dynamic", () => { + const scriptcCli = join(repoRoot, "packages/cli/src/main.ts"); + const outDir = mkdtempSync(join(tmpdir(), "scriptc-tier-")); + const run = (...args: string[]) => + spawnSync(process.execPath, ["--import", "tsx", scriptcCli, ...args], { + cwd: repoRoot, + encoding: "utf8", + env: { ...process.env, SCRIPTC_NO_CACHE: "1" }, + }); + try { + const explained = run( + "coverage", + fixture("tier-demotions.ts"), + "--explain-dynamic", + "--tier=static-only", + ); + expect(explained.status).toBe(0); + expect(explained.stdout).toContain("in dynamic tier 1"); + expect(explained.stdout).toContain("--tier=static-only"); + expect(explained.stdout).toContain("binding n in precise"); + const one = run("coverage", fixture("tier-demotions.ts"), "--explain-dynamic=Point"); + expect(one.stdout).toContain("class Point"); + expect(one.stdout).not.toContain("binding n in precise"); + const bad = run("coverage", fixture("tier-demotions.ts"), "--tier=dynamic-only"); + expect(bad.status).toBe(1); + expect(bad.stderr).toContain('unknown --tier value "dynamic-only"'); + const misplaced = run("build", fixture("tier-demotions.ts"), "--explain-dynamic"); + expect(misplaced.status).toBe(1); + expect(misplaced.stderr).toContain("--explain-dynamic is a coverage option"); + // Until demotion lands, static-only compiles exactly like the default. + const ir = (name: string, ...args: string[]) => { + const out = join(outDir, name); + const built = run( + "build", + join(repoRoot, "tests/corpus/400-fib.ts"), + "--emit=ir", + "-o", + out, + ...args, + ); + expect(built.status).toBe(0); + return readFileSync(out, "utf8"); + }; + expect(ir("static-only.ir.json", "--tier=static-only")).toBe(ir("auto.ir.json")); + } finally { + rmSync(outDir, { recursive: true, force: true }); + } +}); + test("fully static program reports 100%", () => { const out = report(join(repoRoot, "tests/corpus/400-fib.ts")); expect(out).toContain("(100%)"); From 4bba6c1e0b1f370c64c34ba8ea6528cd521f8010 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 11:30:08 -0500 Subject: [PATCH 28/47] 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 29/47] 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 30/47] 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([ From da1af7437f6f2c07bb6b65ab6793227cd5975dbb Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 12:20:36 -0500 Subject: [PATCH 31/47] Revert "Read fields as undefined before their assignment (#1292)" This reverts commit ff90245b27862eeec38687df9c8f4c078ffc12d0. --- .../frontend/lowering/construction-escapes.ts | 9 - .../src/frontend/lowering/lower-classes.ts | 208 +++++------------- .../src/frontend/lowering/lower-exprs.ts | 94 -------- .../compiler/src/frontend/lowering/lowerer.ts | 12 - .../test/class-early-field-reads.test.ts | 93 -------- ...5943-fields-read-before-assignment.ts.json | 6 - ...4-js-fields-read-before-assignment.js.json | 6 - .../5943-fields-read-before-assignment.ts | 181 --------------- .../5944-js-fields-read-before-assignment.js | 28 --- tests/harness/corpus-costs.json | 4 - 10 files changed, 58 insertions(+), 583 deletions(-) delete mode 100644 packages/compiler/test/class-early-field-reads.test.ts delete mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5943-fields-read-before-assignment.ts.json delete mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5944-js-fields-read-before-assignment.js.json delete mode 100644 tests/corpus/5943-fields-read-before-assignment.ts delete mode 100644 tests/corpus/5944-js-fields-read-before-assignment.js diff --git a/packages/compiler/src/frontend/lowering/construction-escapes.ts b/packages/compiler/src/frontend/lowering/construction-escapes.ts index a1626f12d..484920a1c 100644 --- a/packages/compiler/src/frontend/lowering/construction-escapes.ts +++ b/packages/compiler/src/frontend/lowering/construction-escapes.ts @@ -124,15 +124,6 @@ export function constructionEscape(inputs: ConstructionInputs): ConstructionEsca continue; } if (ts.isExpressionStatement(stmt) && !exposes(stmt.expression, depth)) continue; - // A check that only reads assigned fields and throws or does nothing - // with the receiver (`if (this.size < 0) throw new RangeError()`) - // does not expose the instance; assignments in its branches are not - // definite and still count as exposures. - if ( - (ts.isIfStatement(stmt) || ts.isThrowStatement(stmt) || ts.isBlock(stmt)) && - !exposes(stmt, depth) - ) - continue; return false; } return true; diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 7b2d176c3..f70499e6f 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -143,7 +143,7 @@ import { lowerObjectFactoryNew } from "./object-factory-new.js"; import { tryLowerExpression } from "./expressions/try-lower-expression.js"; import { lowerInstanceConstructorNew } from "./class-instance-constructor.js"; import { classPrototypeData } from "./class-prototypes.js"; -import { constructionEscape, mentionsReceiver } from "./construction-escapes.js"; +import { constructionEscape } from "./construction-escapes.js"; import { checkedClassConstruction, checkedClassConstructionPacked } from "./class-construction.js"; import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-statics.js"; import { reflectedClassStaticMethodValue } from "./class-method-values.js"; @@ -468,11 +468,6 @@ export interface ClassInfo { * unassigned read throws the catchable TypeError instead of yielding * an undefined the declared type cannot hold (SEMANTICS.md). */ deferredInitFields?: Set; - /** Fields (inherited included) that code construction exposes the - * instance to can read before their assignment: the slot is the - * undefined-armed union, allocation writes undefined, and reads yield the - * union value, so an early read sees undefined as in Node. */ - earlyReadFields?: Set; /** True when construction may hand the instance to other code (a method * call, an argument, a callback, or a base constructor that does) — a * subclass's own fields can then be read before their assignment. */ @@ -3507,54 +3502,55 @@ export function collectClassShapeInner( const derived = decl.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ?? false; - // A generic family is not emitted; its instances and each mixin - // application analyze their own construction with their actual base. - const escape: { escapes: boolean; assigned: Set | null } = familyMode - ? { escapes: derived, assigned: null } - : constructionEscape({ - ctor, - fields: fieldOrder.flatMap((f) => - paramProps.some((pp) => pp.name === f.name) - ? [] - : [{ name: f.name, initializer: f.initializer }], - ), - paramProps: paramProps.map((pp) => pp.name), - derived, - baseEscapes: - base === null || - callableBase !== undefined || - factoryBaseExpression !== undefined || - base.constructionEscapes === true, - isField: (name) => - fields.has(name) && - !methods.has(`set:${name}`) && - !lowerer.findMethodOn(base, `set:${name}`), - privateMethodBody: (call) => { - const callee = call.expression; - if (!ts.isPropertyAccessExpression(callee)) return null; - const name = callee.name.text; - const declaration = decl.members.find( - (member): member is ts.MethodDeclaration => - ts.isMethodDeclaration(member) && - member.body !== undefined && - (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) && - member.name.text === name, - ); - if (!declaration?.body || declaration.asteriskToken) return null; - const modifiers = ts.getModifiers(declaration) ?? []; - if ( - modifiers.some( - (m) => - m.kind === ts.SyntaxKind.StaticKeyword || m.kind === ts.SyntaxKind.AsyncKeyword, + // Generic instances and mixins share layouts across declarations, so + // they only report whether construction exposes the instance. + const escape: { escapes: boolean; assigned: Set | null } = + familyMode || mixin + ? { escapes: derived, assigned: null } + : constructionEscape({ + ctor, + fields: fieldOrder.flatMap((f) => + paramProps.some((pp) => pp.name === f.name) + ? [] + : [{ name: f.name, initializer: f.initializer }], + ), + paramProps: paramProps.map((pp) => pp.name), + derived, + baseEscapes: + base === null || + callableBase !== undefined || + factoryBaseExpression !== undefined || + base.constructionEscapes === true, + isField: (name) => + fields.has(name) && + !methods.has(`set:${name}`) && + !lowerer.findMethodOn(base, `set:${name}`), + privateMethodBody: (call) => { + const callee = call.expression; + if (!ts.isPropertyAccessExpression(callee)) return null; + const name = callee.name.text; + const declaration = decl.members.find( + (member): member is ts.MethodDeclaration => + ts.isMethodDeclaration(member) && + member.body !== undefined && + (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) && + member.name.text === name, + ); + if (!declaration?.body || declaration.asteriskToken) return null; + const modifiers = ts.getModifiers(declaration) ?? []; + if ( + modifiers.some( + (m) => + m.kind === ts.SyntaxKind.StaticKeyword || m.kind === ts.SyntaxKind.AsyncKeyword, + ) ) - ) - return null; - const isPrivate = - ts.isPrivateIdentifier(declaration.name) || - modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword); - return isPrivate ? declaration.body : null; - }, - }); + return null; + const isPrivate = + ts.isPrivateIdentifier(declaration.name) || + modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword); + return isPrivate ? declaration.body : null; + }, + }); // The deferred definite-assignment check: a field on the unguarded // list passes only with an unconditional `this.x = ...` at the // constructor's TOP LEVEL — the same standard the JS-class path @@ -3610,30 +3606,18 @@ export function collectClassShapeInner( } } - // Fields assigned after construction can expose the instance (a method - // call, a base constructor that calls an override) can be read while - // Node still holds undefined. Their slots admit undefined, allocation - // writes it, and reads yield it, as in Node. - const earlyReadFields = new Set(base?.earlyReadFields ?? []); - if (escape.assigned && escape.escapes) { + if (escape.assigned && !inst) { for (const f of fieldOrder) { if (f.redeclared || escape.assigned.has(f.name) || deferredInitFields.has(f.name)) continue; + if (paramProps.some((pp) => pp.name === f.name)) continue; const declared = fields.get(f.name); - if (declared === undefined || !earlyReadable(lowerer, declared)) continue; - // A declared `T | undefined` field already starts undefined. - if (declared.kind === "union" && lowerer.armTag(declared.unionId, UNDEFINED_T) >= 0) + if (declared?.kind !== "object" || lowerer.classes.get(declared.className)?.def.runtime) continue; - const armed = lowerer.runtimeOptionalType(declared); - if (armed.kind !== "union") continue; + const armed = lowerer.withUndefinedArm(declared); + if (armed === null || armed.kind !== "union") continue; fields.set(f.name, armed); f.type = armed; - // Primitive and union slots yield the undefined value itself. - // Reference slots keep the deferred-init reads: consumers that - // observe undefined (printing, equality, typeof, nullish defaults) - // see it, and member access on it throws a TypeError, as in Node. - if (declared.kind === "union" || PRIMITIVE_EARLY_READS.has(declared.kind)) - earlyReadFields.add(f.name); - else deferredInitFields.add(f.name); + deferredInitFields.add(f.name); } } @@ -3738,43 +3722,6 @@ export function collectClassShapeInner( (name) => !hasAccessor(name) && !methods.has(name) && !lowerer.findMethodOn(base, name), ) : null; - // Constructor statements that run after the instance may have been - // exposed (a method call, `this` passed along, a base constructor - // that exposes it): a field they create can be read before its - // assignment, while Node holds undefined. - const exposedBefore = new Set(); - { - let exposed = false; - for (const stmt of ctor?.body?.statements ?? []) { - const expression = ts.isExpressionStatement(stmt) ? stmt.expression : null; - if ( - expression && - ts.isCallExpression(expression) && - expression.expression.kind === ts.SyntaxKind.SuperKeyword - ) { - if (base?.constructionEscapes === true || expression.arguments.some(mentionsReceiver)) - exposed = true; - continue; - } - const assigned = - expression && - ts.isBinaryExpression(expression) && - expression.operatorToken.kind === ts.SyntaxKind.EqualsToken && - ts.isPropertyAccessExpression(expression.left) && - expression.left.expression.kind === ts.SyntaxKind.ThisKeyword - ? expression - : null; - if (exposed || (assigned && mentionsReceiver(assigned.right))) exposedBefore.add(stmt); - const plainAssignment = - assigned !== null && - ts.isPropertyAccessExpression(assigned.left) && - !mentionsReceiver(assigned.right) && - !hasAccessor(assigned.left.name.text) && - !methods.has(assigned.left.name.text) && - !lowerer.findMethodOn(base, assigned.left.name.text); - if (!plainAssignment && mentionsReceiver(stmt)) exposed = true; - } - } if (ctor?.body) { for (const stmt of ctor.body.statements) { const lhs = @@ -3845,15 +3792,8 @@ export function collectClassShapeInner( type = inheritedJsFieldType(lowerer, decl, name, type); // super() can invoke a subclass setter or method before its // constructor assignments run. These slots start undefined. - const sealed = sealedPrefix?.created.has(name) === true; - if (base && lowerer.dynConvertible(type) && !sealed) type = DYN; - if (exposedBefore.has(stmt) && !sealed && earlyReadable(lowerer, type)) { - const armed = lowerer.runtimeOptionalType(type); - if (armed.kind === "union") { - type = armed; - earlyReadFields.add(name); - } - } + if (base && lowerer.dynConvertible(type) && !sealedPrefix?.created.has(name)) + type = DYN; fields.set(name, type); fieldOrder.push({ name, type, initializer: undefined }); continue; @@ -4114,7 +4054,6 @@ export function collectClassShapeInner( ? { classDecorators: { nodes: classDecoratorNodes } } : {}), ...(deferredInitFields.size > 0 ? { deferredInitFields } : {}), - ...(earlyReadFields.size > 0 ? { earlyReadFields } : {}), ...(escape.escapes ? { constructionEscapes: true as const } : {}), }; // GENERIC members get their declaring-class backlink now that the @@ -6289,33 +6228,6 @@ function overrideReturnAbi( return declared; } -/** Field kinds whose early reads yield the undefined value (earlyReadFields). */ -const PRIMITIVE_EARLY_READS: ReadonlySet = new Set([ - "f64", - "bool", - "string", - "bigint", -]); - -/** Field types whose slot can admit undefined for reads before the field's - * assignment. Date values are scalars, so their unassigned slot is memory - * safe; checked-dynamic slots already hold undefined. */ -function earlyReadable(lowerer: Lowerer, type: IrType): boolean { - if (isUnitType(type)) return false; - switch (type.kind) { - case "dyn": - case "void": - case "date": - case "generator": - case "caught": - return false; - case "object": - return lowerer.classes.get(type.className)?.def.runtime !== true; - default: - return true; - } -} - /** The nearest declaration of `name` at or above `info` — the method a * receiver of that static class runs when nothing below overrides it. */ export function findMethodOn( @@ -7753,11 +7665,7 @@ function paramPropInitStmts(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLoca obj: { kind: "varRef", localId: thisLocal.id, type: thisType, loc }, className: info.def.name, field: pp.name, - // An early-readable field's slot admits undefined (earlyReadFields). - value: lowerer.coerceToExpected( - { kind: "varRef", localId: local!.id, type: local!.type, loc }, - info.fields.get(pp.name) ?? local!.type, - ), + value: { kind: "varRef", localId: local!.id, type: local!.type, loc }, loc, }); } diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index 4ef139293..c108ceb71 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -3161,51 +3161,6 @@ export function lowerTernary( * the same union (unnarrowed use), to a SUB-union (partial narrowing — * unrepresentable without a re-tag), or to nothing (`never` in an * exhaustive default) leaves the expression union-typed. */ -/** Uses that read an early-read field's value as Node does when it is - * undefined: printing, templates, operators, tests, member access, calls of - * program functions (whose parameters the optional-value analysis widens), - * and stores into bindings, fields and returns. Other uses, such as library - * arguments, extract the declared type with a check. */ -function observesEarlyRead(node: ts.Node): boolean { - let child = node; - let parent = node.parent; - while (parent && ts.isParenthesizedExpression(parent)) { - child = parent; - parent = parent.parent; - } - if (!parent) return false; - if ( - ts.isTemplateSpan(parent) || - ts.isBinaryExpression(parent) || - ts.isPrefixUnaryExpression(parent) || - ts.isPostfixUnaryExpression(parent) || - ts.isTypeOfExpression(parent) || - ts.isConditionalExpression(parent) || - ts.isIfStatement(parent) || - ts.isWhileStatement(parent) || - ts.isReturnStatement(parent) || - ts.isVariableDeclaration(parent) || - ts.isPropertyAssignment(parent) || - ts.isArrayLiteralExpression(parent) || - (ts.isPropertyAccessExpression(parent) && parent.expression === child) || - (ts.isElementAccessExpression(parent) && parent.expression === child) - ) - return true; - if (ts.isCallExpression(parent) && parent.arguments.includes(child as ts.Expression)) { - const callee = parent.expression; - if ( - ts.isPropertyAccessExpression(callee) && - ts.isIdentifier(callee.expression) && - callee.expression.text === "console" - ) - return true; - return ( - !ts.isPropertyAccessExpression(callee) || callee.expression.kind === ts.SyntaxKind.ThisKeyword - ); - } - return false; -} - export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrExpr { if ( (expr.type.kind === "union" || expr.type.kind === "dyn") && @@ -3416,25 +3371,6 @@ export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrEx if (expr.type.kind !== "union") return expr; if (ts.isPropertyAccessExpression(node) && isOptionalProcessStreamProperty(lowerer, node)) return expr; - // A field read before its assignment holds undefined although its - // declared type omits it; the declared type is no narrowing proof. A flow - // narrowing past the declared type (`if (this.x !== null)`) extracts the - // narrowed arm with a check, since the slot may still hold undefined. - if ( - expr.kind === "fieldGet" && - lowerer.classes.get(expr.className)?.earlyReadFields?.has(expr.field) === true - ) { - const symbol = ts.isPropertyAccessExpression(node) - ? lowerer.checker.getSymbolAtLocation(node.name) - : undefined; - const declared = symbol ? lowerer.mapTypeOf(lowerer.checker.getTypeOfSymbol(symbol)) : null; - const narrowedArm = lowerer.mapTypeOf(lowerer.typeOf(node)); - if (narrowedArm === null || narrowedArm.kind === "union") return expr; - if (declared !== null && typeEquals(declared, narrowedArm) && observesEarlyRead(node)) - return expr; - const helper = lowerer.narrowedArmHelper(expr.type.unionId, narrowedArm, expr.loc); - return helper ? lowerer.checkedNarrowCall(helper, expr, narrowedArm, expr.loc) : expr; - } // Represented fields and index values can include undefined even when // checker inference or lib.d.ts declares strings (RegExp captures). @@ -15465,20 +15401,6 @@ export function fieldGetExpr( const helper = lowerer.deferredReadHelper(target.fieldType.unionId, inner, loc); if (helper) return { kind: "call", callee: helper, args: [read], type: inner, loc }; } - // An early-read field (ClassInfo.earlyReadFields) yields its undefined - // where the use reads it as Node does; elsewhere the declared type is - // extracted with a check. - if ( - target.fieldType.kind === "union" && - lowerer.classes.get(target.className)?.earlyReadFields?.has(target.field) === true && - !observesEarlyRead(blame) - ) { - const declared = lowerer.mapTypeOf(lowerer.typeOf(blame)); - if (declared && declared.kind !== "union") { - const helper = lowerer.narrowedArmHelper(target.fieldType.unionId, declared, loc); - if (helper) return lowerer.checkedNarrowCall(helper, read, declared, loc); - } - } return read; } return { @@ -16019,22 +15941,6 @@ function lowerFieldCompoundValue( if (op === "+" && read.type.kind === "string") { appended = lowerer.ensureString(rhs, rhsNode ?? access); value = { kind: "strConcat", left: read, right: appended, type: STRING, loc }; - } else if ( - op === "+" && - read.type.kind === "union" && - lowerer.stripUndefinedArm(read.type).kind === "string" && - target.container === "class" && - lowerer.classes.get(target.className)?.earlyReadFields?.has(target.field) === true - ) { - // A string field read before its assignment holds undefined, which - // concatenates as "undefined". - value = { - kind: "strConcat", - left: lowerer.ensureString(read, access), - right: lowerer.ensureString(rhs, rhsNode ?? access), - type: STRING, - loc, - }; } else if (numericRead.type.kind === "f64" && numericRhs.type.kind === "f64") { value = { kind: "bin", op, left: numericRead, right: numericRhs, type: F64, loc }; } else if (bigintValue) { diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index b77768c28..33dfcfb19 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -3976,18 +3976,6 @@ export class Lowerer { if (!s) return null; return s.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(s) : s; }; - // Fields that can be read before their assignment hold undefined then; - // their reads are runtime-optional values like missing array reads. - for (const info of this.classes.values()) { - if (!info.earlyReadFields || !info.decl?.name) continue; - const classSymbol = symbolOf(info.decl.name); - if (!classSymbol) continue; - const instance = this.checker.getDeclaredTypeOfSymbol(classSymbol); - for (const name of info.earlyReadFields) { - const property = this.checker.getPropertyOfType(instance, name); - if (property) optionalSymbols.add(property); - } - } const signatureOf = (node: ts.Identifier): FnSig | null => { const symbol = symbolOf(node); if (!symbol) return null; diff --git a/packages/compiler/test/class-early-field-reads.test.ts b/packages/compiler/test/class-early-field-reads.test.ts deleted file mode 100644 index c602a2f42..000000000 --- a/packages/compiler/test/class-early-field-reads.test.ts +++ /dev/null @@ -1,93 +0,0 @@ -import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; -import { tmpdir } from "node:os"; -import { join } from "node:path"; -import { expect, test } from "vitest"; -import { compile, deserializeModule, validateModule } from "../src/index.js"; -import type { IrModule } from "../src/ir/ir.js"; - -async function lower(source: string, file = "main.ts"): Promise { - const dir = await mkdtemp(join(tmpdir(), "scriptc-early-field-reads-")); - try { - const entry = join(dir, file), - output = join(dir, "main.ir.json"); - await writeFile(entry, source); - const result = await compile(entry, { outDir: dir, outPath: output, outputKind: "ir" }); - if (!result.ok) - throw new Error(result.diagnostics.map((item) => `${item.code}: ${item.message}`).join("\n")); - const module = deserializeModule(await readFile(output, "utf8")); - expect(validateModule(module)).toEqual([]); - return module; - } finally { - await rm(dir, { recursive: true, force: true }); - } -} - -/** Field name → IR kind for a class. */ -function fields(module: IrModule, name: string): string { - const cls = module.classes.find((candidate) => candidate.name === name); - expect(cls, name).toBeDefined(); - return cls!.fields - .filter((field) => !field.name.startsWith("%")) - .map((field) => `${field.name}:${field.type.kind}`) - .join(" "); -} - -test("fields assigned after construction can call an override admit undefined", async () => { - const module = await lower(` -abstract class Base { - constructor() { - this.describe(); - } - abstract describe(): void; -} -class Panel extends Base { - label: string; - width: number; - count = 0; - constructor() { - super(); - this.label = "panel"; - this.width = 2; - } - describe(): void { - console.log(this.label, this.width, this.count); - } -} -class Plain { - label: string; - width: number; - constructor() { - this.label = "plain"; - this.width = 1; - this.describe(); - } - describe(): void { - console.log(this.label, this.width); - } -} -new Panel(); -new Plain(); -`); - expect(fields(module, "Panel")).toBe("label:union width:union count:union"); - expect(fields(module, "Plain")).toBe("label:string width:f64"); -}); - -test("JavaScript fields created after the constructor calls a method admit undefined", async () => { - const module = await lower( - ` -class Widget { - constructor() { - this.ready = true; - this.render(); - this.title = "widget"; - } - render() { - console.log(this.ready, this.title); - } -} -new Widget(); -`, - "main.js", - ); - expect(fields(module, "Widget")).toBe("ready:bool title:union"); -}); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5943-fields-read-before-assignment.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5943-fields-read-before-assignment.ts.json deleted file mode 100644 index d2dcdcc24..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5943-fields-read-before-assignment.ts.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "order": [ - "/tests/corpus/5943-fields-read-before-assignment.ts" - ], - "diags": [] -} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5944-js-fields-read-before-assignment.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5944-js-fields-read-before-assignment.js.json deleted file mode 100644 index e9800b71d..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5944-js-fields-read-before-assignment.js.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "order": [ - "/tests/corpus/5944-js-fields-read-before-assignment.js" - ], - "diags": [] -} diff --git a/tests/corpus/5943-fields-read-before-assignment.ts b/tests/corpus/5943-fields-read-before-assignment.ts deleted file mode 100644 index 922b3c34d..000000000 --- a/tests/corpus/5943-fields-read-before-assignment.ts +++ /dev/null @@ -1,181 +0,0 @@ -// @transform-types -// Fields that a base constructor (or the constructor itself) can read -// through an override or a method call before they are assigned hold -// undefined then, as in Node, for every field kind. After construction -// the fields read and update normally. -class Point { - x: number; - constructor(x: number) { - this.x = x; - } -} -function show(label: string, value: number): string { - return `${label}=${value}`; -} -abstract class Widget { - log: string[] = []; - constructor() { - this.describe("base"); - } - abstract describe(when: string): void; -} -class Panel extends Widget { - label: string; - width: number; - visible: boolean; - origin: Point; - items: number[]; - options: { depth: number }; - key: string | number; - index: Map; - tags: Set; - count = 5; - constructor(label: string, readonly id: string) { - super(); - this.label = label; - this.width = 10; - this.visible = true; - this.origin = new Point(1); - this.items = [1, 2]; - this.options = { depth: 2 }; - this.key = 7; - this.index = new Map([["a", 1]]); - this.tags = new Set(["t"]); - this.describe("ctor"); - } - describe(when: string): void { - console.log(when, this.label, this.width, this.visible, this.origin, this.items, this.options, this.key, this.count, this.id); - console.log(when, `${this.label}:${this.width}`, this.width + 1, this.count * 2, this.label === undefined, typeof this.items, this.origin?.x, this.options?.depth ?? -1, this.index?.size, this.tags?.has("t")); - console.log(when, show(this.label, this.width), String(this.key), [this.label].length); - try { - console.log(this.label.length, this.items.length); - } catch (error) { - console.log(when, (error as Error).message); - } - } - grow(): number { - this.count++; - this.width += 5; - this.label += "!"; - this.items.push(this.width); - return this.count + this.width + this.items.length; - } -} -const panel = new Panel("main", "p1"); -console.log(panel.grow(), panel.label, panel.items, panel.count, panel.width); - -class Plain { - total: number; - name: string; - constructor() { - this.total = 1; - this.name = "plain"; - this.bump(); - } - bump(): void { - this.total++; - } -} -const plain = new Plain(); -console.log(plain.total, plain.name); - -class Toucher { - constructor() { - this.touch(); - } - touch(): void {} -} -class Counter extends Toucher { - count = 0; - label: string; - items: string[]; - constructor() { - super(); - this.label = "c"; - this.items = []; - } - override touch(): void { - this.count++; - this.label += "x"; - console.log(this.count, this.label, Number.isNaN(this.count)); - try { - this.items.push("a"); - } catch (error) { - console.log(error instanceof TypeError); - } - } -} -const c = new Counter(); -c.touch(); -console.log(c.count, c.label, c.items); - -class Shower { - constructor() { - this.show(); - } - show(): void {} -} -class Box extends Shower { - label: string; - value: T; - constructor(value: T) { - super(); - this.label = "box"; - this.value = value; - } - override show(): void { - console.log("show", this.label, this.value); - } -} -new Box(3).show(); -new Box("s").show(); - -type Ctor = new (...args: any[]) => T; -class Viewer { - constructor() { - this.show(); - } - show(): void {} -} -function Labeled>(Parent: B) { - return class extends Parent { - label = "mixed"; - override show(): void { - console.log("show", this.label); - } - }; -} -const L = Labeled(Viewer); -new L().show(); - -interface Crash { loc: number; message: string } -class Setupper { - constructor() { - this.setup(); - } - setup(): void {} -} -class Host extends Setupper { - crash: Crash | null; - name: string | null; - constructor(c: Crash | null) { - super(); - this.crash = c; - this.name = "host"; - } - override setup(): void { - console.log("setup", this.crash, this.name); - if (this.crash !== null) { - try { - console.log(this.crash.loc); - } catch (error) { - console.log(error instanceof TypeError); - } - } - } - report(): string { - if (this.crash) return `${this.crash.message} at ${this.crash.loc}`; - return this.name === null ? "none" : this.name.toUpperCase(); - } -} -console.log(new Host({ loc: 3, message: "boom" }).report(), new Host(null).report()); diff --git a/tests/corpus/5944-js-fields-read-before-assignment.js b/tests/corpus/5944-js-fields-read-before-assignment.js deleted file mode 100644 index e313a12b0..000000000 --- a/tests/corpus/5944-js-fields-read-before-assignment.js +++ /dev/null @@ -1,28 +0,0 @@ -// JavaScript class fields that the constructor creates after it calls a -// method, or after a base constructor that does, hold undefined until -// they are assigned, as in Node. -class Widget { - constructor(name) { - this.render(); - this.name = name; - this.size = 3; - this.title = "widget"; - this.parts = ["a"]; - this.meta = { id: 1 }; - } - render() { - console.log("render", this.name, this.title, this.size, this.parts, this.meta, this.size + 1, `${this.name}!`); - } -} -class Big extends Widget { - constructor() { - super("big"); - this.extra = 2; - } - render() { - super.render(); - console.log("big", this.extra); - } -} -new Widget("w").render(); -new Big().render(); diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index e4dd020cd..09e45ea7f 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -2160,8 +2160,6 @@ "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, @@ -5173,8 +5171,6 @@ "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, From 7cfb6b16d207294bedb546f1476f9ea756a6df33 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 12:47:01 -0500 Subject: [PATCH 32/47] Report unhandled rejections between timers and between immediates Node runs runNextTicks after each timer and each immediate callback, which reports the unhandled rejections the callback left before the next one runs. The event loop now leaves the timer phase when a callback leaves the rejection ledger non-empty, the check phase waits for that report, and the check phase reports the ledger after each immediate's checkpoint. When several timers expired in the same turn, a later timer ran before an earlier timer's rejection was reported. On macOS the 2 ms and 3 ms timers in 5809-process-exit-and-rejections.cjs expire together, so its uncaught 'thrown string' was printed before the TypeError rejection. 5996-rejections-between-macrotasks.cjs makes five timers expire in the same turn and checks the order across three immediates. --- ...996-rejections-between-macrotasks.cjs.json | 6 + packages/runtime/src/scr_async.c | 13 +- .../5996-rejections-between-macrotasks.cjs | 33 + tests/harness/corpus-costs.json | 10836 ++++++++-------- 4 files changed, 5471 insertions(+), 5417 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5996-rejections-between-macrotasks.cjs.json create mode 100644 tests/corpus/5996-rejections-between-macrotasks.cjs diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5996-rejections-between-macrotasks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5996-rejections-between-macrotasks.cjs.json new file mode 100644 index 000000000..0e719fe78 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5996-rejections-between-macrotasks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5996-rejections-between-macrotasks.cjs" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_async.c b/packages/runtime/src/scr_async.c index 308c9198d..48f3a5329 100644 --- a/packages/runtime/src/scr_async.c +++ b/packages/runtime/src/scr_async.c @@ -4464,7 +4464,9 @@ static bool scr_loop_run_pass(ScrPromise *top_level, bool first_checkpoint) { } scr_firing_id = 0; if (scr_exc_pending()) return false; /* uncaught throw in a callback: main handles it */ - if (scr_ready_len > 0 || scr_nt_head != NULL) break; /* drain ticks and microtasks before more timers */ + /* Drain ticks and microtasks, and report the rejections the callback + * left, before more timers (Node's runNextTicks between timers). */ + if (scr_ready_len > 0 || scr_nt_head != NULL || scr_nunhandled > 0) break; } /* The check phase: immediates queued BEFORE this phase started run * now, FIFO; ones a callback queues wait for the next turn (the end @@ -4474,7 +4476,7 @@ static bool scr_loop_run_pass(ScrPromise *top_level, bool first_checkpoint) { * every macrotask; pending ticks or a woken fiber restart the turn * first (the timer loop's break above), so the phase only runs on a * drained checkpoint. */ - if (scr_ready_len == 0 && scr_nt_head == NULL && scr_pending_immediates > 0) { + if (scr_ready_len == 0 && scr_nt_head == NULL && scr_nunhandled == 0 && scr_pending_immediates > 0) { size_t end = scr_nimmediates; while (scr_immediates_head < end) { size_t i = scr_immediates_head++; @@ -4490,6 +4492,13 @@ static bool scr_loop_run_pass(ScrPromise *top_level, bool first_checkpoint) { scr_closure_release(cb); if (scr_exc_pending()) return false; /* uncaught throw: main handles it */ if (!scr_loop_run_checkpoint()) return false; + /* Node's runNextTicks between immediates also reports the + * rejections the callback left before the next one runs; a + * listener's jobs drain before the next report. */ + while (scr_nunhandled > 0 && (top_level == NULL || top_level->state != SCR_PROM_REJECTED)) { + if (scr_report_unhandled_rejections()) return true; + if (!scr_loop_run_checkpoint()) return false; + } if (top_level != NULL && top_level->state == SCR_PROM_REJECTED) break; } /* Fully drained: reset the cursor so the array reuses its slots. */ diff --git a/tests/corpus/5996-rejections-between-macrotasks.cjs b/tests/corpus/5996-rejections-between-macrotasks.cjs new file mode 100644 index 000000000..1afd8c8e8 --- /dev/null +++ b/tests/corpus/5996-rejections-between-macrotasks.cjs @@ -0,0 +1,33 @@ +'use strict'; +// Unhandled rejections are reported after the callback that left them, +// before the next due timer or the next immediate runs (Node's +// runNextTicks between macrotasks), also when several timers expire in +// the same turn. +process.on('unhandledRejection', (reason) => { + console.log('unhandledRejection', reason instanceof Error ? reason.message : JSON.stringify(reason)); +}); +process.on('uncaughtException', (err, origin) => console.log(origin, err)); + +const start = Date.now(); +setTimeout(() => void Promise.reject({ a: 1 }), 1); +setTimeout(() => void Promise.reject(new TypeError('typed reason')), 2); +setTimeout(() => { + throw 'thrown string'; +}, 3); +setTimeout(() => { + console.log('timer 4'); + Promise.reject('handled later').catch((e) => console.log('caught', e)); +}, 4); +setTimeout(() => console.log('timer 5'), 5); +// Every timer above is due once this returns. +while (Date.now() - start < 20) {} + +setTimeout(() => { + setImmediate(() => void Promise.reject('first immediate')); + setImmediate(() => { + console.log('second immediate'); + process.nextTick(() => console.log('tick')); + void Promise.reject('second immediate'); + }); + setImmediate(() => console.log('third immediate')); +}, 30); diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index ea2d8da87..7d8030e95 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -1,1699 +1,1699 @@ { "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": 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": 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, + "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, + "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": 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": 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": 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, + "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, "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, + "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, "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, + "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, "5250-cipher-aes-gcm.ts": 5771, "5251-cipher-aes-cbc.ts": 3823, "5252-cipher-aes-ctr.ts": 2580, @@ -1704,45 +1704,45 @@ "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, + "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, "5321-integer-closed-arithmetic-loops.ts": 3349, "5321-json-parse-cycles.ts": 3308, "5322-integer-variable-step-loops.ts": 2801, @@ -1751,29 +1751,29 @@ "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, + "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, "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, + "5333-record-boundary-nullable-argument.ts": 3012, + "5334-fetch-mentions-without-calls.ts": 2532, "5335-stream-operators-values.ts": 3448, - "5335-top-level-await-pending-exit-code.ts": 2359, + "5335-top-level-await-pending-exit-code.ts": 1919, "5336-stream-operators-promise-timing.ts": 3509, - "5336-top-level-await-pending-exit-listener.ts": 2649, - "5337-dc-subscriber-throw-next-tick.cjs": 2705, + "5336-top-level-await-pending-exit-listener.ts": 3734, + "5337-dc-subscriber-throw-next-tick.cjs": 2604, "5337-stream-operators-concurrency.ts": 2478, - "5338-js-tdz-function-element.js": 2787, + "5338-js-tdz-function-element.js": 2562, "5338-stream-operators-checks.cjs": 3991, - "5339-array-buffer-constructor.js": 3134, + "5339-array-buffer-constructor.js": 2502, "5339-stream-for-await-hops.ts": 2919, - "534-record-width-subtyping.ts": 3068, + "534-record-width-subtyping.ts": 2615, "5340-readable-from-options.ts": 1980, "5341-compound-any-operand.ts": 3314, "5341-generator-callback-params.ts": 3955, @@ -1789,28 +1789,28 @@ "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, + "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, "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, + "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, "5370-zlib-stream-roundtrip.ts": 3486, "5371-zlib-stream-chunking.cjs": 4025, "5372-zlib-stream-errors.cjs": 2794, @@ -1821,29 +1821,29 @@ "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, + "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, "5415-zlib-dynamic-inputs.cjs": 3606, - "542-union-element-arrays.ts": 3131, + "542-union-element-arrays.ts": 2846, "5420-readable-from-generators.ts": 3459, "5421-readable-from-generators.cjs": 3156, "5422-stream-async-push-wakeup.ts": 3051, @@ -1854,43 +1854,43 @@ "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, + "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, "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, + "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, "5510-assert-error-properties.js": 2744, "5511-assert-error-class.ts": 3998, "5512-assert-error-options.js": 3572, @@ -1911,20 +1911,20 @@ "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, + "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, "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, + "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, "5554-fs-streams-typed.ts": 4016, "5555-fs-callback-turns.cjs": 3136, "5555-http-server-close-keep-alive.ts": 6777, @@ -1937,15 +1937,15 @@ "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, + "5565-fs-dirent-untyped.mjs": 2600, + "5566-fs-dirent-dyn-boundaries/main.mjs": 2607, "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, + "5585-record-results-inlined.ts": 2922, + "5595-net-ref-unref.ts": 2593, "5600-dyn-cycle-self.ts": 2318, "5601-dyn-cycle-mutual.ts": 2455, "5602-dyn-cycle-arrays.ts": 3115, @@ -1970,19 +1970,19 @@ "5624-timers-promises-unawaited.ts": 2304, "5625-promisify-exec.ts": 7463, "5626-promisify-forms.ts": 2936, - "5627-exec-callback.ts": 2909, + "5627-exec-callback.ts": 1900, "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, + "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, "5651-tls-socket-protocol.ts": 2771, "5652-http-client-trailer-overflow.ts": 3884, "5653-net-socket-read-ahead.ts": 4524, @@ -1995,7 +1995,7 @@ "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, + "5681-array-pop-and-length.ts": 3754, "5682-publish-wide-objects.ts": 3326, "5700-cycle-release-retained.ts": 2156, "5701-cycle-release-old-edges.ts": 2601, @@ -2060,39 +2060,39 @@ "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, + "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, "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, + "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, "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, + "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, "5845-groupby-null-prototype.ts": 2868, - "5846-events-esm-default-max.ts": 2670, - "5847-events-cjs-default-max.cjs": 2274, + "5846-events-esm-default-max.ts": 2633, + "5847-events-cjs-default-max.cjs": 2823, "5849-class-view-observations.ts": 3073, "5850-using-disposable-values.ts": 3391, "5851-using-suppressed-error-values.ts": 2932, @@ -2101,45 +2101,45 @@ "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, + "5857-regexp-unicode-sets.ts": 3350, + "5858-disposable-stack.ts": 3050, + "5859-disposable-stack-js.js": 3100, "5860-url-ipv4-hosts.ts": 3101, - "5870-worker-thread-names.ts": 3899, - "5871-worker-untransferable.cjs": 3409, + "5870-worker-thread-names.ts": 3106, + "5871-worker-untransferable.cjs": 2786, "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, + "5874-worker-stdio-streams.ts": 2839, + "5875-worker-stdout-pipe.cjs": 2740, + "5879-worker-stdin.ts": 3158, "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, + "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, "5885-events-max-listener-helpers.ts": 2992, - "5886-inspect-dates.ts": 3072, - "5887-inspect-typed-arrays.ts": 2960, - "5888-inspect-sorted.ts": 3397, + "5886-inspect-dates.ts": 2559, + "5887-inspect-typed-arrays.ts": 3448, + "5888-inspect-sorted.ts": 2998, "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, + "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, + "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, "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, + "5922-matchall-groups-callbacks.ts": 3650, + "5923-matchall-groups-js.js": 3970, "5924-js-literal-identity.js": 2577, "5925-class-view-identity-observers.ts": 2297, "5926-class-view-switch-js.js": 2243, @@ -2155,2564 +2155,2567 @@ "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, + "5938-object-literal-computed-keys-keep-methods.ts": 3195, + "5939-js-let-object-reassigned-wider.js": 1945, "5940-callback-helper-specialization.ts": 3109, "5941-callback-specialization-recursion.ts": 3112, "5942-callback-specialization-throws.ts": 3221, - "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, + "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, + "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-frame-records-own-references.ts": 3563, - "5960-generic-mapped-types.ts": 2996, + "5960-generic-mapped-types.ts": 2540, "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, + "5970-net-connect-host-name.ts": 2400, + "5971-buffer-chunks-to-string.ts": 2700, + "5972-net-set-encoding-listeners.ts": 2550, "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, + "5974-typeof-module-exports.cjs": 2000, + "5975-zlib-class-values.ts": 2800, + "5990-worker-uncloneable.mjs": 3283, + "5991-worker-async-dispose.mjs": 5699, + "5992-worker-thread-name-lifetime.mjs": 2687, "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": 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, + "5996-rejections-between-macrotasks.cjs": 3034, + "600-closures-basic.ts": 2349, + "601-closures-loops.ts": 1788, + "602-closures-identity-recursion.ts": 2372, + "6020-class-extends-function-constructor.js": 4300, + "6021-asserted-literal-union-arm.ts": 3400, + "603-closures-rc-stress.ts": 1832, + "604-closures-for-of.ts": 2639, "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, + "605-closures-forward-capture-tdz.ts": 3277, "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, + "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-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-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-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, + "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, + "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, "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, + "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-null-byte-paths-js.cjs": 2762, "fs-null-byte-paths.ts": 3411, - "fs-read-encodings.ts": 3220, + "fs-read-encodings.ts": 2505, "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, + "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-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, + "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-builder-string-method-names/main.ts": 4550, "js-callable-builder.js": 4500, - "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-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-constructor-returns/main.ts": 4350, - "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-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-function-prototype-value.js": 3650, - "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-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-number-parse-dynamic.js": 2700, - "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-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-process-destructure.mjs": 4750, - "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-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-reshaped-object-literal.js": 5700, - "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, + "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, "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, + "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-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, + "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, "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, + "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-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, + "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, "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, + "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, "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, + "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, "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-char-code-integer-loops.ts": 2495, + "string-code-points.ts": 1970, + "string-concat-number-parts.ts": 2044, + "string-construction-order.ts": 2502, "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, + "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, "truthy-object-logical.ts": 5950, - "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 + "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 }, "san": { - "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": 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, + "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, "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, + "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, "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, + "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, "5250-cipher-aes-gcm.ts": 8740, "5251-cipher-aes-cbc.ts": 42449, "5252-cipher-aes-ctr.ts": 26060, @@ -4723,45 +4726,45 @@ "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, + "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, "5321-integer-closed-arithmetic-loops.ts": 3710, "5321-json-parse-cycles.ts": 3383, "5322-integer-variable-step-loops.ts": 3384, @@ -4770,29 +4773,29 @@ "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, + "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, "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, + "5333-record-boundary-nullable-argument.ts": 3100, + "5334-fetch-mentions-without-calls.ts": 4032, "5335-stream-operators-values.ts": 6378, - "5335-top-level-await-pending-exit-code.ts": 3377, + "5335-top-level-await-pending-exit-code.ts": 2383, "5336-stream-operators-promise-timing.ts": 4282, - "5336-top-level-await-pending-exit-listener.ts": 3680, - "5337-dc-subscriber-throw-next-tick.cjs": 3947, + "5336-top-level-await-pending-exit-listener.ts": 2814, + "5337-dc-subscriber-throw-next-tick.cjs": 3273, "5337-stream-operators-concurrency.ts": 8858, - "5338-js-tdz-function-element.js": 3181, + "5338-js-tdz-function-element.js": 3733, "5338-stream-operators-checks.cjs": 5284, - "5339-array-buffer-constructor.js": 4102, + "5339-array-buffer-constructor.js": 2884, "5339-stream-for-await-hops.ts": 5704, - "534-record-width-subtyping.ts": 3856, + "534-record-width-subtyping.ts": 3530, "5340-readable-from-options.ts": 4031, "5341-compound-any-operand.ts": 3905, "5341-generator-callback-params.ts": 4564, @@ -4808,28 +4811,28 @@ "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, + "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, "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, + "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, "5370-zlib-stream-roundtrip.ts": 4546, "5371-zlib-stream-chunking.cjs": 6071, "5372-zlib-stream-errors.cjs": 6496, @@ -4840,29 +4843,29 @@ "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, + "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, "5415-zlib-dynamic-inputs.cjs": 4054, - "542-union-element-arrays.ts": 4182, + "542-union-element-arrays.ts": 2812, "5420-readable-from-generators.ts": 5843, "5421-readable-from-generators.cjs": 3752, "5422-stream-async-push-wakeup.ts": 3679, @@ -4873,43 +4876,43 @@ "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, + "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, "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, + "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, "5510-assert-error-properties.js": 5349, "5511-assert-error-class.ts": 4329, "5512-assert-error-options.js": 3469, @@ -4930,20 +4933,20 @@ "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, + "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, "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, + "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, "5554-fs-streams-typed.ts": 4873, "5555-fs-callback-turns.cjs": 3708, "5555-http-server-close-keep-alive.ts": 15618, @@ -4956,15 +4959,15 @@ "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, + "5565-fs-dirent-untyped.mjs": 2898, + "5566-fs-dirent-dyn-boundaries/main.mjs": 3333, "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, + "5585-record-results-inlined.ts": 3681, + "5595-net-ref-unref.ts": 3036, "5600-dyn-cycle-self.ts": 3365, "5601-dyn-cycle-mutual.ts": 4239, "5602-dyn-cycle-arrays.ts": 3453, @@ -4989,19 +4992,19 @@ "5624-timers-promises-unawaited.ts": 4420, "5625-promisify-exec.ts": 8488, "5626-promisify-forms.ts": 3100, - "5627-exec-callback.ts": 3311, + "5627-exec-callback.ts": 2500, "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, + "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, "5651-tls-socket-protocol.ts": 30873, "5652-http-client-trailer-overflow.ts": 3512, "5653-net-socket-read-ahead.ts": 6212, @@ -5014,7 +5017,7 @@ "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, + "5681-array-pop-and-length.ts": 3216, "5682-publish-wide-objects.ts": 3376, "5700-cycle-release-retained.ts": 3414, "5701-cycle-release-old-edges.ts": 4210, @@ -5079,39 +5082,39 @@ "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, + "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, "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, + "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, "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, + "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, "5845-groupby-null-prototype.ts": 4290, - "5846-events-esm-default-max.ts": 2759, - "5847-events-cjs-default-max.cjs": 3509, + "5846-events-esm-default-max.ts": 3102, + "5847-events-cjs-default-max.cjs": 3039, "5849-class-view-observations.ts": 4659, "5850-using-disposable-values.ts": 3072, "5851-using-suppressed-error-values.ts": 3950, @@ -5120,45 +5123,45 @@ "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, + "5857-regexp-unicode-sets.ts": 3900, + "5858-disposable-stack.ts": 3750, + "5859-disposable-stack-js.js": 3600, "5860-url-ipv4-hosts.ts": 4018, - "5870-worker-thread-names.ts": 7328, - "5871-worker-untransferable.cjs": 43661, + "5870-worker-thread-names.ts": 31697, + "5871-worker-untransferable.cjs": 27481, "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, + "5874-worker-stdio-streams.ts": 27801, + "5875-worker-stdout-pipe.cjs": 31391, + "5879-worker-stdin.ts": 33232, "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, + "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, "5885-events-max-listener-helpers.ts": 3588, - "5886-inspect-dates.ts": 2966, - "5887-inspect-typed-arrays.ts": 3325, - "5888-inspect-sorted.ts": 3559, + "5886-inspect-dates.ts": 2736, + "5887-inspect-typed-arrays.ts": 2997, + "5888-inspect-sorted.ts": 2861, "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, + "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, + "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, "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, + "5922-matchall-groups-callbacks.ts": 5960, + "5923-matchall-groups-js.js": 6650, "5924-js-literal-identity.js": 3065, "5925-class-view-identity-observers.ts": 2685, "5926-class-view-switch-js.js": 3057, @@ -5174,868 +5177,871 @@ "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, + "5938-object-literal-computed-keys-keep-methods.ts": 7194, + "5939-js-let-object-reassigned-wider.js": 4436, "5940-callback-helper-specialization.ts": 4548, "5941-callback-specialization-recursion.ts": 4448, "5942-callback-specialization-throws.ts": 3443, - "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, + "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, + "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-frame-records-own-references.ts": 3535, - "5960-generic-mapped-types.ts": 3052, + "5960-generic-mapped-types.ts": 3300, "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, + "5970-net-connect-host-name.ts": 2800, + "5971-buffer-chunks-to-string.ts": 3100, + "5972-net-set-encoding-listeners.ts": 3000, "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, + "5974-typeof-module-exports.cjs": 2500, + "5975-zlib-class-values.ts": 4200, + "5990-worker-uncloneable.mjs": 22432, + "5991-worker-async-dispose.mjs": 25768, + "5992-worker-thread-name-lifetime.mjs": 28932, "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": 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, + "5996-rejections-between-macrotasks.cjs": 22172, + "600-closures-basic.ts": 2534, + "601-closures-loops.ts": 2297, + "602-closures-identity-recursion.ts": 2427, + "6020-class-extends-function-constructor.js": 7500, + "6021-asserted-literal-union-arm.ts": 7200, + "603-closures-rc-stress.ts": 2589, + "604-closures-for-of.ts": 3514, "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, + "605-closures-forward-capture-tdz.ts": 4638, "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": 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, + "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-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-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-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, + "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, + "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, "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, + "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-null-byte-paths-js.cjs": 3914, "fs-null-byte-paths.ts": 5084, - "fs-read-encodings.ts": 3336, + "fs-read-encodings.ts": 3111, "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, + "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-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, + "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-builder-string-method-names/main.ts": 5400, "js-callable-builder.js": 10100, - "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-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-constructor-returns/main.ts": 5400, - "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-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, + "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-function-prototype-value.js": 5100, - "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-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-number-parse-dynamic.js": 4350, - "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-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-process-destructure.mjs": 4600, - "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-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-reshaped-object-literal.js": 7750, - "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, + "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, "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, + "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-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, + "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, "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, + "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-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, + "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, "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, + "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, "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, + "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, "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-char-code-integer-loops.ts": 2575, + "string-code-points.ts": 2460, + "string-concat-number-parts.ts": 2155, + "string-construction-order.ts": 3307, "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, + "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, "truthy-object-logical.ts": 4450, - "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 + "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 } } From a08aada5f5eea6ac4049e39dfca7f1374210683d Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 12:48:38 -0500 Subject: [PATCH 33/47] Name 5980-cycle-components.ts in its order baseline The program moved from 5973 with its baseline, but the baseline still recorded the old path as the module order. --- .../order-parity/tests/corpus/5980-cycle-components.ts.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json index e97b429fa..cdbf47751 100644 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json @@ -1,6 +1,6 @@ { "order": [ - "/tests/corpus/5973-cycle-components.ts" + "/tests/corpus/5980-cycle-components.ts" ], "diags": [] } From f3b5696d5d5ed51279f5a25b697a51bf2f80d5ea Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 13:08:49 -0500 Subject: [PATCH 34/47] Stop repeating two frontend scans Class dynamic dispatch decides whether a class family keeps a fixed field layout from the property names a delete can remove. It cached that set with ??=, but the scan returns null when the program reflects on properties, so a program that does recomputed it, walking every source file, for each class in every dispatch wave. Only an undefined value now means the set has not been computed. npm-static re-export pruning read and parsed a package's package.json for every file whose purity it checked, and for every package boundary an import crossed. Each plan now parses each package.json once. Output is unchanged. three.js nodes lowering takes 6 s less and an Effect fixture's frontend load 4 s less. --- .../lowering/class-dynamic-dispatch.ts | 4 +- .../compiler/src/frontend/npm-static-prune.ts | 47 ++++++++++++++----- 2 files changed, 39 insertions(+), 12 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index 444a9cf23..120032bf5 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -1159,7 +1159,9 @@ export class ClassDynamicDispatch { // Runtime-owned roots keep their dedicated property contracts. A // family whose fields all exist from construction and are never // deleted keeps a fixed layout, as TypeScript classes do. - this.deletedNames ??= deletedPropertyNames(lowerer.moduleOrder); + // null is a result too; undefined means not computed yet. + if (this.deletedNames === undefined) + this.deletedNames = deletedPropertyNames(lowerer.moduleOrder); if (!root.base?.def.runtime && !fixedFieldFamily(root, this.deletedNames)) track(root); } const loc = this.propertyBag.loc; diff --git a/packages/compiler/src/frontend/npm-static-prune.ts b/packages/compiler/src/frontend/npm-static-prune.ts index c6c1f9caf..a420b6b7c 100644 --- a/packages/compiler/src/frontend/npm-static-prune.ts +++ b/packages/compiler/src/frontend/npm-static-prune.ts @@ -15,7 +15,21 @@ export function isPrunedNpmReexport(program: ts.Program, stmt: ts.ExportDeclarat return program.analysis.prunedNpmReexports.has(stmt); } -function packageJson(path: string): Record | null { +type PackageJson = Record | null; + +/** Parsed package.json files by path, kept for one plan: every purity check + * reads the metadata of its file's package again. */ +type PackageJsonCache = Map; + +function packageJson(path: string, cache: PackageJsonCache): PackageJson { + const cached = cache.get(path); + if (cached !== undefined) return cached; + const json = readPackageJson(path); + cache.set(path, json); + return json; +} + +function readPackageJson(path: string): PackageJson { const source = trackedReadFile(path); if (source === null) return null; try { @@ -58,12 +72,16 @@ function sideEffectPattern(pattern: string): RegExp { /** A nested format scope such as dist/esm/package.json is not the package's * published metadata. Stay inside the resolved package while finding its * named root, including pnpm's realpath and workspace-linked installs. */ -function packageRootJsonPath(fromFile: string, packageName: string): string | null { +function packageRootJsonPath( + fromFile: string, + packageName: string, + cache: PackageJsonCache, +): string | null { let dir = dirname(resolve(fromFile)); let root: string | null = null; while (npmPackageNameOf(dir.replaceAll("\\", "/")) === packageName) { const path = join(dir, "package.json"); - if (packageJson(path)?.["name"] === packageName) root = path; + if (packageJson(path, cache)?.["name"] === packageName) root = path; const parent = dirname(dir); if (parent === dir) break; dir = parent; @@ -73,9 +91,13 @@ function packageRootJsonPath(fromFile: string, packageName: string): string | nu // An external package's executable sources may not be in this program. // Preserve the conservative whole-dependency promise in that case. -function pureExternalPackage(path: string, visiting = new Set()): boolean { +function pureExternalPackage( + path: string, + cache: PackageJsonCache, + visiting = new Set(), +): boolean { if (visiting.has(path)) return true; - const json = packageJson(path); + const json = packageJson(path, cache); const value = json?.["sideEffects"]; if (json === null || !(value === false || (Array.isArray(value) && value.length === 0))) return false; @@ -85,8 +107,8 @@ function pureExternalPackage(path: string, visiting = new Set()): boolea if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) continue; for (const name of Object.keys(dependencies)) { const resolved = resolveBareModule(path, name, "js-only"); - const root = resolved === null ? null : packageRootJsonPath(resolved.typesFile, name); - if (root === null || !pureExternalPackage(root, visiting)) return false; + const root = resolved === null ? null : packageRootJsonPath(resolved.typesFile, name, cache); + if (root === null || !pureExternalPackage(root, cache, visiting)) return false; } } return true; @@ -135,10 +157,11 @@ export function planNpmStaticReexports( for (const path of extraRoots) request(program.getSourceFile(path) ?? null, null); const pureMemo = new Map(); + const packageJsons: PackageJsonCache = new Map(); const filePure = (sf: ts.SourceFile): boolean => { const pkg = npmPackageNameOf(sf.fileName) ?? npmStaticPackageOfPath(sf.fileName); - const path = pkg === null ? null : packageRootJsonPath(sf.fileName, pkg); - const json = path === null ? null : packageJson(path); + const path = pkg === null ? null : packageRootJsonPath(sf.fileName, pkg, packageJsons); + const json = path === null ? null : packageJson(path, packageJsons); const value = json?.["sideEffects"]; if (value === false) return true; if ( @@ -195,8 +218,10 @@ export function planNpmStaticReexports( const resolved = resolveBareModule(sf.fileName, edge.spec, "js-only"); const pkg = resolved === null ? null : npmPackageNameOf(resolved.typesFile); const root = - pkg === null || resolved === null ? null : packageRootJsonPath(resolved.typesFile, pkg); - return root !== null && pureExternalPackage(root); + pkg === null || resolved === null + ? null + : packageRootJsonPath(resolved.typesFile, pkg, packageJsons); + return root !== null && pureExternalPackage(root, packageJsons); }); }; const pure = visit(root); From 761252e173218ae53025ab5a1a3e4cc99f2bf489 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 13:20:51 -0500 Subject: [PATCH 35/47] Expect the run-time refusals of node24-file-url-conversion and stream-shims Both fixtures declare a function-local class whose base has no static lowering (`class FileURL extends URL {}`, `class Counter extends Readable`). The SC1090 for it used to come from the whole-program type queries, which collected the class outside any statement, so the build failed. Those queries now keep a refused local class out of their results and drop its diagnostics; the class declaration reports the refusal when it lowers, and in a JavaScript source a refused statement becomes a runtime fence. Both programs therefore compile and throw the fence when they reach a construct without a lowering, like the other fixtures listed with a run refusal. --- tests/harness/npm.test.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/harness/npm.test.ts b/tests/harness/npm.test.ts index a6cdee2b5..c4e70294e 100644 --- a/tests/harness/npm.test.ts +++ b/tests/harness/npm.test.ts @@ -73,7 +73,7 @@ const KNOWN: Record = { "node24-env": { run: "SC1090" }, "node24-esm-metadata": { run: "SC1090" }, "node24-event-emitter": { run: "SC2020" }, - "node24-file-url-conversion": { build: "SC1090" }, + "node24-file-url-conversion": { run: "SC2020" }, "node24-fs-descriptors": { run: "SC1090" }, "node24-mime": { run: "SC2020" }, "node24-mime-errors": { run: "SC1090" }, @@ -104,7 +104,7 @@ const KNOWN: Record = { "package-imports": { build: "SC2013" }, "promise-bridge": { build: "SC1090" }, "self-name": { build: "SC2013" }, - "stream-shims": { build: "SC1090" }, + "stream-shims": { run: "SC1090" }, "util-shims": { run: "SC2020" }, "web-streams": { build: "SC2013" }, "workspace-copied": { build: "SC2013" }, From fe7b1cd199d9a21f6b0765eeb7942cbabf449d76 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 13:33:41 -0500 Subject: [PATCH 36/47] Convert a Date to local time once for its local getters and follow TZ changes Each local-time getter (getFullYear, getMonth, getDate, getHours, ..., getTimezoneOffset) called localtime_r and walked the calendar for its own field. The thread now keeps its last local conversion, keyed by the instant and a timezone generation, so reading several local fields of one Date converts it once. The UTC walk and the second computation use integer division instead of floor. Writing or deleting process.env.TZ calls tzset and starts a new generation, so later local-time reads use the new zone, as in Node. Before, the zone the process started with stayed in effect. --- .../corpus/5683-date-local-fields-tz.ts.json | 6 ++ packages/runtime/src/scr_lib.c | 66 ++++++++++++- tests/corpus/5683-date-local-fields-tz.ts | 95 +++++++++++++++++++ tests/harness/corpus-costs.json | 2 + 4 files changed, 164 insertions(+), 5 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5683-date-local-fields-tz.ts.json create mode 100644 tests/corpus/5683-date-local-fields-tz.ts diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5683-date-local-fields-tz.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5683-date-local-fields-tz.ts.json new file mode 100644 index 000000000..7ac133650 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5683-date-local-fields-tz.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5683-date-local-fields-tz.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_lib.c b/packages/runtime/src/scr_lib.c index 9307d9b01..fd51e9c78 100644 --- a/packages/runtime/src/scr_lib.c +++ b/packages/runtime/src/scr_lib.c @@ -824,6 +824,26 @@ static void scr_node_debug_capture(const ScrStr *name) { if (name->len == 10 && memcmp(name->data, "NODE_DEBUG", 10) == 0) (void)scr_node_debug_initial(); } +/* Counts writes and deletes of process.env.TZ. The local-time getters keep + * their last conversion for the generation it was made in. */ +#ifdef SCR_WORKERS +static atomic_uint scr_date_tz_generation; +#else +static unsigned scr_date_tz_generation; +#endif + +/* After a write or delete of the process's TZ, local time follows the new + * value, as in Node: tzset(3) rereads it for later localtime calls. */ +static void scr_env_tz_changed(const ScrStr *name) { + /* Compared by character: a string literal would join the merged + * read-only strings of every program that links this file. */ + if (name->len != 2 || name->data[0] != 'T' || name->data[1] != 'Z') return; +#if !defined(_WIN32) && !defined(__wasi__) + tzset(); +#endif + scr_date_tz_generation++; +} + /* process.env.NAME = v — setenv(3): later scr_env_get reads and spawned * children (posix_spawn inherits environ) observe the write, like Node. * Both args borrowed (NUL-terminated ScrStr data); setenv copies. */ @@ -842,6 +862,7 @@ void scr_env_set(const ScrStr *name, const ScrStr *value) { #else setenv(k, v, 1); #endif + scr_env_tz_changed(name); #ifdef SCR_WORKERS done: #endif @@ -861,6 +882,7 @@ void scr_env_unset(const ScrStr *name) { #else unsetenv(name->data); #endif + scr_env_tz_changed(name); } static ScrStr *scr_fs_read_file_core(ScrStr *path, bool env_file, size_t *ascii); @@ -10475,9 +10497,14 @@ typedef struct ScrDateParts { * endpoint. The checked wrapper is the public UTC-getter gate; the inner * walk accepts those bounded local-time values too. */ static void scr_date_utc_parts_unchecked(double t, ScrDateParts *out) { - double dayd = floor(t / 86400000.0); - long long msday = (long long)(t - dayd * 86400000.0); - long long z = (long long)dayd + 719468; + /* t is an integral number of milliseconds within about 2^53. */ + long long tms = (long long)t; + long long day = tms / 86400000, msday = tms % 86400000; + if (msday < 0) { + msday += 86400000; + day--; + } + long long z = day + 719468; long long era = (z >= 0 ? z : z - 146096) / 146097; unsigned long long doe = (unsigned long long)(z - era * 146097); unsigned long long yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; @@ -10487,7 +10514,7 @@ static void scr_date_utc_parts_unchecked(double t, ScrDateParts *out) { unsigned long long d = doy - (153 * mp + 2) / 5 + 1; unsigned long long m = mp < 10 ? mp + 3 : mp - 9; if (m <= 2) y++; - long long wday = ((long long)dayd + 4) % 7; + long long wday = (day + 4) % 7; if (wday < 0) wday += 7; out->year = y; out->month = (int)m - 1; @@ -10516,10 +10543,39 @@ static bool scr_date_localtime(double secd, struct tm *out) { #endif } +/* The thread's last local conversion: reading several local fields of one + * Date (getFullYear, getMonth, getDate, getHours, ...) converts it once. + * A change of process.env.TZ starts a new generation. */ +typedef struct { + bool valid; + unsigned generation; + double ms; + ScrDateParts parts; +} ScrDateLocalCache; +static SCR_TL ScrDateLocalCache scr_date_local_cache; + +static bool scr_date_local_parts_uncached(double clipped, ScrDateParts *out); + static bool scr_date_local_parts(double ms, ScrDateParts *out) { if (!isfinite(ms) || fabs(ms) > 8640000000000000.0) return false; double clipped = trunc(ms); - double secd = floor(clipped / 1000.0); + ScrDateLocalCache *c = &scr_date_local_cache; + unsigned generation = scr_date_tz_generation; + if (c->valid && c->ms == clipped && c->generation == generation) { + *out = c->parts; + return true; + } + if (!scr_date_local_parts_uncached(clipped, out)) return false; + c->valid = true; + c->generation = generation; + c->ms = clipped; + c->parts = *out; + return true; +} + +static bool scr_date_local_parts_uncached(double clipped, ScrDateParts *out) { + long long cms = (long long)clipped; + double secd = (double)(cms / 1000 - (cms % 1000 < 0)); struct tm tmv; double basis_secd = secd; if (!scr_date_localtime(basis_secd, &tmv)) { diff --git a/tests/corpus/5683-date-local-fields-tz.ts b/tests/corpus/5683-date-local-fields-tz.ts new file mode 100644 index 000000000..dc75011ed --- /dev/null +++ b/tests/corpus/5683-date-local-fields-tz.ts @@ -0,0 +1,95 @@ +// Local-time getters read repeatedly on one Date and alternately on two, +// on Dates parsed from strings, and across process.env.TZ writes and +// deletes: every read answers the fields of the zone in effect at that +// moment, as in Node. + +function fields(d: Date): string { + return [ + d.getFullYear(), + d.getMonth(), + d.getDate(), + d.getDay(), + d.getHours(), + d.getMinutes(), + d.getSeconds(), + d.getMilliseconds(), + d.getTimezoneOffset(), + ].join(","); +} + +const a = new Date(Date.UTC(2024, 2, 10, 6, 59, 59, 999)); +const b = new Date(Date.UTC(2024, 2, 10, 7, 0, 0, 0)); +const c = new Date(Date.UTC(2024, 10, 3, 5, 30, 0, 250)); + +function report(label: string): void { + console.log(label, fields(a), fields(a)); + console.log(label, fields(b), fields(c), fields(b)); + let mixed = 0; + for (let i = 0; i < 6; i++) mixed += a.getHours() * 100 + b.getHours() + c.getDate(); + console.log(label, "alternating", mixed); +} + +report("start"); +process.env.TZ = "America/New_York"; +report("new york"); +process.env.TZ = "Asia/Kolkata"; +report("kolkata"); +process.env.TZ = "Australia/Lord_Howe"; +report("lord howe"); + +// Dates parsed from strings with an explicit offset, read in local time. +const d = new Date("2024-06-01T23:45:00+05:30"); +console.log("offset string", fields(d), d.getTime()); +const e = new Date("2024-07-11T00:15:30.001Z"); +console.log("offset string", fields(e), e.getTime()); +console.log("first again", fields(d)); + +delete process.env.TZ; +report("deleted"); +process.env.TZ = "UTC"; +report("utc"); + +// Many instants read field by field. +process.env.TZ = "Europe/Berlin"; +let sum = 0; +for (let i = 0; i < 2000; i++) { + const t = new Date(1700000000000 + i * 3_599_999); + sum += t.getHours() + t.getDate() * 3 + t.getMonth() * 7 + t.getTimezoneOffset(); +} +console.log("berlin sum", sum); + +const invalid = new Date(Number.NaN); +console.log("invalid", fields(invalid), fields(invalid)); + +// Instants around day and second boundaries, before the epoch and at the +// ends of the Date range, in UTC and local fields; then 2000-2030 in a zone +// with DST. +function utcFields(d: Date): string { + return [ + d.getUTCFullYear(), + d.getUTCMonth(), + d.getUTCDate(), + d.getUTCDay(), + d.getUTCHours(), + d.getUTCMinutes(), + d.getUTCSeconds(), + d.getUTCMilliseconds(), + ].join(","); +} +const edges = [ + 0, -0, -0.5, 0.5, -1, 1, -999, -1000, -1001, 999.9, -86_400_000, -86_400_001, 86_399_999, + -62_198_755_200_000, -62_198_755_200_001, 8_640_000_000_000_000, -8_640_000_000_000_000, + 8_639_999_999_999_999, -8_639_999_999_999_999, 951_782_400_000, 4_107_542_399_999, +]; +process.env.TZ = "UTC"; +for (const t of edges) { + const x = new Date(t); + console.log(t, utcFields(x), fields(x)); +} +process.env.TZ = "America/Sao_Paulo"; +let walk = 0; +for (let t = 946_684_800_000; t < 1_893_456_000_000; t += 77_777_777) { + const x = new Date(t); + walk = (walk * 31 + x.getUTCDate() + x.getUTCHours() * 7 + x.getDate() + x.getMinutes() + x.getDay()) % 1_000_003; +} +console.log("walk", walk); diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index 7d8030e95..907f27383 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -1997,6 +1997,7 @@ "5680-array-growth-after-copy.ts": 3791, "5681-array-pop-and-length.ts": 3754, "5682-publish-wide-objects.ts": 3326, + "5683-date-local-fields-tz.ts": 3848, "5700-cycle-release-retained.ts": 2156, "5701-cycle-release-old-edges.ts": 2601, "5702-publish-candidate-buffers.ts": 3469, @@ -5019,6 +5020,7 @@ "5680-array-growth-after-copy.ts": 4581, "5681-array-pop-and-length.ts": 3216, "5682-publish-wide-objects.ts": 3376, + "5683-date-local-fields-tz.ts": 3911, "5700-cycle-release-retained.ts": 3414, "5701-cycle-release-old-edges.ts": 4210, "5702-publish-candidate-buffers.ts": 3848, From f80eb5fc39ce2232abd2fd793241786a20951b84 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 13:39:12 -0500 Subject: [PATCH 37/47] Give every arm of record unions that share arms a collector header A shape union's arms all carry a collector header when one of them does. The emitter applied that rule in one pass over the unions in module order, so a header that a later union gave a shared arm did not reach the other arms of an earlier union. With First = A | B and Second = B | C, where only C is cyclic, B got a header through Second, First's trace helper then called A's trace function, and A had none: the module failed LLVM verification with "use of undefined value '@sc_rtrace_r0'". The rule now repeats until no union adds a header. Corpus 5919-record-unions-shared-arms chains Third = D | A, First = A | B and Second = B | C, so the requirement passes from Second through First to Third. --- packages/compiler/src/backend/llvm/emitter.ts | 26 +++++--- .../5919-record-unions-shared-arms.ts.json | 6 ++ .../corpus/5919-record-unions-shared-arms.ts | 60 +++++++++++++++++++ tests/harness/corpus-costs.json | 2 + 4 files changed, 87 insertions(+), 7 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5919-record-unions-shared-arms.ts.json create mode 100644 tests/corpus/5919-record-unions-shared-arms.ts diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 775e771ca..26c3b840e 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -1395,13 +1395,25 @@ export class LlEmitter { this.tracedUnions = traced.unions; // A shape union's value is whichever record it holds, and the collector // visits it as that record: when one arm carries a collector header, - // every arm must (nullable-unions.ts). - for (const union of this.nullableUnions.allShapeUnions()) - if ( - this.tracedUnions.has(union.unionId) || - union.arms.some((arm) => this.tracedShapes.has(`record:${arm.shapeId}`)) - ) - for (const arm of union.arms) this.tracedShapes.add(`record:${arm.shapeId}`); + // every arm must (nullable-unions.ts). Unions that share an arm pass a + // header on to each other's arms, so repeat until no union adds one. + const shapeUnions = this.nullableUnions.allShapeUnions(); + for (let changed = true; changed;) { + changed = false; + for (const union of shapeUnions) { + if ( + !this.tracedUnions.has(union.unionId) && + !union.arms.some((arm) => this.tracedShapes.has(`record:${arm.shapeId}`)) + ) + continue; + for (const arm of union.arms) { + const key = `record:${arm.shapeId}`; + if (this.tracedShapes.has(key)) continue; + this.tracedShapes.add(key); + changed = true; + } + } + } this.shapeHost = { sizeType: this.sizeType, cycleBufOffset: this.cycleBufOffset, diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5919-record-unions-shared-arms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5919-record-unions-shared-arms.ts.json new file mode 100644 index 000000000..bfb23e115 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5919-record-unions-shared-arms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5919-record-unions-shared-arms.ts" + ], + "diags": [] +} diff --git a/tests/corpus/5919-record-unions-shared-arms.ts b/tests/corpus/5919-record-unions-shared-arms.ts new file mode 100644 index 000000000..89f34dd83 --- /dev/null +++ b/tests/corpus/5919-record-unions-shared-arms.ts @@ -0,0 +1,60 @@ +// Record unions that share arms: Third = D | A, First = A | B and +// Second = B | C. Only C is cyclic. Every arm of a union whose values the +// cycle collector can visit carries a collector header, and the shared +// arms pass that requirement from Second back through First to Third. +type A = { kind: "a"; v: number }; +type B = { kind: "b"; w: number }; +type C = { kind: "c"; kids: C[] }; +type D = { kind: "d"; label: string }; +type Third = D | A; +type First = A | B; +type Second = B | C; + +function third(u: Third): string { + return u.kind === "d" ? u.label : `a${u.v}`; +} + +function first(u: First): number { + return u.kind === "a" ? u.v : u.w; +} + +function second(u: Second): number { + return u.kind === "b" ? u.w : u.kids.length + u.kids.reduce((n, k) => n + second(k), 0); +} + +const zs: Third[] = [ + { kind: "d", label: "dee" }, + { kind: "a", v: 7 }, +]; +console.log(zs.map(third).join(",")); + +const xs: First[] = [ + { kind: "a", v: 1 }, + { kind: "b", w: 2 }, +]; +console.log(xs.map(first).join(",")); + +const leaf: C = { kind: "c", kids: [] }; +const ys: Second[] = [ + { kind: "b", w: 3 }, + { kind: "c", kids: [leaf, { kind: "c", kids: [leaf] }] }, +]; +console.log(ys.map(second).join(",")); + +// One record held through two unions. +const sharedA: A = { kind: "a", v: 5 }; +const sharedB: B = { kind: "b", w: 6 }; +const viaThird: Third = sharedA; +const viaFirst: First[] = [sharedA, sharedB]; +const viaSecond: Second = sharedB; +console.log(third(viaThird), viaFirst.map(first).join(","), second(viaSecond)); + +// A cyclic C reachable only through Second, dropped and rebuilt in a loop. +let total = 0; +for (let i = 0; i < 200; i++) { + const node: C = { kind: "c", kids: [] }; + node.kids.push(node); + const held: Second[] = [node, { kind: "b", w: i }]; + total += held.length + node.kids.length; +} +console.log("total", total); diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index c393620c3..8ef52f39a 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -2136,6 +2136,7 @@ "5913-prototype-type-error-messages.ts": 3102, "5914-dyn-in-class-prototype-members.ts": 2530, "5915-dyn-error-string-conversions.ts": 3023, + "5919-record-unions-shared-arms.ts": 3182, "5920-promise-try-args.ts": 3028, "5921-promise-try-args-js.js": 3179, "5922-matchall-groups-callbacks.ts": 4418, @@ -5154,6 +5155,7 @@ "5913-prototype-type-error-messages.ts": 3454, "5914-dyn-in-class-prototype-members.ts": 3792, "5915-dyn-error-string-conversions.ts": 3851, + "5919-record-unions-shared-arms.ts": 4941, "5920-promise-try-args.ts": 3195, "5921-promise-try-args-js.js": 3082, "5922-matchall-groups-callbacks.ts": 5275, From fa64c19fdc8a536867144474fcae3e7d22d3fb42 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 09:51:38 -0700 Subject: [PATCH 38/47] Build the coverage result without a conditional spread over its tiers The self-hosted compiler refuses a conditional spread of `tiers` over a LowerResult that already declares the field, so assign it instead. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/src/frontend/lowering/lowerer.ts | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index c535d603f..d104eae39 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -1091,7 +1091,7 @@ export function lowerToIr( // Unreached JS statements whose fences deferred to runtime count as // failed statements in the remainder's stats, so their diagnostics must // travel with them: a failed statement is never left unexplained. - return { + const covered: LowerResult = { ...result, stats: { ...result.stats, statementsDynamic }, unreached: { @@ -1099,8 +1099,9 @@ export function lowerToIr( stats: rem.stats, ...(rem.runtimeFences.length > 0 ? { runtimeFences: rem.runtimeFences } : {}), }, - ...(tiers !== undefined ? { tiers } : {}), }; + if (tiers !== undefined) covered.tiers = tiers; + return covered; } /** The native namespace type produced by a literal static import() of a From b0ce48f168fdb9170e185ff4ae7f6a4f9aa79ef2 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 11:47:04 -0700 Subject: [PATCH 39/47] Fence refused statements inside capture buffers instead of dropping them A refused statement in a JavaScript function body was dropped without a diagnostic or runtime fence when the body lowered inside a capture buffer whose owner kept the result. tryLowerExpression lowers the receiver of `(function () { ... }).call(this)` or `.apply(...)` and a computed class base that way: the refused statement (for example `console.log(root === module.exports)`) was missing from the kept function, its diagnostic was handed back to the enclosing statement, and that statement, having lowered cleanly, filed it as an informational runtime-fence entry. The program printed nothing for that statement. lowerStmts now emits the statement's runtime fence inside a buffer as well (Lowerer.capturedRuntimeFence, the same message deferToRuntimeFence would give), leaving the diagnostics with the buffer's owner. The three JavaScript class initializer sites that skipped their fence under a buffer (static field, instance field, static initializer block) do the same. An owner that discards the candidate discards the fence with it, so every program that compiled before keeps byte-identical IR unless it contained such a dropped statement: all 3006 corpus programs produce the same IR as before. Co-Authored-By: Claude Opus 5.5 --- .../src/frontend/lowering/lower-classes.ts | 28 +++++--- .../src/frontend/lowering/lower-stmts.ts | 6 ++ .../compiler/src/frontend/lowering/lowerer.ts | 65 ++++++++++++++----- .../6110-cjs-speculative-wrapper-fences.cjs | 26 ++++++++ .../speculative-function-refusal.ts | 14 ++++ tests/harness/errors.test.ts | 53 +++++++++++++++ 6 files changed, 166 insertions(+), 26 deletions(-) create mode 100644 tests/corpus/6110-cjs-speculative-wrapper-fences.cjs create mode 100644 tests/diagnostics/speculative-function-refusal.ts diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 7b2d176c3..f666effd1 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -4419,6 +4419,7 @@ export function lowerStaticFieldInits(lowerer: Lowerer, info: ClassInfo): IrStmt // instantiation's bindings/context (a no-op for everything else — // generic FAMILIES own their statics and carry no genericInstance). const diagsBefore = lowerer.diags.length; + const sinkMark = lowerer.diagSinkMark(); try { return withInstanceBindings(lowerer, info, () => lowerStaticFieldInitsInner(lowerer, info)); } catch (error) { @@ -4426,8 +4427,11 @@ export function lowerStaticFieldInits(lowerer: Lowerer, info: ClassInfo): IrStmt // Keep their refusal attached to the class declaration instead of // letting a poisoned initializer escape the module lowering pass. if (!(error instanceof PoisonError)) throw error; - if (info.decl && isJsSourceFile(info.decl.getSourceFile()) && lowerer.diagSink === null) { - const fence = lowerer.deferToRuntimeFence(diagsBefore, info.decl, { kind: "statement" }); + if (info.decl && isJsSourceFile(info.decl.getSourceFile())) { + const fence = + lowerer.diagSink === null + ? lowerer.deferToRuntimeFence(diagsBefore, info.decl, { kind: "statement" }) + : lowerer.capturedRuntimeFence(sinkMark, info.decl); if (fence) return [fence]; } return []; @@ -4564,6 +4568,7 @@ function lowerStaticFieldInitsInner(lowerer: Lowerer, info: ClassInfo): IrStmt[] lowerer.stats.statementsTotal++; lowerer.bumpFileStat(locOf(f.initializer).file, "total"); const diagsBefore = lowerer.diags.length; + const sinkMark = lowerer.diagSinkMark(); try { const previousThis = lowerer.ctx.thisLocal; const receiver = @@ -4599,10 +4604,11 @@ function lowerStaticFieldInitsInner(lowerer: Lowerer, info: ClassInfo): IrStmt[] if (!(e instanceof PoisonError)) throw e; lowerer.stats.statementsFailed++; lowerer.bumpFileStat(locOf(f.initializer).file, "failed"); - if (isJsSourceFile(f.initializer.getSourceFile()) && lowerer.diagSink === null) { - const fence = lowerer.deferToRuntimeFence(diagsBefore, f.initializer, { - kind: "statement", - }); + if (isJsSourceFile(f.initializer.getSourceFile())) { + const fence = + lowerer.diagSink === null + ? lowerer.deferToRuntimeFence(diagsBefore, f.initializer, { kind: "statement" }) + : lowerer.capturedRuntimeFence(sinkMark, f.initializer); if (fence) out.push(fence); } } @@ -7703,6 +7709,7 @@ export function fieldInitStmts(lowerer: Lowerer, info: ClassInfo, thisLocal: IrL lowerer.stats.statementsTotal++; lowerer.bumpFileStat(locOf(f.initializer).file, "total"); const diagsBefore = lowerer.diags.length; + const sinkMark = lowerer.diagSinkMark(); try { const value = lowerer.lowerExprExpecting(f.initializer, f.type); out.push({ @@ -7717,10 +7724,11 @@ export function fieldInitStmts(lowerer: Lowerer, info: ClassInfo, thisLocal: IrL if (!(e instanceof PoisonError)) throw e; lowerer.stats.statementsFailed++; lowerer.bumpFileStat(locOf(f.initializer).file, "failed"); - if (isJsSourceFile(f.initializer.getSourceFile()) && lowerer.diagSink === null) { - const fence = lowerer.deferToRuntimeFence(diagsBefore, f.initializer, { - kind: "statement", - }); + if (isJsSourceFile(f.initializer.getSourceFile())) { + const fence = + lowerer.diagSink === null + ? lowerer.deferToRuntimeFence(diagsBefore, f.initializer, { kind: "statement" }) + : lowerer.capturedRuntimeFence(sinkMark, f.initializer); if (fence) out.push(fence); } } diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 76a3971d0..148f837ec 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -671,6 +671,7 @@ export function lowerStmts(lowerer: Lowerer, stmts: readonly ts.Statement[]): Ir if (sf !== undefined) lowerer.bumpFileStat(sf.fileName, "total"); } const diagsBefore = lowerer.diags.length; + const sinkMark = lowerer.diagSinkMark(); try { let lowered: IrStmt | IrStmt[] | null; let appended = false; @@ -755,6 +756,11 @@ export function lowerStmts(lowerer: Lowerer, stmts: readonly ts.Statement[]): Ir }, }); if (fence) out.push(fence); + } else if (deferFences) { + // Inside a capture buffer the owner keeps the diagnostics, but + // the statement still must not vanish from a result it keeps. + const fence = lowerer.capturedRuntimeFence(sinkMark, stmt); + if (fence) out.push(fence); } } } diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index fe998af36..42cc16705 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -7011,23 +7011,8 @@ export class Lowerer { } this.runtimeFences.push(...captured); - const first = captured[0]; + const fence = this.runtimeFenceStmt(captured[0], node, target.fallback, target.bareMessage); const loc = locOf(node); - const code = first?.code ?? target.fallback!.code; - const baseMessage = first?.message ?? target.fallback!.message; - const messageLoc = first?.loc ?? loc; - const source = first - ? (this.program.getSourceFile(messageLoc.file) ?? node.getSourceFile()) - : node.getSourceFile(); - const pos = ts.getLineAndCharacterOfPosition(source, messageLoc.start); - const fence: IrStmt = { - kind: "runtimeFence", - code, - message: target.bareMessage - ? baseMessage - : `${baseMessage} [${code} at ${messageLoc.file}:${pos.line + 1}]`, - loc, - }; if (target.kind === "statement") return fence; const params = target.params ?? []; @@ -7055,6 +7040,54 @@ export class Lowerer { return { kind: "closure", fnName: fn.name, captures: [], type: target.type, loc }; } + /** The runtimeFence statement that throws `first`'s message (or the + * fallback's) at `node`. */ + private runtimeFenceStmt( + first: ScrDiagnostic | undefined, + node: ts.Node, + fallback: { code: string; message: string } | undefined, + bareMessage = false, + ): IrStmt & { kind: "runtimeFence" } { + const loc = locOf(node); + const code = first?.code ?? fallback?.code ?? "SC1090"; + const baseMessage = + first?.message ?? + fallback?.message ?? + "this statement uses a construct with no static lowering"; + const messageLoc = first?.loc ?? loc; + const source = first + ? (this.program.getSourceFile(messageLoc.file) ?? node.getSourceFile()) + : node.getSourceFile(); + const pos = ts.getLineAndCharacterOfPosition(source, messageLoc.start); + return { + kind: "runtimeFence", + code, + message: bareMessage + ? baseMessage + : `${baseMessage} [${code} at ${messageLoc.file}:${pos.line + 1}]`, + loc, + }; + } + + /** The current length of the capture buffer (diagSink), or 0 without one: + * the mark capturedRuntimeFence reads the refusal from. */ + diagSinkMark(): number { + return this.diagSink?.length ?? 0; + } + + /** The runtimeFence for a JavaScript statement refused while a capture + * buffer (diagSink) is active. The buffer's owner decides whether its + * diagnostics report, and some owners keep the lowered result (a + * successful tryLowerExpression candidate, a computed class base whose + * diagnostics defer to the class). Without a fence the refused statement + * would vanish from that result; with one it throws the refusal when it + * runs, exactly like the fence lowerStmts emits outside a buffer. The + * diagnostics stay in the buffer for its owner. Null without a buffer. */ + capturedRuntimeFence(sinkMark: number, node: ts.Node): IrStmt | null { + if (this.diagSink === null) return null; + return this.runtimeFenceStmt(this.diagSink[sinkMark], node, undefined); + } + /** All diagnostics land here; while a generic instance body is lowering, * the instantiation context is appended so the user knows which concrete * types made the (source-anchored) construct fail. */ diff --git a/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs b/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs new file mode 100644 index 000000000..a26760710 --- /dev/null +++ b/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs @@ -0,0 +1,26 @@ +// Function expressions lowered speculatively — the `.call(this)` and +// `.apply` receivers of CommonJS wrappers, and a computed class base — keep +// every statement of their bodies. A statement with no static lowering +// (here `module.exports` read as a value) compiles to its runtime fence +// instead of vanishing; these never run, so the binary matches Node. +const verbose = process.argv.length > 99; +(function () { + var root = this; + console.log("call wrapper"); + if (verbose) console.log(root === module.exports); + console.log("call wrapper done"); +}).call(this); +(function (label) { + console.log("apply wrapper", label); + if (verbose) console.log(typeof module.exports); +}).apply(null, ["ok"]); +class Base { + hello() { + return "hello"; + } +} +class Derived extends (function () { + if (verbose) console.log(module.exports); + return Base; +})() {} +console.log(new Derived().hello()); diff --git a/tests/diagnostics/speculative-function-refusal.ts b/tests/diagnostics/speculative-function-refusal.ts new file mode 100644 index 000000000..fc48d9935 --- /dev/null +++ b/tests/diagnostics/speculative-function-refusal.ts @@ -0,0 +1,14 @@ +// Function expressions lowered speculatively — an `.apply` receiver and a +// computed class base — report a refused statement in their body like any +// other function: the statement never disappears from the build. +(function () { + console.log("wrapper"); + console.log(eval("1 + 1")); +}).apply(null, []); + +class Base {} +class Derived extends (function () { + console.log(new Function("return 1")()); + return Base; +})() {} +console.log(typeof Derived); diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts index 28daa88d3..51f04d310 100644 --- a/tests/harness/errors.test.ts +++ b/tests/harness/errors.test.ts @@ -960,3 +960,56 @@ for (const input of [ciphertext, Buffer.from("forged data"), Buffer.alloc(0)]) { expect(r.stderr).toBe(""); }); }); + +// Function expressions the frontend lowers speculatively (the receiver of +// `.call`/`.apply`, a computed class base) keep their refused statements as +// runtime fences. They used to vanish: the capture buffer held the refusal, +// the candidate was kept, and the statement was simply missing from it. +describe("refused statements in speculatively lowered JavaScript functions", () => { + test.each([ + [ + "speculative-call-this", + `(function () { + var root = this; + console.log("before"); + console.log(root === module.exports); + console.log("after"); +}).call(this); +`, + "before\n", + 4, + ], + [ + "speculative-apply", + `(function () { + console.log("before"); + console.log(typeof module.exports); +}).apply(null, []); +`, + "before\n", + 3, + ], + [ + "speculative-class-base", + `class Base {} +class Derived extends (function () { + console.log("before"); + console.log(typeof module.exports); + return Base; +})() {} +console.log(typeof Derived); +`, + "before\n", + 4, + ], + ] as const)("%s", async (name, source, stdout, line) => { + const r = await compileAndRun(name, source, "cjs"); + expect(r.exitCode).toBe(1); + expect(r.stdout).toBe(stdout); + expect(r.stderr).toMatch( + new RegExp( + `^Uncaught Error: 'module\\.exports' is part of the standard library types but has no scriptc lowering yet \\[SC2020 at .*${name}\\.cjs:${line}\\]\\n$`, + ), + ); + }); +}); From a5548597e5d4481a5fb79dc0978308770cddf4f0 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 14:02:03 -0500 Subject: [PATCH 40/47] Read zlib options held in typed objects A zlib options object that reaches the runtime as a typed reference (a cast object literal such as `{ level: 0 } as zlib.ZlibOptions`, which the checked-dynamic options slot holds by reference) was not a plain checked-dynamic object, so the options reader found no keys: every option was ignored and out-of-range values were not reported. The sync, callback and promisified one-shots and the stream constructors compressed with the defaults instead. scr_zlib_options_parse and scr_zlib_stream_new now read a typed reference through its materialized view, as the blob and fetch option readers do, so the options apply and invalid ones throw Node's ERR_OUT_OF_RANGE. --- .../corpus/5633-zlib-typed-options.ts.json | 6 ++ packages/runtime/src/scr_zlib.c | 15 +++++ packages/runtime/src/scr_zlib_stream.c | 7 +++ tests/corpus/5633-zlib-typed-options.ts | 58 +++++++++++++++++++ tests/harness/corpus-costs.json | 2 + 5 files changed, 88 insertions(+) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5633-zlib-typed-options.ts.json create mode 100644 tests/corpus/5633-zlib-typed-options.ts diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5633-zlib-typed-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5633-zlib-typed-options.ts.json new file mode 100644 index 000000000..f4d9673d5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5633-zlib-typed-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5633-zlib-typed-options.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_zlib.c b/packages/runtime/src/scr_zlib.c index b61cdc1cb..ff09e7ea1 100644 --- a/packages/runtime/src/scr_zlib.c +++ b/packages/runtime/src/scr_zlib.c @@ -420,7 +420,22 @@ void scr_zlib_options_drop(ScrZlibOptions *o) { o->dict = NULL; } +static bool scr_zlib_options_parse_object(int mode, const ScrDyn *opts, ScrZlibOptions *out); + +/* A typed options object (a record that crossed into a checked-dynamic + * slot by reference) is read through its materialized view, as a plain + * object is. */ bool scr_zlib_options_parse(int mode, const ScrDyn *opts, ScrZlibOptions *out) { + if (opts == NULL || opts->kind != SCR_DYN_TYPED_REF) return scr_zlib_options_parse_object(mode, opts, out); + ScrDyn *view = scr_dyn_typed_ref_materialize(opts); + bool ok = false; + if (scr_exc_pending()) memset(out, 0, sizeof *out); + else ok = scr_zlib_options_parse_object(mode, view, out); + scr_dyn_release(view); + return ok; +} + +static bool scr_zlib_options_parse_object(int mode, const ScrDyn *opts, ScrZlibOptions *out) { memset(out, 0, sizeof *out); out->window_bits = 15; out->level = Z_DEFAULT_COMPRESSION; diff --git a/packages/runtime/src/scr_zlib_stream.c b/packages/runtime/src/scr_zlib_stream.c index 14d8747e8..4ed717d53 100644 --- a/packages/runtime/src/scr_zlib_stream.c +++ b/packages/runtime/src/scr_zlib_stream.c @@ -431,6 +431,13 @@ static const char *scr_zs_class_name(int mode) { } ScrStream *scr_zlib_stream_new(double mode_d, ScrDyn *opts) { + /* A typed options object is read through its materialized view. */ + if (opts != NULL && opts->kind == SCR_DYN_TYPED_REF) { + ScrDyn *view = scr_dyn_typed_ref_materialize(opts); + ScrStream *stream = scr_exc_pending() ? NULL : scr_zlib_stream_new(mode_d, view); + scr_dyn_release(view); + return stream; + } int mode = (int)mode_d; const ScrDyn *o = opts != NULL && scr_dyn_truthy(opts) ? opts : NULL; ScrZlibOptions zo; diff --git a/tests/corpus/5633-zlib-typed-options.ts b/tests/corpus/5633-zlib-typed-options.ts new file mode 100644 index 000000000..da657ca14 --- /dev/null +++ b/tests/corpus/5633-zlib-typed-options.ts @@ -0,0 +1,58 @@ +// zlib options held in a typed object (a cast object literal that crosses +// into the options slot by reference) are read like a plain options +// object: levels, windowBits and strategies apply, and out-of-range values +// throw Node's ERR_OUT_OF_RANGE from the sync, callback, promisified and +// stream forms. +import * as zlib from "node:zlib"; +import { promisify } from "node:util"; + +const data = Buffer.from("hello hello hello hello hello"); +const stored = { level: 0 } as zlib.ZlibOptions; +const fast = { level: 1 } as zlib.ZlibOptions; +const huffman = { strategy: zlib.constants.Z_HUFFMAN_ONLY } as zlib.ZlibOptions; +const smallWindow = { windowBits: 9, memLevel: 1 } as zlib.ZlibOptions; +const badLevel = { level: 99 } as zlib.ZlibOptions; +const badWindow = { windowBits: 3 } as zlib.ZlibOptions; + +function attempt(label: string, run: () => void): void { + try { + run(); + console.log(label, "ok"); + } catch (e) { + const err = e as NodeJS.ErrnoException; + console.log(label, err.name, err.code, err.message); + } +} + +console.log("sync stored", zlib.deflateSync(data, stored).toString("hex")); +console.log("sync fast", zlib.deflateSync(data, fast).toString("hex")); +console.log("sync huffman", zlib.deflateSync(data, huffman).toString("hex")); +console.log("raw small window", zlib.deflateRawSync(data, smallWindow).toString("hex")); +console.log("gzip stored", zlib.gzipSync(data, stored).subarray(10).toString("hex")); +attempt("sync bad level", () => zlib.deflateSync(data, badLevel)); +attempt("sync bad window", () => zlib.inflateSync(zlib.deflateSync(data), badWindow)); +attempt("callback bad level", () => zlib.gzip(data, badLevel, () => console.log("not called"))); +attempt("stream bad level", () => zlib.createDeflate(badLevel)); + +const deflateAsync = promisify(zlib.deflate); + +async function main(): Promise { + const viaCallback = await new Promise((resolve, reject) => + zlib.deflate(data, stored, (err, out) => (err ? reject(err) : resolve(out))), + ); + console.log("callback stored", viaCallback.toString("hex")); + console.log("promise stored", (await deflateAsync(data, stored)).toString("hex")); + try { + await deflateAsync(data, badLevel); + console.log("promise bad level fulfilled"); + } catch (e) { + console.log("promise bad level", (e as NodeJS.ErrnoException).code); + } + const stream = zlib.createDeflate(fast); + const parts: Buffer[] = []; + stream.on("data", (chunk: Buffer) => parts.push(chunk)); + stream.on("end", () => console.log("stream fast", Buffer.concat(parts).toString("hex"))); + stream.end(data); +} + +main().catch((e) => console.log("unexpected", String(e))); diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index acaa95479..33d8c4c1d 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -1976,6 +1976,7 @@ "5630-promisify-zlib.ts": 2503, "5631-promisify-crypto.ts": 2200, "5632-promisify-dns.ts": 1700, + "5633-zlib-typed-options.ts": 1800, "5644-net-socket-addresses.ts": 2220, "5645-net-socket-callbacks.ts": 2442, "5646-net-server-connections.ts": 2389, @@ -5006,6 +5007,7 @@ "5630-promisify-zlib.ts": 3392, "5631-promisify-crypto.ts": 2600, "5632-promisify-dns.ts": 2000, + "5633-zlib-typed-options.ts": 2200, "5644-net-socket-addresses.ts": 2393, "5645-net-socket-callbacks.ts": 2060, "5646-net-server-connections.ts": 2755, From 8531a45509303e0db37786863fe67bb077b3bd68 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 12:04:28 -0700 Subject: [PATCH 41/47] Record baselines for the capture-buffer fence fixtures The diagnostics snapshot for speculative-function-refusal.ts and the ts7 order-parity baselines for it and 6110-cjs-speculative-wrapper-fences.cjs. Co-Authored-By: Claude Opus 5.5 --- ...6110-cjs-speculative-wrapper-fences.cjs.json | 6 ++++++ .../speculative-function-refusal.ts.json | 6 ++++++ .../speculative-function-refusal.ts.txt | 17 +++++++++++++++++ 3 files changed, 29 insertions(+) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/speculative-function-refusal.ts.json create mode 100644 tests/harness/__snapshots__/speculative-function-refusal.ts.txt diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs.json new file mode 100644 index 000000000..0a5ce66b0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/speculative-function-refusal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/speculative-function-refusal.ts.json new file mode 100644 index 000000000..e24349766 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/speculative-function-refusal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/speculative-function-refusal.ts" + ], + "diags": [] +} diff --git a/tests/harness/__snapshots__/speculative-function-refusal.ts.txt b/tests/harness/__snapshots__/speculative-function-refusal.ts.txt new file mode 100644 index 000000000..c8b0cd28c --- /dev/null +++ b/tests/harness/__snapshots__/speculative-function-refusal.ts.txt @@ -0,0 +1,17 @@ +speculative-function-refusal.ts:6:15 - error SC2020: 'eval' is part of the standard library types but has no scriptc lowering yet + + 5 | console.log("wrapper"); + 6 | console.log(eval("1 + 1")); + | ^~~~ + 7 | }).apply(null, []); + + hint: runtime code evaluation cannot be compiled ahead of time + +speculative-function-refusal.ts:11:15 - error SC2020: 'new Function' is part of the standard library types but has no scriptc lowering yet + + 10 | class Derived extends (function () { + 11 | console.log(new Function("return 1")()); + | ^~~~~~~~~~~~~~~~~~~~~~~~ + 12 | return Base; + + hint: runtime code generation cannot be compiled ahead of time (the eval stance) — write the function \ No newline at end of file From f6499596099e02d46a31520dee83fc518ad67150 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 09:31:23 -0700 Subject: [PATCH 42/47] Report refused local classes from speculative type queries again The previous change dropped the diagnostics of a function-local class refused during a speculative whole-program type query, expecting the class's own declaration to report them. In JavaScript that declaration only defers them to a runtime fence, so two npm programs that the compile refused (stream-shims and node24-file-url-conversion, both SC1090) began to compile and diverged from Node at run time. The speculative query now leaves the refusal reported, as it was wherever such an analysis already caught the poison, and only stops the poison from escaping the compiler. The JavaScript crash repro becomes a diagnostics fixture (local-class-type-query-js.js); the corpus program 6102 never crashed the base compiler and is removed. Co-Authored-By: Claude Opus 5.5 --- .../compiler/src/frontend/lowering/lowerer.ts | 14 ++----- .../6102-local-class-type-query.js.json | 6 --- .../local-class-type-query-js.js.json | 6 +++ tests/corpus/6102-local-class-type-query.js | 42 ------------------- .../diagnostics/local-class-type-query-js.js | 26 ++++++++++++ .../local-class-type-query-js.js.txt | 6 +++ 6 files changed, 42 insertions(+), 58 deletions(-) delete mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6102-local-class-type-query.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query-js.js.json delete mode 100644 tests/corpus/6102-local-class-type-query.js create mode 100644 tests/diagnostics/local-class-type-query-js.js create mode 100644 tests/harness/__snapshots__/local-class-type-query-js.js.txt diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index bf4ed5464..94f99185a 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -9804,27 +9804,21 @@ export class Lowerer { * instance type. Collection and body lowering own a refusal of that * class: the poison reaches the declaration or statement that asked, as * before. A speculative whole-program analysis owns none, so there the - * class is unmappable for the query and its diagnostics are dropped; - * lowering the class's own declaration collects it again and reports - * them if the program reaches it. */ + * refusal stays reported (the build fails with it, as it did where such + * an analysis already caught the poison) and the class is unmappable for + * the query instead of the poison escaping the compiler. */ collectLocalClassForType(decl: ts.ClassLikeDeclaration): boolean { if (this.speculativeTypeQueryDepth === 0 || this.fnStack.length > 0) { this.lowerClassExpressionInfo(decl); return true; } - const sink: ScrDiagnostic[] = []; - const previousSink = this.diagSink; - this.diagSink = sink; try { this.lowerClassExpressionInfo(decl); + return true; } catch (e) { if (e instanceof PoisonError) return false; throw e; - } finally { - this.diagSink = previousSink; } - for (const d of sink) this.pushDiag(d); - return true; } lowerClassExpression(expr: ts.ClassLikeDeclaration): IrExpr { diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6102-local-class-type-query.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6102-local-class-type-query.js.json deleted file mode 100644 index 86c6ba9e8..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6102-local-class-type-query.js.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "order": [ - "/tests/corpus/6102-local-class-type-query.js" - ], - "diags": [] -} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query-js.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query-js.js.json new file mode 100644 index 000000000..6bf774cd8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-type-query-js.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/local-class-type-query-js.js" + ], + "diags": [] +} diff --git a/tests/corpus/6102-local-class-type-query.js b/tests/corpus/6102-local-class-type-query.js deleted file mode 100644 index 92fe35725..000000000 --- a/tests/corpus/6102-local-class-type-query.js +++ /dev/null @@ -1,42 +0,0 @@ -// A whole-program analysis that queries types before reachability is known -// (the computed-key write census here) can name a function-local class whose -// collection is refused. That query has no owner for the refusal: the class -// stays unmapped for it, and the refusal belongs to the class's own -// declaration, which this program never executes (it used to crash the -// compiler with an uncaught PoisonError). -function main(run) { - if (!run) return "skipped"; - const Project = class { - constructor() { - this.name = "p"; - } - close() { - if (this.missingFilesMap) { - this.missingFilesMap.clear(); - this.missingFilesMap = void 0; - } - } - add(k) { - (this.missingFilesMap || (this.missingFilesMap = new Map())).set(k, 1); - } - }; - const holder = { p: new Project() }; - const key = String(run); - holder.p[key] = "q"; - return holder.p.name; -} - -class Counter { - constructor() { - this.counts = {}; - } - bump(key) { - this.counts[key] = (this.counts[key] || 0) + 1; - return this.counts[key]; - } -} - -const counter = new Counter(); -const word = process.argv.length > 99 ? "unused" : "word"; -counter.bump(word); -console.log(main(0), counter.bump(word)); diff --git a/tests/diagnostics/local-class-type-query-js.js b/tests/diagnostics/local-class-type-query-js.js new file mode 100644 index 000000000..2da619133 --- /dev/null +++ b/tests/diagnostics/local-class-type-query-js.js @@ -0,0 +1,26 @@ +// A whole-program analysis that queries types before reachability is known +// (the computed-key write census here, through `holder.p`) names a +// function-local class whose collection is refused. The refusal is reported, +// once, at the class; it used to crash the compiler with an uncaught +// PoisonError. +function main() { + const Project = class _Project { + constructor() { + this.name = "p"; + } + close() { + if (this.missingFilesMap) { + this.missingFilesMap.clear(); + this.missingFilesMap = void 0; + } + } + add(k) { + (this.missingFilesMap || (this.missingFilesMap = new Map())).set(k, 1); + } + }; + const holder = { p: new Project() }; + const key = process.argv.length > 5 ? String(process.argv.length) : "name"; + holder.p[key] = "q"; + console.log(holder.p.name); +} +main(); diff --git a/tests/harness/__snapshots__/local-class-type-query-js.js.txt b/tests/harness/__snapshots__/local-class-type-query-js.js.txt new file mode 100644 index 000000000..60422a5dc --- /dev/null +++ b/tests/harness/__snapshots__/local-class-type-query-js.js.txt @@ -0,0 +1,6 @@ +local-class-type-query-js.js:14:9 - error SC1090: fields assigned outside the constructor's top level ('this.missingFilesMap' would be undefined until the first assignment runs — assign it unconditionally at the top of the constructor) is not supported yet + + 13 | this.missingFilesMap.clear(); + 14 | this.missingFilesMap = void 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 15 | } \ No newline at end of file From 5746dc30c5fb4db460563988ef19beb2fe79018e Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 12:05:40 -0700 Subject: [PATCH 43/47] Expect the compile to refuse stream-shims and node24-file-url-conversion again With the local-class refusal reported again, both npm fixtures fail to compile with SC1090 as they did before #1303; restore their build expectations. The deleted corpus program 6102 also leaves the measured cost table. Co-Authored-By: Claude Opus 5.5 --- tests/harness/corpus-costs.json | 2 -- tests/harness/npm.test.ts | 4 ++-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index 810e6a798..e413e9d3a 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -2209,7 +2209,6 @@ "605-closures-forward-capture-tdz.ts": 3277, "6100-record-get-or-create.ts": 3771, "6101-record-get-or-create-unchecked/main.ts": 2107, - "6102-local-class-type-query.js": 2600, "6103-typeof-builtin-bindings.cjs": 2202, "6104-typeof-builtin-bindings.mjs": 2031, "6105-cjs-top-level-this/main.js": 1371, @@ -5245,7 +5244,6 @@ "605-closures-forward-capture-tdz.ts": 4638, "6100-record-get-or-create.ts": 3173, "6101-record-get-or-create-unchecked/main.ts": 3228, - "6102-local-class-type-query.js": 1967, "6103-typeof-builtin-bindings.cjs": 1796, "6104-typeof-builtin-bindings.mjs": 1715, "6105-cjs-top-level-this/main.js": 3213, diff --git a/tests/harness/npm.test.ts b/tests/harness/npm.test.ts index c4e70294e..a6cdee2b5 100644 --- a/tests/harness/npm.test.ts +++ b/tests/harness/npm.test.ts @@ -73,7 +73,7 @@ const KNOWN: Record = { "node24-env": { run: "SC1090" }, "node24-esm-metadata": { run: "SC1090" }, "node24-event-emitter": { run: "SC2020" }, - "node24-file-url-conversion": { run: "SC2020" }, + "node24-file-url-conversion": { build: "SC1090" }, "node24-fs-descriptors": { run: "SC1090" }, "node24-mime": { run: "SC2020" }, "node24-mime-errors": { run: "SC1090" }, @@ -104,7 +104,7 @@ const KNOWN: Record = { "package-imports": { build: "SC2013" }, "promise-bridge": { build: "SC1090" }, "self-name": { build: "SC2013" }, - "stream-shims": { run: "SC1090" }, + "stream-shims": { build: "SC1090" }, "util-shims": { run: "SC2020" }, "web-streams": { build: "SC2013" }, "workspace-copied": { build: "SC2013" }, From 470d3177030e799b15f5b67016210892e8959c93 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 14:21:32 -0500 Subject: [PATCH 44/47] Keep class methods named kind and code direct in the compiler resolveInferredReturn turns a return statement into a runtime fence through a Record view with element writes (`mutable["kind"] = ...`). The class method census treats a literal element write as a possible write to every method of that name, so in the native compiler every method named `kind` or `code` became a dynamic callback: AstWireFile.kind, called for each AST node access, went through a property bag and a method value. Property writes go through the receiver check instead, and no class instance is assignable to Record, so those methods are called directly again. Output of the compiler is unchanged. --- .../src/frontend/lowering/function-returns.ts | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/function-returns.ts b/packages/compiler/src/frontend/lowering/function-returns.ts index d3c5eb1ba..5ba63be26 100644 --- a/packages/compiler/src/frontend/lowering/function-returns.ts +++ b/packages/compiler/src/frontend/lowering/function-returns.ts @@ -429,11 +429,14 @@ export function resolveInferredReturn( if (ice.length > 0) lowerer.diags.push(...ice); lowerer.runtimeFences.push(...captured.filter((d) => d.code !== "SC9001")); const first = captured.find((d) => d.code !== "SC9001"); + // Property writes, not literal element writes: the class method + // census reads `x["kind"] = …` as a possible write to every method + // named `kind`, which would make those methods dynamic in native builds. const mutable = e.stmt as unknown as Record; - delete mutable["value"]; - mutable["kind"] = "runtimeFence"; - mutable["code"] = first?.code ?? "SC1090"; - mutable["message"] = first + delete mutable.value; + mutable.kind = "runtimeFence"; + mutable.code = first?.code ?? "SC1090"; + mutable.message = first ? `${first.message} [${first.code}]` : "this return value has no lowering onto the instance's settled return type [SC1090]"; } From c20c21b22cd6300e7a426d8628e0913117688c2c Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 18 Oct 2026 13:05:47 -0700 Subject: [PATCH 45/47] Declare the deferred fences of 6110 for the coverage contract The corpus program deliberately carries refused statements on untaken paths; the `// @deferred-fences: 9` header is the coverage sweep's exemption for such programs (9 failed statements across the speculative and final lowerings), so it still runs against Node in the differential oracle. Co-Authored-By: Claude Opus 5.5 --- tests/corpus/6110-cjs-speculative-wrapper-fences.cjs | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs b/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs index a26760710..6040f009c 100644 --- a/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs +++ b/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs @@ -1,3 +1,4 @@ +// @deferred-fences: 9 // Function expressions lowered speculatively — the `.call(this)` and // `.apply` receivers of CommonJS wrappers, and a computed class base — keep // every statement of their bodies. A statement with no static lowering From 547e59529f50446bee47663a19f652c41294a0be Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 15:23:20 -0500 Subject: [PATCH 46/47] Resolve builtin classes through const aliases `const E = EventEmitter`, `const M = Map`, `const T = TypeError` and `const R = Readable` stopped at SC2020, and so did `typeof EventEmitter`, `Readable.name`, `Map.name`, `Error.name` and `===` between builtin classes. The zlib class alias resolver now covers the error classes, EventEmitter, the node:stream classes and Map/Set: a const binding of one (an alias of an alias, or an export used through a named or namespace import) constructs, extends and tests instanceof like the direct name, and typeof, .name and === fold for aliases and direct names. In TypeScript files the alias owns no runtime slot and other value uses report SC1090 at the use. In JavaScript files a copy of a name or of a globalThis property keeps its slot, which holds the same value as the name it copies; builtin module members (`zlib.Gzip`) own none, as before. --- .../lowering/builtins/class-values.ts | 159 ++++++++++++++++++ .../frontend/lowering/builtins/compression.ts | 72 +------- .../src/frontend/lowering/lower-classes.ts | 41 ++++- .../src/frontend/lowering/lower-exprs.ts | 45 ++--- .../src/frontend/lowering/lower-modules.ts | 4 +- .../src/frontend/lowering/lower-stmts.ts | 7 +- .../compiler/src/frontend/lowering/lowerer.ts | 15 +- .../src/frontend/lowering/surfaces.ts | 6 +- .../corpus/5976-builtin-class-aliases.ts.json | 6 + .../5977-builtin-class-aliases.cjs.json | 6 + .../main.ts.json | 7 + .../builtin-class-alias-escape.ts.json | 6 + tests/corpus/5976-builtin-class-aliases.ts | 109 ++++++++++++ tests/corpus/5977-builtin-class-aliases.cjs | 45 +++++ .../classes.ts | 8 + .../5978-builtin-class-alias-modules/main.ts | 33 ++++ .../diagnostics/builtin-class-alias-escape.ts | 15 ++ tests/diagnostics/class-values.ts | 4 +- .../builtin-class-alias-escape.ts.txt | 22 +++ .../harness/__snapshots__/class-values.ts.txt | 64 +++---- .../zlib-class-alias-escape.ts.txt | 2 +- tests/harness/corpus-costs.json | 6 + 22 files changed, 541 insertions(+), 141 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/builtins/class-values.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5976-builtin-class-aliases.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5977-builtin-class-aliases.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5978-builtin-class-alias-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/builtin-class-alias-escape.ts.json create mode 100644 tests/corpus/5976-builtin-class-aliases.ts create mode 100644 tests/corpus/5977-builtin-class-aliases.cjs create mode 100644 tests/corpus/5978-builtin-class-alias-modules/classes.ts create mode 100644 tests/corpus/5978-builtin-class-alias-modules/main.ts create mode 100644 tests/diagnostics/builtin-class-alias-escape.ts create mode 100644 tests/harness/__snapshots__/builtin-class-alias-escape.ts.txt diff --git a/packages/compiler/src/frontend/lowering/builtins/class-values.ts b/packages/compiler/src/frontend/lowering/builtins/class-values.ts new file mode 100644 index 000000000..f24db09cf --- /dev/null +++ b/packages/compiler/src/frontend/lowering/builtins/class-values.ts @@ -0,0 +1,159 @@ +import * as ts from "../../ts7/adapter.js"; +import { type Lowerer } from "../lowerer.js"; +import { type ClassInfo } from "../lower-classes.js"; +import { isJsSourceFile } from "../../program.js"; +import { builtinMemberRequireDecl } from "./module-bindings.js"; +import { stripTypeCasts } from "./arguments.js"; +import { streamClassAliasDecl } from "../lower-stream.js"; +import { zlibClassName, zlibStreamModeOf } from "./compression.js"; +import { stdlibGlobalNameOf } from "../surfaces.js"; + +/** A builtin class an expression names at compile time: the error + * classes, node:events EventEmitter, the node:stream classes (each a + * runtime ClassInfo), the node:zlib stream classes (by node_zlib_mode), + * and the Map and Set constructors. `name` is the class's `name` + * property. */ +export type BuiltinClassRef = + | { kind: "error" | "emitter" | "stream"; info: ClassInfo; name: string } + | { kind: "zlib"; mode: number; name: string } + | { kind: "collection"; which: "Map" | "Set"; name: string }; + +/** The builtin class `expr` names: a direct spelling (`EventEmitter`, + * `stream.Readable`, `zlib.Gzip`, `Map`, `globalThis.TypeError`) or a + * `const` binding of one (`const E = EventEmitter`, an alias of an alias, + * an imported alias), through parentheses and type assertions. Null for + * anything else. */ +export function builtinClassRefOf(lowerer: Lowerer, expr: ts.Expression): BuiltinClassRef | null { + const e = stripTypeCasts(expr); + // Checker lookups only: answering must not run the fences and deferred + // diagnostics of a lowered reference (resolveValueSymbol). + let symbol: ts.Symbol | undefined; + if (ts.isIdentifier(e)) { + symbol = lowerer.checker.getSymbolAtLocation(e); + } else if (ts.isPropertyAccessExpression(e) && !e.questionDotToken) { + symbol = lowerer.checker.getSymbolAtLocation(e.name); + } else { + return null; + } + if (!symbol) return null; + const alias = builtinClassAliasOf(lowerer, symbol); + if (alias !== null) return alias; + if (symbol.flags & ts.SymbolFlags.Alias) symbol = lowerer.checker.getAliasedSymbol(symbol); + const which = stdlibGlobalNameOf(lowerer, e); + if (which === "Map" || which === "Set") return { kind: "collection", which, name: which }; + const error = lowerer.builtinErrorInfoOf(symbol); + if (error) return { kind: "error", info: error, name: runtimeClassName(error) }; + const emitter = lowerer.builtinEmitterInfoOf(symbol); + if (emitter) return { kind: "emitter", info: emitter, name: runtimeClassName(emitter) }; + const stream = lowerer.builtinStreamInfoOf(symbol); + if (stream) return { kind: "stream", info: stream, name: runtimeClassName(stream) }; + const mode = zlibStreamModeOf(lowerer, symbol); + if (mode !== null) return { kind: "zlib", mode, name: zlibClassName(mode) }; + return null; +} + +/** The builtin class a `const` binding names (`const E = EventEmitter`, + * `const M = Map`, `const C = zlib.Gzip`, or an alias of such a binding), + * or null. `let` and `var` bindings could be reassigned, and annotated + * bindings give the value another type, so they are not aliases. Resolved from the declaration, so uses lowered before the + * declaration statement (hoisted functions) see the same answer. */ +export function builtinClassAliasOf(lowerer: Lowerer, symbol: ts.Symbol): BuiltinClassRef | null { + const cached = lowerer.builtinClassAliases.get(symbol); + if (cached !== undefined) return cached; + // An import of an exported alias names the exporting binding. + if (symbol.flags & ts.SymbolFlags.Alias) { + lowerer.builtinClassAliases.set(symbol, null); + const target = lowerer.checker.getAliasedSymbol(symbol); + const ref = target === symbol ? null : builtinClassAliasOf(lowerer, target); + lowerer.builtinClassAliases.set(symbol, ref); + return ref; + } + const init = constInitializerOf(lowerer, symbol); + if (init === null) { + lowerer.builtinClassAliases.set(symbol, null); + return null; + } + // Marked first: a cycle through other bindings answers null. + lowerer.builtinClassAliases.set(symbol, null); + const ref = builtinClassRefOf(lowerer, init); + lowerer.builtinClassAliases.set(symbol, ref); + return ref; +} + +/** True when `symbol` is a builtin class alias whose declaration owns no + * runtime slot: new, instanceof, typeof, .name and === lower at each use, + * and other uses report SC1090. In JavaScript files, a binding whose + * initializer has a value (`const E = EventEmitter`, `const M = + * globalThis.Map`, both identity tokens) keeps its slot; only builtin + * module members (`zlib.Gzip`) and copies of slotless aliases own none. + * The `require("events").EventEmitter` and `stream.Writable` spellings + * keep their own declaration handling. */ +export function builtinClassAliasOwnsNoSlot(lowerer: Lowerer, symbol: ts.Symbol): boolean { + if (builtinClassAliasOf(lowerer, symbol) === null) return false; + const binding = + symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol; + const decl = lowerer.checker.valueDeclarationOf(binding); + if (decl === undefined || !ts.isVariableDeclaration(decl)) return false; + if (builtinMemberRequireDecl(decl.name, decl.initializer)) return false; + if (streamClassAliasDecl(lowerer, decl.name, decl.initializer)) return false; + if (!isJsSourceFile(decl.getSourceFile())) return true; + let init = decl.initializer; + while (init !== undefined && ts.isParenthesizedExpression(init)) init = init.expression; + if (init === undefined) return true; + let source: ts.Symbol | undefined; + if (ts.isPropertyAccessExpression(init)) { + if (lowerer.builtinNamespaceModuleOf(init.expression) !== null) return true; + source = lowerer.checker.getSymbolAtLocation(init.name); + } else { + source = lowerer.checker.getSymbolAtLocation(init); + } + return source !== undefined && builtinClassAliasOwnsNoSlot(lowerer, source); +} + +/** True for a `const` declaration that is a builtin class alias owning no + * runtime slot (see builtinClassAliasOwnsNoSlot): both declaration walks + * skip it. */ +export function registerBuiltinClassAlias( + lowerer: Lowerer, + nameNode: ts.Node, + init: ts.Expression | undefined, +): boolean { + if (!ts.isIdentifier(nameNode) || init === undefined) return false; + const symbol = lowerer.checker.getSymbolAtLocation(nameNode); + return symbol !== undefined && builtinClassAliasOwnsNoSlot(lowerer, symbol); +} + +/** True when two references name the same builtin class. */ +export function sameBuiltinClass(a: BuiltinClassRef, b: BuiltinClassRef): boolean { + if (a.kind === "zlib") return b.kind === "zlib" && a.mode === b.mode; + if (a.kind === "collection") return b.kind === "collection" && a.which === b.which; + return b.kind === a.kind && b.info === a.info; +} + +/** The initializer of an unannotated `const` binding whose initializer + * can name a class (an identifier or a property access), or null. */ +function constInitializerOf(lowerer: Lowerer, symbol: ts.Symbol): ts.Expression | null { + if ((symbol.flags & ts.SymbolFlags.BlockScopedVariable) === 0) return null; + const decl = lowerer.checker.valueDeclarationOf(symbol); + if ( + decl === undefined || + !ts.isVariableDeclaration(decl) || + !ts.isIdentifier(decl.name) || + decl.type !== undefined + ) { + return null; + } + const list = decl.parent; + if (!ts.isVariableDeclarationList(list) || (list.flags & ts.NodeFlags.Const) === 0) return null; + let init = decl.initializer; + while (init !== undefined && ts.isParenthesizedExpression(init)) init = init.expression; + if (init === undefined) return null; + if (ts.isIdentifier(init)) return init; + if (ts.isPropertyAccessExpression(init) && !init.questionDotToken) return init; + return null; +} + +/** Node's constructor name of a runtime class (`%TypeError` → TypeError). */ +function runtimeClassName(info: ClassInfo): string { + return info.def.name.startsWith("%") ? info.def.name.slice(1) : info.def.name; +} diff --git a/packages/compiler/src/frontend/lowering/builtins/compression.ts b/packages/compiler/src/frontend/lowering/builtins/compression.ts index c9553c2f9..6de345dfe 100644 --- a/packages/compiler/src/frontend/lowering/builtins/compression.ts +++ b/packages/compiler/src/frontend/lowering/builtins/compression.ts @@ -132,8 +132,8 @@ export function zlibStreamModeOf( symbol: ts.Symbol | null | undefined, ): number | null { if (!symbol) return null; - const aliasMode = zlibClassAliasModeOf(lowerer, symbol, 0); - if (aliasMode !== undefined) return aliasMode; + const alias = lowerer.builtinClassAliasOf(symbol); + if (alias !== null) return alias.kind === "zlib" ? alias.mode : null; const target = symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol; const mode = ZLIB_STREAM_MODES.get(target.name); @@ -499,80 +499,12 @@ export function lowerZlibModuleCall( throw new InternalCompilerError(`unhandled lowered zlib member ${bi.member}`); } -/** The zlib stream class an expression names (`zlib.Gzip`, an imported - * `Gzip`, a `const C = zlib.Gzip` alias), as its node_zlib_mode, or null. */ -export function zlibClassModeOfExpr(lowerer: Lowerer, expr: ts.Expression): number | null { - let e = expr; - while (ts.isParenthesizedExpression(e)) e = e.expression; - if (ts.isIdentifier(e)) return zlibStreamModeOf(lowerer, lowerer.checker.getSymbolAtLocation(e)); - if (ts.isPropertyAccessExpression(e) && !e.questionDotToken) { - return zlibStreamModeOf(lowerer, lowerer.checker.getSymbolAtLocation(e.name)); - } - return null; -} - /** The class name of a zlib stream mode (Node's constructor name). */ export function zlibClassName(mode: number): string { for (const [name, m] of ZLIB_STREAM_MODES) if (m === mode) return name; return "Zlib"; } -/** The mode of a `const C = zlib.Gzip` binding (or an alias of such a - * binding), null when the symbol is a const binding of something else, - * undefined when it is not a const binding. Resolved from the declaration, - * so uses lowered before the declaration statement see the same answer. */ -function zlibClassAliasModeOf( - lowerer: Lowerer, - symbol: ts.Symbol, - depth: number, -): number | null | undefined { - const cached = lowerer.zlibClassAliases.get(symbol); - if (cached !== undefined) return cached; - if ((symbol.flags & ts.SymbolFlags.BlockScopedVariable) === 0) return undefined; - const decl = lowerer.checker.valueDeclarationOf(symbol); - if (decl === undefined || !ts.isVariableDeclaration(decl) || !ts.isIdentifier(decl.name)) { - return undefined; - } - // const only: a var or let binding could be reassigned - const list = decl.parent; - if (!ts.isVariableDeclarationList(list) || (list.flags & ts.NodeFlags.Const) === 0) { - return undefined; - } - let init = decl.initializer; - while (init !== undefined && ts.isParenthesizedExpression(init)) init = init.expression; - if (init === undefined || depth > 16) return null; - let mode: number | null = null; - if (ts.isIdentifier(init)) { - const next = lowerer.checker.getSymbolAtLocation(init); - if (next !== undefined) { - const nested = zlibClassAliasModeOf(lowerer, next, depth + 1); - mode = nested === undefined ? zlibStreamModeOf(lowerer, next) : nested; - } - } else if (ts.isPropertyAccessExpression(init) && !init.questionDotToken) { - mode = zlibStreamModeOf(lowerer, lowerer.checker.getSymbolAtLocation(init.name)); - } - if (mode !== null) lowerer.zlibClassAliases.set(symbol, mode); - return mode; -} - -/** True for `const C = zlib.Gzip` (or an alias of an alias): a - * compile-time zlib class alias that owns no runtime slot, so the - * statement lowering skips it. */ -export function registerZlibClassAlias( - lowerer: Lowerer, - nameNode: ts.Node, - init: ts.Expression | undefined, -): boolean { - if (!ts.isIdentifier(nameNode) || init === undefined) return false; - const symbol = lowerer.checker.getSymbolAtLocation(nameNode); - return symbol !== undefined && zlibClassAliasOf(lowerer, symbol) !== null; -} - -/** The mode of a `const C = zlib.Gzip` alias symbol, or null. */ -export function zlibClassAliasOf(lowerer: Lowerer, symbol: ts.Symbol): number | null { - return zlibClassAliasModeOf(lowerer, symbol, 0) ?? null; -} - /** `value instanceof zlib.Gzip` (any spelling of the class, aliases * included). zlib streams are runtime Transforms: a Transform operand asks * the runtime for the stream's mode, and an operand typed as one of diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 39b3242d6..186936f48 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -12,6 +12,11 @@ import { InternalCompilerError } from "../../errors.js"; import { fsStreamClassOf, lowerFsStreamNew } from "./builtins/fs-streams.js"; import * as ts from "../ts7/adapter.js"; import { lowerZlibStreamNew, zlibClassName, zlibStreamModeOf } from "./builtins/compression.js"; +import { + type BuiltinClassRef, + builtinClassAliasOf, + builtinClassRefOf, +} from "./builtins/class-values.js"; import type { FnCtx, Lowerer } from "./lowerer.js"; import { BOOL, @@ -924,12 +929,15 @@ export function registerBuiltinStreamClasses(lowerer: Lowerer): void { * "stream" ambient module, EXCLUDING @types/node's (whose stream.Readable * also types child stdio — under @types/node the childStream mapping * keeps priority and the static stream classes stand down; the shipped - * fallback declarations are the supported surface). */ + * fallback declarations are the supported surface). A const binding of + * one (`const R = Readable`) names the same class (builtinClassAliasOf). */ export function builtinStreamInfoOf( lowerer: Lowerer, symbol: ts.Symbol | null | undefined, ): ClassInfo | null { if (!symbol) return null; + const alias = builtinClassAliasOf(lowerer, symbol); + if (alias !== null) return alias.kind === "stream" ? alias.info : null; if (!lowerer.isStdlibSymbol(symbol)) { // A const ALIAS of a namespace member (`const Writable = // stream.Writable` — the two-step spelling; the one-step @@ -1284,12 +1292,16 @@ function undefArmedFieldType(lowerer: Lowerer, p: ts.Symbol): IrType | null { * `extends EventEmitter`, `x instanceof EventEmitter`) — any import * spelling (named/default/namespace member, CJS require) resolves to * the ambient class. Provenance-checked like the error classes: only a - * stdlib-file declaration inside the "events" ambient module counts. */ + * stdlib-file declaration inside the "events" ambient module counts. A + * const binding of it (`const E = EventEmitter`) names the same class + * (builtinClassAliasOf). */ export function builtinEmitterInfoOf( lowerer: Lowerer, symbol: ts.Symbol | null | undefined, ): ClassInfo | null { if (!symbol) return null; + const alias = builtinClassAliasOf(lowerer, symbol); + if (alias !== null) return alias.kind === "emitter" ? alias.info : null; if (!lowerer.isStdlibSymbol(symbol)) { // A const ALIAS of the emitter class member (`const EventEmitter = // require('node:events').EventEmitter` — commander's spelling; the @@ -1330,12 +1342,17 @@ export function builtinEmitterInfoOf( /** The builtin error ClassInfo a VALUE symbol refers to (`new Error`, * `extends TypeError`, `x instanceof RangeError`), or null. Provenance- * checked: only the standard library's declarations count — a user's own - * `class Error` resolves through classBySymbol instead. */ + * `class Error` resolves through classBySymbol instead. A const binding + * of one (`const E = TypeError`) names the same class + * (builtinClassAliasOf). */ export function builtinErrorInfoOf( lowerer: Lowerer, symbol: ts.Symbol | null | undefined, ): ClassInfo | null { - if (!symbol || !lowerer.isStdlibSymbol(symbol)) return null; + if (!symbol) return null; + const alias = builtinClassAliasOf(lowerer, symbol); + if (alias !== null) return alias.kind === "error" ? alias.info : null; + if (!lowerer.isStdlibSymbol(symbol)) return null; for (const [irName, rec] of RUNTIME_ERROR_CLASSES) { if (rec.lib === symbol.name) return lowerer.classes.get(irName) ?? null; } @@ -8435,6 +8452,12 @@ function assignedThisFieldType(lowerer: Lowerer, expr: ts.NewExpression): IrType return lowerer.currentClass?.fields.get(parent.left.name.text) ?? null; } +/** Map, Set and the error classes construct in lowerNew's identifier + * branch, which a module member alias of one (`new mod.M()`) also takes. */ +function isCollectionOrErrorClass(ref: BuiltinClassRef | null): boolean { + return ref?.kind === "collection" || ref?.kind === "error"; +} + export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { const loc = locOf(expr); const worker = lowerWorkerNew(lowerer, expr); @@ -8729,7 +8752,10 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { ts.isIdentifier(expr.expression) || (ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.name) && - lowerer.isStdlibGlobal(expr.expression.expression, "globalThis")) + (lowerer.isStdlibGlobal(expr.expression.expression, "globalThis") || + // `new mod.M()` over an exported `const M = Map` or `const E = + // TypeError` + isCollectionOrErrorClass(builtinClassRefOf(lowerer, expr.expression)))) ) { // `import C = N.C; new C()` — the alias's own source-order guards // (a no-op for every non-import= binding). @@ -9094,7 +9120,8 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { if (symbol?.name === "Array" && lowerer.isStdlibSymbol(symbol)) { return lowerArrayConstructor(lowerer, expr, expr.arguments ?? []); } - if (symbol?.name === "Map" && lowerer.isStdlibSymbol(symbol)) { + // A const alias (`const M = Map`) constructs the same Map. + if (ts.isIdentifier(identifier) && lowerer.isStdlibGlobal(identifier, "Map")) { const seedArg = (expr.arguments?.length ?? 0) === 1 ? expr.arguments![0]! : null; const isPairLit = (el: ts.Expression): el is ts.ArrayLiteralExpression => ts.isArrayLiteralExpression(el) && @@ -9226,7 +9253,7 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { } // `new Set()`: construct + bulk add from supported values, // including live collection cursors. Duplicates collapse in insertion order. - if (symbol?.name === "Set" && lowerer.isStdlibSymbol(symbol)) { + if (ts.isIdentifier(identifier) && lowerer.isStdlibGlobal(identifier, "Set")) { const tsType = lowerer.typeOf(expr); let mapped = lowerer.mapTypeOf(tsType); const fieldType = assignedThisFieldType(lowerer, expr); diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index d4d03591d..09296bdfe 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -35,10 +35,12 @@ import { isZlibStreamMember, lowerZlibInstanceOf, lowerZlibStreamBytesWritten, - zlibClassAliasOf, - zlibClassModeOfExpr, - zlibClassName, } from "./builtins/compression.js"; +import { + builtinClassAliasOwnsNoSlot, + builtinClassRefOf, + sameBuiltinClass, +} from "./builtins/class-values.js"; import { constituentTypes } from "../ts7/checker.js"; import { dirname } from "node:path"; import * as posix from "node:path/posix"; @@ -616,8 +618,9 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { if (isNodeModuleValue(lowerer, expr.expression)) { return { kind: "strLit", value: "object", type: STRING, loc }; } - // `typeof zlib.Gzip`, `typeof C` over a zlib class alias. - if (zlibClassModeOfExpr(lowerer, expr.expression) !== null) { + // `typeof EventEmitter`, `typeof zlib.Gzip`, `typeof C` over a + // builtin class alias. + if (builtinClassRefOf(lowerer, expr.expression) !== null) { return { kind: "strLit", value: "function", type: STRING, loc }; } if (ts.isPropertyAccessExpression(expr.expression)) { @@ -902,13 +905,13 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { `a builtin function alias as an escaping value (call '${expr.text}' directly)`, ); } - // `const C = zlib.Gzip` owns no runtime slot: construction, + // `const E = EventEmitter` owns no runtime slot: construction, // instanceof, typeof and .name lower at their use sites. - if (sym && zlibClassAliasOf(lowerer, sym) !== null) { + if (sym && builtinClassAliasOwnsNoSlot(lowerer, sym)) { lowerer.unsupported( "SC1090", expr, - `a zlib class alias as an escaping value (use '${expr.text}' with new, instanceof, typeof or .name)`, + `a builtin class alias as an escaping value (use '${expr.text}' with new, instanceof, typeof or .name)`, ); } } @@ -1849,10 +1852,11 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { const table = lowerInternTableProperty(lowerer, expr); if (table) return table; } - // `zlib.Gzip.name`, `C.name` over a zlib class alias. + // `EventEmitter.name`, `zlib.Gzip.name`, `C.name` over a builtin + // class alias. if (expr.name.text === "name" && !expr.questionDotToken) { - const mode = zlibClassModeOfExpr(lowerer, expr.expression); - if (mode !== null) return { kind: "strLit", value: zlibClassName(mode), type: STRING, loc }; + const ref = builtinClassRefOf(lowerer, expr.expression); + if (ref !== null) return { kind: "strLit", value: ref.name, type: STRING, loc }; } // Expando statics may still be absent even when JS inference sees // the eventual assignment's scalar type. Preserve the checked value. @@ -10266,17 +10270,18 @@ export function lowerBinary(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr lowerUnionTypeofTest(lowerer, expr, loc); if (test) return test; } - // `C === zlib.Gzip` between two zlib class references: the classes - // are compile-time values, so the answer folds. + // `C === EventEmitter` between two builtin class references: the + // classes are compile-time values, so the answer folds. if ( op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsEqualsToken ) { - const leftClass = zlibClassModeOfExpr(lowerer, expr.left); - const rightClass = leftClass === null ? null : zlibClassModeOfExpr(lowerer, expr.right); + const leftClass = builtinClassRefOf(lowerer, expr.left); + const rightClass = leftClass === null ? null : builtinClassRefOf(lowerer, expr.right); if (leftClass !== null && rightClass !== null) { const negated = op === ts.SyntaxKind.ExclamationEqualsEqualsToken; - return { kind: "boolLit", value: (leftClass === rightClass) !== negated, type: BOOL, loc }; + const same = sameBuiltinClass(leftClass, rightClass); + return { kind: "boolLit", value: same !== negated, type: BOOL, loc }; } } @@ -12352,11 +12357,11 @@ export function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc // h2 compat 'connect' narrowing (lower-server.ts): a union tag test. const sockTest = lowerSocketInstanceOf(lowerer, expr, loc); if (sockTest !== null) return sockTest; - const zlibMode = zlibClassModeOfExpr(lowerer, expr.right); - if (zlibMode !== null) return lowerZlibInstanceOf(lowerer, expr, zlibMode, loc); + const rightClass = builtinClassRefOf(lowerer, expr.right); + if (rightClass?.kind === "zlib") return lowerZlibInstanceOf(lowerer, expr, rightClass.mode, loc); - if (lowerer.isStdlibGlobal(expr.right, "Set") || lowerer.isStdlibGlobal(expr.right, "Map")) { - const collection = lowerer.isStdlibGlobal(expr.right, "Map") ? "map" : "set"; + if (rightClass?.kind === "collection") { + const collection = rightClass.which === "Map" ? "map" : "set"; const value = lowerer.lowerExpr(expr.left); if (value.type.kind === "union") { const union = lowerer.unions.get(value.type.unionId); diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index 3baab9dd0..da70cd53a 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -80,7 +80,7 @@ import { createRequireProgramModuleDecl, } from "./builtins/module-bindings.js"; import { isPromisifyCall, registerBuiltinCallableAlias } from "./builtins/callable-aliases.js"; -import { registerZlibClassAlias } from "./builtins/compression.js"; +import { registerBuiltinClassAlias } from "./builtins/class-values.js"; import { stripTypeCasts } from "./builtins/arguments.js"; import { bindingContextualGenericFnNodeOf, @@ -1701,7 +1701,7 @@ export function collectGlobals( // resolution and value reads reuse the source's interned closure. if (isConst && registerOverloadedCallableAlias(lowerer, decl)) continue; if (isConst && registerBuiltinCallableAlias(lowerer, decl.name, decl.initializer)) continue; - if (registerZlibClassAlias(lowerer, decl.name, decl.initializer)) continue; + if (registerBuiltinClassAlias(lowerer, decl.name, decl.initializer)) continue; // `const f = (x) => ...` at file scope of an npm-static JS file // whose params are implicit-any: the implicit-monomorphization // twin of the generic binding above — no global exists; calls and diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 0f1b606ef..76ee0d48d 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -148,7 +148,7 @@ import { } from "./builtins/module-bindings.js"; import { lowerNodeModuleCall } from "./builtins/module-resolution.js"; import { registerBuiltinCallableAlias } from "./builtins/callable-aliases.js"; -import { registerZlibClassAlias } from "./builtins/compression.js"; +import { builtinClassAliasOwnsNoSlot, registerBuiltinClassAlias } from "./builtins/class-values.js"; import { lowerEnumDeclaration } from "./lower-enums.js"; import { abstractPropertyDeclOf, @@ -847,6 +847,9 @@ export function predeclareForwardCapture(lowerer: Lowerer, symbol: ts.Symbol): b if (!decl.initializer) return false; const flags = ts.getCombinedNodeFlags(decl); if ((flags & ts.NodeFlags.BlockScoped) === 0 || (flags & ts.NodeFlags.Using) !== 0) return false; + // `const E = EventEmitter` has no storage to box: uses resolve at + // compile time (builtinClassAliasOf). + if (builtinClassAliasOwnsNoSlot(lowerer, symbol)) return false; // MODULE-scope bindings are pre-registered globals (collectGlobals): // references resolve through globalOf after the local search fails, so // a TDZ box here would SHADOW the global and never fill (the top-level @@ -4423,7 +4426,7 @@ export function lowerVarDecl( // reads reuse its interned closure identity. if (!isLet && registerOverloadedCallableAlias(lowerer, decl)) return null; if (!isLet && registerBuiltinCallableAlias(lowerer, decl.name, decl.initializer)) return null; - if (registerZlibClassAlias(lowerer, decl.name, decl.initializer)) return null; + if (registerBuiltinClassAlias(lowerer, decl.name, decl.initializer)) return null; // `const knownBy = (cmd) => ...` — an IMPLICIT-ANY function-value // binding in npm-static JS (function-scope bindings register here, in diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index e19c4785d..5adeb7481 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -261,6 +261,7 @@ import { stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js"; +import { type BuiltinClassRef, builtinClassAliasOf } from "./builtins/class-values.js"; import { type FileParts, splitFiles, @@ -1858,11 +1859,11 @@ export class Lowerer { * typeParamBindings — the checker has no `T` to substitute, so the * binding rides the node-type accessor instead of mapType. */ implicitParamTypes: Map | null = null; - /** Immutable bindings that name a zlib stream class (`const C = - * zlib.Gzip`), keyed by the binding's symbol: the class's - * node_zlib_mode. No runtime slot exists: new, typeof, .name and === - * resolve at compile time, and instanceof checks the stream's mode. */ - readonly zlibClassAliases = new Map(); + /** The builtin class each binding names (`const E = EventEmitter`, + * `const C = zlib.Gzip`), keyed by the binding's symbol; null for + * bindings that name none (builtinClassAliasOf). new, instanceof, + * typeof, .name and === resolve at compile time. */ + readonly builtinClassAliases = new Map(); /** Whether some net.Socket in this program may get an encoding: a * setEncoding call whose receiver is a socket or an untyped value. * Computed once on first use (null until then). */ @@ -3073,6 +3074,10 @@ export class Lowerer { return builtinStreamInfoOf(this, symbol); } + builtinClassAliasOf(symbol: ts.Symbol): BuiltinClassRef | null { + return builtinClassAliasOf(this, symbol); + } + /** Program-wide qualified name for a top-level declaration. */ qualify(sf: ts.SourceFile, name: string): string { return `${this.fileTag.get(sf) ?? ""}${name}`; diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index d394c1960..73cc58c45 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -3207,7 +3207,9 @@ export function isStdlibSymbol(lowerer: Lowerer, symbol: ts.Symbol | undefined): * `global.process`) — `declare var` globals ARE properties of * `typeof globalThis`, same symbol either way; * - a local alias binding (`const process = globalThis.process`, the - * tamper-guard prologue) registered in stdlibGlobalAliases. */ + * tamper-guard prologue) registered in stdlibGlobalAliases; + * - a const binding of the Map or Set constructor (`const M = Map`, + * builtinClassAliasOf). */ export function stdlibGlobalNameOf(lowerer: Lowerer, expr: ts.Expression): string | null { if (ts.isParenthesizedExpression(expr)) return stdlibGlobalNameOf(lowerer, expr.expression); if (ts.isIdentifier(expr)) { @@ -3225,6 +3227,8 @@ export function stdlibGlobalNameOf(lowerer: Lowerer, expr: ts.Expression): strin if (!symbol) return null; const alias = lowerer.stdlibGlobalAliases.get(symbol); if (alias !== undefined) return alias; + const classAlias = lowerer.builtinClassAliasOf(symbol); + if (classAlias?.kind === "collection") return classAlias.which; const decl = lowerer.checker.declarationsOf(symbol)[0]; if (decl !== undefined && ts.isImportClause(decl) && decl.name !== undefined) { const importDecl = decl.parent; diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5976-builtin-class-aliases.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5976-builtin-class-aliases.ts.json new file mode 100644 index 000000000..f83d23fc7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5976-builtin-class-aliases.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5976-builtin-class-aliases.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5977-builtin-class-aliases.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5977-builtin-class-aliases.cjs.json new file mode 100644 index 000000000..99d07e4cd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5977-builtin-class-aliases.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5977-builtin-class-aliases.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5978-builtin-class-alias-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5978-builtin-class-alias-modules/main.ts.json new file mode 100644 index 000000000..fd6bb94f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5978-builtin-class-alias-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/5978-builtin-class-alias-modules/classes.ts", + "/tests/corpus/5978-builtin-class-alias-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/builtin-class-alias-escape.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/builtin-class-alias-escape.ts.json new file mode 100644 index 000000000..f56d058f1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/builtin-class-alias-escape.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/builtin-class-alias-escape.ts" + ], + "diags": [] +} diff --git a/tests/corpus/5976-builtin-class-aliases.ts b/tests/corpus/5976-builtin-class-aliases.ts new file mode 100644 index 000000000..692b3928d --- /dev/null +++ b/tests/corpus/5976-builtin-class-aliases.ts @@ -0,0 +1,109 @@ +// Builtin classes through const aliases: EventEmitter, the stream classes, +// the error classes, Map and Set construct, extend and test instanceof +// through an alias, and typeof, .name and === answer as in Node for the +// aliases and the direct spellings. +import { EventEmitter } from "node:events"; +import * as events from "node:events"; +import { PassThrough, Readable, Transform } from "node:stream"; +import * as stream from "node:stream"; +import { AssertionError } from "node:assert"; +import * as assert from "node:assert"; + +function lateEmitter(): boolean { + return new LateEmitter() instanceof EventEmitter && typeof LateMap === "function"; +} + +function localHoist(): string { + function inner(): string { + return `${typeof LocalMap} ${LocalMap.name} ${new LocalMap().size}`; + } + const LocalMap = Map; + return inner(); +} + +const Emitter = EventEmitter; +const NsEmitter = events.EventEmitter; +const Again = Emitter; +const LateEmitter = events.EventEmitter; +const LateMap = Map; + +const e = new Emitter(); +e.on("ping", (n: number) => console.log("ping", n)); +e.emit("ping", 1); +console.log("emitter", e instanceof Emitter, e instanceof NsEmitter, e instanceof Again); +console.log("hoisted use", lateEmitter(), localHoist()); + +class Bus extends Again { + send(text: string): void { + this.emit("text", text); + } +} +const bus = new Bus(); +bus.on("text", (text: string) => console.log("bus", text)); +bus.send("hello"); +console.log("subclass", bus instanceof Emitter, bus instanceof Bus); + +const Pass = PassThrough; +const R = Readable; +const T = stream.Transform; +const pass = new Pass(); +console.log("stream", pass instanceof Pass, pass instanceof R, pass instanceof T); +console.log("readable", new R({ read() {} }) instanceof Pass, e instanceof R); + +class Upper extends T { + override _transform( + chunk: Buffer, + _encoding: BufferEncoding, + callback: (error: Error | null, data?: string) => void, + ): void { + callback(null, chunk.toString().toUpperCase()); + } +} +const upper = new Upper(); +upper.on("data", (chunk: Buffer) => console.log("upper", chunk.toString())); +upper.end("quiet"); + +const TE = TypeError; +const RE = RangeError; +class LimitError extends RE { + constructor(limit: number) { + super(`over ${limit}`); + this.name = "LimitError"; + } +} +try { + throw new TE("bad input"); +} catch (err) { + console.log("error", err instanceof TE, err instanceof RE, err instanceof Error, (err as Error).message); +} +try { + throw new LimitError(3); +} catch (err) { + console.log("subclass error", err instanceof RE, err instanceof LimitError, (err as Error).message); +} +const AE = AssertionError; +try { + assert.strictEqual(1, 2); +} catch (err) { + console.log("assertion", err instanceof AE, err instanceof TE); +} +const viaNamespace = new assert.AssertionError({ message: "custom" }); +console.log("namespace error", viaNamespace.message, viaNamespace instanceof AE); + +const M = Map; +const S = Set; +const m = new M([ + ["a", 1], + ["b", 2], +]); +m.set("c", 3); +const s = new S([1, 2, 2, 3]); +console.log("collections", m.get("b"), m.size, s.size, m instanceof M, s instanceof S, s instanceof M); +const groups = M.groupBy([1, 2, 3, 4, 5], (n: number) => (n % 2 === 0 ? "even" : "odd")); +console.log("groupBy", groups.get("even"), groups.get("odd")); + +console.log("typeof", typeof Emitter, typeof R, typeof TE, typeof M, typeof EventEmitter, typeof Readable); +console.log("name", Emitter.name, NsEmitter.name, Pass.name, T.name, TE.name, AE.name, M.name, S.name); +console.log("direct name", EventEmitter.name, stream.Duplex.name, Error.name, RangeError.name, Map.name, Set.name); +console.log("identity", Emitter === EventEmitter, Again === NsEmitter, T === Transform, R === stream.Readable); +console.log("other class", (Pass as unknown) === (R as unknown), (M as unknown) !== (S as unknown), (TE as unknown) === (RE as unknown)); diff --git a/tests/corpus/5977-builtin-class-aliases.cjs b/tests/corpus/5977-builtin-class-aliases.cjs new file mode 100644 index 000000000..c149884ba --- /dev/null +++ b/tests/corpus/5977-builtin-class-aliases.cjs @@ -0,0 +1,45 @@ +// Builtin classes through const aliases in a CommonJS file. A copy of a +// name (or of a globalThis property) keeps its value, so it can be stored +// and compared; construction, instanceof, typeof and .name resolve to the +// class. Builtin module members construct through the alias. +const { EventEmitter } = require("node:events"); +const events = require("node:events"); +const zlib = require("node:zlib"); +const { PassThrough } = require("node:stream"); + +const Emitter = EventEmitter; +const NsEmitter = events.EventEmitter; +const Gz = zlib.Gzip; +const Gz2 = Gz; +const M = Map; +const GlobalSet = globalThis.Set; +const Pass = PassThrough; +const TE = TypeError; + +const e = new Emitter(); +e.on("ping", (n) => console.log("ping", n)); +e.emit("ping", 2); +console.log("emitter", e instanceof Emitter, e instanceof NsEmitter, e instanceof EventEmitter); + +const m = new M(); +m.set("k", 1); +const s = new GlobalSet(["a", "b", "a"]); +console.log("collections", m.get("k"), s.size, m instanceof M, s instanceof GlobalSet, m instanceof GlobalSet); + +const gz = new Gz2(); +console.log("zlib", gz instanceof Gz, gz instanceof zlib.Gunzip, Gz2 === zlib.Gzip); + +const pass = new Pass(); +console.log("stream", pass instanceof Pass, pass instanceof EventEmitter); + +try { + throw new TE("typed"); +} catch (err) { + console.log("error", err instanceof TE, err.message); +} + +const stored = [Emitter, M, GlobalSet, Pass]; +console.log("stored", stored.length, stored[0] === EventEmitter, stored[1] === Map, stored[2] === Set); +console.log("typeof", typeof Emitter, typeof NsEmitter, typeof Gz2, typeof M, typeof GlobalSet, typeof TE); +console.log("name", Emitter.name, NsEmitter.name, Gz2.name, M.name, GlobalSet.name, Pass.name, TE.name); +console.log("identity", Emitter === NsEmitter, M === Map, GlobalSet === Set, M === GlobalSet); diff --git a/tests/corpus/5978-builtin-class-alias-modules/classes.ts b/tests/corpus/5978-builtin-class-alias-modules/classes.ts new file mode 100644 index 000000000..73590d1e8 --- /dev/null +++ b/tests/corpus/5978-builtin-class-alias-modules/classes.ts @@ -0,0 +1,8 @@ +import { EventEmitter } from "node:events"; +import { PassThrough } from "node:stream"; + +export const Emitter = EventEmitter; +export const Pass = PassThrough; +export const Dict = Map; +export const Bag = Set; +export const Failure = TypeError; diff --git a/tests/corpus/5978-builtin-class-alias-modules/main.ts b/tests/corpus/5978-builtin-class-alias-modules/main.ts new file mode 100644 index 000000000..cf39cd712 --- /dev/null +++ b/tests/corpus/5978-builtin-class-alias-modules/main.ts @@ -0,0 +1,33 @@ +// Builtin class aliases exported from one module and used through named +// and namespace imports: construction, instanceof, typeof, .name and === +// resolve to the builtin class in the importing module. +import { EventEmitter } from "node:events"; +import { Emitter, Pass, Dict, Bag, Failure } from "./classes.ts"; +import * as classes from "./classes.ts"; + +const e = new Emitter(); +e.on("tick", (n: number) => console.log("tick", n)); +e.emit("tick", 7); +console.log("emitter", e instanceof Emitter, e instanceof classes.Emitter, e instanceof EventEmitter); + +const viaNs = new classes.Emitter(); +console.log("namespace emitter", viaNs instanceof Emitter, Emitter === classes.Emitter); + +const pass = new classes.Pass(); +console.log("stream", pass instanceof Pass, pass instanceof classes.Emitter); + +const dict = new Dict([["k", 1]]); +const viaNsDict = new classes.Dict(); +viaNsDict.set("a", "b"); +const bag = new classes.Bag([1, 1, 2]); +console.log("collections", dict.get("k"), viaNsDict.get("a"), bag.size, dict instanceof classes.Dict, bag instanceof Bag); + +try { + throw new classes.Failure("wrong type"); +} catch (err) { + console.log("error", err instanceof Failure, err instanceof classes.Failure, (err as Error).message); +} + +console.log("typeof", typeof Emitter, typeof classes.Pass, typeof Dict, typeof classes.Bag, typeof Failure); +console.log("name", Emitter.name, classes.Pass.name, Dict.name, classes.Bag.name, Failure.name); +console.log("identity", Dict === Map, classes.Bag === Set, Failure === TypeError, (Dict as unknown) === (Bag as unknown)); diff --git a/tests/diagnostics/builtin-class-alias-escape.ts b/tests/diagnostics/builtin-class-alias-escape.ts new file mode 100644 index 000000000..b3f9be5d3 --- /dev/null +++ b/tests/diagnostics/builtin-class-alias-escape.ts @@ -0,0 +1,15 @@ +// A builtin class alias owns no runtime value in a TypeScript file: +// construction, instanceof, typeof and .name compile, other uses report +// at the use. A let binding of a class is not an alias. +import { EventEmitter } from "node:events"; + +const Emitter = EventEmitter; +const kinds = [Emitter]; +console.log(kinds.length); + +const M = Map; +const boxed: unknown = M; +console.log(boxed !== undefined); + +let Mutable = EventEmitter; +console.log(typeof Mutable); diff --git a/tests/diagnostics/class-values.ts b/tests/diagnostics/class-values.ts index 02c5360fa..3a53e5185 100644 --- a/tests/diagnostics/class-values.ts +++ b/tests/diagnostics/class-values.ts @@ -18,8 +18,10 @@ class Unrelated { static tag = "unrelated"; } -// Builtin classes as values: their construction is libCall-shaped. +// Builtin classes as values: a const alias resolves at compile time, and +// an array of builtin classes has no element type. const E = Error; +const errorClasses = [E]; // Classes extending builtin bases as values (the error-message completion // rule has no thunk ABI). diff --git a/tests/harness/__snapshots__/builtin-class-alias-escape.ts.txt b/tests/harness/__snapshots__/builtin-class-alias-escape.ts.txt new file mode 100644 index 000000000..9d1d981e2 --- /dev/null +++ b/tests/harness/__snapshots__/builtin-class-alias-escape.ts.txt @@ -0,0 +1,22 @@ +builtin-class-alias-escape.ts:7:16 - error SC1090: a builtin class alias as an escaping value (use 'Emitter' with new, instanceof, typeof or .name) is not supported yet + + 6 | const Emitter = EventEmitter; + 7 | const kinds = [Emitter]; + | ^~~~~~~ + 8 | console.log(kinds.length); + +builtin-class-alias-escape.ts:11:24 - error SC1090: a builtin class alias as an escaping value (use 'M' with new, instanceof, typeof or .name) is not supported yet + + 10 | const M = Map; + 11 | const boxed: unknown = M; + | ^ + 12 | console.log(boxed !== undefined); + +builtin-class-alias-escape.ts:14:15 - error SC2020: 'events.EventEmitter' is part of the standard library types but has no scriptc lowering yet + + 13 | + 14 | let Mutable = EventEmitter; + | ^~~~~~~~~~~~ + 15 | console.log(typeof Mutable); + + hint: the type checker sees the full standard library, but only the supported surface compiles (https://scriptc.dev/limitations) \ No newline at end of file diff --git a/tests/harness/__snapshots__/class-values.ts.txt b/tests/harness/__snapshots__/class-values.ts.txt index 9d5a43c1f..953d1c2d1 100644 --- a/tests/harness/__snapshots__/class-values.ts.txt +++ b/tests/harness/__snapshots__/class-values.ts.txt @@ -1,52 +1,52 @@ -class-values.ts:22:7 - error SC2020: 'ErrorConstructor' is part of the standard library types but has no scriptc lowering yet +class-values.ts:24:7 - error SC2009: values of type 'ErrorConstructor[]' cannot be compiled: the array shape is supported, but its element type 'ErrorConstructor' does not compile - 21 | // Builtin classes as values: their construction is libCall-shaped. - 22 | const E = Error; - | ^ - 23 | + 23 | const E = Error; + 24 | const errorClasses = [E]; + | ^~~~~~~~~~~~ + 25 | - hint: the type checker sees the full standard library, but only the supported surface compiles (https://scriptc.dev/limitations) + hint: the outer shape is supported — the named component is the blocker; restate it inside the compilable set (number, string, boolean, arrays, Maps, Sets, RegExp, functions, classes, records, unions of those, and 'unknown') -class-values.ts:22:11 - error SC2020: 'Error' is part of the standard library types but has no scriptc lowering yet +class-values.ts:24:22 - error SC2009: values of type 'ErrorConstructor[]' cannot be compiled: the array shape is supported, but its element type 'ErrorConstructor' does not compile - 21 | // Builtin classes as values: their construction is libCall-shaped. - 22 | const E = Error; - | ^~~~~ - 23 | + 23 | const E = Error; + 24 | const errorClasses = [E]; + | ^~~ + 25 | - hint: the type checker sees the full standard library, but only the supported surface compiles (https://scriptc.dev/limitations) + hint: the outer shape is supported — the named component is the blocker; restate it inside the compilable set (number, string, boolean, arrays, Maps, Sets, RegExp, functions, classes, records, unions of those, and 'unknown') -class-values.ts:44:1 - error SC1090: assigning the static 'tag' through a class value (JS creates an OWN property on the runtime class — assign through the declaring class's name, which subclasses here) is not supported yet +class-values.ts:46:1 - error SC1090: assigning the static 'tag' through a class value (JS creates an OWN property on the runtime class — assign through the declaring class's name, which subclasses here) is not supported yet - 43 | let someClass: typeof Base = Base; - 44 | someClass.tag = "write"; + 45 | let someClass: typeof Base = Base; + 46 | someClass.tag = "write"; | ^~~~~~~~~~~~~ - 45 | + 47 | -class-values.ts:48:13 - error SC1090: reading the static member 'tag' through a class value (a subclass of 'Base' redeclares it, so the runtime class decides which declaration answers) is not supported yet +class-values.ts:50:13 - error SC1090: reading the static member 'tag' through a class value (a subclass of 'Base' redeclares it, so the runtime class decides which declaration answers) is not supported yet - 47 | // runtime class decides which declaration answers. - 48 | console.log(someClass.tag); + 49 | // runtime class decides which declaration answers. + 50 | console.log(someClass.tag); | ^~~~~~~~~~~~~ - 49 | + 51 | -class-values.ts:52:10 - error SC1090: function-local classes with statics, decorators, or generic members are not supported yet +class-values.ts:54:10 - error SC1090: function-local classes with statics, decorators, or generic members are not supported yet - 51 | function make(): unknown { - 52 | return class { static value = 1; }; + 53 | function make(): unknown { + 54 | return class { static value = 1; }; | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ - 53 | } + 55 | } -class-values.ts:59:18 - error SC1090: class expressions with static initializers or static blocks outside a whole-initializer position (their declaration-time code must run exactly where the expression evaluates — bind the class in its own top-level `const C = class …` statement) is not supported yet +class-values.ts:61:18 - error SC1090: class expressions with static initializers or static blocks outside a whole-initializer position (their declaration-time code must run exactly where the expression evaluates — bind the class in its own top-level `const C = class …` statement) is not supported yet - 58 | // evaluates. - 59 | const pair = [1, class WithStatic { static x = 1; }] as const; + 60 | // evaluates. + 61 | const pair = [1, class WithStatic { static x = 1; }] as const; | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 60 | + 62 | -class-values.ts:79:56 - error SC1090: receiver-dependent static methods through a polymorphic class value is not supported yet +class-values.ts:81:56 - error SC1090: receiver-dependent static methods through a polymorphic class value is not supported yet - 78 | class OtherThis extends UsesThis {} - 79 | function self(value: typeof UsesThis): string { return value.self(); } + 80 | class OtherThis extends UsesThis {} + 81 | function self(value: typeof UsesThis): string { return value.self(); } | ^~~~~~~~~~ - 80 | console.log(self(OtherThis)); \ No newline at end of file + 82 | console.log(self(OtherThis)); \ No newline at end of file diff --git a/tests/harness/__snapshots__/zlib-class-alias-escape.ts.txt b/tests/harness/__snapshots__/zlib-class-alias-escape.ts.txt index ea9d76089..703038025 100644 --- a/tests/harness/__snapshots__/zlib-class-alias-escape.ts.txt +++ b/tests/harness/__snapshots__/zlib-class-alias-escape.ts.txt @@ -1,4 +1,4 @@ -zlib-class-alias-escape.ts:7:18 - error SC1090: a zlib class alias as an escaping value (use 'Gz' with new, instanceof, typeof or .name) is not supported yet +zlib-class-alias-escape.ts:7:18 - error SC1090: a builtin class alias as an escaping value (use 'Gz' with new, instanceof, typeof or .name) is not supported yet 6 | const Gz = zlib.Gzip; 7 | const classes = [Gz]; diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index b91073f87..5403a1468 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -2190,6 +2190,9 @@ "5973-large-closure-environment.ts": 4499, "5974-typeof-module-exports.cjs": 2000, "5975-zlib-class-values.ts": 2800, + "5976-builtin-class-aliases.ts": 3100, + "5977-builtin-class-aliases.cjs": 2950, + "5978-builtin-class-alias-modules/main.ts": 2750, "5990-worker-uncloneable.mjs": 3283, "5991-worker-async-dispose.mjs": 5699, "5992-worker-thread-name-lifetime.mjs": 2687, @@ -5226,6 +5229,9 @@ "5973-large-closure-environment.ts": 5145, "5974-typeof-module-exports.cjs": 2500, "5975-zlib-class-values.ts": 4200, + "5976-builtin-class-aliases.ts": 5450, + "5977-builtin-class-aliases.cjs": 4300, + "5978-builtin-class-alias-modules/main.ts": 4450, "5990-worker-uncloneable.mjs": 22432, "5991-worker-async-dispose.mjs": 25768, "5992-worker-thread-name-lifetime.mjs": 28932, From 66027d850bf9d6245f0fa8184276cb3aace5da7e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 18 Oct 2026 15:53:37 -0500 Subject: [PATCH 47/47] Explain 6110's deferred-fence count and record its corpus costs Corpus 6110 has three statements with no static lowering, and its @deferred-fences directive is 9 because coverage counts each lowering of a wrapper body: the .call and .apply wrapper bodies are each lowered four times. The program's header now says so. The commit also adds the program's corpus-costs entries, which shard balancing reads. --- tests/corpus/6110-cjs-speculative-wrapper-fences.cjs | 3 +++ tests/harness/corpus-costs.json | 2 ++ 2 files changed, 5 insertions(+) diff --git a/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs b/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs index 6040f009c..1b3546518 100644 --- a/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs +++ b/tests/corpus/6110-cjs-speculative-wrapper-fences.cjs @@ -4,6 +4,9 @@ // every statement of their bodies. A statement with no static lowering // (here `module.exports` read as a value) compiles to its runtime fence // instead of vanishing; these never run, so the binary matches Node. +// Coverage counts the three fenced statements nine times: each lowering of +// a wrapper body counts its statements, and the `.call` and `.apply` +// wrapper bodies are each lowered four times. const verbose = process.argv.length > 99; (function () { var root = this; diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index 5403a1468..18147374d 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -2217,6 +2217,7 @@ "6104-typeof-builtin-bindings.mjs": 2031, "6105-cjs-top-level-this/main.js": 1371, "6106-esm-top-level-this.mjs": 1915, + "6110-cjs-speculative-wrapper-fences.cjs": 1980, "6140-cjs-require-tdz-throws/main.js": 2731, "6141-cjs-require-tdz-checked/main.js": 2856, "6142-cjs-require-published-early/main.js": 3400, @@ -5256,6 +5257,7 @@ "6104-typeof-builtin-bindings.mjs": 1715, "6105-cjs-top-level-this/main.js": 3213, "6106-esm-top-level-this.mjs": 1672, + "6110-cjs-speculative-wrapper-fences.cjs": 2500, "6140-cjs-require-tdz-throws/main.js": 2989, "6141-cjs-require-tdz-checked/main.js": 4062, "6142-cjs-require-published-early/main.js": 5156,