diff --git a/packages/compiler/src/backend/llvm/dense-array-access.ts b/packages/compiler/src/backend/llvm/dense-array-access.ts index 183bb8239..f19073b75 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..405ad67e7 --- /dev/null +++ b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts @@ -0,0 +1,147 @@ +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..271a5ddf8 --- /dev/null +++ b/packages/compiler/src/backend/llvm/dense-array-loops.ts @@ -0,0 +1,215 @@ +/* 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 698a48aaf..1157cfb30 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, @@ -229,7 +236,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"; @@ -623,6 +633,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(); @@ -674,6 +688,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}`; @@ -1030,6 +1059,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< @@ -1325,6 +1362,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 @@ -6675,6 +6714,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(); @@ -6713,6 +6753,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) @@ -6750,6 +6796,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; @@ -8185,7 +8240,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": { @@ -8632,7 +8696,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 @@ -8645,6 +8714,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"), @@ -8747,7 +8859,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(); @@ -8762,7 +8877,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 9c77690f8..22a0b4df5 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, @@ -395,6 +395,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)", @@ -403,6 +404,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)", @@ -575,7 +577,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..e237f8f13 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`); + // 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. (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 + 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/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/src/ir/array-length-stability.test.ts b/packages/compiler/src/ir/array-length-stability.test.ts new file mode 100644 index 000000000..44e461ca2 --- /dev/null +++ b/packages/compiler/src/ir/array-length-stability.test.ts @@ -0,0 +1,141 @@ +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..8e1c97f66 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,77 @@ 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/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": [] +} 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/5993-array-length-loop-resizing.ts b/tests/corpus/5993-array-length-loop-resizing.ts new file mode 100644 index 000000000..a1d5f6d11 --- /dev/null +++ b/tests/corpus/5993-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/5994-array-length-sparse-loops.ts b/tests/corpus/5994-array-length-sparse-loops.ts new file mode 100644 index 000000000..589c1df60 --- /dev/null +++ b/tests/corpus/5994-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/5995-array-dense-loop-boundaries.ts b/tests/corpus/5995-array-dense-loop-boundaries.ts new file mode 100644 index 000000000..5efad78ec --- /dev/null +++ b/tests/corpus/5995-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"); +} 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("|")); diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index dee54f628..797986e20 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": 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, + "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": 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, + "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, "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, + "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, "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": 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, + "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": 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": 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, + "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": 3036, "5333-integer-guarded-while-counters.ts": 2907, - "5333-record-boundary-nullable-argument.ts": 3066, - "5334-fetch-mentions-without-calls.ts": 2537, + "5333-record-boundary-nullable-argument.ts": 3012, + "5334-fetch-mentions-without-calls.ts": 2532, "5335-stream-operators-values.ts": 3463, - "5335-top-level-await-pending-exit-code.ts": 2626, + "5335-top-level-await-pending-exit-code.ts": 1919, "5336-stream-operators-promise-timing.ts": 3056, - "5336-top-level-await-pending-exit-listener.ts": 2547, - "5337-dc-subscriber-throw-next-tick.cjs": 2655, + "5336-top-level-await-pending-exit-listener.ts": 3734, + "5337-dc-subscriber-throw-next-tick.cjs": 2604, "5337-stream-operators-concurrency.ts": 2539, - "5338-js-tdz-function-element.js": 2247, + "5338-js-tdz-function-element.js": 2562, "5338-stream-operators-checks.cjs": 3619, - "5339-array-buffer-constructor.js": 3106, + "5339-array-buffer-constructor.js": 2502, "5339-stream-for-await-hops.ts": 2525, - "534-record-width-subtyping.ts": 2764, + "534-record-width-subtyping.ts": 2615, "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": 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, + "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": 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, + "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": 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": 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, + "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": 2520, - "542-union-element-arrays.ts": 2223, + "542-union-element-arrays.ts": 2846, "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": 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, + "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": 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, + "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": 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": 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, + "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": 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, + "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": 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": 3810, - "5566-fs-dirent-dyn-boundaries/main.mjs": 3533, + "5565-fs-dirent-untyped.mjs": 2600, + "5566-fs-dirent-dyn-boundaries/main.mjs": 2607, "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, + "5585-record-results-inlined.ts": 2922, + "5595-net-ref-unref.ts": 2593, "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": 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, + "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": 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": 4270, + "5681-array-pop-and-length.ts": 3754, "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": 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, + "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": 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, + "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": 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, + "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": 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": 2021, - "5858-disposable-stack.ts": 4753, - "5859-disposable-stack-js.js": 3636, + "5857-regexp-unicode-sets.ts": 3350, + "5858-disposable-stack.ts": 3050, + "5859-disposable-stack-js.js": 3100, "5860-url-ipv4-hosts.ts": 3030, - "5870-worker-thread-names.ts": 3457, - "5871-worker-untransferable.cjs": 2368, + "5870-worker-thread-names.ts": 3106, + "5871-worker-untransferable.cjs": 2786, "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, + "5874-worker-stdio-streams.ts": 2839, + "5875-worker-stdout-pipe.cjs": 2740, + "5879-worker-stdin.ts": 3158, "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, + "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": 3645, - "5886-inspect-dates.ts": 2931, - "5887-inspect-typed-arrays.ts": 2476, - "5888-inspect-sorted.ts": 3227, + "5886-inspect-dates.ts": 2559, + "5887-inspect-typed-arrays.ts": 3448, + "5888-inspect-sorted.ts": 2998, "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, + "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": 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, + "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": 3150, "5921-promise-try-args-js.js": 2112, - "5922-matchall-groups-callbacks.ts": 4259, - "5923-matchall-groups-js.js": 4523, + "5922-matchall-groups-callbacks.ts": 3650, + "5923-matchall-groups-js.js": 3970, "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": 2362, + "5939-js-let-object-reassigned-wider.js": 1945, "5940-callback-helper-specialization.ts": 3130, "5941-callback-specialization-recursion.ts": 3996, "5942-callback-specialization-throws.ts": 2908, @@ -2158,2531 +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": 3865, - "5951-result-never-widening.ts": 3022, + "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": 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, + "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, "5975-zlib-class-values.ts": 2800, - "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, + "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, + "6020-class-extends-function-constructor.js": 4300, "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, + "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-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-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": 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, + "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": 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, + "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": 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, + "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": 2166, "fs-null-byte-paths.ts": 3560, - "fs-read-encodings.ts": 2192, + "fs-read-encodings.ts": 2505, "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, + "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": 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, + "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, "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, + "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": 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, + "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": 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, + "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": 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, + "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": 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, + "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": 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, + "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": 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-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": 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 + "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 }, "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, - "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, + "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": 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, + "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, "5250-cipher-aes-gcm.ts": 7929, "5251-cipher-aes-cbc.ts": 15678, "5252-cipher-aes-ctr.ts": 26018, @@ -4693,45 +4696,45 @@ "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, + "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": 3363, "5321-json-parse-cycles.ts": 3162, "5322-integer-variable-step-loops.ts": 3747, @@ -4740,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": 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, + "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": 3391, "5333-integer-guarded-while-counters.ts": 3537, - "5333-record-boundary-nullable-argument.ts": 4003, - "5334-fetch-mentions-without-calls.ts": 3134, + "5333-record-boundary-nullable-argument.ts": 3100, + "5334-fetch-mentions-without-calls.ts": 4032, "5335-stream-operators-values.ts": 5552, - "5335-top-level-await-pending-exit-code.ts": 3309, + "5335-top-level-await-pending-exit-code.ts": 2383, "5336-stream-operators-promise-timing.ts": 3761, - "5336-top-level-await-pending-exit-listener.ts": 4072, - "5337-dc-subscriber-throw-next-tick.cjs": 4314, + "5336-top-level-await-pending-exit-listener.ts": 2814, + "5337-dc-subscriber-throw-next-tick.cjs": 3273, "5337-stream-operators-concurrency.ts": 9296, - "5338-js-tdz-function-element.js": 2718, + "5338-js-tdz-function-element.js": 3733, "5338-stream-operators-checks.cjs": 4825, - "5339-array-buffer-constructor.js": 3399, + "5339-array-buffer-constructor.js": 2884, "5339-stream-for-await-hops.ts": 5761, - "534-record-width-subtyping.ts": 3917, + "534-record-width-subtyping.ts": 3530, "5340-readable-from-options.ts": 4100, "5341-compound-any-operand.ts": 4139, "5341-generator-callback-params.ts": 4032, @@ -4778,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": 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, + "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": 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, + "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": 6069, "5371-zlib-stream-chunking.cjs": 3999, "5372-zlib-stream-errors.cjs": 4377, @@ -4810,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": 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, + "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": 3913, - "542-union-element-arrays.ts": 4031, + "542-union-element-arrays.ts": 2812, "5420-readable-from-generators.ts": 5476, "5421-readable-from-generators.cjs": 3700, "5422-stream-async-push-wakeup.ts": 4528, @@ -4843,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": 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, + "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": 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, + "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": 3848, "5511-assert-error-class.ts": 3354, "5512-assert-error-options.js": 3961, @@ -4900,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": 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, + "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": 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, + "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": 4826, "5555-fs-callback-turns.cjs": 4160, "5555-http-server-close-keep-alive.ts": 16562, @@ -4926,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": 4190, - "5566-fs-dirent-dyn-boundaries/main.mjs": 4370, + "5565-fs-dirent-untyped.mjs": 2898, + "5566-fs-dirent-dyn-boundaries/main.mjs": 3333, "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, + "5585-record-results-inlined.ts": 3681, + "5595-net-ref-unref.ts": 3036, "5600-dyn-cycle-self.ts": 2377, "5601-dyn-cycle-mutual.ts": 3087, "5602-dyn-cycle-arrays.ts": 3074, @@ -4965,13 +4968,13 @@ "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, + "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": 4232, "5652-http-client-trailer-overflow.ts": 3846, "5653-net-socket-read-ahead.ts": 5725, @@ -4984,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": 4603, + "5681-array-pop-and-length.ts": 3216, "5682-publish-wide-objects.ts": 2847, "5700-cycle-release-retained.ts": 2881, "5701-cycle-release-old-edges.ts": 2910, @@ -5045,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": 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, + "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": 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, + "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": 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, + "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": 3946, "5846-events-esm-default-max.ts": 3102, "5847-events-cjs-default-max.cjs": 3039, @@ -5086,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": 3156, - "5858-disposable-stack.ts": 4000, - "5859-disposable-stack-js.js": 4197, + "5857-regexp-unicode-sets.ts": 3900, + "5858-disposable-stack.ts": 3750, + "5859-disposable-stack-js.js": 3600, "5860-url-ipv4-hosts.ts": 3379, - "5870-worker-thread-names.ts": 5388, - "5871-worker-untransferable.cjs": 38904, + "5870-worker-thread-names.ts": 31697, + "5871-worker-untransferable.cjs": 27481, "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, + "5874-worker-stdio-streams.ts": 27801, + "5875-worker-stdout-pipe.cjs": 31391, + "5879-worker-stdin.ts": 33232, "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, + "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": 3524, - "5886-inspect-dates.ts": 3606, - "5887-inspect-typed-arrays.ts": 3660, - "5888-inspect-sorted.ts": 2960, + "5886-inspect-dates.ts": 2736, + "5887-inspect-typed-arrays.ts": 2997, + "5888-inspect-sorted.ts": 2861, "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, + "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": 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, + "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": 2731, "5921-promise-try-args-js.js": 2533, - "5922-matchall-groups-callbacks.ts": 4812, - "5923-matchall-groups-js.js": 4191, + "5922-matchall-groups-callbacks.ts": 5960, + "5923-matchall-groups-js.js": 6650, "5924-js-literal-identity.js": 2661, "5925-class-view-identity-observers.ts": 2640, "5926-class-view-switch-js.js": 2843, @@ -5141,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": 3070, + "5939-js-let-object-reassigned-wider.js": 4436, "5940-callback-helper-specialization.ts": 5355, "5941-callback-specialization-recursion.ts": 4385, "5942-callback-specialization-throws.ts": 3535, @@ -5149,837 +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": 5999, - "5951-result-never-widening.ts": 3370, + "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": 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, + "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, "5975-zlib-class-values.ts": 4200, - "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, + "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, + "6020-class-extends-function-constructor.js": 7500, "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, - "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, + "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-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-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": 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, + "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": 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, + "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": 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, + "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": 2643, "fs-null-byte-paths.ts": 5975, - "fs-read-encodings.ts": 3730, + "fs-read-encodings.ts": 3111, "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, + "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": 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, + "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, "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, + "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, "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, + "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": 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, + "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": 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, + "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": 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, + "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": 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, + "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": 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, + "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": 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-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": 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 + "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 } } 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 });