[cramforce]

Eight language fixes, most of them for programs that compiled and then printed something other than Node with no diagnostic, validated together in one round and landed as one branch. Each was proven by its owner on its own head; this is the eight merged on main, with their conflicts resolved once. A ninth member of the round, #3156, was merged by itself while the round ran and is main's now.

What lands

• Supersedes Type an untyped empty array where it is written, and stop copying it at typed slots #3288: an untyped empty array has one identity. const o = { files: [] }; const f: string[] = o.files; f.push("x"); console.log(o.files.length): Node 1, main 0. Its element type is decided where it is written; a use that cannot decide it is refused by name (SC2015) instead of copied.
• Supersedes Give a function every argument of the final call, whatever slots it passed through #3263: a function receives every argument of the final call, whatever slots it passed through. const ops = { make: label }; const wide: (p: string, o: { upper: boolean }) => string = ops.make; wide("abc", { upper: true }): Node ABC, main abc.
• Supersedes Report width copies from the lowered program and test that no warning means Node's behaviour #3221: SC6001 (a conversion that copies, where JavaScript keeps one object) is reported from the lowered program instead of five spellings of the syntax tree, and a test holds the rule it stands for: a program that builds with no SC6001 behaves as under Node at every conversion that copies. m.set("k", w); m.get("k")!.a = 3; console.log(w.a): Node 3, compiled 1; no diagnostic on main, SC6001 now. --no-copy-warning leaves the warning out.
• Supersedes Fix four small differences from Node in the lowering: <T>process.env, satisfies, undefined results, class-field function names #3302: four small differences in the lowering. <T>process.env is the environment (writes and deletes reached a copy); satisfies is looked through in the require and fork recognizers; an untyped value returned where the result is declared undefined is checked; an anonymous function is named after the class field it initializes.
• Supersedes Judge generic loops by each instance's array facts; reject missing elements in array conversions with a TypeError #3243: an array that can hold a hole or a stored undefined, read by a for…of loop inside a generic function, no longer aborts the process, and a missing element in an array conversion is a TypeError. The branch's local head is taken (the PR's head plus the fix of its own failing test and a corpus program, by the agent that owns main's red tests).
• fix/member-call-receiver-narrowing (no PR; the follow-up to Pass the holder as the receiver of a typed member call #3308 that was decided when it landed): a member call carries its holder only where a store under the member's name may hold the function that escaped. The three this-forwarding wrapper programs (6380, 6381, 6383) are byte-identical to before Pass the holder as the receiver of a typed member call #3308 again and link no dynamic-tier symbol; (Registry.f)() on a class's static field passes the class, where main passed no receiver.
• fix/f5-typed-resolve (no PR; on top of Adopt a promise that an untyped promise is resolved with (executor, Promise.resolve, async generators, finally) #3345): new Promise<T>((resolve) => resolve(v)) with v: T | Promise<T> adopts the promise as Node does. On main the promise arm rejected the new promise at run time, v: Promise<T> did not build, and with T = void the promise fulfilled at once and lost a rejection, silently.
• Supersedes Refuse a write to a built-in member only where the program also reads it natively #3241: a program that replaces a member of a built-in object (Array.prototype.push = f) and also reads that member natively is refused by name (SC1092, naming the write and the use); main built it and ignored the replacement. A write the program never reads natively is lowered as before.

Not in this train: #3156, #3345, #3310 and #3169 (merged by themselves), #3150 (its gate proof needs the allow pattern \bawait\b, which would hide other members' rows) and #3053 (it conflicts with main in the runtime pack matrix and is a train by itself).

Conflicts and fix-ups on the train

• program-facts.ts, lowerer.ts: members and main added rows and fields at the same places; every row stays.
• coercions/structural.ts, Report width copies from the lowered program and test that no warning means Node's behaviour #3221 against Type an untyped empty array where it is written, and stop copying it at typed slots #3288: Type an untyped empty array where it is written, and stop copying it at typed slots #3288 deletes the empty-array lift that Report width copies from the lowered program and test that no warning means Node's behaviour #3221 renamed. The deletion stays and the names Report width copies from the lowered program and test that no warning means Node's behaviour #3221 gave it go with it. tests/harness/copy-soundness-baseline.json: the one case that stored an empty array under two element types is refused by Type an untyped empty array where it is written, and stop copying it at typed slots #3288 now (SC2015), so it moves to the baseline's refused list and the emptyArr count goes.
• Fix four small differences from Node in the lowering: <T>process.env, satisfies, undefined results, class-field function names #3302 against Peel expression wrappers through one module with a function per set #3254 (the shared peel helpers) and against main's lowered-program cache rules: resolved as its owner wrote down; executable-cache.test.ts is main's.
• packages/cli/src/bootstrap.ts, Report width copies from the lowered program and test that no warning means Node's behaviour #3221 against main's table of the options a launcher fast path answers for: main's table stays, Report width copies from the lowered program and test that no warning means Node's behaviour #3221's rule for --fail-on=divergences with --no-copy-warning is kept, and copy-warning joins the coverage fast path's options.
• Two of main's guards met Report width copies from the lowered program and test that no warning means Node's behaviour #3221, each merged without the other: --no-copy-warning gets its cache key rule (executable-cache.test.ts), and the width-copy scan's prefix list is registered in builtin-attributes.test.ts.
• ir/codec.generated.ts is regenerated.

Validation

All in Vercel Sandboxes. One full round on the train, then the checks on the tree that is pushed.

1. The full round (aa197fe248 = main 4e3f07164b plus the nine members, #3156 among them at the time), 49.0 minutes

• Type check: pnpm -r build passes.
• Lanes: plain 23,097 passed, sanitized 19,760 passed. What failed is not the train's, each with its control:
  • 108 cells of tests/harness/island-value-matrix.test.ts in both lanes: main's table is stale at that commit. The table regenerated on plain main 4e3f07164b is byte-identical to the table regenerated on the train (same sha256), so the train changes no cell; another train's round on a main of the same hour fails the same 108 cells, and a round on main 4a71162f4c fails none.
  • tests/harness/effect4.test.ts, cluster-entity.ts, sanitized lane only: the compile step hit the test's time limit (542 s) on a loaded lane box. Alone on one Sandbox (Intel Xeon 2.50GHz, 8 vCPU) the same test passes in 326.8 s on plain main and in 319.1 s on the train.
• Native bootstraps: both pass. Plain: commands 1,251 s, rebuild 1,797 s. Sanitized: commands 1,581 s, rebuild-emit 2,577 s, rebuild-frontend 2,676 s.
• Zero-cost gate, --gate-corpus=all, 5,580 programs: 5,389 identical, 121 fail to build on both sides, 45 allowed, no runtime-only row, no program of main's that differs outside the allow list, and no program of main's gained a dynamic-tier symbol. The gate also compiles the corpus programs a PR adds with main: 11 of the train's do not build on main, and 14 build and print something else, which is what they pin; the tool counts those 14 as "differs", so its verdict line reads FAIL and it stopped the self-compile and fixture shards. The gate-only round on the pushed tree (below) has them in the allow list by id and measures those shards.
• Test262 (Function, JSON, Object, Promise, Proxy, Reflect; 10,396 variants): 0 regressed, 0 gained.
• bench-runtime, 66 workloads: 66 neutral, geomean -0.3%.
• Focused, on the same tree: the 29 corpus programs the train adds with their neighbours, differential.test.ts and llvm-differential.test.ts 82 of 82 plain, differential.test.ts 41 of 41 sanitized; 87 unit and harness test files, 1,258 tests; scripts/gen-builtin-object-members.mjs --check; docs gate 25 of 25.

An earlier round of the same train (17:26, with #3345, #3310 and #3169 still in it) is what found the two guard rows listed under fix-ups; it passed both bootstraps too.

Allow list

45 allowed rows; every row matches the list of the member that explains it. Executables of programs that exist on main change by -14.41% to +3.11% (one of #3288's own new programs, which main builds with the copying lift, is 45.17% smaller):

• Write and delete through every erased wrapper on the operand, not on a copy #3156, on main since: 8808-asserted-write-in-place.ts.
• Fix four small differences from Node in the lowering: <T>process.env, satisfies, undefined results, class-field function names #3302: 18 programs with a class field initialized by an anonymous function (the function's name), and 8872-asserted-method-callee.ts by id (same class; it came to main with Train lang 1: JSON.stringify of undefined stays undefined, RegExp source is escaped, method values check their receiver, empty containers through generic calls, Object.create as a record is refused #3357).
• Type an untyped empty array where it is written, and stop copying it at typed slots #3288: 11 programs that write an untyped empty array as a property, a conditional arm or a default.
• Judge generic loops by each instance's array facts; reject missing elements in array conversions with a TypeError #3243: 10 programs whose arrays can hold a stored undefined (largest growth, 2024-width-array-elems.ts, +3.11%).
• The Pass the holder as the receiver of a typed member call #3308 narrowing: the three this-forwarding wrappers (6380 -14.41%, 6383 -3.52%, 6381 -1.64%) and 8915-member-call-receiver.ts, all smaller.
• Give a function every argument of the final call, whatever slots it passed through #3263: 4040-adapted-function-identity.ts and 8924-boxed-function-name-lookup.ts; self/cli and fixture/llvm-emitter by its recorded exception (GATE-EXCEPTIONS.md).
• Refuse a write to a built-in member only where the program also reads it natively #3241: three programs that stop building by decision (SC1092): 8110-builtin-prototype-own-members.js, array-from-checked.js, collection-constructor-sparse-array-seed.js.
• Report width copies from the lowered program and test that no warning means Node's behaviour #3221 and the f5 branch need no entry.
• --gate-max-size-growth=6 (Give a function every argument of the final call, whatever slots it passed through #3263's function-extra-optional-params.ts, +5.66% in its own round).

2. The pushed tree (258566b418 = that train merged with main fdf68fdf57)

Main gained fourteen merges after the round started (#3156 among them). Two merges of main into the train: cc77cb7a1b (main e7378e4fa1, no conflict) and 258566b418 (main fdf68fdf57; one conflict, ir/builtin-never-throw.ts, where main's #2832 and the f5 branch each add a row: both stay).

• On cc77cb7a1b (Intel Xeon 2.50GHz, 8 vCPU): pnpm -r build (the type check) passes; pnpm generate:ir-codec, pnpm manifest, pnpm node-compat --local and scripts/gen-builtin-object-members.mjs --check change no generated file; pnpm lint, pnpm format:check, pnpm node-compat:check pass; pnpm test:ts7 --baselines-only: every fixture has a baseline. Main's guard tests and the members' unit tests (85 files, 1,282 tests) pass. The corpus programs the train adds, with their neighbours: differential.test.ts and llvm-differential.test.ts 76 of 76 plain, differential.test.ts 38 of 38 sanitized.

• On 258566b418 (the pushed head): the build, the generated-file checks, lint, format and baselines again; the guard tests (builtin-attributes, outer-expressions, executable-cache, program-facts, function-references, the launcher's option test, copy-soundness): 97 of 97; the f5 program and main's existsSync programs: 5 of 5.

• Zero-cost gate on 258566b418 against main fdf68fdf57, --gate-corpus=all (ended after the PR was opened): 5,416 identical, 123 fail to build on both sides, 62 allowed, 8 of the train's new programs that main cannot build, none that differs outside the allow list, no runtime-only row. The allowed rows are the members' lists above, the train's own new programs (main builds 29 of them and prints something else), self/cli, fixture/llvm-emitter and fixture/llvm-layouts (Give a function every argument of the final call, whatever slots it passed through #3263's recorded exception and Judge generic loops by each instance's array facts; reject missing elements in array conversions with a TypeError #3243's rows in the compiler's own source). The tool's verdict line reads FAIL by two size lines, both programs the train adds, compared with what main makes of them (8751-builtin-polyfill-guards-js.cjs +24.8%, 8765-fn-view-array-methods.ts +8.4%), and by one of four self-compile pairs (+2.76%). Compile time: benchmarks +0.90% [95% CI +0.39%, +1.75%], within tolerance; self-compile +1.49% [+0.27%, +2.76%] and fixtures +0.37% [-1.90%, +2.64%], which the gate calls inconclusive. The train adds 1.3% to the compiler's own source; compiling that source costs 1.9% more, with 1.0% more LLVM text and 1.1% more functions.

3. The review fix (3bf19d3309) and the head after it (74e48e3548 = main cb9665e11a merged)

The review bot found a silent difference in #3241's fold on this PR: a polyfill guard that compares a built-in member with void e was decided without evaluating e. if (Array.prototype.at === void note()) { … } under Node calls note(); the compiled program did not (reproduced on 258566b418: four note lines under Node, none compiled, in the if form and in the || and && statement forms). Fixed on the train: a void whose operand is not a literal counts as an operand that runs, so the statement form is not a dead polyfill and an if guard keeps the test's evaluation, where void with an effectful operand in value position is refused by name (SC1090), as everywhere else. void 0 decides the test as before. Pinned by tests/diagnostics/builtin-polyfill-guard-void-operand.ts (five shapes) and tests/corpus/builtin-polyfill-guard-void-literal.ts.

On 74e48e3548 (Intel Xeon 2.50GHz, 8 vCPU): the build (the type check) passes; the diagnostics snapshots, 337 of 337 with the new one; the built-in member programs with the new corpus program, differential.test.ts and llvm-differential.test.ts 20 of 20 plain, differential.test.ts 10 of 10 sanitized; scripts/checker-identity.mjs for the new program; main's guard tests 97 of 97; pnpm lint, pnpm format:check, pnpm test:ts7 --baselines-only, pnpm node-compat:check; no generated file changes. The merge of main cb9665e11a brings main's regenerated island value matrix; it had no conflict. A gate-only round on this head runs beside CI.

4. The second review fix, main's new refusal, and the head after them (4f6d08df91, which contains main 0f154df0e1)

The fold's rule, once (0d3aab12e6). The review bot's second thread on #3241's fold: if (!Object.getPrototypeOf([note()]).at) { Array.prototype.at = … } calls note() under Node and did not when compiled (reproduced on 74e48e3548 in eleven shapes, statement forms and new Map(note()) among them). Both threads are one question, answered by one predicate: a feature test is decided without evaluating it only when nothing in it runs. Going through every operand position found a third silent one: a const alias of a built-in object read before its declaration has run (function probe() { if (!proto.at) { … } } probe(); const proto = Array.prototype; throws a ReferenceError under Node and did nothing compiled). Where something runs, the guard of an if keeps its test's evaluation and a statement form is lowered as any other statement. An early-exit guard (if (X.m) return; in front of a polyfill) always evaluated its test, so it stays decided with an operand that runs (4f6d08df91). The other positions (a computed key, a comma, a call argument, the key of in, a call in front of .prototype) were never resolved by the fold; each was measured under Node and natively and is evaluated or refused by name. new X(…) always counts as running, so if (!Object.getPrototypeOf(new Map()).get) { … } is no longer decided: its test is evaluated and stops at the existing run-time refusal of that call, loudly, as it does on main. Pinned by tests/corpus/builtin-polyfill-guard-prototype-operand.ts, tests/corpus/builtin-polyfill-guard-operand-positions.ts (one case per position) and tests/diagnostics/builtin-polyfill-prototype-operand.ts.

CI's one failure on 74e48e3548 that was not main's: copy-soundness.test.ts. CI tests the merge with main, and main's #2761 now refuses a width copy the program writes through (SC2021). #3221's family has such a case, partial/declaration/increment (const n: T = w; n.a++ where T makes a field of w's type optional): a copy the family counted, a named refusal now. That is main's intended refusal meeting the train's test, not something that built on main and stopped building: no program of main's changes. The case joins the baseline's refused list and the counts are regenerated by the test's update mode: aliasable width copies 364 to 363, nothing else (715a3d473c).

Merges. Main 37323b08f8 (355145304d): no conflict, and it did not build: main added three calls of withoutParenthesesAssertionsNonNull to builtins/module-bindings.ts, a file #3302 moved to withoutParenthesesTypeWrappers; the three calls use the file's helper (4904372f64). The branch of #3371 (main's fix for its weak-collection tests and the runtime refusal baseline; on main since) as the same commits, and main 0f154df0e1 (5012504325), both without a conflict.

On 5012504325 (Intel Xeon 2.50GHz, 8 vCPU): the build (the type check) passes; pnpm generate:ir-codec, pnpm manifest, pnpm node-compat --local, scripts/gen-builtin-object-members.mjs --check change no generated file; pnpm format:check, pnpm node-compat:check, pnpm test:ts7 --baselines-only pass. Guard and unit tests, copy-soundness, the diagnostics snapshots (339) and the three test files #3371 fixes: 518 of 519. The built-in member and polyfill programs with the two new ones, main's record-width-alias and three members' programs: differential.test.ts and llvm-differential.test.ts 26 of 26 plain, differential.test.ts 13 of 13 sanitized. Two things fail, and both are main's at 0f154df0e1, with nothing of the train in them:

• pnpm lint: one runtime refusal site missing from main's baseline, scr_events_emitter.c:442 (node:events: symbol event names and the max-listeners warning's fields #2766; the file is identical to main's).
• builtin-attributes.test.ts "every builtin says whether it can throw": worker.shareEnv (Support the Worker env option and worker_threads.SHARE_ENV #3023) and emitter.symName (node:events: symbol event names and the max-listeners warning's fields #2766).

On the tree before the last merge of main (c2c4044afb with the two later commits' files): the members' unit and harness tests, 86 files and 1,302 tests; copy-soundness plain and sanitized, 12 of 12 each; the members' corpus programs, 84 plain and 42 sanitized; scripts/checker-identity.mjs for the polyfill programs. After that, one more commit (4f6d08df91: the early-exit guard, one predicate call and two fixtures), checked on its tree: the build; the 41 repro programs under Node and natively (each prints what Node prints or is refused by name); the diagnostics snapshots, 344 of 344, and the two polyfill fixtures sanitized; the built-in member and polyfill programs, 16 of 16 plain and 8 of 8 sanitized; copy-soundness and two guard tests, 35 of 35; scripts/checker-identity.mjs; format:check, oxlint, the ts7 baselines. Main has since fixed both of its failures (#3373), which CI's merge with main picks up. A gate-only round on 4f6d08df91 against main 0f154df0e1 runs beside CI; its result follows as a comment.

5. The third review fix: the fold's table (a332810c74), and the head after it (0463579800, which contains main 14960424a1)

The review bot's third thread on #3241's fold: Math.PI = Math.PI || 3.14 was erased as a polyfill that never runs. It does run, it assigns the member its own value, and in strict code that assignment is a TypeError when the member is read-only. Node throws; the compiled program did nothing.

That was the fourth thing the fold dropped that Node does (the void operand, the value behind a prototype lookup, an alias read before its declaration, and this). So the fold got the table it should have had from the start: every guard and assignment form it decides (17) by the member's attributes (9: a writable function, read-only data, read-only falsy data, an accessor, an inherited function, a missing member, a member of a frozen object, of a sealed object, writable falsy data), in strict (.mjs) and sloppy (.cjs) code: 306 programs, one per cell, each under Node and compiled, on the train and on main.

• Before the fix (4f6d08df91): four silent cells, one class: X.m = X.m || f and X.m = X.m ?? f in strict code, over a read-only member and over a member of a frozen object.
• The rule now: the fold erases a statement only where Node writes nothing, or where the write does nothing whatever the object's state. X.m ||= f and X.m ??= f never assign over a member that is there: erased in both modes. X.m = X.m || f, X.m = X.m ?? f and X.m = X.m assign the member's own value: erased in sloppy code over a data member the object itself holds (the write changes nothing or is ignored), lowered as the assignment it is in strict code, where the runtime answers as Node does. X.m = X.m is no longer refused as a replacement (SC1092).
• After the fix: no silent cell, and no cell where main prints what Node prints and the train does not; seven cells where the train matches Node and main does not. Of the 306 cells, 223 print what Node prints, 2 are refused by name at build time, 73 stop with a run-time refusal (an accessor of RegExp.prototype, Map.prototype.hasOwnProperty and the like, on main too), and in 8 both sides throw the TypeError and the message names the object differently, on main too.
• What it costs: in a strict source, String.prototype.trimStart = String.prototype.trimStart || function … is not erased and meets SC1090 (an assignment to a member of String.prototype has no lowering), as on main today. Refuse a write to a built-in member only where the program also reads it natively #3241's own program 8738 had that line in a module; it is gone from there and pinned where it runs: 8751 (sloppy, erased) and the new tests/corpus/builtin-polyfill-keep-value-assignment.mjs (strict, lowered) with its sloppy twin. Deciding it in strict code again needs the census to record freezes and redefinitions that keep the value (FOLLOWUPS.md).

Merges. Main ee6d7f7240 (fe192725fd), which carries train islands-1: one conflict, lowerer.ts, where islands-1 removed the stdioPatchSites field beside #3241's three census fields and #3221's loweredFunctions; the field and its two mentions are gone, the train's lines stay. Main 14960424a1 (0463579800): no conflict, no file in common.

On fe192725fd with the 8738 change (Intel Xeon 2.50GHz, 8 vCPU): the build (the type check); no generated file changes (generate:ir-codec, generate:ir-fields, manifest, node-compat --local, gen-builtin-object-members --check); pnpm lint (390 runtime refusal sites, none missing), format:check, node-compat:check, the ts7 baselines; guard and unit tests with the diagnostics snapshots, copy-soundness and main's formerly red files, 93 files, 1,343 tests; copy-soundness sanitized 12 of 12; the members' corpus programs, 96 of 96 plain (differential and llvm-differential) and 48 of 48 sanitized; scripts/checker-identity.mjs for the seven polyfill programs; the 306-cell table and the 41 repro programs.

On 0463579800, the pushed head: the build; no generated file changes; pnpm lint, format:check, node-compat:check, the ts7 baselines; the guard tests with copy-soundness, dyncheck and the diagnostics snapshots, 17 files, 621 tests; the built-in member and polyfill programs with five other members' programs, 34 of 34 plain and 17 of 17 sanitized; the 306-cell table again: no silent cell. A gate-only round on this head against main 14960424a1 runs beside CI; its result follows as a comment.

Zero-cost gate on 4f6d08df91 against main 0f154df0e1, --gate-corpus=all (the head before this fix; the fix changes only what the fold erases): 5,461 identical, 125 fail to build on both sides, 65 allowed, 8 of the train's new programs that main cannot build, none that differs outside the allow list, no runtime-only row. The tool's verdict reads FAIL by the same two size lines as before, both programs the train adds (8751 +24.9%, 8765 +8.4% against what main makes of them). Compile time: benchmarks +1.04% [95% CI +0.08%, +1.87%], within tolerance; self-compile +3.02% [+1.82%, +5.93%] and fixtures +0.91% [-0.76%, +2.58%], which the gate calls inconclusive.

6. Main's variadic rule meets #3263's function views (5b32646f38, which contains main 851b59b90f)

Three more trains landed on main (cli-5, startup-1, cli-4) and one earlier one (perf-2) brought a rule that meets #3263 on the same conversion: a variadic function (a rest function, a reader of arguments, a bound partial application) stored under a fixed signature is refused at the end of lowering (SC1090) when the program hands a function of that type to a caller that passes more arguments. The merge was clean in text and refused three of #3263's own corpus programs and one dyncheck fixture, whose views had made some of those stores answer as Node does.

Which rule holds was measured, not argued: 90 programs, 9 function kinds (untyped rest held by a constant, returned by a call, declared; a reader of arguments; typed rest three ways; optional parameters; a bound function) by 10 callers (a wider function type, a chain of two, a cast call, map, forEach, reduce and findIndex, through a function, a record slot, an untyped call, apply and call), each stored as (x: number) => number first, under Node and compiled, on three trees:

tree	same as Node	refused at build	loud at run time	silent
main 952d9fb2be	7	56	0	27
this train before the merge (0463579800)	41	23	12	14
this train merged with main	18	64	3	5

• With main's refusal left out of the merged tree, six of main's eight pinned shapes are silently wrong ([3, 1, 2].map(one) prints 1,1,1): a store main's variadic adapter made is not a view. So the rule stays exactly as main has it: one rule decides a variadic store, and no compiler source changes on the train.
• The five silent cells of the merged tree are silent on plain main with the same output (an untyped call loose(1, 2, 3) of a stored optional, typed-rest or arguments function, and apply of a stored arguments function). Nothing is silent here that main does not have, and 22 of main's 27 silent cells are gone. The five are written down for the untyped-call branch that follows this train.
• The train's own 14 silent cells from before the merge are refused by main's rule now (9) or are the same five.
• The price: 27 cells this train answered as Node does are SC1090 for now (a typed rest function, a bound function or an untyped rest constant stored under a shorter signature and then widened, cast, passed through a function, held in a record slot or mapped). Give a function every argument of the final call, whatever slots it passed through #3263's sentence "a function receives every argument of the final call" holds for functions with fixed and optional parameters and for bound methods. The shapes main refuses left Give a function every argument of the final call, whatever slots it passed through #3263's tests (8762, 8765, 8916, one dyncheck fixture); main's tests/diagnostics/variadic-store-longer-call.ts pins the refusal.
• The three loud cells are Give a function every argument of the final call, whatever slots it passed through #3263's checked view: [3, 1, 2].map(one) over a function with three optional number parameters hands it the array as its third argument, which its parameter type excludes.

Merges. Main 952d9fb2be (d10eec1a8b): three conflicts, each two additions at one place, both kept (diagnostics/diagnostic.ts, diagnostics/render.ts, the import lines of frontend/program.ts). Main 851b59b90f (5b32646f38): ir/codec.generated.ts only, regenerated on the merged sources (pnpm generate:ir-codec).

On 5b32646f38, the pushed head (Intel Xeon 2.50GHz, 8 vCPU): the build (the type check); no generated file changes (generate:ir-codec, generate:ir-fields, manifest, node-compat --local, gen-builtin-object-members --check); pnpm lint (390 runtime refusal sites, none missing), format:check, node-compat:check, the ts7 baselines; guard and unit tests with the diagnostics snapshots, dyncheck, copy-soundness and the function-view tests, 93 files, 1,367 tests; the members' corpus programs with main's variadic programs, differential.test.ts and llvm-differential.test.ts 114 of 114 plain, differential.test.ts 57 of 57 sanitized. The Node island conformance lane in check mode (which CI skips for a PR that touches no island path) ran on d10eec1a8b, the merge with 952d9fb2be: four shards, 422 passed, none failed, the list untouched; it runs again on the pushed head. A full round on the pushed head (zero-cost gate, both lanes, both native bootstraps) runs beside CI; its result follows as a comment.

Not run

On the merged trees and after the review fixes: the native bootstraps, bench-runtime, Test262 and the full lanes (they ran in step 1; CI runs the lanes on the merge). Anywhere: the macOS lanes, the Node island conformance lane (no member touches island code), a pi build (the f5 branch and the narrowing were measured against pi by their owners).

🤖 Generated with Claude Code

[cramforce]

Zero-cost gate on the pushed head 0463579800 against main 14960424a1, --gate-corpus=all (gate-only round, Vercel Sandboxes): 5,463 identical, 229 fail to build on both sides (the island programs, which the gate builds without a libnode pack on both sides), 67 allowed, 8 of the train's new programs that main cannot build, none that differs outside the allow list, no runtime-only row.

• The allowed rows are the members' lists of the PR body, the corpus programs the train adds (main builds 34 of them and prints something else, which is what they pin; the five the review fixes added are among them), self/cli, fixture/llvm-emitter and fixture/llvm-layouts.
• The tool's verdict reads FAIL by two size lines, the same two as in every round of this PR, both programs the train adds, compared with what main makes of them: 8751-builtin-polyfill-guards-js.cjs and 8765-fn-view-array-methods.ts.
• Compile time, all within tolerance in this round: benchmarks +0.39% [95% CI -0.13%, +1.03%], self-compile +1.37% [+0.08%, +1.90%], fixtures +0.66% [-0.04%, +1.37%].

The type check of the round (the candidate's pnpm -r build on a fresh tree) passes.

[cramforce]

CI on 0463579800: one red job, "test (Linux, plain, 9/20)", and it is a race in a program of main's, not the train.

• What failed: tests/harness/llvm-differential.test.ts, 5547-fs-write-stream.cjs, the dev build: the program's last line printed unknown-encoding stream opened its file false where Node prints true. That line asks whether a write stream whose constructor threw (encoding: "buffer") has created its file; the open is scheduled before the throw and nothing in the program waits for it.
• Not the train: no member touches the fs streams, the worker pool or that program, and the merge resolution in lowerer.ts removes a field main removed.
• Measured, the program alone, in two Sandboxes (8 vCPU), the pushed head and plain main 14960424a1: the llvm-differential case (release and dev) 12 of 12 on each; the dev binary 800 runs sixteen at a time on each, last line true 800 of 800 and the whole output equal to Node's 800 of 800; the release binary 320 runs eight at a time on each, 320 of 320. It does not reproduce on either tree.
• Seen before: the same program failed once in CI on another PR for the same unawaited open (its file appearing while the program's last line removes the directory).

I will re-run the failed job once the workflow run has finished.

[cramforce]

Full round on the pushed head 5b32646f38 against main 851b59b90f (Vercel Sandboxes, 54.2 minutes):

• Type check: passes.
• Lanes: plain 24,183 passed, none failed; sanitized 20,827 passed, none failed (95 jobs).
• Native bootstraps: both pass. Job times, Sandbox start included: plain commands 19.8 min, rebuild 35.4 min; sanitized commands 30.4 min, rebuild-emit 33.3 min, rebuild-frontend 48.0 min.
• Zero-cost gate, --gate-corpus=all: 5,497 identical, 288 fail to build on both sides (the island programs, built without a libnode pack on both sides), 68 allowed, 8 of the train's new programs that main cannot build, nothing that differs outside the allow list, no runtime-only row. The tool's verdict reads FAIL by the same two size lines as in every round of this PR, both programs the train adds, against what main makes of them (8751-builtin-polyfill-guards-js.cjs +24.7%, 8765-fn-view-array-methods.ts +7.5%). Compile time: benchmarks -0.08% [95% CI -0.83%, +1.17%] and fixtures +0.93% [+0.35%, +1.52%], within tolerance; self-compile +2.55% [+1.10%, +4.13%], which the gate calls inconclusive.
• Node island conformance lane (CI skips it for a PR that touches no island path), check mode, four shards, on the same head: 430 passed, none failed, the list untouched.

Not run in this round: bench-runtime and Test262 (they ran in the round of section 1 of the description and on no later head).

[cramforce]

Landed through #3395 (the landing rollup, merge commit 3dddae7): this train's head 5b32646 is merged there as it was.