[cramforce]

Lowering fixes for typed code, as commits by compiler area on current main. This replaces #3352: the same compiler changes with test programs rewritten around the one behaviour each pins, minus one refusal that is taken back out, plus the corrections the rebuild needed.

What the commits do

1. Generic functions. A generic function declared inside another function compiles. A generic function used as a value has one identity per declaration (===, Map and Set keys, listener removal), across objects, worker threads and library instances; the build-time pins that stood in for that are gone. A nested generic function used as a value is still refused, by name.
2. Process streams and child processes. process.stdout and process.stderr passed or stored where stream.Writable is declared are withheld (see "Not in this train"): such a program stops at the build by name (SC1090), as on main. process.stdin where stream.Readable is declared is withheld (see "Not in this train"): such a program stops at the slot with the TypeError main gives it. A program that reads process.stdin with descriptor 0 closed ends, as in Node, instead of waiting forever. Once setEncoding has been called on process.stdin, a consumer compiled for bytes stops by name where a chunk is handed to it (SC2020 at run time), and a 'data' listener whose parameter is declared string receives the decoded text. The stream unit scr_stream.c is main's file and its objects are byte-identical to main's. spawn and spawnSync with shell and a separate argument list join the arguments onto the command as Node does (with DEP0190), and shell may be decided at run time. Merged with main's maxBuffer work and with main's evaluation of option values a launch does not read: one check function orders the launch's values, the joined line, those option values and the limit as Node does.
3. Five forms of typed code that were refused: Object.keys and Object.entries over what typeof v === "object" leaves of a JSON value; left ?? right with a wider right side (see 7); a function created above let x: T;; a call through an optional callable member every arm of a record union declares; a generic rest binding typed by the type argument's fields. (Three more forms of Train pi 1: lowering fixes on pi's path (generic identity, Proxy slots, shell arguments, stdin as a stream, dictionaries and unions) #3352 reached main by other changes meanwhile: iterating a typed Headers, Promise.all over an entry of type Promise<T | undefined> | undefined, and reduce and reduceRight on a checked-dynamic array. Main's lowering stands for them; this branch keeps its test programs.)
4. Dictionaries. A dictionary that keeps identity can be an arm of a recursive union. A dictionary type is one type however it is spelled ({ [key: string]: V }, Record<string, V>, an alias, another module), so a value passed between two spellings is the same object.
5. Unions. Members that share a discriminant literal are stored as one record, so a value of one member is the object the union holds. A value whose type only has the layout of such a member (an inferred literal type, as const, a function's inferred result, an assertion's type) is built as that record where it is created, so it enters the union with no copy: every program of that shape that builds on main builds here and prints the same (a family of 1,491 programs: 1,332 equal Node; 144 differ from Node exactly as on main, with main's copy warning; 15 are refused, as on main). The same member written in two unions is one record in both. Where several arms hold a record of optional members, a value takes the arm that declares the properties it has. A dictionary record that is a union arm no longer crashes when it converts to an untyped value.
6. A dictionary copied where its identity is observed is reported (SC6001) by the lowered-program scan. A record that holds such a dictionary, declared or passed as a record whose dictionary has another value type and written through, is refused as on main (SC2021, SC1090). This depends on how the dictionary type is spelled: a field whose type is another spelling of the type the object entered is refused, a field declared with the very type the object entered is a reported copy. Over 1,362 programs of the dictionary family and 144 of the holder family, every program main builds still builds and prints what main prints.
7. left ?? right with a wider right side compiles where taking the left side keeps the value, and stays refused where it would copy it (SC1090, with the spellings that compile). JavaScript answers the left side itself; converting an array, a tuple or a record of another layout builds a second object, so a write through the result would miss the left side. Main refuses every such expression. In a family of 2,156 programs (7 forms of the left side, 19 kinds of value, a plain or side-effecting right side, present or absent, five things the program observes): main has 642 equal to Node, 1,324 refused and 190 that differ; this branch has 738, 1,228 and the same 190 with the same output. No program main builds is refused; 96 that main refuses compile and equal Node.
8. The island conformance list is regenerated on this tree; the check mode passes (460 of 460 on 1c406f827c, before the merges of main).
9. The weak-key memory test measures bytes per additional key.
10. Two corrections found by building the branch. The dictionary-copy scan and the ?? change did not type-check together. And the search that finds a copied dictionary compared a large union of record types with itself at every step: the compiler's own build did not get past one declaration (stopped after 55 minutes there; the build takes about nine). The search now asks first whether the target can hold a native dictionary at all. With it the self-compile budget check (scripts/self-compile-budget.mjs --check) passes: 454 s, one lowering pass, 131 bytes per source byte against a budget of 136, and CopyScan stays out of the dynamic tier (main alone in the same sandbox: 487 s, 132 bytes). The compiler's own build prints 9,850 copy reports here against 9,770 on main.
11. Three test-only commits. The narrowing test that was red on an earlier head says what the tree does: ?? over a binding only a closure assigns builds, || stays refused. The stdin iteration test this branch adds printed the bytes of its first read and of the iteration that follows separately, so its output depended on where the pipe's chunks ended; it failed once on a loaded machine. Its fixture now reports all the bytes together (one output over twelve runs with four arrival patterns, where the old fixture had three). And the snapshot of one of main's fixtures is recorded again; see "A build-time refusal that becomes a run-time stop" below.

Not in this train

• The build-time refusal of a Proxy stored where a record type or a class is declared (part of Train pi 1: lowering fixes on pi's path (generic identity, Proxy slots, shell arguments, stdin as a stream, dictionaries and unions) #3352) is reverted here. Where the store runs it replaced a wrong answer; where the store is in code the program never reaches it rejected a program that builds on main and prints what Node prints. Proxy stores behave as on main. The form returns as a store that throws by name when reached, with a build warning.
• process.stdout / process.stderr passed or stored where stream.Writable is declared is withheld by the last commit (e5da0f4dc3). The train had made that flow ask for the general stream representation by itself, so every such program reached main's conversion. Printing the writable state through both names after one operation through one name (500 runs, see "Evidence") found 103 runs on 83489c44ec that main refuses by name and that differed from Node with no diagnostic: a write through process.stdout after stream.end() or stream.destroy() was written; the stream stayed ended, destroyed and closed where Node's stdio stream is writable again; with the reader gone the program ended with status 0 where Node ends with EPIPE and status 1; a 200 kB write to a pipe and a corked write read writableLength 0 where Node reports the queued bytes. Now the flow stops at the build with SC1090: 'WriteStream' values where 'Writable' is expected is not supported yet, as on main; a program that asks for the general representation through another member reaches the conversion as on main, with main's 52 silent runs of the family unchanged. The cure (one writable state behind both names) is a train of its own, with the stdin one.
• process.stdin passed or stored where stream.Readable is declared is withheld by the commit before it (83489c44ec). In Node the two names are one object with one readable state. The review of 21:38 UTC found that process.stdin.readableLength answered 0 while the stream held the unread input. Printing every readable-state property through both names (41 programs, two inputs each) found 20 cells on 53e1c31e7e that differ from Node with no diagnostic, from five causes: that one; process.stdin.destroy() not destroying the stream; input held before a late conversion missing from the stream; destroyed and closed after the end of a file's input; closed right after destroy() on a file's input. Main stops such a program by name, so the conversion is not made until the two names answer as one: the program stops with main's TypeError (expected Readable, got ProcessStream). The runtime unit scr_stream_stdin.c, its link feature and its fixtures stay in the tree and no program links the unit; the differential cases and tests of the conversion are skipped with Node's answers kept, and one test pins the stop by name for the 14 fixtures that convert. The conversion returns with those five causes cured and that family as its evidence.

What is refused

Every diagnostics fixture this branch adds or changes was built with main's compiler and with this branch's, site by site: no site is refused here that main builds. Three fixtures hold lines main refuses and this branch compiles (the typed union arm and the two nested generic function fixtures). Refusals this branch words anew, all at sites main refuses too:

• left ?? right where the left side would be copied to reach the result type (SC1090): give both sides one type, or write the copy out.
• A record holding a dictionary, converted to a record whose dictionary has another value type and written through (SC2021, SC1090, as on main; see 6 for the spelling).
• A function created above let x: T; with no initializer that reads x (SC1030 instead of main's SC1090).
• A nested generic function declaration used as a value (SC1090, named; main refuses the declaration itself).

process.stdin where stream.Readable is declared stops at run time with a TypeError that names both types, exactly as on main (see "Not in this train"). The limitations page says so.

A build-time refusal that becomes a run-time stop

let seen: { n: number } | null = null, assigned only inside a closure, then seen ?? word() with word(): string | undefined. The checker narrows seen to null and types the pair as string | undefined. Main refuses the line at build time. This branch builds it: while the binding is still null the program answers as Node does; when it holds a value the program stops with TypeError: a '{ n: number }' value is not representable in the target union (a value narrowed or asserted past it still held it), where Node answers the binding. Over 100 programs of the shape (five stored types of the left side, five types of the right, ?? and ||, the binding holding a value or not): 3 that main refuses stop with that error, 3 that main refuses now equal Node, none answers differently in silence, || is unchanged, and nothing main builds is refused. The build does not warn at such a site yet; that warning is the first item of the next train.

Evidence

All in Vercel Sandboxes. The pushed head is 0e6a32a9c3: five merges of main on top of 6ad5580db0. It holds main 9a6d7290f2 (#3471, #3473, #3474). Main was b4e908ef00 when it was pushed (#3476, #3477, #3478, #3479, #3480 and train cli 28 #3463 on top): that delta merges without a conflict, nine files are both sides' and no hunk of main's lies in a region this train changes, but nothing below ran on that merge; CI's merge commit runs it (see "Not run"). 0e6a32a9c3 merges main 9a6d7290f2. No file conflicted and no line is changed by hand. Three files that both sides change merged by themselves, and both sides' hunks were read. In lower-stdlib.ts main changes npmMemberFence and this train the Headers fences; in type-mapper.ts main adds packageMemberIsData, which calls two functions this train does not change. In lower-calls.ts both change lowerOrdinaryCall, in different branches: main answers a member call off a receiver that evaluates ((await import("./m")).f(1)) as the namespace member's own call, and this train adds the call of an optional callable that every arm of a record union declares, about 450 lines later; main's branch returns only for a namespace member, this train's only for a receiver that is a union of records (see "Where the two sides meet"). 33d8ebd7d8 merges main e0d43347aa (#3465, #3470, #3472). One file conflicted, the generated packages/compiler/src/ir/codec.generated.ts: it was regenerated from the merged sources, not resolved by hand. Eight files that both sides change merged by themselves (dyn.ts, emit-module.ts, emitter.ts, coercions/structural.ts, expressions/narrowing.ts, lowerer.ts, ir.ts, runtime-features.ts); main's hunks there are additions. 859d769484 merges main 8152700b48 (#3469). There is no textual conflict, but both sides change lowerNullishPair in expressions/binary.ts, and one line is changed by hand in the merge: main now lowers the default of a ?? b once, where it can be a literal built wider than the checker typed the pair, and replaced every later lowering of the default in that function with lowerDefault(); this train adds one more place that lowers the default (the present value that converts into the result and stays the value it is), which main could not see, and that place now calls lowerDefault() like the others. 067bd10eed merges main 7569a9ca6b (#3466 and #3467): no conflict, and main changes no file this train changes. dd8031f5b4 merges main 44f9f34d6b (#3461, #3464, and #3462, which moves the TypeScript 7 frontend to TypeScript 7.1). Two files conflicted there, both hand-written. In packages/compiler/src/frontend/lowering/class-protocols.ts both sides added an import at the same line (this train TypeSameness, main extendsElementOf), and both stay. In tests/harness/__snapshots__/child-process.ts.txt this train's fixture has two refusals fewer, which moves the remaining overload diagnostic from line 37 to line 26, and main re-recorded that diagnostic's type text as TypeScript 7.1 prints it; the snapshot was re-recorded by its test on the merged tree and is this train's file with 7.1's type text in its first line. The ts7 baselines are unchanged: the whole order-parity suite passes on the merged tree as recorded (353 of 353). 6ad5580db0 is a merge of main 6ae2f2d365 (train perf 8a #3458 and #3459) into 20e05369a6. One file conflicted there, the generated packages/compiler/src/ir/codec.generated.ts: it was regenerated from the merged sources, not resolved by hand. 20e05369a6 is a merge of main 0424e4e684 (train react 1 #3455, train cli 27 #3456, and #3457, which makes main's five red Linux tests green) into d57ec3e16c. Two files conflicted. In packages/compiler/src/frontend/lowering/expressions/narrowing.ts both sides added a function at the same place (this train classRecordMemberRead, main the functions for stranded instance arms), and both stay, no line of either changed. packages/compiler/src/ir/codec.generated.ts is generated: it was regenerated from the merged sources, not resolved by hand, and regeneration on the merged tree changes no generated file. d57ec3e16c is a merge of main cf9b741144 (trains #3451 and #3450, #3452, #3454, #2178 and the release preparation) into e5da0f4dc3. One file conflicted there, tests/harness/coverage.test.ts: both sides added a test at the same place, and both stay; nineteen files that both sides change merged by themselves, the lowering and backend files among them, and no generated file conflicted. e5da0f4dc3 is 83489c44ec plus the commit that withholds the Writable hand-on, and 83489c44ec is 53e1c31e7e plus the one commit that withholds the stdin conversion. 53e1c31e7e is the head of the full round below, then the commit that moves two stdin functions out of the stream unit, then four merges of main (6c1e5ac877, no conflict; d3f840eb2e, one conflict: both sides added a function at the same place in the call lowering, and both stay; 5d42c2b87c and a57eaacffd, no conflict). After each, the files both sides change were read. Main's runtime is built with the hardening flags of #3442 from the second of them on.

• Gate-only round on the pushed head 0e6a32a9c3, against main 9a6d7290f2 (round 21; lanes, bench-runtime and Test262 skipped): passes. Type check passes. Gate: 5,814 programs identical, 176 allowed (below), 367 fail to build on both sides, none outside the list and no executable-only row outside it. The three more that fail on both sides are the Node island programs main gained with Read a shared module's var export only after its declaration ran, evaluate a dynamic import before a member read, and read package data members through a copy #3474: the gate builds without the Node pack, and the test list below builds and runs them with it. No program joins the list: main's new 2607-dynamic-import-member-read is byte-identical, and the two process-stream-write-error programs main changed with Fix the macOS process.hrtime clock and make the three macOS-failing corpus tests deterministic #3471 were listed already (they link the event dispatcher). Timing: bench geomean +0.44% [-0.29%, +1.32%] and fixtures +0.39% [+0.29%, +1.06%] within tolerance; compiler self-timing +1.37% [+0.57%, +2.20%], which this round reports as inconclusive (two runs; the full round one merge earlier, with the same train commits, measured +0.64% [-0.12%, +0.88%]). The compiler builds its own source in 548 s in one lowering pass, at 135 bytes per source byte against a budget of 136.
• On the pushed head, in a sandbox with main 9a6d7290f2 built beside it:
  • Tests: the build, the generated-file checks (regeneration changes nothing), lint, format, the ts7 baselines (complete); the whole order-parity suite as recorded (354 of 354: it had not been rerun since the merge of TypeScript 7.1); 23 files of guard and unit tests (614 of 614); the type mapper tests (22); the whole diagnostics suite (429); the members' corpus programs in both backends (986 cases), the same programs and the diagnostics with the type walk memo in verify mode (525); the 4 programs main gained with Read a shared module's var export only after its declaration ran, evaluate a dynamic import before a member read, and read package data members through a copy #3474 and the 3 it changed with Fix the macOS process.hrtime clock and make the three macOS-failing corpus tests deterministic #3471, in both backends (14), sanitized (7) and in verify mode (7); the stdin tests plain and sanitized (44 passed and 18 skipped each); the node-types project tests sanitized (104); the cases of the test file that conflicted seven merges ago (6); the Node island suite (47).
  • The cell families, against main in the same sandbox: the writable-state family, 500 runs: 410 refused on both, 36 silent on both, 44 equal on both, 10 stop by name at run time on both, 0 hang; all 256 rows are main's, verdict and text. The readableLength cells: 9 of 9 rows are main's. The readable-state family: 73 of 73. The stdin family of 400 runs: 4 equal Node, 396 stop by name, 0 differ in silence, 0 hang; main: 3, 396, and the one control cell that hangs.
  • Where the two sides meet: main's member call off a dynamic import and this train's call of an optional callable of a record union, both in lowerOrdinaryCall: a program that calls a function off (await import("./m.ts")), calls the optional callable on records made through a namespace and through a dynamic import, and calls it on a namespace member that holds such a record (the one call both branches look at): 18 of 18 lines equal Node here and on main. The generic-function identity probe described below: 8 of 8 lines equal Node here; main differs in 4. The ?? probe of Answer a literal right operand of &&, || and ?? as it was built #3469 (next bullet): 7 of 7 here and on main.
• Full round one merge earlier, on 33d8ebd7d8 against main e0d43347aa (round 20, nothing skipped; the lanes, bench-runtime and Test262 were not rerun on the pushed head, whose only difference is the merge of main 9a6d7290f2): passes. Lanes: plain 26,296 passed, 0 failed; sanitized 22,599 passed, 0 failed; both native bootstraps among them. Gate: 5,813 programs identical, 176 allowed (below), 364 fail to build on both sides, none outside the list and no executable-only row outside it. Timing, all within tolerance: bench geomean +0.31% [-0.13%, +0.98%], compiler self-timing +0.64% [-0.12%, +0.88%], fixtures -0.09% [-0.87%, +0.37%]. The compiler builds its own source in 560 s in one lowering pass, at 142 bytes per source byte against a budget of 136, inside the gate's 5% tolerance; that number is main's since Move TypeScript 7 support to TypeScript 7.1 #3462 (see the round on dd8031f5b4 below). bench-runtime: 75 workloads, geomean +0.5%, 74 neutral, 1 slower: value-records +11.4% [+2.7%, +37.1%], whose executable is byte-identical to main's in the same round's gate, so the mark is measurement (the two rounds before had it neutral). Test262 (Function, Reflect, JSON, Proxy, Object): 0 regressed, 0 gained.
• On 33d8ebd7d8, in a sandbox with main e0d43347aa built beside it: the same test list with the same counts (without the order-parity suite), the cell families row for row main's, and the 5 programs main gained with Keep one object when an untyped value meets a typed record slot, and read typed arrays through untyped values from the array itself #3465 and Keep types that carry the collector header only for the weak analysis out of the collector #3470 and the one of Answer a literal right operand of &&, || and ?? as it was built #3469, in both backends (12), sanitized (6) and in verify mode (6), each of which builds to a byte-identical executable on main's tree and on that one. The ?? rules of Answer a literal right operand of &&, || and ?? as it was built #3469 and of this train (a present class instance defaulted to a literal that builds wider than the checker typed the pair, directly and through a || pair, with a write through the answer): 7 of 7 lines equal Node there and on main.
• Full round three merges earlier, on 859d769484 against main 8152700b48 (round 19): passes. Lanes: plain 26,278 passed, 0 failed; sanitized 22,581 passed, 0 failed; both native bootstraps among them. Gate: 5,808 identical, 176 allowed, 364 fail to build on both sides, none outside the list and no executable-only row outside it. Timing: bench geomean -0.56% [-1.31%, +0.41%] and fixtures +0.54% [-0.25%, +1.38%] within tolerance; compiler self-timing +0.79% [+0.21%, +2.02%], which that round reports as inconclusive (the rounds before and after it measure it within tolerance). bench-runtime: 75 workloads, geomean -0.3%, 75 neutral. Test262: 0 regressed, 0 gained.
• Full round five merges earlier, on dd8031f5b4 against main 44f9f34d6b (round 18):
  • Gate: 5,800 programs identical, 176 allowed (below), 364 fail to build on both sides, none outside the list and no executable-only row outside it. Timing, all within tolerance: bench geomean +0.09% [-1.00%, +0.97%], compiler self-timing +0.42% [-0.01%, +0.92%], fixtures +0.46% [-0.27%, +0.89%]. The compiler builds its own source in 518 s in one lowering pass, at 142 bytes per source byte against a budget of 136, inside the gate's 5% tolerance. That number is main's since Move TypeScript 7 support to TypeScript 7.1 #3462, not this train's: rounds of other branches against the same main measure 3,519 to 3,521 MB, this one 3,532 MB, and this train measured 130 bytes per source byte one merge earlier.
  • Lanes: plain 26,250 passed, 1 failed; sanitized 22,552 passed, 2 failed; both native bootstraps passed, plain and sanitized. The three failures are time-outs, so the round's own verdict line is FAIL: self-hosting-serialization.test.ts "llvm round-trips IR and produces a working program" at its 300 s limit (plain), and commander-calc at its 120 s limit in npm.test.ts and in npm-shape-overlay.test.ts (sanitized, one shard). Each passes alone, on this tree and on main's tree in the same sandbox, in the same time. The round trip: 120 s here, 117 s on main. commander-calc, sanitized, from a cold cache: 96.5 s here, 96.6 s and 93.8 s on main, of which 85 to 87 s are the sanitized link. Its compile by phase is equal on both trees, and its LLVM module has the same number of lines and functions. These are two budgets that main's tree nearly fills by itself and a busy lane machine exceeds; both tests have timed out in rounds of unrelated branches.
  • bench-runtime: 75 workloads, geomean -0.4%, 75 neutral. Test262 (Reflect, Function, JSON, Object, Proxy): 0 regressed, 0 gained.
• The same lists on the heads between: on dd8031f5b4 all of them, with the same counts (612 unit tests) and the cell families row for row main's; on 067bd10eed and 859d769484 the build, the static checks, the unit, type mapper and diagnostics tests and the members' corpus programs in both backends and in verify mode. On 067bd10eed also the 7 programs main gained with Arenas no longer drop objects kept reachable through virtual calls, generators, library callbacks or callback-made cycles #3466 and Name the fields of the entry a layout-mode property copy builds #3467, in both backends (14), sanitized (7) and in verify mode (7): each builds to a byte-identical executable on main's tree and on this one.
• On 6ad5580db0, against main 6ae2f2d365:
  • Gate-only rounds: 5,800 programs identical, 176 allowed, 364 fail to build on both sides, none outside the list and no executable-only row outside it; self-compile 535 s, one pass, 130 bytes per source byte. The first round reported bench geomean +0.53% [-0.49%, +2.39%] and fixtures +1.82% [+0.26%, +3.14%] as inconclusive; the second, with twice the timing runs, measured bench +0.36% [-0.27%, +1.10%], compiler self-timing +0.38% [+0.03%, +1.35%] and fixtures +0.58% [-0.18%, +1.04%], all within tolerance. The round one merge earlier, on 20e05369a6 against main 0424e4e684 (the same train commits): 5,798 identical, 176 allowed, 364 fail on both sides, none outside the list; bench geomean -0.23% [-1.66%, +1.22%], compiler self-timing +0.40% [-0.10%, +0.63%], fixtures +0.48% [-0.21%, +1.45%], all within tolerance; self-compile 594 s. The round before that one, with the list of 176, had two rows outside it of 6,356 programs compared: terminal-color-methods-piped.ts and terminal-method-answers-collected.mjs, which main gained with Train cli 27: destructured parameters without a static type, Promise.all entries, held createRequire loader members, primitive constructors as values, generic instances that bind several layouts, the terminal color methods, one island round per statement #3456 and which link the event dispatcher (see "Gate rows").
  • Where the two sides meet: main now gives a generic function one instance per set of type arguments its signature hides, and this train gives a generic function value one identity. One function demanded as a value at two hidden type arguments, then compared, added to a Set, used as a Map key and searched with indexOf: 8 of 8 lines equal Node here; main differs from Node in 4 of them without a diagnostic.
  • Tests: the build, the generated-file checks (regeneration changes nothing), lint, format, the ts7 baselines; 23 files of guard and unit tests (612 of 612: the two of main's that failed here before are fixed on main by Decide the checked-data promise writes can throw, record their unit reference, and prove factory-made exports through namespaces #3457); the type mapper tests (22); the whole diagnostics suite (430); the members' corpus programs in both backends (984 cases), the same programs and the diagnostics with the type walk memo in verify mode (524); the 2 programs main gained with that merge, in both backends (4), sanitized (2) and in verify mode (2); the stdin tests plain and sanitized (44 passed and 18 skipped each); the node-types project tests sanitized (104); the cases of the test file that conflicted two merges earlier (6); the Node island suite (47). The same lists ran on 20e05369a6 with the same counts, there with the 27 programs main gained with that merge (56, 28 and 28).
  • The cell families, against main 6ae2f2d365 in the same sandbox: the writable-state family, 500 runs: 410 refused on both, 36 silent on both, 44 equal on both, 10 stop by name at run time on both, 0 hang; all 256 rows are main's, verdict and text. The readableLength cells: 9 of 9 rows are main's. The readable-state family: 73 of 73. The stdin family of 400 runs: 4 equal Node, 396 stop by name, 0 differ in silence, 0 hang; main: 3, 396, and the one control cell that hangs.
• Full round on 1c406f827c against the main it contains (a7783ba94c): type check passes. Lanes: plain 25,737 passed, 0 failed; sanitized 22,237 passed, 0 failed; both native bootstraps are among them, plain and sanitized. bench-runtime: 73 workloads, geomean -0.3%, 73 neutral. Test262 (Function, JSON, Proxy, Reflect, Object): 0 regressed, 0 gained. Timing: bench geomean -0.17% [-1.53%, +1.20%], compiler self-timing +0.55% [-0.29%, +1.05%], fixtures -0.36% [-1.42%, +0.81%]; the compiler builds its own source in 704 s in one lowering pass at 131 bytes per source byte (budget 136).
• That round's identity check failed, and the next commit is the fix. 297 stream programs that do not convert stdin differed in the executable only: two functions added in the middle of scr_stream.c made the C compiler lay the unit's other functions and string constants out in another order (equal file size, equal symbol names and sizes). The two functions now live in the stdin unit; scr_stream.c is main's file and scr_stream.o is byte-identical to main's in all 12 flavor objects.
• Gate-only round after the first merge (f6d05db1ac against main 6c1e5ac877): 5,724 programs identical, 173 allowed (below), 358 fail to build on both sides, none outside the list and no stream program among the rows; bench geomean +0.52% [-0.26%, +1.68%], compiler self-timing +0.30% [-0.37%, +1.13%], fixtures +0.69% [-0.77%, +2.16%]; self-compile 758 s, one pass, 131 bytes per source byte.
• Gate-only round after the second merge (cd0bd7c6db against main d3f840eb2e): 5,736 identical, 173 allowed, 358 fail on both sides, none outside the list; bench geomean +0.73% [+0.08%, +1.42%], compiler self-timing +0.55% [-0.19%, +1.23%], fixtures +0.15% [-1.03%, +0.92%], all within tolerance; self-compile 535 s, one pass, 130 bytes per source byte.
• After the third merge (ce3c3e0a04 against main 5d42c2b87c) the gate-only round was cut off by a restart of the machine that drives it, before its self-compile and timing lines: at that point 5,742 of 6,294 programs were identical, 358 failed on both sides and none differed outside the list. It was not repeated; the next round covers its tree.
• Gate-only round on 53e1c31e7e against main a57eaacffd: 5,748 programs identical, 173 allowed, 358 fail to build on both sides, none outside the list and no stream program among the rows; bench geomean +0.31% [-0.48%, +1.23%], compiler self-timing -0.26% [-0.90%, +0.27%], fixtures +0.47% [-0.69%, +1.07%]; self-compile 498 s, one pass, 130 bytes per source byte.
• Gate-only round on the withholding commit against main a57eaacffd (on its first form b8867c93a4; the pushed 83489c44ec differs from it in two test files only): 5,748 identical, 173 allowed, 358 fail on both sides, none outside the list and no executable-only row outside it; bench geomean +0.82% [-0.09%, +1.83%], compiler self-timing +0.59% [-0.05%, +1.17%], fixtures -0.35% [-1.22%, +1.63%], all within tolerance; self-compile 494 s, one pass, 130 bytes per source byte.
• The stdin cell family (400 runs per tree: 9 states of process.stdin before the hand-on, 11 consumers of the Readable, 4 inputs). On the pushed tree: 4 equal Node, 396 stop by name with main's TypeError, 0 differ in silence, 0 hang. Main: 3 equal Node, 396 stop by name, 1 hangs; the one cell that differs is a control without a conversion (a 'data' listener with descriptor 0 closed), which hangs on main and ends here. With the conversion, on 53e1c31e7e: 340 equal Node, 60 stop by name.
• The writable-state family (process.stdout and process.stderr; handed to a function typed Writable, stored in a typed field, or only a pipe / pipeline destination; 19 operations through one name; 11 writable-state properties read through both names; the reader holding a pipe, a file, or a pipe it closed early; 500 runs, each against Node, one source per cell in every tree). Main a57eaacffd against 83489c44ec: 103 refused by name to silent, 105 refused to equal, 202 refused on both, 52 silent on both, 28 equal on both, 10 stop by name at run time on both, 0 hang. Main against the pushed tree: 410 refused on both, 52 silent on both, 28 equal, 10 loud; all 256 rows are main's, verdict and text.
• The readable-state family (every readable-state property through both names: 22 programs of one read and 19 scenarios, with three lines piped in and with empty input). With the conversion, on 53e1c31e7e: 20 runs differ from Node with no diagnostic (see "Not in this train"). On the pushed tree: all 73 rows are main's, row by row (64 stop with the TypeError, 9 are refused at build time by name).
• On the pushed tree 83489c44ec: the build, lint, format, the ts7 baselines, the stdin tests plain and sanitized (44 passed and 18 skipped each; the skipped ones are the conversion's), and the cell families above. On its first form b8867c93a4, which has the same compiler and runtime source: the generated-file checks (regeneration changes nothing), 23 files of guard and unit tests (610 tests), the type mapper tests and the whole diagnostics suite (428).
• On 53e1c31e7e: the build, the generated-file checks (regeneration changes nothing), lint, format, the ts7 baselines, 23 files of guard and unit tests (610 tests: the stream layout test and the island value matrix, 239 of 239, among them), the type mapper tests, the whole diagnostics suite (428), the members' corpus programs and main's newest in both backends (984 cases), the same programs and the diagnostics with the type walk memo in verify mode (524 cases), the stdin tests plain and sanitized (48 of 48 each, on the runtime built with the hardening flags of Harden the vendored libraries and the runtime's stack #3442).
• On 1c406f827c, before the merges of main: island conformance in check mode (460 passed, 0 failed), order parity (153 of 153), the docs gate (25 route tests).
• The three program families of 5, 6 and 7 were measured on the head before the Proxy refusal was taken out and before the merges of main; none of those touches their rules.
• Probes on the earlier head c909fcd1a5 against the main it contains: the 13 fixtures site by site (above); 26 hand-written programs, each member's feature in a function the program never calls and in one it runs: every program main builds builds here with the same answer; the Proxy programs answer exactly as on main.
• A large third-party TypeScript program, unedited, on c909fcd1a5: this branch reports about three fifths as many lowering errors as main alone (main measured one merge earlier), no site that main does not report, and one site with the ?? wording of 7 where main refuses the same expression in its own words. On 1c406f827c it reports the same 18 sites.

Gate rows

178 programs are allowed by id, one reason per class:

• 149, executable only: programs that link the event dispatcher. IR and LLVM are identical; the one build of scr_events.c carries the stdin checks of 2, so scr_events_dispatch is resized: +0.07% to +0.33% of the executable. None is fully typed; the dynamic benchmark line-reader is among them. Seventeen of them are programs main gained while this branch was validated, the last two with Train cli 27: destructured parameters without a static type, Promise.all entries, held createRequire loader members, primitive constructors as values, generic instances that bind several layouts, the terminal color methods, one island round per statement #3456 (terminal-color-methods-piped.ts, +0.30%, and terminal-method-answers-collected.mjs, +0.27%); a later program that links the dispatcher joins the class until this merges. A stream program that does not convert stdin is byte-identical: none is in the list.
• 10, generic function identity: eight existing programs that use a generic function as a value (one interned closure initializer field differs), one new program, and generic-interface-type-arguments.ts, which main gained with Train lang 13: the arguments object, Object.assign key order, generic instances, function kind tags, rejections across views, a removeAllListeners use after free, untyped Map and Set in typed slots, global object names, typed records across unknown #3451 and which holds one generic function as a value at two signatures (the same row: one field, 64 bytes of 862,696).
• 9, unions whose members share a discriminant literal: four existing programs that declare such a union, and five new programs (one of them turned out identical).
• 6, dictionaries that keep identity: one existing program and five new ones.
• 3 new programs of the other members: union-dictionary-arm-untyped.ts, asserted-method-param-union-arm.ts, nullish-wider-default-keeps-left.ts. Main compiles the forms they pin differently or refuses them.
• 1, IR order only: unassigned-let-slot-kinds.ts differs in the order of one entry of the module's union table; its LLVM and its executable are byte-identical.

Not run

• macOS, Windows and iOS: CI's.
• On the pushed head 0e6a32a9c3 the lanes (plain and sanitized, with the native bootstraps), bench-runtime and Test262 did not run. They ran on 33d8ebd7d8, one merge earlier, and passed with 0 failed (round 20); the pushed head adds the merge of main 9a6d7290f2, which got the gate-only round and the test list above.
• The merge with what main gained after 9a6d7290f2 (Leave out code a constant condition never runs, and scan text through the UTF-16 units copy in more loops #3476, Train perf 9d: answer typeof, in and Reflect.has on a stream behind an untyped value without building its member view #3477, Re-record the two @hono/zod-validator island conformance entries #3478, Give the same IR with tsgo 7.1 as with tsc-ts #3479, Train perf 9e: answer Object.keys and own-key questions about a typed record from its static layout #3480, Train cli 28: var requires of island modules, Reflect.apply and Reflect.getPrototypeOf as values, Buffer.alloc and fill with untyped arguments, stream members through optional chains, builtin globals off a stored global object, optional-chain tails, chained JavaScript declarations #3463) ran nowhere but in CI's merge commit. It merges without a conflict. One place where the two sides can meet there, which CI's corpus programs only cover by chance: Train perf 9e: answer Object.keys and own-key questions about a typed record from its static layout #3480 answers Object.keys and own-key questions about a typed record from its static layout, and this train stores the members of a union that share a discriminant literal as one record, in which the members only some of them declare are optional slots.
• The island conformance lane and the docs gate were not rerun after the merges of main. The members' corpus programs were not rerun on the withholding commit: CI's lanes run them.
• tests/harness/coverage.test.ts's whole-corpus case exceeds its 600 s limit when the file runs alone and unsharded, on main as well (601 s on main, 600 s here, same 32-CPU sandbox); the lanes split it.

🤖 Generated with Claude Code

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated
scriptc	Ready	Preview, v0	Nov 9, 2026 1:30pm UTC

[cramforce]

The gate-only round on this head (c909fcd1a5) against the main it contains (6642a17b5f) has ended; the body said its timing lines would follow.

• Type check passes.
• Zero-cost gate: 5,662 programs identical, 166 allowed (the classes in the body), 328 fail to build on both sides, 2 executable-only rows outside the list as it was when the round started: 9753-file-handle-stream-signal.ts and 9754-fs-stream-signal-option-values.ts, programs main gained with its file-stream signal change. They link the event dispatcher and belong to the first class in the body (IR and LLVM identical, scr_events_dispatch resized, +0.07% each); the body's count of 142 includes them.
• Time: bench geomean +0.13% [-1.23%, +1.22%] and compiler self-timing +0.33% [-0.81%, +0.98%], both within tolerance. Fixtures geomean +0.50% [-1.35%, +2.46%]: the gate calls this interval inconclusive; the two earlier rounds measured +1.01% [-0.92%, +1.98%] and +0.68% [-1.15%, +1.64%], both within tolerance.
• Self-compile: the compiler builds its own source in one lowering pass at 131 bytes per source byte (budget 136), with Lowerer, LlEmitter and CopyScan out of the dynamic tier; its source costs the same compile time as main's source built by the same compiler (-0.0%, one pair), with +0.6% LLVM bytes and +0.7% functions for +0.4% source bytes. The wall time of that build was 716 s in this round's shard (511 s and 524 s in the two earlier rounds).

Not run on this head: the full lanes, both native bootstraps, bench-runtime and Test262. They ran on the head before the three merges of main and the two test-only commits (the body's "Full round"); the third merge resolved a conflict in the child launch check function, which this round and both sides' child-process tests cover.

[cramforce]

HOLD: do not merge yet.

The review bot left one finding on this train (packages/runtime/src/scr_stream_stdin.c:79): when process.stdin is paused before it is passed on as a Readable, async iteration of the converted stream never receives input, because its _read callback leaves the underlying stdin paused. A program that hangs where Node reads may not land: the finding is being reproduced under Node, on main and on this head. This hold is lifted here when it is fixed or shown not to apply.

🤖 Generated with Claude Code

[cramforce]

Held again: please do not merge yet. The review of 21:38 UTC on head 53e1c31 is right, reproduced: after process.stdin is handed on as a Readable, process.stdin.readableLength answers 0 while the shared stream holds unread bytes. Node answers the same number through both names.

Three lines piped in, read 300 ms later (process.stdin.readableLength / the Readable's readableLength):

cell	Node	main	this head
pause(), hand-on, 'readable' listener on the Readable	19 / 19	stops by name at the hand-on (TypeError)	0 / 19
hand-on, 'readable' listener on the Readable	19 / 19	the same TypeError	0 / 19
hand-on, 'readable' listener on process.stdin	19 / 19	the same TypeError	0 / 19
pause(), hand-on, one read(5)	14 / 14	the same TypeError	0 / 14

With empty input every runner prints 0 / 0. The cause is the one the review names: process.stdin.readableLength counts the stdin unit's own buffer, which the stream empties when it pulls. The 400-run cell family printed isPaused() and readableFlowing through both names and not readableLength, so it did not see this. The fix and its cells follow on this branch; the hold is lifted in a comment when they are pushed.

🤖 Generated with Claude Code

[cramforce]

On the review of 21:38 UTC (process.stdin.readableLength after the hand-on): the finding is right, and it is not cured here. The conversion is withheld instead (83489c44ec, pushed 22:21 UTC), so the program stops by name as on main.

The cells of the finding, three lines piped in, read 300 ms later (process.stdin.readableLength / the Readable's readableLength):

cell	Node	main	before (53e1c31e7e)	now (83489c44ec)
pause(), hand-on, 'readable' listener on the Readable	19 / 19	TypeError at the hand-on	0 / 19	TypeError at the hand-on
hand-on, 'readable' listener on the Readable	19 / 19	the same TypeError	0 / 19	the same TypeError
hand-on, 'readable' listener on process.stdin	19 / 19	the same TypeError	0 / 19	the same TypeError
pause(), hand-on, one read(5)	14 / 14	the same TypeError	0 / 14	the same TypeError

The TypeError is main's: Uncaught TypeError: expected Readable at $, got ProcessStream, exit status 1.

Why not the one-function fix. Before trusting it I printed every readable-state property the two names share through both names (readableLength, readable, readableEnded, readableFlowing, isPaused(), destroyed, readableHighWaterMark, readableEncoding, readableObjectMode, closed, errored), before and after a read, paused and not, at the end of the input: 22 programs of one read and 19 scenarios, each with three lines piped in and with empty input. On 53e1c31e7e, 20 runs differ from Node with no diagnostic, from five causes:

cause	runs	Node	53e1c31e7e
process.stdin.readableLength counts the stdin unit's buffer, which the stream empties (the finding)	7	19 or 14	0
process.stdin.destroy() does not destroy the stream	2	stream destroyed true, readable false	false, true
input held before a late hand-on is not in the stream	3	stream readableLength 19, read() hands it out, the stream ends	0, read() null, not ended 200 ms later
input from a file (/dev/null): the stream after the end	7	destroyed false, closed false	true, true
input from a file: right after stream.destroy()	1	closed false	true

Through the process.stdin name the other nine properties are refused at build time by name, on main as well.

Main stops every one of these programs at the hand-on, and a stop by name must not become a different answer. Three of the five causes need more than the helper (one is how the stream is created, one needs a ruling on listener order), so the conversion leaves this train and returns with all five cured and this family as its evidence.

Now, on 83489c44ec (row by row against main, same sandbox):

family	main	83489c44ec
the finding's cells (9 rows)	8 stop with the TypeError, 1 refused at build time	the same 9 rows
readable-state family (73 rows)	64 stop with the TypeError, 9 refused at build time	the same 73 rows
the train's stdin family (400 runs)	3 equal Node, 396 stop by name, 1 hangs	4 equal Node, 396 stop by name, 0 differ in silence, 0 hang

The one run that differs from main in the last row is a control without a hand-on (a 'data' listener with descriptor 0 closed): it hangs on main and ends here as in Node.

What the commit changes: processStreamAs no longer answers the stdin stream, so nothing emits the call that links scr_stream_stdin.c; the unit, its link feature and its fixtures stay in the tree. The conversion's differential cases and tests are skipped with Node's answers kept, one test pins the stop by name for the 14 fixtures that convert, and the limitations page says the conversion throws. process.stdout and process.stderr as a Writable are unchanged. A gate-only round against main a57eaacffd: 5,748 programs identical, 173 allowed, none outside the list (run on the commit's first form, which differs from the pushed one in two test files). The description is updated.

The hold of 21:46 UTC is lifted for this finding: the head no longer answers differently from main where process.stdin is passed as a Readable.

🤖 Generated with Claude Code

[cramforce]

Held again: please do not merge head 83489c4. The question left open in the last comment has an answer: process.stdout / process.stderr handed on as a Writable has the same two-names defect the stdin hand-on had.

A family of 500 runs, each against Node (stdout and stderr; handed to a function typed Writable, stored in a typed field, or only a pipe / pipeline destination; 19 operations through one name; the writable-state properties read through both names; the reader holding a pipe, a file, or a pipe it closed early). In its first run, 104 runs that main refuses at build by name (SC1090: 'WriteStream' values where 'Writable' is expected is not supported yet) build on this head and differ from Node with no diagnostic; no run hangs.

The clearest rows on this head:

• after stream.end(), process.stdout.write("late") is written and returns true (Node: write after end, nothing written);
• after stream.end() or stream.destroy() the stream stays ended, destroyed and closed (Node's stdio stream is writable again);
• with the reader gone, Node ends with EPIPE and status 1; the binary ends with status 0 and errored null.

The stopgap is the same as for stdin: the hand-on stops by name again, as on main. It is committed and in the sandbox checks now. One push follows; the full table against main comes with it, and the hold is lifted in a comment then.

🤖 Generated with Claude Code

[cramforce]

Pushed e5da0f4dc3 (one commit on 83489c44ec): process.stdout / process.stderr where stream.Writable is declared stops at the build by name again, as on main. Still held until the gate-only round on this head reports (about 23:15 UTC); I lift the hold in a comment then.

The writable-state family, 500 runs, each against Node, one source per cell in every tree (stdout and stderr; a function typed Writable, a typed field, or only a pipe / pipeline destination; 19 operations through one name; 11 writable-state properties read through both names; the reader holding a pipe, a file, or a pipe it closed early):

main a57eaacffd to the tree	83489c44ec	e5da0f4dc3
refused at build by name (SC1090) to differs from Node with no diagnostic	103	0
refused by name to equal to Node	105	0
refused by name on both	202	410
differs with no diagnostic on both (main's conversion, reached through another stream member)	52	52
equal to Node on both	28	28
stops by name at run time on both	10	10
hangs	0	0

On e5da0f4dc3 all 256 rows are main's, verdict and text. The 52 runs that are silent on main are main's and go to the cure train with the stdin causes.

Also on the pushed tree: build, lint, format and the ts7 baseline check pass; the project-config tests pass plain and sanitized (102, the fixture stdout-writable-parameter is now tested to stop by name); the event-loop tests pass plain and sanitized (44 passed, 18 skipped); the readableLength cells are main's in 9 of 9 rows and the readable-state cells in 73 of 73; the 400 cells read 396 loud / 4 same / 0 silent / 0 hang.

The diff is one clause out of needsGeneralNodeStreams in general-streams.ts, one sentence for two on the limitations page, and the test. The description is updated.

🤖 Generated with Claude Code

[cramforce]

Hold lifted for head e5da0f4dc3. The gate-only round on this head against main a57eaacffd passed: zero-cost gate: PASS — 5748 identical, 173 allowed, 358 both-fail, 21 changed-by-pr, the same counts as the round before the Writable stopgap; compile time within tolerance (bench +0.39%, self +0.23%, fixtures -0.03%).

With the rows in the comment above, both process-stream conversions are withheld on this head and stop by name as on main: process.stdin as a Readable (TypeError at the slot) and process.stdout / process.stderr as a Writable (SC1090 at the build). Their cure, one state behind both names, is a train of its own. CI on this head is running; I report on it when the Linux lanes are in.

🤖 Generated with Claude Code

[cramforce]

Merged main cf9b741144 into the train; the head is d57ec3e16c (a signed merge commit, fast-forward from e5da0f4dc3).

• The merge. One file conflicted, tests/harness/coverage.test.ts: both sides added a test at the same place, and both stay. Nineteen files that both sides change merged by themselves (the lowering and backend files among them); no generated file conflicted, and regeneration changes nothing.
• Gate-only round against cf9b741144: 5,776 programs identical, 174 allowed, 358 fail to build on both sides, none outside the list, no executable-only row outside it; bench -0.15% [-0.92%, +0.45%], self-timing +0.01% [-0.96%, +0.75%], fixtures +0.09% [-2.12%, +1.63%]. One id joined the list: generic-interface-type-arguments.ts, a program of Train lang 13: the arguments object, Object.assign key order, generic instances, function kind tags, rejections across views, a removeAllListeners use after free, untyped Map and Set in typed slots, global object names, typed records across unknown #3451 that holds a generic function as a value at two signatures. Its row is the row of the generic function identity member (one closure initializer field, 64 bytes).
• Where the two sides meet. Train lang 13: the arguments object, Object.assign key order, generic instances, function kind tags, rejections across views, a removeAllListeners use after free, untyped Map and Set in typed slots, global object names, typed records across unknown #3451 gives a generic function one instance per set of type arguments its signature hides; this train gives a generic function value one identity. A function demanded as a value at two hidden type arguments, compared and used as a Set member and a Map key, equals Node in 8 of 8 lines here and differs in 4 on main.
• The two withheld hand-ons are unchanged. Against current main in one sandbox: all 256 rows of the writable-state family, 9 of 9 readableLength cells and 73 of 73 readable-state rows are main's; the stdin family of 400 runs has 0 silent differences and 0 hangs.
• Main is red on Linux by itself, and this head inherits it: runtime-unit-references.test.ts and builtin-attributes.test.ts (both from Accept any ArrayBufferView in the fs write paths #3452), and three Effect fixtures (effect4 test-clock.ts and observability-otlp.ts, effect request-batching.ts). The first two fail on main's tree and on this one with the same text; none is in a file this train changes. The body has the list ("Red on main").

Main has since gained #3455 (four files, none of this train's, no conflict).

🤖 Generated with Claude Code

[cramforce]

CI on d57ec3e16c, read by cause from the job logs:

• Linux: four red jobs, two causes, both main's. Linux, plain, 13/20 and Linux, san, 13/20: tests/harness/runtime-unit-references.test.ts. Linux, plain, 9/20 and Linux, san, 9/20: packages/compiler/test/builtin-attributes.test.ts. One failed test in each job, nothing else. Main cf9b741144 fails the same two tests in the same four shards (they came with Accept any ArrayBufferView in the fs write paths #3452), and they fail on main's tree in a sandbox with the same text. Every other Linux job that has finished is green, Linux, san, native frontend checks among them.
• macOS: three causes, none this train's. 9811-node-island-load-reads-clock/main.cjs and the test of the same clock load in the two "LLVM artifacts, no clang" jobs; and Node itself aborting on 9444-process-stream-write-error.ts and 9445-process-stream-write-error-js.mjs (Assertion failed: (fd > STDERR_FILENO), function uv__close, under node, before any compiled binary runs).

So the branch has no conflict with main and no red of its own; it cannot be green on Linux until main is. Once main has the two tests fixed, I merge main again. That fix will edit the table of builtins that can throw, which this train also changes, so the merge gets the type check, the fast test list and a gate round of its own.

🤖 Generated with Claude Code

[cramforce]

Pushed 6ad5580db0: two merges of main on top of d57ec3e16c. The branch conflicted with main twice since the last push, both times in the generated IR codec.

The merges

• 20e05369a6 merges main 0424e4e684 (Train react 1: the immediate queue on a chain of immediates #3455, Train cli 27: destructured parameters without a static type, Promise.all entries, held createRequire loader members, primitive constructors as values, generic instances that bind several layouts, the terminal color methods, one island round per statement #3456, Decide the checked-data promise writes can throw, record their unit reference, and prove factory-made exports through namespaces #3457). Two files conflicted. narrowing.ts: both sides added a function at the same place, and both stay, no line of either changed. codec.generated.ts: regenerated from the merged sources.
• 6ad5580db0 merges main 6ae2f2d365 (Train perf 8a: a member question on an untyped value costs less, and a WeakMap or WeakSet releases the entries whose key is dead #3458, Keep build-time values out of island snapshots #3459). One file conflicted, codec.generated.ts: regenerated again.

Main has since gained #3461 (5bb6fb9617); it merges into this head without a conflict and touches no file this train changes.

Proof on 6ad5580db0 against main 6ae2f2d365

• Gate-only round: PASS. 5,800 programs identical, 176 allowed, 364 fail to build on both sides, no row outside the list, no executable-only row outside it. Self-compile 535 s, one pass, 130 bytes per source byte.
• Timing of that round: compiler self-timing +0.10% [-0.25%, +1.11%], within tolerance. Bench geomean +0.53% [-0.49%, +2.39%] and fixtures +1.82% [+0.26%, +3.14%] are reported as inconclusive, not as within tolerance. One merge earlier the same train commits measured -0.23% [-1.66%, +1.22%] and +0.48% [-0.21%, +1.45%], both within tolerance. A second round with twice the timing runs is running on this head; I will post its three lines here.
• Regeneration changes no generated file; the refusal registry, the codec, fields and node-compat checks, lint, format and the ts7 baselines pass.
• Tests: 23 files of guard and unit tests, 612 of 612 (main's two red tests are fixed by Decide the checked-data promise writes can throw, record their unit reference, and prove factory-made exports through namespaces #3457, so the "Red on main" section is gone from the description); type mapper 22; diagnostics 430; the members' corpus programs in both backends 984, in verify mode 524; main's 2 new programs 4, sanitized 2, verify mode 2 (and its 27 from the merge before: 56, 28, 28); stdin tests 44 passed and 18 skipped, plain and sanitized; node-types project tests sanitized 104; Node island suite 47.
• Cell families against main in the same sandbox: writable 256 of 256 rows are main's (500 runs: 410 refused, 36 silent, 44 equal, 10 loud, 0 hang, on both); readableLength 9 of 9; readable-state 73 of 73; the stdin family 396 stop by name, 4 equal Node, 0 silent, 0 hang (main: 396, 3, and the one control cell that hangs).
• The generic-function identity probe: 8 of 8 lines equal Node here; main still differs in 4.

The allow list grew by two, to 178. The first round on 20e05369a6 had two rows outside the list: terminal-color-methods-piped.ts (+0.30%) and terminal-method-answers-collected.mjs (+0.27%), which main gained with #3456. Both link the event dispatcher: IR and LLVM identical, scr_events_dispatch resized. That is the existing class of 147, now 149.

🤖 Generated with Claude Code

[cramforce]

The timing rerun promised above (round 17: the same head 6ad5580db0 against main 6ae2f2d365, twice the runs) is clean: all three lines are within tolerance, so the two "inconclusive" lines of the previous round were measurement.

validate train-pi-1b @ 6ad5580db0 vs 6ae2f2d36: PASS in 41.5m
time       bench geomean +0.36% [95% CI -0.27%, +1.10%]: within tolerance
time       self +0.38% [95% CI +0.03%, +1.35%]: within tolerance
time       fixtures geomean +0.58% [95% CI -0.18%, +1.04%]: within tolerance
zero-cost gate: PASS — 5800 identical, 176 allowed, 364 both-fail, 21 changed-by-pr over 8 shards

CI on this head, by cause: test (Linux, plain, 17/20), test (Linux, san, 5/20) and test (TypeScript 7 parity) fail on the ts7 preflight baseline of tests/corpus/9812-node-island-load-reads-zone-locale/main.cjs, which was red on main itself and is cured there by #3464; test (Linux, san, native frontend programs) lost its runner ("The runner has received a shutdown signal").

Main has since moved to 44f9f34d6b (#3462, TypeScript 7.1) and this branch now conflicts with it in packages/compiler/src/frontend/lowering/class-protocols.ts and tests/harness/__snapshots__/child-process.ts.txt. The merge of main is next; it is pushed only after the gate round on the merged tree.

🤖 Generated with Claude Code

[cramforce]

Pushed 0e6a32a9c3: five merges of main on top of 6ad5580db0, no train commit added. The head holds main 9a6d7290f2. Main was b4e908ef00 at the push; that delta merges without a conflict and is CI's to run (last section).

The merges since the last pushed head

• dd8031f5b4 = main 44f9f34d6b (The receiver proof no longer follows a call that redefines call or apply #3461, Re-record the ts7 preflight baseline of 9812-node-island-load-reads-zone-locale #3464, Move TypeScript 7 support to TypeScript 7.1 #3462 TypeScript 7.1). Two hand-written files conflicted. class-protocols.ts: both sides added an import at the same line, and both stay. tests/harness/__snapshots__/child-process.ts.txt: re-recorded by its test on the merged tree; it is this train's file with 7.1's type text in its first line.
• 067bd10eed = main 7569a9ca6b (Arenas no longer drop objects kept reachable through virtual calls, generators, library callbacks or callback-made cycles #3466, Name the fields of the entry a layout-mode property copy builds #3467). No conflict, no file in common.
• 859d769484 = main 8152700b48 (Answer a literal right operand of &&, || and ?? as it was built #3469). No textual conflict, one line changed by hand: both sides change lowerNullishPair. Main lowers the default of a ?? b once and replaced every later lowering of it in that function with lowerDefault(); this train adds one more place that lowers the default, which main could not see, and that place now calls lowerDefault() too. A probe of the two rules together: 7 of 7 lines equal Node here and on main.
• 33d8ebd7d8 = main e0d43347aa (Keep one object when an untyped value meets a typed record slot, and read typed arrays through untyped values from the array itself #3465, Keep types that carry the collector header only for the weak analysis out of the collector #3470, Run the sanitized native-frontend builds on two of the runner's cores #3472). The generated codec.generated.ts conflicted and was regenerated from the merged sources.
• 0e6a32a9c3 = main 9a6d7290f2 (Fix the macOS process.hrtime clock and make the three macOS-failing corpus tests deterministic #3471, Keep one descriptor per source file in the TypeScript 7.1 symbol table #3473, Read a shared module's var export only after its declaration ran, evaluate a dynamic import before a member read, and read package data members through a copy #3474). No conflict, no hand change. Three files are both sides' and both sides' hunks were read: lower-stdlib.ts and type-mapper.ts are independent; in lower-calls.ts both change lowerOrdinaryCall in different branches (main: a member call off a dynamic import; this train: the call of an optional callable of a record union). A probe of the calls both branches look at: 18 of 18 lines equal Node here and on main.

On the pushed head 0e6a32a9c3 against main 9a6d7290f2

validate train-pi-1b @ 0e6a32a9c3 vs 9a6d7290f: PASS in 84.6m   (gate-only: lanes, bench-runtime, Test262 skipped)
PASS  typecheck
PASS  zero-cost gate
      time       bench geomean +0.44% [95% CI -0.29%, +1.32%]: within tolerance
      time       self +1.37% [95% CI +0.57%, +2.20%]: inconclusive (rerun with more runs)
      time       fixtures geomean +0.39% [95% CI +0.29%, +1.06%]: within tolerance
      listed     178 programs in --allow-programs: 177 differ, 1 identical
      zero-cost gate: PASS — 5814 identical, 176 allowed, 367 both-fail, 21 changed-by-pr over 8 shards

• No row outside the list of 178 ids, none executable-only outside it, and no id joins the list. The three more programs that fail on both sides are main's new Node island programs (the gate builds without the Node pack; the tests below run them with it).
• The self-timing line is inconclusive in this round (two runs). The full round one merge earlier measured +0.64% [-0.12%, +0.88%] with the same train commits. Self-compile: 548 s, one pass, 135 bytes per source byte (budget 136).
• Tests in a sandbox with main built beside it: regeneration changes no generated file; lint, format, ts7 baselines; the whole order-parity suite as recorded, 354 of 354; guard and unit tests 614 of 614; type mapper 22; diagnostics 429; the members' corpus programs in both backends 986, in verify mode 525; main's 4 new and 3 changed programs 14, sanitized 7, verify mode 7; stdin tests 44 passed and 18 skipped, plain and sanitized; node-types project tests sanitized 104; Node island suite 47.
• Cell families against main: writable 256 of 256 rows are main's; readableLength 9 of 9; readable-state 73 of 73; the stdin family 396 stop by name, 4 equal Node, 0 silent, 0 hang (main: 396, 3, and the one control cell that hangs).

The full rounds, on the heads before

• 33d8ebd7d8 against main e0d43347aa (round 20, one merge before the pushed head): PASS in 79.1m. Lanes: plain 26,296 passed, 0 failed; sanitized 22,599 passed, 0 failed; both native bootstraps. Gate: 5,813 identical, 176 allowed, 364 fail on both sides, none outside the list. Timing within tolerance on all three lines. bench-runtime: 75 workloads, geomean +0.5%, 74 neutral, 1 slower: value-records +11.4% [+2.7%, +37.1%] on an executable that is byte-identical to main's in the same round's gate, so the mark is measurement (the two rounds before had it neutral). Test262: 0 regressed.
• 859d769484 against main 8152700b48 (round 19): passes, lanes 0 failed plain and sanitized, gate with none outside the list, bench-runtime 75 neutral, Test262 0 regressed. Its self-timing line was inconclusive (+0.79% [+0.21%, +2.02%]).
• dd8031f5b4 against main 44f9f34d6b (round 18): gate, bench-runtime and Test262 pass; the round's verdict is FAIL for three time-outs in the lanes, which I do not read as this train's. self-hosting-serialization.test.ts "llvm round-trips IR and produces a working program" hit its 300 s limit (plain): alone it takes 120 s on this tree and 117 s on main's. commander-calc hit its 120 s limit in npm.test.ts and in npm-shape-overlay.test.ts (sanitized, one shard): alone and from a cold cache 96.5 s here, 96.6 s and 93.8 s on main's, of which 85 to 87 s are the sanitized link. Rounds 19 and 20 have them green.

Not rerun on the pushed head, and what CI proves

• The lanes, bench-runtime and Test262 ran on 33d8ebd7d8, not on 0e6a32a9c3. The difference between the two is the merge of main 9a6d7290f2.
• Main's commits after 9a6d7290f2 (Leave out code a constant condition never runs, and scan text through the UTF-16 units copy in more loops #3476, Train perf 9d: answer typeof, in and Reflect.has on a stream behind an untyped value without building its member view #3477, Re-record the two @hono/zod-validator island conformance entries #3478, Give the same IR with tsgo 7.1 as with tsc-ts #3479, Train perf 9e: answer Object.keys and own-key questions about a typed record from its static layout #3480, Train cli 28: var requires of island modules, Reflect.apply and Reflect.getPrototypeOf as values, Buffer.alloc and fill with untyped arguments, stream members through optional chains, builtin globals off a stored global object, optional-chain tails, chained JavaScript declarations #3463) are merged by CI's merge commit only. git merge-tree is clean; nine files are both sides' and no hunk of main's lies in a region this train changes. One place the two sides can meet there: Train perf 9e: answer Object.keys and own-key questions about a typed record from its static layout #3480 answers Object.keys and own-key questions about a typed record from its static layout, and this train stores the members of a union that share a discriminant literal as one record with optional slots. Probed on a trial merge of this head with main b4e908ef00 (not committed, not pushed), built in a sandbox beside that main: the merged tree builds (type check), and a program that asks Train perf 9e: answer Object.keys and own-key questions about a typed record from its static layout #3480's questions (a key list used by length and by compared names, the three lists' lengths, the prototype) about values held under a member's type, written in the declared order and in another, a larger member held under the smaller member's type, the same through the union and back, and values whose type only has a member's layout, prints 18 of 18 lines as Node on the trial merge and on the pushed head. Main alone differs in 3 of them, with its copy and key-order warnings. The call probe above also prints 18 of 18 on the trial merge. The rest of the test list is running on the trial merge; I will add a line here only if it shows something.

🤖 Generated with Claude Code

[cramforce]

CI on 0e6a32a9c3 (run 42626021764, the merge with main b4e908ef00), read by cause from the job logs: 82 passed, 7 skipped, 2 failed. The two are one failure, and it is not this train's.

• test (macOS, san, darwin 1/3) (and the aggregate test, which fails with it) fails on one test: tests/harness/terminal-geometry.test.ts > getColorDepth and hasColors on terminal streams answer as Node does for every environment rule. The answers on stdout are equal; the native run's stderr holds one more line than Node's, written by Apple's sanitizer allocator before the program starts: malloc: nano zone abandoned due to inability to reserve vm space.
• Why it is main's. The test file is main's own: it is byte-identical on this head and on main b4e908ef00. Its first two tests run the native binary with MallocNanoZone=0 on the darwin sanitized lane for exactly this line (the comment at line 30); the third test, which came with the terminal colour methods (ba9dc56f15), passes its own environments and does not. The same job fails on the same test with the same one extra line on Find a promise again as the key of an untyped Map or Set #3483's run (42628626454), a change to promise keys of Map that touches no stream code.
• No main run to name. Main's own push runs skip the macOS jobs (the latest completed one, 42629902640 on 21213e5fde, is green with them skipped), so the comparison is the other pull request's run, not a run of main.
• Everything else that ran passed: the 40 Linux lanes (20 plain, 20 sanitized), the two Effect lanes of this run, test (TypeScript 7 parity), both tsgo and tsc-ts give the same IR jobs, and the 13 other macOS jobs. Skipped on this run, so not proven by it: the Node island conformance lanes, the native bootstrap jobs, the shape overlay jobs and the thread sanitizer.

Nothing is pushed for this; the cure is one environment entry in that test, outside this train.

🤖 Generated with Claude Code