Skip to content

AOT: replace the flow passes and the B3 back end with a scan, a link and one walk - #997

Merged
Jarred-Sumner merged 53 commits into
mainfrom
claude/one-walk
Nov 7, 2026
Merged

Jarred-Sumner merged 53 commits into
mainfrom
claude/one-walk

Conversation

@Jarred-Sumner

@Jarred-Sumner Jarred-Sumner commented Nov 4, 2026 •

Copy link
Copy Markdown
Collaborator

What this does

Rewrites the middle of the ahead-of-time compiler so that builds are fast.

The compiler on main runs a whole-program flow analysis to a fixpoint, dozens of passes over each function, and B3 and Air for code generation. On large programs that is minutes of CPU time. This PR replaces those three with:

Folder What it is
aot/facts/ One scan of each function, then Link: types, callees and layouts carried through the whole program once, on several threads
aot/plan/ Slots, layouts and calling conventions, decided from what Link found
aot/walk/ One walk over each function that types, folds, inlines and selects operations as it goes
aot/machine/ A small back end with its own register allocator and encoder. Compiled code no longer goes through B3 or Air

ir/, codegen/, stubs/, runtime/, object/, image/ and builtins/ are kept, and changed where they met the old middle. What changes outside aot/ has a section of its own below: it is more than hooks, and most of it is not under #if ENABLE(AOT).

Numbers

The TypeScript compiler, built from its typed sources, type-checking a project.

main This PR
Build, instructions retired (November 4) 543 G 55 G
Code (November 4) 19.7 MB 13.3 MB
Run, instructions retired, one core (d07fb695) 26.0 G 28.9 G
Run, wall time (d07fb695) 4.39 s 5.11 s
Peak RSS of the run (d07fb695) 939 MB 923 MB

The three rows of the run are from one sitting on November 5, six runs of each in turns. The run's instruction counts are not comparable with the ones that stood here before (23.2 G and 31.5 G): the benchmark's setup has changed since.

So builds are about ten times cheaper and the code is smaller, but the output still retires about 11% more instructions and takes about 16% longer on this benchmark. Closing that is what is being worked on.

What changes outside aot/

An earlier form of this description said that the changes outside aot/ are hooks, "all under #if ENABLE(AOT), plus two small fixes in runtime/". That was false. A reading of every hunk from main (b83d8a12) to bf18bbfc, behind which nothing outside aot/ has changed, 131 files and 539 hunks outside aot/, nothing built or run for it, counts: 153 hunks take out code of the previous compiler (84 of them something that a program that is not compiled ran on main), 136 add what only a build or a process with compiled code reaches, 93 are comments, declarations and tests, and 157 change code that a plain bun file.js passes through. Of the 335 hunks that add code, 254 add it outside any #if ENABLE(AOT): 1,785 of 2,101 added lines. Those lines are kept from a plain program by a test at run time (the assembler's policy, a null pointer, vm.hasCompiledCode()), not by the preprocessor, and are compiled into a build with ENABLE_AOT=0 too.

Folder Added lines under #if ENABLE(AOT) Outside it What it is, and why
assembler 0 805 Part of the new back end. X86JumpShortening.h is rewritten; both macro assemblers get three kinds of relocation, nine emitters for accesses to "the instance" that can be patched, and on ARM64 a way to rewrite such an access whose distance does not fit. Code for an executable may hold no address of the process that builds it. Only the compiler and testmasm call these, but seven emitters that the x86-64 JIT calls got a second arm, and X86Assembler itself changes (below)
wasm 3 642 WebAssembly ahead of time moves from OMG to BBQ. The previous compiler made a module's code for an executable with the optimizing tier, through B3; the new one does not use B3. That second mode goes out of WasmOMGIRGenerator.cpp (41 hunks) and a new one is written into BBQ, the baseline WebAssembly JIT that every program with WebAssembly compiles through (WasmBBQJIT.cpp, WasmBBQJIT64.cpp, .h: 62 hunks), the stub that calls JavaScript imports (WasmToJS.cpp, 14) and three thunks. The switch is a pointer, m_codeForImage, or the assembler's policy, tested while code is emitted
ffi 11 169 A feature: the pool of JSCallback entries of an executable grows, where main had a fixed number: the entry code is mapped again for each block (mach_vm_remap; mmap of the executable file, or anonymous memory and mprotect; VirtualAlloc and VirtualProtect). Reached only where an image was found; it is new code that makes memory executable
runtime 247 151 Hooks, and the tests listed below
heap, interpreter, yarr 14 18 Hooks, and the tests listed below
llint (C++) 41 0 29 of its 40 hunks are LowLevelInterpreterAOT.asm, included only if AOT, its handlers installed only where Options::runsCompiledImage()

Source/bmalloc is main's since bf18bbfc. CMakeLists.txt, Sources.txt, Source/cmake, JSTests, LayoutTests and PerformanceTests do not change. One line of .github/workflows/ci.yml is the number of the compiler's own tests that are expected to be left out (33 becomes 19).

What a program that is not compiled sees otherwise

This PR is to change nothing for a program that is not compiled ahead of time. It still does. By that reading no answer of such a program changes but in the first three items; "the emitted code is the same" is by reading everywhere: no bytes were compared. The lines are the head's.

Answers:

  • runtime/StringPrototypeInlines.h:962: String.prototype.replace() and replaceAll() with a function answer otherwise in one rare case on long texts.
  • runtime/OptionsList.h:156: seven BUN_JSC_ options of the previous compiler are gone (useNarrowReferenceScan, validateAOTRuntime, freeAOTFlowSetsEveryRound, dumpAOTIR, dumpAOTB3Graph, dumpAOTDisassembly, aotFunctionToDump) and verifyAOTMachineCode is new. JavaScriptCore refuses an option that it does not know. No default of another option changes.
  • runtime/StackManager.cpp:92, runtime/VMTraps.cpp:572: forceTrapAwareStackChecks, a testing option, is acted on in another place. Without the option: one load and branch for each setStackSoftLimit().

WebAssembly (89 hunks, none under #if ENABLE(AOT)):

  • wasm/WasmBBQJIT.cpp, WasmBBQJIT64.cpp, WasmBBQJIT.h (62 hunks): the second mode. A plain module pays a test for each construct while a function is compiled, nothing at run time. A slip here would be a silent miscompilation of plain WebAssembly: a comparison of BBQ's code with main's over a corpus has not been made.
  • wasm/WasmThunks.cpp:49, :59, :285: the thunk that every WebAssembly trap goes through is emitted otherwise, by a few bytes: the one place where the machine code of a plain program is known to differ.
  • wasm/WasmBinding.cpp:44, wasm/WasmIRGeneratorHelpers.h:148, :165, :258, :326, :343: one test of the assembler's policy for each call that is emitted.
  • wasm/js/WasmToJS.cpp (14 hunks): tests while the stub that calls a JavaScript import is emitted; one label in a disassembly dump changes.
  • wasm/WasmCalleeGroup.cpp:68, :156, wasm/WasmCodeInImage.cpp:204, wasm/js/JSWebAssemblyInstance.cpp:279: a plain module pays one lookup less than on main, a plain instance one call and test more for each JavaScript import.
  • interpreter/Interpreter.cpp:1272: one load of an option and a branch for each WebAssembly exception that JIT code catches.

The x86-64 JIT (9 hunks, none under #if ENABLE(AOT)):

  • assembler/MacroAssemblerX86_64.h:1339, :1364, :9166, :9202, :9240, :9264, :9486: negateDouble, negateFloat and five vector conversions test the policy each time the JIT emits one.
  • assembler/X86Assembler.h:6669: linkJump(), called for every jump that is linked inside a buffer, is written otherwise.
  • assembler/X86Assembler.h:7825: each MacroAssembler is about 24 bytes larger and has one more Vector to make and destroy.

Objects and properties:

  • runtime/JSObjectInlines.h:286, :329: getNonIndexPropertySlot(), the generic lookup, has a new arm. Until bbf91047 it stood under no #if and cost a call of 10 instructions at each lookup that goes on past an object whose class overrides getPrototype (the global proxy): counted, 20.0 M over 2,000,000 lookups, in jsc and in bun. At the head it stands under #if ENABLE(AOT) behind vm.hasCompiledCode(): such a lookup tests one byte of the VM, and the helper lies out of line in aot/object/AOTPropertyWalk.cpp. What stays, counted against a build without the arm: 2 to 4 instructions at every lookup that no cache holds and that starts at or reaches an object that answers for its own properties (an array, a function, a proxy, the global object), because the arm keeps the object at which the search began alive through the loop. Lookups that a cache holds and chains of plain objects pay nothing. That part is not fixed at the head.
  • runtime/JSObjectInlines.h:632, :679, :742: putDirectInternal(): one load and branch for each store that replaces a property outside an inline cache.
  • runtime/JSObjectInlines.h:1108, :1135: definePrivateField() has one more parameter.
  • runtime/CommonSlowPathsInlines.h:271: o[k] = v inside for (k in o): one test of a bit for each store, in the interpreter and Baseline; under no #if.
  • runtime/ObjectConstructor.cpp:285, :339, :419, :440: the generic road of Object.assign() has one more argument.
  • runtime/Lookup.cpp:70: one test the first time a static function property is read.
  • runtime/ReflectObject.cpp:323: one test for each Reflect.setPrototypeOf().
  • runtime/ProgramExecutable.cpp:71: the same test of a bit as on main, by another name, for each global that a script declares.

Modules:

  • runtime/JSModuleLoader.cpp:425, :764, :867, :1116, :1174, :1220, :1344, :1412, :1427, runtime/JSMicrotask.cpp:1223, :1275, :1654: each import edge of an ES module passes about eight more tests; three of the places are under no #if. The two ASSERTs on the plain loader (JSModuleLoader.cpp:1174) that this branch had deleted stand again at the head for every program without compiled code.
  • runtime/ModuleGraphLoadingState.h:135, ModuleGraphLoadingState.cpp:64: a module allocates 16 bytes more while it loads (m_wholeLoad: 208 to 224 bytes).
  • runtime/CyclicModuleRecord.cpp:903: one scope object more in asyncExecutionFulfilled().

Built-in functions:

  • runtime/JSONObject.cpp:3094: one load and branch for each JSON.stringify() that a fast path answers. :3364: one test of a bit for each property that a reviver of JSON.parse() gets; under no #if. :886, :1054, :2998: the depth limit of the fast stringifier is held otherwise. :3459, :3499: the same one test in JSON.parse(), written in line.
  • runtime/JSMicrotask.cpp:330, :357, :615: each step of a for await that drives an async generator passes one or two tests more.
  • runtime/StringConstructor.cpp:126: one test for each call of String.fromCodePoint(); under no #if.
  • runtime/ArrayConstructor.cpp:807, :882: Array.from() without a map function: its body moves into an inline function, and one test more where no fast path matches.
  • runtime/RegExpConstructor.cpp:201, runtime/RegExpGlobalData.cpp:44, :77, :98: RegExp.input, $1 to $9 and their kin: one test as before, through another function.
  • runtime/ErrorInstance.cpp:289: an error whose top frame has no CodeBlock asks twice, not once, whether the process has compiled code.
  • runtime/ResourceExhaustion.cpp:38: one call on the way to a crash for lack of memory.

The interpreter and the heap:

  • llint/LLIntSlowPaths.cpp:382: a relaxed load of a global and a branch each time the interpreter asks whether to compile a function. llint/LLIntEntrypoint.cpp:265: three tests for each CodeBlock, as before, in another order.
  • heap/Collector.cpp:571: one relaxed load and branch for each collection. heap/FastMallocAlignedMemoryAllocator.cpp:341: one for each new block of cells.
  • shell/CMakeLists.txt:153: on macOS with a sanitizer jsc, testFFI and testaot are linked with -dead_strip; not the libraries that Bun links.

Linkage: 14 host functions lose static so that the compiler can name them (ArrayPrototype.cpp, StringPrototype.cpp, MapPrototype.cpp, SetPrototype.cpp, MathObject.cpp, ObjectPrototype.cpp, RegExpPrototype.cpp).

What such a program no longer pays (84 hunks): hooks of the previous compiler that it ran on main: a test on every call and every new of a native function from C++ (interpreter/Interpreter.cpp:1900, :1979); after every getter called from C++ and every custom getter (runtime/GetterSetter.cpp:60, runtime/PropertySlot.cpp:48); at every Structure made, 11 places (runtime/Structure.cpp); in LocalAllocator::stopAllocating() and allocateSlowCase(); for each bound function, each Error, each createSubclassStructure(); two tests for each object in the general JSON.stringify(); in slow_path_put_by_id; a scope object at the end of every collection and for each plain object in a heap snapshot; a call at the start of every B3 and Air phase of every FTL and OMG compile; the previous compiler's second mode in OMG (41 hunks, which was under no #if either); a store and two tests for each start and stop of an automatic thread (WTF/wtf/AutomaticThread.cpp).

Counted. Four of these roads cost other numbers of instructions until f87bb065, and c563e0de brought the numbers back; the code is not main's: three of the four still bear a new test (runtime/JSObjectInlines.h:679 and :742, runtime/StringConstructor.cpp:126, runtime/JSONObject.cpp:3364). Counted with CI's published jsc (the Linux x64 LTO lane) of main (b83d8a12), of this PR at 2e069424 and at c563e0de, in M user instructions, the answers the same in every run; a neutral program reads 1,367.7 on main's and on c563e0de's. A loop that stores into a prototype, without the JIT: 535.5 on main, 1,432.3 at 2e069424, 535.5 at c563e0de; with the JIT 114.3 and 114.3. String.fromCodePoint called by value: 1,867.4, 1,381.9, 1,867.4; with the JIT 60.4 and 60.4. JSON.parse() with a reviver over nested objects: 2,059.6 and 2,074.3 on main in two runs, about 2,431 at 2e069424, 2,054.6 and 2,068.8 at c563e0de; with the JIT 1,768.4 and 1,764.1 beside 1,767.5 and 1,769.8. One is not level yet: lookups of properties that no cache holds, half of them through a proxy: 2,813.1 on main, 2,826.1 at 2e069424, 2,819.1 at c563e0de (+0.21%, about 1.5 instructions a lookup); with the JIT 1,678.8, 1,693.8, 1,680.8 (+0.12%). Where those lie is found: the new arm of getNonIndexPropertySlot() (runtime/JSObjectInlines.h:329); its numbers stand under "Objects and properties".

Left behind: compiled code no longer goes through B3 or Air, yet this PR deletes 8 lines of b3/: what served the previous compiler alone there (B3RelocatableValue.*, B3LowerRelocatableValues.*, B3RelocationLowering.h, Procedure::setSubjectOfClient(), B3::Policy) has no caller outside b3/ and its tests any more and is not deleted here. So FastStringifier::startBelow() and the levelsAround parameter of five functions in runtime/JSONObject.cpp, and JSArray::validatePristine().

State

  • Merged: 42067fce on main, squashed; its tree is the tree of the head 3c42aae2 to the byte. CI at 3c42aae2: 85 checks pass, none fails. One test of about 125,000 failed at the first run and passed when its job was run again: stress/intl-datetimeformat-language-change-mid-construction.js.default on the arm64 lto-hardened lane, which has no AOT in it: an exception, no signal: "cacheable resolution pinned at de-DE across 25 turns". It is upstream's own test, on timing; the file is main's byte for byte, and this PR changes no file of runtime/Intl*, wtf/Language* or VMEntryScope*. Not looked into further. With 3c42aae2, outside aot/ two files change, both toward main's text: runtime/JSObjectInlines.h (+3 -16) and runtime/JSModuleLoader.cpp (+2), see "Objects and properties" and the loader's item above.
    • New with bbf91047, found before Bun pinned it: the block of thread-local storage that every thread of bun pays for grew from 23,488 to 23,664 bytes, past the 23 KiB that test/aot/static-tls-size.test.ts in Bun's tree holds it to: four thread-local pointers had become objects with guards. Each is one pointer again; at its first use on a thread it hands a function to one list of the thread, whose destructor runs them from the youngest (aot/support/AOTThreads.cpp, AOTEndOfThread.h, aot/walk/AOTSharedArray.h, aot/runtime/AOTPoisonedCell.cpp, +68 -13). The bound is not moved. By readelf -lW, Linux x64, release: 23,488 at bf18bbfc, 23,664 at bbf91047, 23,504 here. Under ASAN and assertions test/aot/no-leak-records-at-exit.test.ts stays at 6 pass.
  • bbf91047: nothing outside aot/ changes.
    • Red in Bun's CI under ASAN since bf18bbfc: test/aot/no-leak-records-at-exit.test.ts, 2 cases pass and 4 fail: leak records of 56 bytes at the end of a build and of 80 bytes at the end of an executable. The records are older: the 13 lines of bmalloc that bf18bbfc took out had kept them from the leak sanitizer's sight. What a thread makes for itself on first use goes with the thread, and a private name of the engine is no longer leaked on purpose (aot/walk/AOTSharedArray.h, aot/runtime/AOTProgramIdentifiers.cpp, aot/runtime/AOTPoisonedCell.cpp, +26 -20). On two builds with ASAN and assertions, Linux x64: 2 pass and 4 fail at bf18bbfc, 6 pass here.
  • bf18bbfc: outside aot/ two files of bmalloc go back to main's text.
    • Back to main's text: Source/bmalloc/bmalloc/Environment.cpp, SystemHeap.cpp: the 13 lines that 16f838b3 added go. With them a build with AddressSanitizer took the system's allocator without Malloc=1 in the environment. Such a build is slower, also for a program that is not compiled; in Bun's CI vendor/elysia/test/response/stream.test.ts, which races a timer of 5 ms, failed under ASAN on every build of this branch. Whether it passes without the lines was not run: CI is the judge. A run that wants the sanitizer to see the engine's heap sets Malloc=1, as on main.
    • Silent, and one executable that does not end: fake timers in an executable: const { jest } = Bun.jest(); jest.useFakeTimers(); let fired = 0; setTimeout(() => fired++, 1000).unref(); jest.advanceTimersByTime(1000); console.log(fired, jest.getTimerCount()); printed 0 0 where bun <file> prints 1 0; an executable whose interval turns the fake timers off in its first tick did not end. Test runs were right (aot/facts/AOTLinkTestRuns.cpp, AOTLinkReach.cpp, +6 -8; 5 stored programs: 4 print otherwise and 1 does not end at dacd2d81, 5 pass here).
    • Silent, test runs with module mocks: two files hold export * to a mocked ES file and one of them was loaded in front of the mock: the namespace of the other read both=undefined,kept=10 where bun test reads both=file,kept=10 (aot/runtime/AOTModules.cpp, +12 -11; 4 stored test runs: 3 fail at dacd2d81, 4 pass here).
    • A right program ended with exit 134, The built-in function 'throw' was left out of the executable: an async generator that relays a sync one by yield* and is resumed by a throw that nobody writes, as by await stream.return(Promise.reject("late")) (aot/facts/AOTScan.cpp, +2; 13 stored programs: 2 end so at dacd2d81, 13 pass here; 23 more of another hand: 6 and 23).
    • New with 42121540, slower, no answer wrong: a const of a file that is read in a loop of a function of the same file stayed in every turn. It leaves the loops that the frame itself opened; in a loop of another frame, where the crash that 42121540 fixed came from, that commit's asking stays (aot/walk/, aot/ir/schema/statistics.def, +26 -5). No time was measured on this tree. The two programs of that crash and 24 more answer as bun <file>.
    • What is foreseen of the texts of regular expressions in one file hung on the files beside it by three more roads (aot/facts/AOTFactsRegExpTexts.cpp, +8 -1).
  • dacd2d81: nothing outside aot/ changes with it.
    • Taken back: the engine's half of a fix that e75efb3b had (below): it let go of too much and alone turned three test files of Bun's tree red (the third, test/aot/subclasses-of-collections-stay-tracked.test.ts, was seen in CI: 6 pass at bd8bd487, 5 pass and 1 fails at e75efb3b: Map.prototype.set escapes where a subclass of Map overrides set). The six files of aot/facts are as at bd8bd487 again, but for one line. All three pass again (25, 14 and 6 cases). This commit does not fix the crash. Its fix goes by another road, in Bun's front end, which is not pushed; the engine's share is that one line. On a build with that half: 30 stored programs: 22 fail and 8 pass at e75efb3b, 30 pass; 17 of them, each built alone: 10 end with exit 134 and 2 throw there, 17 answer as bun <file> here.
    • Silent: a direct eval in a method of a class whose text is evaluated more than once told private names apart by their spelling alone: function make() { return class { #m() {} has(o) { return eval("#m in o"); } }; }, asked of an instance of the class that another call of make() gave: bun <file> answers false, the executable answered true; so a private field or accessor of the other class was read, and its method run, where bun <file> throws a TypeError (nine files, +133 -9; 13 stored programs: 10 fail and 3 pass at e75efb3b, 13 pass here).
    • Silent: a key that is deleted by the number 4294967295, one past the greatest index and so a name: a key added behind it took its place in the order of the keys (aot/object/AOTObjectMethodTable.cpp, +2; 3 stored programs).
    • The build of a right program stopped with "the walk is over and an edge is open": a generator that one for .. of alone consumes, with a yield under a finally in a loop, under a finally with a break, in a loop (aot/walk/AOTWalkGeneratorsInLoops.cpp, +10 -2; 2 stored programs).
    • A build could hang on a program that lays a built-in function where the engine calls it: more forms (7 stored programs: 4 fail at e75efb3b, by their limits of time, 7 pass here).
    • The text of a message: a call that fails in the value of a field of a class was quoted at the constructor, not where it stands (In 'callee()' for In 'callee(a, b)'; below a parent class super is not a function). Found by the review on Bun's PR.
  • e75efb3b: nothing outside aot/ changes with it.
    • Silent: a wrong value was stored: a whole number that is boxed as a fraction, stored into a list of whole numbers behind a comparison that says that the number is whole: const parsed = JSON.parse("[0.5,1,2,3,4]"); parsed.push("text"); function fill(list, value) { switch (value) { case 3: for (let i = 0; i < list.length; i++) list[i] = value; } return list; } const list = fill([9, 9, 9, 9, 9, 9, 9].slice(), parsed[3]);: a loop read 3 out of the list; list.join() and JSON.stringify(list) said 0, list.indexOf(3) -1, list.includes(3) false. The store laid the box as it came; what came in a box goes in the form of its type now (aot/codegen/AOTArrayIntrinsicEmitter.cpp, +6). On this branch since a1cb2d06, by the history of the line that makes such a store; no older commit was run. 4 stored programs fail without the change and pass with it; 3 more, each built alone: 15 of 45, 3 of 12 and 15 of 48 lines part from bun <file> without it, none with it.
    • New with 42121540, no answer wrong: the global object went out of sight for more built-in modules, all that load node:net, so --trim kept more, and test/aot/runtime-use-of-built-in-code.test.ts of Bun's tree was red in one case of twelve. Where no row of a native function of the host speaks of a receiver, the receiver stays in sight. The test file: 11 pass and 1 fails on every build since 42121540, 12 pass here; a build of console.log(typeof require("net")) with --explain=trim prints 7,551 lines at e8d187c4, 8,488 at bd8bd487 and 7,551 here; the bytes under --trim were not measured.
    • Half a fix, and two test files red by it (taken back at dacd2d81). A right program ends with exit 134 where one of the two methods that take the global object for their target comes out without a receiver: EventTarget.prototype.dispatchEvent.call(undefined, event); typeof event.target.process.finalization; so by a pattern, bound to nothing, under a key of the run or a constant, through Reflect.get() or a describer, or through super where this is nothing. This commit has the engine's half of the fix (aot/facts, six files, +99 -13); the front end's half, in Bun's tree, is held back, so the crash is not fixed yet. With both halves 19 stored programs pass (17 fail and the 2 controls pass at bd8bd487). With this half alone, of 17 of them, each built alone, 10 still end with exit 134, 2 throw an error that says what was left out, 3 answer as bun <file> (15 end with exit 134 at bd8bd487). And this half alone turns two test files of Bun's tree red, no answer wrong: too much is kept: test/aot/runtime-use-prototypes.test.ts (25 pass at bd8bd487; 24 pass and 1 fails) and test/aot/asking-about-a-class-keeps-none-of-its-code.test.ts (14 pass; 12 pass and 2 fail). What a user sees: for a program that stores the prototype object of a built-in class as the prototype of a function of its own, the report names globalThis, process and Bun as escaped; for one that asks whether an object made over such a prototype object is an instance of the class, 13 lines of the report say what blocks --trim where 3 did. The bytes under --trim were not measured. Found after the push. Not fixed here.
    • With --aot-harden=proof-checks alone, at build time: a false alarm of a check of the compiler ended the build of const o = { pattern: () => "x" }; console.log(o.pattern(), require("node:fs").globSync("nothing-*").length); with exit 134. Reported by a user of the last commits.
    • A build could hang on a program that lays a built-in function where the engine calls it. 46 small programs, each built alone, 15 s given: 22 builds do not end at bd8bd487; here all 46 build and answer as bun <file>. One of them builds slower than before: 0.99 s and 544 MB for 0.21 s and 123 MB.
  • bd8bd487 fixes two crashes of right programs, both old, and a line that 42121540 made builds print. Outside aot/ two files change, no answer: the generic road of Object.assign() asks the target's own bit first, and String.prototype.replace() with a function copies a replacement of 8-bit characters by the 8-bit road again, as on main (by reading; no time was measured).
    • New with 42121540, loud, no wrong answer: the build of a program with a class that has private fields, a method of which is called in a loop, printed AOT: TypeTest, operand 0: OperandTypeMismatch .. and went on; the executable answered as bun <file>; the loop was compiled in its slower form. The read that 42121540 asks in front of a loop was also asked where what is left of the type is no value of JavaScript; such a read stays in the turn (aot/walk/AOTWalk.cpp, +1 -1). 3 programs, each built alone: the line shows in 2 builds at 42121540 and in none here; a test file of five cases: 5 fail without the change, 5 pass with it.
    • Exit 134: an index laid on an instance that has no elements, then a walk over its values: const cache = new Map([["a", 1]]); cache[0] = "x"; cache[1] = { v: 5 }; let kinds = ""; for (const value of Object.values(cache)) kinds += typeof value;; so a Set, a Date, a RegExp, an Error, a Promise. Link laid such a store among the elements, which such an instance has not, and nowhere else (aot/facts/AOTLinkAccesses.cpp, +2). 5 stored programs fail at 42121540 and pass here; 13 more, each built alone: 6 exit 134 there, 13 answer as bun <file> here.
    • Exit 134: one form that was left of the crash on a read in front of a copy by a spread (7016427a): a class that is never made bears the names of the literals. A maker whose list of fields the choices have cut was stopped at build time as one that never runs; it is asked at run time behind its rest (aot/walk, +10 -2). Reported by a user of the last commits.
    • A test in front of a call through a table of methods.
  • 42121540 fixes three crashes of right programs, all old, and takes back what a program that is not compiled saw or paid in eight files outside aot/.
    • A right program crashed: a function that reads a variable of its file is called, in a loop of another function, before the variable is filled: function go(turns, record) { let sum = 0; for (let turn = 0; turn < turns; turn++) { JSON.parse("1"); sum += record.read(turn); } return sum; } console.log(go(Number("0"), null)); const held = { width: Number("5") }; function read(turn) { return held.width + turn; } console.log(go(Number("3"), { read }));. The walk lays a read that every turn repeats in front of the loop; such a read is now asked there for the word that its variable is born with, or stays in the turn (aot/walk, aot/ir, +59 -2). 13 stored programs fail at e8d187c4 and pass here; 2 more, each built alone, crash there and answer as bun <file> here.
    • Exit 134: Buffer.concat([], null) and Buffer.copyBytesFrom(new Uint8Array(0), null) return a Buffer under bun <file>. Those natives answer before they look at the operand; the table of built-ins has no row for such a call, and Link took a call that fits no row for one that throws. For a native that the host wrote that part of a call goes out of sight now (aot/facts/AOTLinkCalls.cpp, +4). 5 stored programs: 4 exit 134 and the control passes at e8d187c4, 5 pass here; 24 more, each built alone: 6 exit 134 there, 24 answer alike here.
    • Exit 134: the two forms that were left of the crash on a copy by a spread (779e86aa): a second copy beside the first, const first = { z: 1, ...f, live: null } .. const second = { ...f, state: false }, and two instances with a store on each under a test. A field of a record that a spread fills holds no raw value from birth (aot/plan/AOTPlan.cpp, +1 -1). Reported by a user of the last commits.
    • Outside aot/, one answer goes back to main's: const m = new Map(); const it = m.keys(); Array.from(it); m.set("a", 1); it.next() answers { value: "a", done: false } again; this branch had closed the iterator. A spread in a compiled program goes through the same function and closes the iterator itself now. 21 forms in one program and 401 more, one a file, without --aot and compiled, held against a Bun built from main: at e8d187c4 the run without --aot parts from main's in 6 and in 13; here neither run parts in any.
    • Outside aot/, cost, by reading: Array.from(x) without a map function, the making of a static member, a miss of get_by_id in the interpreter, eight places in the loader of modules and the driver of for await, a catch in WebAssembly's code and the birth of a WebAssembly array ask for compiled code first, once, or not at all; two lines of main's in wasm/WasmOMGIRGenerator.cpp are back.
  • e8d187c4: nothing outside aot/ changes. It fixes one silent wrong answer and two crashes of right programs, all three old.
    • Silent: const k = {}, v = new Float64Array(1); v[Symbol.iterator] = function* () { yield* [[k, 0.5]]; }; new WeakMap(v).get(k) + 1 answered NaN where bun <file> answers 1.5; other spellings exited 134. For a Map, a Set or a view that is handed to a built-in which iterates it, Link took what lies in the object for what the built-in gets; with an iterator of the program's own it gets what that iterator yields (aot/facts/AOTLinkCalls.cpp, +3). 2 stored programs fail at 7016427a and pass here.
    • Exit 134: function T() {} new T().constructor.a = 1, and a call of the function through .constructor of what it made with another kind of argument. A function for which new has no layout hands out objects that nobody has seen, and the prototype above them names the function; it did not leave, so two proofs about it were false. It leaves where its object is handed out (aot/facts/AOTLinkCalls.cpp, +2). 2 stored programs exit 134 at 7016427a and pass here; 2 more, each built alone: exit 134 | as bun <file>. Reported by a user of the last commits.
    • Exit 134, with the Bun PR's half: addEventListener("ping", e => console.log(typeof e.target.process.finalization)); dispatchEvent(new Event("ping")) ("process.finalization was left out of the executable, because nothing seemed to use it"). The engine's table said that those built-ins hand out the global object; the front end, which decides what is loaded, read no such row. The generator emits the list for it (aot/builtins/generator/emit-rust-table.ts, +22). 12 stored programs: 9 fail and the 3 controls pass at 7016427a, 12 pass here.
  • 7016427a: nothing outside aot/ changes.
    • It fixes a second crash of a right, everyday program. const k = []; function f(o) { if (!o.a) return; k.push({ ...o }); } f({ a: 1 }); f({ a: "x", b: 3 }); exited 134 ("what a field holds is not of the type that the compiler has proven of it"): a read of a field in front of a copy by a spread, where the objects that come differ in their fields; so a reducer that returns early on one action.type and copies the action behind it. Reported by a user of the last commits.
    • The cause: for a slot of the copy the walk took again what it already held for that field, and the read in front had left a value there that is typed over both layouts; it does not fit the slot of one layout, and the arm of the first layout was closed as one that never runs. What is held is taken again only where it fits the slot (aot/walk, +5 -4).
    • Shown: 9 stored programs: 8 fail and the control passes at 779e86aa, 9 pass here; 4 more, each built alone: 4 exit 134 at 779e86aa, 4 answer as bun <file> here.
    • A bound on a table of shapes.
  • 779e86aa: nothing outside aot/ changes.
    • It fixes a crash of a right, everyday program. const o: Record<string, number | null | undefined> = {}; o.a = null; o.b = undefined; console.log({ z: 1, ...o, a: 0.5 }.a) exited 134 ("StoreOfOtherType .. the compiler has proven that it never happens"); so { ...job, startedAt: Date.now() } over an instance whose members were set to null by stores. Reported by a user of the last commits.
    • The cause: for a field of a record that is "filled at birth" the plan leans on what the literal's own stores lay into the slot; the copy of the spread lays null there first. A record that a spread fills and that may gain names has no such field now (aot/plan/AOTPlan.cpp, aot/facts/AOTLinkLayouts.cpp, AOTLinkTables.h, +9 -1).
    • Shown: 5 programs, each built alone and held against bun <file>: 5 exit 134 at 461dc671, 5 answer as bun <file> here.
    • The race that 461dc671 fixes has a native test without threads and without a sleep (aot/tests/AOTLinkGrowthTests.cpp).
  • 461dc671 fixes a race that e8d13866 brought: now and then the compiler exited without a message.
    • What exited: the engine's test tool (testaot bytes, walk, and plan at 16 threads) on Linux arm64, Linux x64 with ASAN, macOS arm64 and Windows x64, and bun build --compile --aot --aot-threads=16 itself on Windows arm64.
    • How often, in the Bun PR's CI, in tries of test/aot/compiler/independence.test.ts and determinism.test.ts: 0 of 18 at 0a0d53cd (before the race), 7 of 23 at 39c6f344 (5 lanes; the retries passed and hid all but one), 4 of 18 so far at 186ac75a (2 lanes). Every one that can be tied to a program was on the large generated program (300 features).
    • The cause: two threads of Link share a byte for each function, and it was read twice. It is read once now (aot/facts/AOTLinkFlow.cpp, +8 -2).
    • Found by reading, shown since the push. e8d13866 with 39c6f344, ASAN and assertions, Linux arm64, 30 microseconds of sleep laid in front of the second read in both arms, testaot plan <program> threads=16, 8 runs a program: 38 of 48 exit 134 with an empty stderr; with the fix 0 of 48. The small program (3 features) does not die even with the sleep. Each stack names LinkFlow::tellNameThatBecomesText() under StringTable::builtinName(): a function without a name, one lookup earlier than the commit's message says. A second reading, a type half written by another thread, is ruled out by a build of the pushed text under ThreadSanitizer.
    • A correction to the commit's message. It says that more than 20,000 runs outside CI ended well. That was too many: part of them ran nothing (testaot facts without the word that it needs prints "bad argument" and exits 0), and most of the rest were on the working tree's later text, where the function is not entered at all (37,625 times in one plan on the pushed text). On the pushed text, without the sleep, none of these ended this way: 3,178 runs of the test tool (bytes 862, walk 1,427, plan 889), 3,529 whole builds, 40 runs of independence.test.ts and 20 of determinism.test.ts. All but the runs of the two test files and 168 of the tool's were on programs of 3 and of 50 features, which say little.
    • Whether this is the only cause is not known.
    • The commit also fixes quadratic time for a Map or a Set used as a queue, while (map.size) map.delete(map.keys().next().value), where the compiler does not know the type: one line each in runtime/JSMapIterator.h and JSSetIterator.h, in the step over the compact table of a compiled executable. A program that is not compiled has no such table.
  • a6c0a9a0 takes one fix back: 1607a183 changed when a mock's factory runs for the import() of the mocked module alone; a load beside it kept the old moment, so two loads in one turn of a module whose mock's factory throws came in the other order than under bun test (4,3 for 3,4), and test/aot/test-runs-in-folders-3.test.ts was red on three lanes of the Bun PR. The family of stored test runs on factories, 31 runs: 30 pass and that one fails at e8d13866, 31 pass here. The old fault is back under "Known problems": under bun test --aot the factory of a mock runs inside the import() of the mocked module.
  • e8d13866 changes nothing outside aot/. It fixes a fault that f87bb065 made: the key of an object literal and the name of a function did not count as names that the program writes, so for (const key of Object.keys({ eval: true, label: "made" })) { const found = holder[key]; if (typeof found === "function") found(text); }, with the global object for holder, threw an EvalError where bun <file> answers (5 stored programs: 1 passes and 4 fail at 1607a183, 5 pass here); { eval: true } that nobody lists still opens nothing. New with 1607a183: in a build that verifies exception scopes (debug, ASAN) the compiler aborted while it works out the texts of regular expressions; not run on such a build before the push. Old: a for await at the top level of a module over an async generator went on in the module's context of AsyncLocalStorage (26 stored programs: 11 pass and 15 fail at 1607a183, 26 pass here).
  • At 1607a183 all checks were green. It fixes an old abort of the build on subclasses that are held in an object, picked at run time and made at one new; the factory of a mock that ran inside import() (taken back at a6c0a9a0); a quadratic build on direct evals; and what the review on this PR found in runtime/OwedOutOfMemoryError.h: after an out-of-memory error for more than one kind of memory at once a later shortage ended the process where a RangeError is due (new with this branch; two native tests come with the fix). A step of an async generator that waits resumes its consumer directly.
  • At c563e0de all checks were green. It puts back what a program that is not compiled passes outside aot/, and fixes the second file's partial mock, for await over an object whose method makes the generator, and the labels of a switch. All checks were green at f87bb065 too. Three commits from 2e069424 to it. 714174b0: a test run with partial mocks crashed; the context in which the consumer of an async generator goes on; module mocks under bun test --aot; a name such as "constructor" that reaches the program as a key of constant data, as a label or as a function's name is spelled by the program. a1931fa1 and f87bb065 narrow that last rule: it had heard the key of { eval: true } and the label case "require": and kept such programs from being closed; a member of the global object or a loader is no longer heard that way, and the names are listed once a build. Before: 2e069424: the key of a for .. in over a list is a text again where it is read in a handler around the loop or behind a yield, and list[key] = key keeps -0; a module that exports then and is the entry point gets its whole namespace; the build of a program that hands a regular expression with a redefined property of its own to replace() or match(), called as written, ends. 2ca46e05: code of the program in front of a refusal by a built-in runs; a build could hang on a program that makes a function out of a text; names out of constant data; arm64: a fence behind late stores of a new object; a list is kept while a text is looked for in it.
  • It is merged with main. aot/ is this branch's, whole. The B3 and Air additions that only the old compiler used are deleted (about 87,000 lines); the compiler itself is about 116,000 lines smaller.
  • Fixes that went into aot/ on main after November 1 are not carried over one by one. The folders that were kept (runtime/, stubs/, object/, codegen/) still need to be compared with them.
  • What is known to be wrong is listed in each commit's message under "Known problems". In the Bun PR, 236 test cases are marked as known failures rather than fixed; test/aot/goals-not-met-yet.md there lists them.
  • Several optimizations of the old compiler have their consumers in codegen/ but no producer in the new plan/ yet (split results, parameters that are not passed, entries that omit arguments). They never fire today.

The Bun side is oven-sh/bun#47942.

…and one walk

The ahead-of-time compiler ran a whole-program flow analysis to a fixpoint,
dozens of optimization passes over each function, and B3 and Air to generate
code. Building a large program took minutes of CPU time, nearly all of it in
those three.

This replaces that middle:

- facts/: one scan of each function, then Link, which carries types, callees
  and layouts through the whole program once, on several threads.
- plan/: slots, layouts and calling conventions, decided from what Link found.
- walk/: one walk over each function that types, folds, inlines and selects
  operations as it goes.
- machine/: a small back end with its own register allocator and encoder.
  Compiled code no longer goes through B3 or Air.

ir/, codegen/, stubs/, runtime/, object/, image/ and builtins/ are kept, and
changed where they met the old middle.

Building the TypeScript compiler takes about a tenth of the instructions it
took before, and the code is about a third smaller. It still runs slower than
the old compiler's output on that benchmark.
…clares

JavaScriptCore configured by itself stopped in aot/builtins/generator/engine.ts:
$nextOfStepsOverText stands for a function that only Bun's tables declare, and
only Bun's prelude spells it. The word moves to Bun's syntax table.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Findings marked 🟡 are optional suggestions and need no follow-up push.

Additional findings (outside the current diff — GitHub can't attach inline comments there):

  • 🔴 Source/JavaScriptCore/runtime/OptionsList.h:162 — After merging, every JSC test run that passes --useRegExpImageMode crashes at startup instead of running, because the option no longer exists. OptionsList.h:161-162 drops useRegExpImageMode (and RegExp.cpp no longer reads it), but 21 JSTests still carry //@ runDefault("--useRegExpImageMode=1"), six of them new in this change, and Tools/Scripts/run-jsc-stress-tests:1198 still defines REGEXP_IMAGE_MODE_OPTIONS = ["--useRegExpImageMode=true"] for the regexp-image-mode config. Fix: either keep an accepted useRegExpImageMode option (a no-op alias is enough) or remove every remaining use: the 21 //@ runDefault lines, the RegExpImageMode mode and runRegExpModesConfig in run-jsc-stress-tests, and the BUN-TEST-DIFFERENCES.md entries that describe it. [also at: JSTests/stress/regexp-image-mode-skips-starts-behind-a-failed-run.js:1 - CI's JavaScriptCore test job will crash on every regexp test that uses image mode, because the option they pass no longer exists.]

    Why this was flagged

    The test harness prepends BASE_OPTIONS, which include --validateOptions=true (Tools/Scripts/run-jsc-stress-tests:699, applied in runWithOptions at :1060-1068), to every jsc invocation. A test such as JSTests/stress/regexp-image-mode-skips-starts-behind-a-failed-run.js:1 (added by this change) or JSTests/stress/regexp-one-set-or-run.js:2 then passes --useRegExpImageMode=1. In jsc.cpp:4991-4995, JSC::Options::setOption("useRegExpImageMode=1") returns false because FOR_EACH_JSC_OPTION no longer lists the name (Options.cpp:1307-1325; no alias exists either), so hasBadJSCOptions is set and jsc.cpp:5005-5006 does CRASH() because validateOptions() is true. The same happens for every regexp test in the RegExpImageMode config that run-jsc-stress-tests:1412-1415 and :1619 still schedule when $jitTests && $aot. On the base branch the option exists (it was read in RegExp.cpp patternAnalysisFor and compileWithJIT) and those runs pass.

    Verification: The diff removes the option from Source/JavaScriptCore/runtime/OptionsList.h. jsc.cpp:5005-5006 does if (hasBadJSCOptions && JSC::Options::validateOptions()) CRASH();. The harness always supplies --validateOptions=true: BASE_OPTIONS at Tools/Scripts/run-jsc-stress-tests:699. 21 JSTests still carry //@ runDefault("--useRegExpImageMode=1"). On the base commit the option exists.

  • 🔴 Source/WTF/Scripts/Preferences/UnifiedWebPreferences.yaml:2761 — Anyone building WebCore (Mac, GTK or WPE ports, or TestWebKitAPI with ENABLE_WEBKIT) from this tree now gets a compile error, where the base builds. The yaml drops the HTMLEnhancedSelectParsingEnabled entry (before UnifiedWebPreferences.yaml:2761) and the SVG2TextLayoutAlgorithmEnabled entry (before :5313), but Source/WebCore is untouched by this PR and still calls the generated getters, e.g. HTMLHRElement.cpp:64 and RenderSVGText.cpp:605. Fix: keep the two preference entries (or sync the WebCore/WebKit changes that removed their uses) so every settings getter WebCore, the IDL and HTMLTagNames.in reference is still generated.

    Why this was flagged

    GenerateSettings.rb (Source/WebCore/Scripts/GenerateSettings.rb:77) and the WebCore CMake rule (Source/WebCore/CMakeLists.txt:3075) generate the Settings class from Source/WTF/Scripts/Preferences/UnifiedWebPreferences.yaml. This PR removes the HTMLEnhancedSelectParsingEnabled block (base yaml lines 2751-2758) and the SVG2TextLayoutAlgorithmEnabled block (base lines 5303-5309) while Source/WebCore and Source/WebKit have no changes in the diff. WebCore still calls document().settings().htmlEnhancedSelectParsingEnabled() at Source/WebCore/html/HTMLHRElement.cpp:64 and about 20 more sites, HTMLTagNames.in:115 uses settingsConditional=htmlEnhancedSelectParsingEnabled, and RenderSVGText.cpp:605 calls svg2TextLayoutAlgorithmEnabled(). With the entries gone those getters are not generated and WebCore fails to compile. The fork's CI (.github/workflows/ci.yml:494, --jsc-only) does not build WebCore, so the breakage shows only for full-port builds, which the base tree still supports.

    Verification: WebCore at HEAD still calls the now-ungenerated getters: Source/WebCore/html/HTMLHRElement.cpp:64 and Source/WebCore/rendering/svg/RenderSVGText.cpp:605. Each is a call to a member that Settings.h no longer declares, so WebCore fails to compile where the base (which still has both yaml entries) builds. The fork's own CI/Dockerfile builds only -DPORT="JSCOnly" (Dockerfile:445).

  • 🔴 Source/JavaScriptCore/runtime/JSArray.cpp:1335 — Every array.concat(x) with a non-array x loses its memcpy fast path after merging and copies the array one putDirectIndex at a time. JSArray.cpp:1335 now refuses appendMemcpy whenever startIndex < length(), but tryConcatAppendOneNonArray creates result with length firstArraySize + 1 (ArrayPrototype.cpp:1627) and calls appendMemcpy with startIndex 0 (ArrayPrototype.cpp:1633), so it always falls back to moveArrayElements at :1638. Fix: apply the pre-filled-target guard only where a species constructor can supply the target (ArrayPrototype.cpp:1942), or create result with length 0 in tryConcatAppendOneNonArray and grow it after the copy, so the one-argument concat path uses memcpy again.

    Why this was flagged

    Any first.concat(second) where second is not an array reaches tryConcatAppendOneNonArray (ArrayPrototype.cpp:1590), from arrayProtoFuncConcat and from the DFG's operationArrayConcatAppendOne (DFGOperations.cpp:1749). It allocates result with JSArray::tryCreate(vm, resultStructure, resultSize) where resultSize = firstArraySize + 1 (ArrayPrototype.cpp:1627), so result->length() is at least 1. It then calls result->appendMemcpy(globalObject, vm, 0, first) (ArrayPrototype.cpp:1633). The new check at JSArray.cpp:1335, if (startIndex < length()) return false;, is true for startIndex 0 and length >= 1, so appendMemcpy returns false on every call from this site. The caller then runs moveArrayElementsArrayFillMode::Empty (ArrayPrototype.cpp:1638), which does tryGetIndexQuickly plus putDirectIndex per element. On the base branch the check does not exist and the elements are copied with one memcpy. The result is still correct, but a large array concat is now O(n) slow-path stores instead of one block copy.

    Verification: JSArray.cpp:1334-1336 adds if (startIndex < length()) return false; to appendMemcpy. tryConcatAppendOneNonArray allocates result with resultSize = firstArraySize + 1 (ArrayPrototype.cpp:1627), so result->length() >= 1. appendMemcpy(globalObject, vm, 0, first) at :1633 returns false and falls through to moveArrayElements at :1638. On the base commit the same function used the memcpy path.

  • 🔴 Dockerfile.android:237 — Android, FreeBSD and musl jsc shells (and testaot/testFFI) are now linked with DT_RELR packed relocations, which the base never emitted. Source/cmake/OptionsCommon.cmake:163-165 is new in this diff: LD_PACK_RELATIVE_RELOCS defaults to ON whenever lld advertises pack-relative-relocs, and only Dockerfile:450 turns it off. Dockerfile.android:237 targets ANDROID_API 28, whose loader only understands the Android-specific RELR tags, so a shipped jsc there loads with its relative relocations unapplied. Fix: pass -DLD_PACK_RELATIVE_RELOCS=OFF in every lane whose target loader is not known to support standard DT_RELR (Android API<30 at least), or default the option OFF and opt in per lane.

    Why this was flagged

    The base commit has no LD_PACK_RELATIVE_RELOCS at all: Source/cmake/OptionsCommon.cmake lines 105-108 and 163-166 are added by this change, with option default ${LD_SUPPORTS_PACK_RELATIVE_RELOCS}, which is TRUE for every lld the lanes use. The glibc Dockerfile:450 adds -DLD_PACK_RELATIVE_RELOCS=OFF precisely because the 2.31 loader cannot apply them. Dockerfile.android:200-250 (the cmake invocation around line 237) passes no such OFF, nor do Dockerfile.freebsd:234 or Dockerfile.musl. lanes.mjs:277 fixes ANDROID_API at 28; the API 28/29 bionic linker accepts only DT_ANDROID_RELR tags, and lld's -z pack-relative-relocs emits standard DT_RELR unless --use-android-relr-tags is also given. The Android/FreeBSD/musl lanes are not in lanes.mjs:160-163 tested, so CI never loads these shells; a user running the shipped jsc on an Android 9/10 device gets a crash on the first unrelocated pointer, where the base's binary ran.

    Verification: Triggered whenever the Android lane's shipped jsc/testaot/testFFI executables are run on an Android 9 or 10 device (API 28/29), the minimum this lane declares (Dockerfile.android:8, .github/scripts/lanes.mjs:277). Dockerfile.android:209-242 configures with -fuse-ld=lld (line 232) and passes no -DLD_PACK_RELATIVE_RELOCS=OFF and no --use-android-relr-tags; the only OFF is Dockerfile:450.

  • 🟡 LayoutTests/TestExpectations:8276 — nit: anyone running run-webkit-tests on this tree will see about 40 WebCore layout tests report as unexpected failures that the base marks as known failures. LayoutTests/TestExpectations loses the upstream gardening lines for media/modern-media-controls/spatial-video-support/* (webkit.org/b/328230, b/328236, LayoutTests/TestExpectations:8274-8276), the canvas.2d.lang tests (b/285993), selectedcontent-restore.optional.html, the css-flexbox col-wrap entries (b/116117) and svg-feimage-002/003, while Source/WebCore is unchanged in this PR. Fix: restore the base expectation lines (or drop the TestExpectations change from this JSC PR) so the file matches the WebCore in the tree.

    Why this was flagged

    The PR is a JavaScriptCore AOT change; git diff --name-only shows no file under Source/WebCore or Source/WebKit, yet LayoutTests/TestExpectations is edited (11 insertions, 41 deletions) and no other LayoutTests file changes. Base commit a5ec4c1 added the lines removed at base TestExpectations:8301-8306, and the test files still exist at HEAD. The same happens for the canvas.2d.lang ImageOnlyFailure block (base :639-652), the selectedcontent-restore.optional.html Skip (base :841-842), the col-wrap-* and balance-line-count-intrinsic-005..007 lines (base :1913-1925, :1936-1941, :5178-5179) and svg-feimage-002/003 (base :6005, :6012); all of those test files exist unchanged at HEAD. With the lines gone the expectation is Pass, so run-webkit-tests reports them as unexpected failures where the base reports them as expected. The fork's CI does not run these layout tests (ci.yml:233 excludes LayoutTests/), so only a maintainer running the WebCore suite, or the next upstream sync, hits this.

    Verification: Triggered whenever someone runs run-webkit-tests against WebCore layout tests on this tree. git diff 23d7f1dc HEAD -- LayoutTests/TestExpectations shows 11 insertions / 41 deletions while git diff --name-only -- Source/WebCore Source/WebKit is empty. The deletions are upstream gardening: base TestExpectations:8301-8306, added by commit a5ec4c1. All referenced test files still exist at HEAD.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

… allocating calls

FreeBSD's libc++ gives std::pair copy and move constructors of its own, and
ListOfUnit moves what it holds as bytes and asserts that it may. The list of
callees at sites holds a small struct, CalleeAtSite, instead.

`friend class Allocator;` with no earlier declaration names a class of the
innermost namespace, but in Microsoft mode clang looks further out first and
finds another Allocator. Machine::Allocator and Machine::Builder are declared
ahead of the classes that befriend them.

With LTO on x86-64, four runtime operations kept the 32 bits of a StructureID
across a call that may allocate and decoded it again behind the call.
WTF::opaque() around the decode keeps the pointer itself, as elsewhere in
aot/runtime. find-structures-decoded-behind-calls.py reported all four.
@github-actions

github-actions Bot commented Nov 4, 2026 •

Copy link
Copy Markdown

Preview build of 3c42aae: autobuild-preview-pr-997-3c42aae2

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

… build fixes

useRegExpImageMode had gone from OptionsList.h while 21 tests under JSTests and
a mode of run-jsc-stress-tests still pass it, so jsc stopped at startup in 176
test runs. The option is back as it is on main: the shell compiles a pattern as
for an image and runs that code (aot/image/AOTRegExpInProcessLoader). A pattern
compiled that way has no image record, which matchWithImageCode() now allows for.

With LTO on x86-64, two more runtime operations decoded a StructureID again
behind a call that may allocate. They keep the pointer instead.
find-structures-decoded-behind-calls.py also reports stateOfClassHolder on the
hardened builds. That one is no decode: the instruction is a sort's begin plus
offset, and the script takes the offset's register for the base because a block
above it in address order, which does not lead there, loads the base into it.
It gets a row in the expected list until the script follows the base along
branches as it does the ID.

The Windows SDK defines `small` and `far` as macros. Local variables of those
names are renamed.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

Jarred-Sumner added a commit to oven-sh/bun that referenced this pull request Nov 4, 2026
The earlier merges of main into this branch were made from a merge base older
than what the branch's tree really holds, and took this branch's side wherever
the two differed. That dropped recent changes of main in files this branch has
no reason to touch, among them fixes and tests in node:crypto and WebCrypto.

This redoes the merge over the commit of main that the tree stands on
(2b0ace8), up to main at 05a0ec9. Outside the compiler's own
directories every file is main's again, byte for byte, except for the 347 that
this branch changes on purpose. Of the crypto, TLS and X.509 files that is one,
node_crypto_binding.bind.ts, which gains a declaration of what becomes of
randomInt's callback.

WEBKIT_VERSION names the preview build of oven-sh/WebKit#997 at 1a9ffc0a.

The tree is formatted: cargo fmt, bun fmt, clang-format.
Miscompilations and crashes found by review and by the fuzzers:
- a getter on Array.prototype, Map.prototype or Set.prototype that is found
  under a computed key and stores into `this`
- a module variable read before it is initialized, where Link had proven it
  initialized and dropped the check
- in test runs, a member of Object.prototype that is turned into an accessor
- calls and comparisons in the bodies that are emitted without the register
  allocator

Tests:
- 27 IR tests that were dumps of whole programs with the runtime's library
  are cut down to the functions they look at; each still prints what it printed
- testair and testb3 skip their disassembly checks in builds without a
  disassembler
- testaot loads the repacked ICU data the way the shell does

FFI: a callback block is mapped from the executable only if the descriptor
still names a regular file that is long enough.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nothing blocking. The comments below are optional suggestions. There is no need to push a fix for them before merging.

Additional findings (outside the current diff — GitHub can't attach inline comments there):

  • 🟡 Source/JavaScriptCore/wasm/js/WasmToJS.cpp:534 — A WebAssembly module importing a function whose type uses v128 or exnref now crashes the process when JIT memory is fully exhausted, where the base failed the compile with an error. The base built that import's throw stub through its own LinkBuffer with JITCompilationCanFail and returned BindingFailure::OutOfMemory; after merging, emitWasmToJS returns at WasmToJS.cpp:134 and wasmToJS finalizes every stub with JITCompilationMustSucceed at WasmToJS.cpp:532, so ExecutableAllocator calls CRASH() before the didFailToAllocate() check at :533 can run. Fix: keep the recoverable path for this stub: finalize with JITCompilationCanFail when the signature includes v128 or exnref so an allocation failure still surfaces as BindingFailure::OutOfMemory.

    Why this was flagged

    A module whose import type includes v128 or exnref (signature.argumentsOrResultsIncludeV128() || argumentsOrResultsIncludeExnref(), WasmToJS.cpp:133) is compiled while executable memory is nearly used up; WasmEntryPlan.cpp:351 calls wasmToJS() for that import. In the base, handleBadImportTypeUse created a LinkBuffer with JITCompilationCanFail, which ExecutableAllocator.cpp:1437-1445 refuses once the reserve is reached, and returned BindingFailure::OutOfMemory so WasmEntryPlan.cpp:352-353 fails the plan. After the change, emitWasmToJS just returns at WasmToJS.cpp:134 and wasmToJS() at WasmToJS.cpp:532 constructs the LinkBuffer with JITCompilationMustSucceed; ExecutableAllocator.cpp:1450-1452 then logs "Ran out of executable memory" and CRASH()es, so the didFailToAllocate() branch at WasmToJS.cpp:533-534 that still returns BindingFailure::OutOfMemory is unreachable for this stub. The user gets a process abort instead of a failed WebAssembly compile. The ordinary import path already used JITCompilationMustSucceed on the base, so only the restricted-type path regresses.

    Verification: After the change, that path only emits code inside emitWasmToJS (WasmToJS.cpp:133-134); the new wasmToJS wrapper then finalizes with JITCompilationMustSucceed (WasmToJS.cpp:532). With MustSucceed, on allocator failure it hits CRASH(); (ExecutableAllocator.cpp:1450-1452), so the didFailToAllocate() check at WasmToJS.cpp:533-534 is unreachable. The base path instead returned OutOfMemory, a CompileError rather than a crash.

B3, Air and wtf/InterferenceGraph.h are main's again. The new compiler does not
use them, so the branch had taken them back to upstream's text. That also
dropped the fixes main has for compile time on large functions. With upstream's
text FTL spent 1.2x, 1.4x and 2.0x as long in B3 on one function of 500, 1,000
and 2,000 branches (11%, 20% and 34% more instructions for the whole run), for
the same machine code. Of main's text only two calls into the old compiler's
progress record are gone (B3PhaseScope.cpp, AirPhaseScope.cpp). Outside aot/
the branch now differs from main in 102 files, by 3,224 added and 1,774 deleted
lines.

An ASAN build takes WTF's and JavaScriptCore's memory from the system
allocator, so the sanitizer sees it. No test has to set Malloc=1.

Back to main's text, because the compiler does not need the change:
- Array.prototype.concat of one value copies with memcpy.
- Ten small changes in runtime/, yarr/ and bytecompiler/.
- The collector starts its helper threads as before. A build asks for none
  through a hook of its own.

Fixed:
- The stub of a wasm import with a refused type may fail to get memory instead
  of crashing.
- Three tests of aot/tests name the processor or the flavor that each of their
  runs is for. They failed on arm64.

Deleted:
- 2 MB pages for the memory of testaot.
- About 20,000 lines of the compiler that nothing reached.
- About 109,000 lines of stored test programs, cut down to what each one tests
  (Tools/Scripts/aot/cut-ir-test.py).
A field of an enum or boolean type that holds undefined or null was read wrong
behind a join:

    crate.tint = next as Tint;
    const seen = crate.tint;

`seen` was 0, or the marker that stands for an empty field, where the field
held undefined. The change that moved that marker from the object's header into
its shape goes out again, with its tests.

A build of a large test run stopped with "an allocation lists a value for a name
that has no slot". The change that stopped giving a field to an appended name
without a granule goes out again, with its tests.
dfg/DFGDoesGCCheck.cpp came back to main's text with B3 and Air. There it counts
the places where a collection may run, in a counter of the previous AOT compiler
that this branch no longer has:

    DFGDoesGCCheck.cpp:48: error: no member named 'placesThatMayCollect' in namespace 'JSC::AOT'

Only a build with ENABLE(DFG_DOES_GC_VALIDATION) compiles verifyCanGC(), so the
release lanes did not see it. The include and the four lines go. Nothing else in
b3/, dfg/, ftl/ or wtf/InterferenceGraph.h names the compiler.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nothing blocking. The comments below are optional suggestions. There is no need to push a fix for them before merging.

Additional findings (outside the current diff — GitHub can't attach inline comments there):

  • 🟡 Source/bmalloc/bmalloc/SystemHeap.cpp:177 — Anyone running an ASAN build of JSC or Bun on Linux loses LeakSanitizer reports for every fastMalloc allocation after merging, where the base reports them. SystemHeap.cpp:170 defines BMALLOC_UNSEEN_BY_LEAK_SANITIZER as an __lsan::ScopedDisabler, and SystemHeap.cpp:177, 185 and 193 put it in malloc, memalign and realloc, so all memory handed out by the system heap is marked as never-leaked. Fix: keep leak tracking for ordinary allocations and disable it only around the specific allocations that are known to be retained on purpose (or behind an opt-in), rather than in SystemHeap's three entry points, which cover every bmalloc allocation in a sanitizer build.

    Why this was flagged

    On a Linux ASAN build, Environment.cpp:112-113 makes isSanitizerEnabled() return true, so bmalloc routes every allocation through SystemHeap (as it already did on Linux via the dlsym check at Environment.cpp:133). SystemHeap.cpp:168-170 now defines BMALLOC_UNSEEN_BY_LEAK_SANITIZER as __lsan::ScopedDisabler unseenByLeakSanitizer for ASAN on non-Darwin, non-Windows, and SystemHeap.cpp:177, 185 and 193 place it at the top of SystemHeap::malloc, memalign and realloc. LeakSanitizer treats every allocation made inside a ScopedDisabler as ignored, so no block returned by these functions is ever reported as leaked. WTF::fastMalloc, Vector, String, HashMap and every JSC-side heap allocation go through this path, so a developer running the ASAN test lanes gets no leak report for any of them. The base branch reported such leaks (the functions were plain ::malloc / ::aligned_alloc / ::realloc). Nothing in the diff limits the disabler to a particular build, test or allocation site.

    Verification: Triggers on a Linux ASAN build with LeakSanitizer enabled. SystemHeap.cpp:35-40 defines an __lsan::ScopedDisabler macro used in SystemHeap::malloc, memalign and realloc (lines 177, 185, 193). The base had no disabler here, so LSan reported leaked fastMalloc memory; now all of it is silently excluded. CI runs with detect_leaks=0 (ci.yml:430-434), so no CI coverage is lost.

… aborts

    import { heapSize } from "bun:jsc";
    import { argv } from "node:process";
    import { _nodeModulePaths } from "node:module";

`bun build --compile --aot` ended with an assertion in the builder of the image.
The loader fills such a variable out of the object of a native module. Nobody
follows the variable, so the object counts as handed out, with the importing
file as the witness. The last run over the program saw that. The flow heard of
the module without the witness and ran as if nothing were open, and the two
answers did not agree. Both now come by the requests of an evaluated module in
one place.

The x64 LTO lanes stopped at find-structures-decoded-behind-calls.py:
JSC::AOT::tryCopyAsOrdinaryObject decodes a StructureID that it loaded in front
of a call. A dead condition left the function, and the optimizer now keeps the
ID of source->structure() in a register. That is harmless there: the source is a
live argument and keeps its Structure, and nothing in front of the DeferGC
allocates. The function has its row in the list of expected ones.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

In a test run that mentions Bun.plugin, every require() asks the loader by
name. Two things went wrong there:

- Linking a CommonJS file as a root captured its exports, which evaluated it,
  which linked it again, until the stack ran out (SIGSEGV). The exports of a
  root are now captured after its body has run, and captureExports() checks the
  stack like the rest of the linker, so what is merely deep is a RangeError.
- The table of link requests took a require() that finds its module by name for
  one whose code calls the module itself. A link of the requiring file followed
  it and ran CommonJS files that nobody had required yet. Such a request is no
  longer a link request.

testaot no longer sets mimalloc's purge delay. It mirrored a setting of Bun's
build that is going away.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

…to Bun

Miscompilations:

- One function expression could produce two closures. When a closure was passed
  through an inlined function that used it more than once behind an early
  return, each use allocated its own function object:

      function back(value, open) { if (!open) return null; keep(value); return value; }
      const got = back(() => 1, open);
      held.has(got); // false

  `===`, Set and Map lookups and add/remove listener pairs went wrong. Arrows,
  `function`, `function*` and `async` functions alike. The optimization that
  moved the allocation into the inlined copy is removed.

- `for (const [k, v] of es)` read key/value pairs as a flat list when `es` came
  from Object.entries on one path and from another function on another, so
  "x=299! y=2!" was printed as "x,299=y,2!". Whether a list is in the flat form
  is now a property of the call that made it.

- `[a, b] = [b, a]` aborted the build when `a` was the result of a built-in
  reached through a member.

About 70 smaller fixes, each with a test that fails without it.

Size:

- Source/JavaScriptCore/aot has no comments any more: 39,000 lines fewer.
- 358 tests of aot/tests/answers are now stored programs in Bun's
  test/aot/answers: 147,000 lines fewer here, 13,000 more there.
- The LiteralString slot representations are gone.

Outside aot/:

- FunctionPrototype.cpp drops the branch for the previous compiler's bound
  functions.
- JSRopeString::resolveSubstringBySharing() is resolveBySharing() and takes any
  rope.
- LowLevelInterpreterAOT.asm and JSONObject.cpp drop the two LiteralString
  representations.
- JSModuleLoader.cpp does not send the host a request that the root of the load
  will make itself.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

The arm64 debug ASan lane failed to link testFFI: its code had grown past
128 MB, and calls from the first objects to the sanitizer's stubs were out of
the range of a branch ("relocation BRANCH26 is out of range"). The ELF lanes
already link with --gc-sections; nothing did the same for Mach-O in this port.
The libraries are not affected.

AOTCodeGenerator.cpp and AOTExceptionOperations.cpp include what they use. They
compiled only thanks to the precompiled header or an earlier file of the same
unified source.

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

… a mark in the shape; 403 tests move to Bun

Crashes:

- The whole process aborted when code was ended from outside while an object was
  copied without some of its names:

      const { label_id: _id, ...rest } = entry;

  under `worker.terminate()`, or on the main thread under node:vm's `timeout`.
  A pending termination was taken for a property that could not be deleted.

- A valid program aborted the compiler:

      let seen = "";
      try {
        for (let i = 0; i < text.length; i++) {
          seen += text[i];
          for (let j = 0; j < 3; j++) sum += j * i;
        }
      } catch (error) {}

- A compiled program aborted in every build with assertions:

      // main.mjs
      import "./first.cjs"; import "./second.cjs"; import "./third.cjs";
      // first.cjs
      require("./back.mjs");
      // back.mjs
      import "./main.mjs";

  JSModuleLoader::innerModuleLoading() told whether the host had loaded a request
  during the call by the size of [[LoadedModules]]. A CommonJS file that runs
  during the call may load other requests of the same module, so it asks whether
  the list contains the request.

- `bun test --isolate --aot` aborted when the real body of a mocked package throws
  and another package imports it with `import()`.

- A build whose lists pass two gigabytes aborted without a sentence. It goes on,
  or says which table is full.

Wrong answers in test runs:

- `import { late } from "./half.cjs"`, where half.cjs requires a module that
  imports half.cjs back before `exports.late` is stored: `bun test` reports
  "Export named 'late' not found"; the compiled run passed and read undefined.

Faster:

- Whether a field holds a value of its declared type is a mark in the object's
  shape. The TypeScript compiler compiling itself: 2.6% fewer instructions.
- `const { value, done } = generator.next(x)` written by hand makes no result
  object.
- A loop by index over a list of numbers that begins again: 16.4 instructions a
  visit become 13.4. A step of `for (const x of list)`: 23.5 become 19.4.
- What a CommonJS file exports no longer counts as seen by unknown code, so calls
  through `require()` and `import * as` find their one callee.

Size:

- 403 tests that hold their source move to Bun's test/aot/from-source, where their
  records are made when they run: 110,000 lines fewer here.
- Operations, words of the schema and mechanisms that no program reached are
  removed.

Outside aot/, one file changes: runtime/JSModuleLoader.cpp (+6 -24): the fix above,
and a load that waits for the load around it no longer takes a second state and
extra promise jobs through innerModuleLoading().

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

Jarred-Sumner added a commit to oven-sh/bun that referenced this pull request Nov 7, 2026
The engine is merged: oven-sh/WebKit#997 is 42067fce on WebKit's main, and `WEBKIT_VERSION` names
that commit, no prerelease any more. Its tree is the tree of 3c42aae2, the last pin, to the byte, so
nothing that is compiled changes, with or without --aot. What is still otherwise than on main is
listed under its head.

Back to main's text:

- Nothing in this commit.

What plain Bun still does otherwise than main:

This list is not all, though the messages up to 4954cae offered it as all. A reading of every hunk
from main to d08cc05 outside test/, docs/, src/aot/ and src/js/ahead-of-time/ (627 files, 4,555
hunks) finds 1,592 that a run without --aot passes through: 1,238 in src/sema, which `bun check`,
`bun lint`, `bun fmt`, `--check` and `bun build --dts` run and which this list never named, and 354
elsewhere, 88 separate changes, of which it names nine. The pin also brings eight commits of
WebKit's main (#967 to #983: 99 files outside aot/, B3 and Air among them) that Bun's main, which
pins 4d45755f, never shipped. The description of #47942 has the whole list, by folder and
file, with what is not by intent and not fixed.

- `Bun.build({ compile })` no longer reads `aotHeat`, `aotDisable`, `aotValidate` and
  `aotLogTypeMismatches`, options of main's compiler. Corrected: the messages up to 4954cae went on
  "so an `aotHeat` or an `aotDisable` of the wrong type is no TypeError any more". It is the other
  way round: `Bun.build({ compile: { aotHeat: anything } })` always throws now, `compile.aotHeat is
  not a valid option`: every key of `compile` that begins with `aot` and is not known is refused
  before any is read (src/runtime/api/JSBundler.rs, src/runtime/cli/compile_options.rs). At the top
  level `Bun.build({ aotHeat })` threw "goes inside compile" on main and is passed over now; `({
  aotOut })` and `({ aotHarden })` throw it now. It reads `aotHarden` and `aotOut`.
  `packages/bun-types` follows, but for `aotOut`, which is read and not declared. By intent.

- Flags of main's compiler that this one does not have are not known any more, among them
  `--aot-log-type-mismatches`, `--aot-build-test-part` and `--aot-memory-limit`. All begin with
  `--aot`. By intent.

- Bun reads a file of 64 MB or more on several threads, and writes executables the same way. Those
  threads are named "Bun Parallel"; on main they have no name. A program can see it in
  /proc/self/task/*/comm.

- A `bun test --parallel` worker that waits for its next file sleeps. On main it keeps polling.

- Every start of `bun` compares its first argument with the prefix `--aot-program-file`. Nothing
  follows unless BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING is set.

- Native functions whose results are declared to the compiler test a flag before they return.
  Corrected: the messages priced it at "a load and a branch". Measured it is 3 to 8 instructions a
  call in plain Bun: `Blob.text` +3.0 of 1,777, `Blob.slice` +6 of 926, `Blob.type` +8.0 of 342
  (exact user instructions a call, Linux x64, a build of main against two builds of the working
  tree, each read twice; only the +8.0 is laid to the test by the disassembly: the test behind the
  call takes the thunk's tail call away; the other two are differences of whole builds); about 55 KB
  of thunks. In a release build the flag is false unless compiled code runs, and a native function
  that answers outside its declared type answers as before. A build that asserts (debug, `cargo
  test`, ASAN, or assertions with canary) starts with the flag set: there such an answer throws a
  TypeError, and a value cached outside its type panics.

- In a build of Bun with assertions (debug, ASAN) such a native function throws a TypeError where it
  answers outside what is declared for it: by intent: it holds the declarations to Bun's own tests.
  Corrected: "no released build has it" holds only as long as no release-safe canary is published:
  the switch is `Environment::CI_ASSERT` (src/bun_core/env.rs); and a cached value outside what is
  declared panics there, it throws no TypeError (src/jsc/bindgen.rs).

- `bun build --compile --trim` without --aot fills removed code with `hlt` (x64; on macOS `int3`, as
  main) and `udf` (arm64) where main writes `int3` and `brk`, and also removes what only compiled
  code enters. By reading; not run.

- Since the prerelease 1607a183, which 0a0d53c pins: each step of a `for await` that drives an
  async generator passes one test more, whether the process has compiled code.

- `bun test`: where the runner loads the next test file while a mock's factory has not settled, that
  load, which has no importer, keeps its key. Three lines of this branch in
  `keyOfImportWhileModuleMocksRun()` (src/jsc/bindings/BunPlugin.cpp). By intent.

Every item above was held against `git diff` of main and this tree, file by file, for this message.
What the diff holds beside them was not asked until the reading that is named at the head of this
list.

Known problems:

- 236 cases in 134 files are marked as known failures, not fixed; each runs every time and turns red
  the day it passes. 170 of them are bounds on what a program brings of Bun's library and on what
  `--trim` removes, 15 are on how builds grow, 51 are others. The last commit had the same 236 in
  134 files: the page is unchanged. test/aot/goals-not-met-yet.md lists every one with what was
  measured, the bound, and what keeps the number from growing worse; `bun
  test/aot/tools/list-goals-not-met-yet.ts` writes that page out of the marks in the tree.

- 4 more marks, in 3 files, stand on wrong answers, not goals. Three are on mocks under `bun test
  --aot`: a mock laid over a file URL reaches the other spelling of the same file too
  (test/aot/mock-file-url.test.ts, two cases: plain prints `one-importer mocked real`,
  `two-importers mocked`, `two-importers real`; compiled `mocked mocked`, `mocked`, `mocked`), and a
  mock that is taken back while a plugin waits is still used (test/aot/unmock-while-loading.test.ts:
  plain `k runs`, `seen real/slow`; compiled `factory runs`, `seen first/slow`). The fourth is
  small: where a test catches the error of a file whose import does not parse, `error.name` is
  `BuildMessage` under `bun test --isolate` and `SyntaxError` under `bun test --aot --isolate`
  (test/aot/modules-in-a-test-run.test.ts). They say so in their names and stand under a head of
  their own on the page.

- 57 cases in 18 files are declared `test.todo` and never run; two of them, on macOS, stand for
  faults (test/aot/fault-inside-a-removed-range.test.ts). 5 stored programs are skipped on one
  platform, because `bun <file>` itself answers now one way, now the other there.

- As on the last commit, each found by stored programs or test runs of the working tree that fail on
  a build of the last commit: they do not exit and print as `bun <file>` or `bun test` does. Not run
  again on this one; not run on older commits. Not fixed here; the nine items that follow:

- Silent: one data file imported under several `type`s, one of them by a name made at run time
  (`import("./" + name, { with: { type: "text" } })` beside `import("./conf.yaml", { with: { type:
  "yaml" } })`): an import can get what another `type` made of the file, or fail as another `type`
  failed. 7 programs.

- Silent, node:http: code of the program that runs while a header's value is looked at comes too
  late. 2 programs.

- Silent, node:http: another object stored as `req._readableState` between a chunk of the body and
  its event is not looked at; accessors that a program lays above a server, a response or a request
  are called another number of times than under `bun <file>`. 20 programs.

- Silent, streams and EventEmitter: an accessor that a program lays under `emit`, `write`, `push` or
  `__proto__` is called twice where `bun <file>` calls it once. 6 programs.

- Loud: the text of a function that holds JSX, an experimental decorator or `import.meta.glob()`,
  evaluated again: `SyntaxError: Unexpected token '<'`, `Invalid character: '@'`, `import.meta is
  only valid inside modules`; `bun <file>` answers. 5 programs.

- Loud: `require()` of a conditional name with one written arm like "bun:os" and one unknown arm is
  refused where `bun run` loads the written arm. 1 program.

- Silent, `bun test --aot`: a module that one test file mocks partly (`mock.module("./dep.mjs",
  async () => ({ ...(await import("./dep.mjs")), extra }))`) hands its state on to a later file that
  loads it without a mock: `export const list = []`, filled under the mock, is not empty in the next
  file, where `bun test` runs the module again. 11 test runs.

- Loud, `bun test --aot`: a test fails where it passes under `bun test`: two mocks whose async
  factories import each other's module while a third load leads to both; `await
  vi.importActual("./a")` where a.ts and b.ts import each other and the factory of a.ts takes the
  original; `vi.importActual()` inside a factory that is running. 16 test runs.

- `bun test --aot`, other shapes of mocks: 81 more test runs in 14 families, among them: a factory
  that asks for the module that it mocks; a helper that calls `mock.module()` for its caller; a mock
  laid in a test over the mock of a preload, or over a hoisted mock; a mock laid while the module's
  body waits at its top-level await; a mock of vitest's kind over a module whose body threw; the
  entry of `require.cache` of a module that a mock has set aside.

- `bun test --aot`, five kinds, as on the last commit. Each was seen on a build of the pinned engine
  with Bun's 186ac75, against `bun test` by the same binary: 114 small projects in eight families,
  of which 84 answer otherwise, and two programs more. Not fixed here; the five items that follow:

- Old, silent: the original of a mock that takes it (`importOriginal`, a mock without a factory, a
  spy) runs before the modules that its importer imports in front of it. `import "./setup.js";
  import { part } from "./part.js"`, where part.js reads what setup.js sets and a test mocks part.js
  over its original: `mock real undefined` for `mock real true`. 22 of 24 projects.

- Old, silent: once a mock of a CommonJS file has ended (`vi.doMock("./part.cjs", () => ({ kept: 10
  }))`, an importer loaded under it, `vi.doUnmock("./part.cjs")`), a namespace that passes the
  file's names on by `export *` goes over to the file: it shows the names that the mock left out,
  with the file's values, and the file's body runs: `kept,leftOut 1 2` for `kept 10 undefined`.
  Where a second `export *` brings such a name too, the namespace loses it: `extra,kept` for
  `both,extra,kept`. 45 of 70 projects.

- Silent: two mocks whose factories wait, loaded at once: a factory that imports the other mocked
  module gets the mock where `bun test` hands it the file: `mock 1 < mock 2` for `mock 1 < real 2`,
  and the file's body does not run. A mock laid over a mock whose factory has been called and has
  not answered reaches the load that began under the old one: `new x | new x | new x` for `old x |
  old x | new x`. 16 of 20 projects. Not run on older commits.

- Old, loud: beside a mock whose factory never answers, a load that does not lead to the mocked
  module waits for ever: `vi.doMock("./kept.js", () => new Promise(() => {})); try {
  require("./kept.js") } catch {}; (await import("./side.js")).y` times out where `bun test` prints
  `real side`. Beside such a mock the `import()` of a module that imports a name which nobody
  exports waits too, where `bun test` rejects it with a SyntaxError.

- Old, silent: `let fail; vi.doMock("./part.js", () => new Promise((resolve, reject) => { fail =
  reject; })); try { require("./part.js") } catch {}; fail(new RangeError("late"))`: `bun test`
  reports the RangeError and the test fails; compiled, the test passes.

- Old, silent, node:http in an executable: a listener that a program writes into `res._events` is
  not heard: `close/1` for `close/1,close/2,close/3`; of three listeners of `prefinish` written so,
  none. 2 programs, on a build of the pinned engine with Bun's 186ac75. Not fixed here.

- Reported by a user of the last commits; each seen on a build of this text, each program built
  alone by `bun build --compile --aot` and held against `bun <file>`. Not fixed here; the two items
  that follow:

- The build does not end (40 s given): a type alias that grows where it names itself: `type F<T> = {
  inner: T } & { or?: F<{ inner: T }> }`; `` type F<K extends string> = { key: K; next?: F<`${K}a`>
  } ``. 6 programs.

- Type errors that `tsc` does not report stop the build: TS2322 at `const k: keyof (typeof
  rows)[number] = "y"` over rows out of a .js file; TS7006 at `getRandomValues: array => array` in a
  literal of type `Crypto`; TS2416 at `json(): unknown` in a subclass of `Blob` and at a member
  `count` in a subclass of `Headers`. 4 programs.

- Old, loud: what is left of the crash where `addEventListener` or `dispatchEvent` comes out without
  a receiver (900ca03 fixed most forms): the method is read under a name that stands nowhere in the
  program as a string. 9 programs, each built alone, end with exit 134 ("process.finalization was
  left out of the executable, because nothing seemed to use it") where `bun <file>` answers. All
  nine are of the kinds that docs/compiler/compatibility.mdx declares since 900ca03: the name is
  put together while the program runs (`JSON.parse('["dispatch", "Event"]').join("")`, character
  codes, `atob()`; read by `signal[name]`, a pattern or a descriptor), or comes out of `for .. in`,
  of `Object.keys({ dispatchEvent: true })` or of the `name` of a function of the program's; or the
  method is found without any name, out of `Object.values()` of the prototype. `void dispatchEvent`
  once anywhere in the program keeps all that the global object leads to. Not fixed here.

- Old, silent, `bun test --aot --isolate` and `--parallel`: a source file that a test file writes
  over behind its first load is read anew by the next test file: `a.test.ts` imports `shared.ts` and
  writes it over, `b.test.ts` and `c.test.ts` import it: `bun test --isolate`, which keeps the text
  of every source file that it has read, prints `as built` twice; compiled, `written over` twice.
  Seen on a build of the last commits. Not fixed here.

- New with d08cc05, loud: a program that finds `addEventListener` and `dispatchEvent` by walking
  `performance` itself and calls them without a receiver: `function both(holder) { let add, send;
  for (const k in holder) { if (k.length === 16) add = holder[k]; if (k.length === 13) send =
  holder[k]; } return [add, send]; } const [add, send] = both(performance);`; so
  `Object.getPrototypeOf(performance)`, `performance.__proto__`, `Object.setPrototypeOf({},
  performance)`, `Reflect.get.call(..)`, out of a list, through a constructor. 8 programs of another
  hand, each built alone, answer as `bun <file>` at 900ca03 and end with exit 134 at d08cc05 and
  here. `void dispatchEvent` once anywhere in the program keeps all that the global object leads to.
  Not fixed here.

- Old, silent: under `bun test --aot` the factory of `vi.mock()`, `vi.doMock()` or `mock.module()`
  runs inside the `import()` of the mocked module, where `bun test` runs it in a later job: `let
  state = "before"; vi.mock("./x", () => { seen = state; .. }); const p = import("./x"); state =
  "after"; await p;` leaves "before" in `seen` for "after". An import by statement is right. The fix
  of 0a0d53c was taken back at 186ac75. Not fixed here.

- Old, silent: `module.exports = function () { return typeof this.children }; module.exports()` in a
  CommonJS file answers `undefined` in an executable where `bun <file>` answers `object`; an
  executable built without --aot answers `undefined` too. Not fixed here.

- On the last commits too: in an executable `native.dlopen` of bun:ffi is an accessor where plain
  Bun has a data member: nothing that loads machine code is read while the module loads. Stored as a
  known failure: test/aot/parallel/what-bun-ffi-hands-out/native-dlopen-is-a-data-member.mjs. Not
  fixed here.

- On the last commits too: one script that checks by `Bun.build({ check: true })` and then compiles
  by `Bun.build({ compile: { aot: true } })` lowers on 32 MB of stack a thread, not 64. No program
  is known that is compiled otherwise for it; the command line is not touched. Not fixed here.

- A loader's name as a label (`case "require":`) beside a read of the global object under an unknown
  key keeps a program from being closed, so `--trim` is blocked for it: as before the last two
  commits of the engine. Not fixed here.

- On the last commits too: in a folder without a tsconfig.json a build stops with TS2339 at
  `request.body.text()` (also `json()`, `bytes()`, `blob()` of a stream) where the request has a
  written type `Request`; a tsconfig.json as `bun init` writes it gets past it. Not fixed here.

- On the last commits too, and as docs/compiler/compatibility.mdx says, but silent: under
  `"useDefineForClassFields": false` one computed key that has to be folded (`["ki" + "nd"] =
  "user"`) makes all fields of the class defined: `name!: string` erases what the constructor of the
  base class has assigned (`undefined undefined` for `Ann 3`). Not fixed here.

- On the last commits too. Silent: `const p = await import("node:process"); Object.keys(p);
  process.features = 2`: `typeof p.features` is "number" for "object". Not fixed here.

- On the last commits too, `bun test --aot`. The original of a partial mock that imports another
  mocked module: `ReferenceError: Cannot access 'o' before initialization` where `bun test` prints
  `extra,seen mocked`. `mock.module()` called through `forEach()` in a helper mocks nothing, in
  silence (`real` for `mocked`). Inside a generator of another folder that a spread steps it
  resolves `./x.mjs` from the folder of the consumer: the run stops (`cannot replace .. because the
  build didn't see a test mock it`). Not fixed here.

- On the last commits too: a `.jsonc` file that is no strict JSON (a comment, a comma at the end)
  beside `import("./" + name, { with: { type: "json" } })`: `bun <file>` throws a SyntaxError at the
  import; the executable throws `Cannot load .. from a dynamic path`, and the build, which warned of
  the file before (TS100089), says nothing of it. Loud in both. Not fixed here.

- On the last commits too. Loud: `process instanceof Probe` where `Probe` has a static
  `Symbol.hasInstance` that lists the keys of `holder.stdout`: what the method is handed is not
  seen, and the process ends: `process.stdout .. was left out of the executable`. Not fixed here.

- On the last commits too: `require(JSON.parse('"./lib"'))` where `lib.js` is a symbolic link and a
  folder `lib` lies beside it throws MODULE_NOT_FOUND where Bun finds the file. Not fixed here.

- On the last commits too. Memory, the answers right: a loop that fills a list by `out[at] = at` up
  to a bound held in a variable asks for the room of the whole bound in front of the loop. Where the
  loop ends early the room was asked for nothing: a loop to 150,000,000 that throws a RangeError
  after about thirty turns peaks at 1,195 MB, under `bun <file>` at 23 MB. Not fixed here.

- Type errors stop an ahead-of-time build: still a false stop where the build brings Bun's
  declarations: `timer.toString(36)` on what `setTimeout` returns (TS2554); `case "Linux armv8l":`
  on `navigator.platform` (TS2678); three cases under `"lib": ["es2019"]`. `// @ts-ignore` gets past
  each. What is missed is as the message of the commit that brought the check says; two true errors
  more are known to be forgiven.

- `bun test --aot`: odd shapes of mocks (a late object, a file that throws once) answer otherwise
  than `bun test`; a mock that was taken back while a load waits is used; `vi.doMock()` over an ES
  module whose body threw (eight shapes answer otherwise, one ends the run); vitest's
  `importOriginal()` and a mock without a factory over a setup file's mock; an entry planted in
  `require.cache` makes the next `import()` run the file again; a mock of a barrel does not reach a
  name handed on from `./inner.js?x`; a helper of the tests that names `Object.prototype` by its
  name: writes on other built-ins out of sight are refused; under `--rerun-each` what a test file
  exports stays one object across the runs; `error.name` is "SyntaxError" for "BuildMessage" under
  `--isolate`.

- A store into a typed array at a negative index is slow; `new this.Proxy` in a sloppy function; the
  old spelling of a path above the root written out by hand.

- As on the last commits: a plugin that no compiled file names, with code from disk; an object that
  is lent to a callee lies in the frame; two sibling modules that both await; late private symbols
  of node:http; text run by `eval` that reads a member of `process` which the build left out; an
  `onResolve` callback that throws at a later name; `routes: { "/*": { dir, style } }` is refused;
  an accessor under "noDeprecation" or "throwDeprecation" on `EventEmitter.prototype` ends the
  process; a folder named `root` beside the folder of the entry point; the bytes of an executable
  hang on whether a file named as the entry point's stem lies beside it; accessors on the own names
  of a request or a socket, or on `IncomingMessage.prototype`, that throw once (one form is fixed,
  below); `const f = true && function () {}`: `f.name` is right in 9 of 12 forms.

- Builds that grow faster than their programs: loops nested hundreds deep (a square); two rows of
  classes whose tables grow by the square; n classes below one base and an object of them out of
  sight (four times the build for twice the classes); N calls of a helper with a loop in one
  straight block (a square).

- Red in CI: nothing. The build at ce10cc2 passed (63 minutes, no red file).

Fixed:

- Nothing in this commit.

Tests:

- Of the 2 added lines 1 are tests: 0 files of stored programs, 0 of stored test runs, 0 IR tests
  made from source and answers, 0 of the fuzzers, 0 others under test/aot, 1 outside it.

- test/js/bun/test/mock/mock-module.test.ts: a longer limit for one case.

- No test file was run on this commit before the push. The sources of the engine are those of the
  last pin to the byte (checked: the merged commit's tree and 3c42aae2's are one tree), and of Bun's
  sources nothing changes but the pin's line; what the last message says of a build of those sources
  stands. CI builds with the released engine for the first time.

Outside the compiler's folders:

- test/js/bun/test/mock/mock-module.test.ts (+1 -1): a longer limit for one case.
robobun added a commit that referenced this pull request Nov 7, 2026
#997 replaced the module run time of aot/runtime. Four files of aot/runtime and four of runtime/ had conflicts.

runtime/: both sides stay. loadRequestedModules() takes the load that asks (main) and then the async context (this branch). The scope around the host's resolve() stands in front of willAnswerRequestOfUncompiledModule(). ModuleGraphLoadingState visits both new fields.

aot/runtime: the four files are main's, and the rule is applied to the run time that #997 brings.
- The three CompiledModuleImport jobs carry the async context of the call of import(), as before.
- A call whose text is on its way keeps the async context of the call (TextOnItsWay, and TextThatWaits in a test run). startImportWhoseTextHasCome() and makeCallAgain() make the call again under it.
- A deferred import keeps it for its step.
- A CommonJS file that the loader would run in a job of its own runs under the async context of its load, one scope a file. The start of an entry point does not run all its files in one call where a scope would enter.
- handSynchronousLoadToLoader() passes ModuleLoadFlag::Synchronous: the load that stands for a require() keeps no async context.
- ModuleRecord::executeAsync() asks asyncContextOfModulesThatWait().

Not carried over, because #997 removed what they were for: the counted imports and the imports that wait behind a load. A graph that waits behind earlier calls is held with its payload, which has the async context. The async context that handGraphToLoader() put back before the steps of the loader is not carried over either: no program shows a difference with it in this run time.
Jarred-Sumner added a commit that referenced this pull request Nov 7, 2026
…th mocks, builds that grew (#999)

AOT: fixes behind #997: silent wrong answers, a crash in test runs with mocks, builds that grew

Fixes alone, on 42067fc. Outside aot/ five files change: see "Outside aot/".

Fixed:

- Old, silent, as users build: `receiver.f(swap())` called the function that the argument had just
  stored. With `class A { f(x) {..} } class B { f(x) {..} } class H {}`, `const held = new H();
  held.f = x => x + 1000;` and `function swap() { held.f = another; return 1; }`, a loop over `[a,
  b, held][turn % 3].f(swap())` called what `swap()` had just stored under `held.f`, where `bun
  <file>` calls the function that lay there before the arguments ran: 308 for 208. The read of the
  method was left to the call, behind the arguments, where every other receiver's read counted as
  constant; a field that is appended from outside the constructor counted so too. It is asked of the
  planned layout as well (aot/walk/AOTWalkUnionTableCalls.cpp: +2 -1). The call through the table
  stays where nothing stands between the read and the call. 13 stored programs in Bun's tree.

- Old, silent, as users build, the ordinary spelling among them: a later source of `Object.assign()`
  or of a spread was read as it was made, not as it is by then: `Object.assign({..}, defaults,
  this.options)` behind a getter; a source that a variable of the file, a captured variable, a field
  of a holder or a helper's parameter also holds. And `Object.assign(t, s, t)` with `t` a literal in
  sight laid the old fields over the new. A source is made again in sight only where it is a value
  of this walk that nobody else holds, and an operand behind the sources that names the target is
  the target as it is by then (aot/walk/AOTWalkCopiesOfObjects.cpp: +7). 26 stored programs in Bun's
  tree.

- Old, silent, as users build: the order of an object's keys could be wrong behind a store during
  which code of the program runs (aot/runtime/AOTPropertyCachesOperations.cpp: +10 -1). It only
  narrows what a store remembers. 4 stored programs in Bun's tree.

- Old: a test run that mocks a module and ends the mock could crash (aot/runtime/AOTModules.cpp,
  AOTModules.h, AOTModuleRecord.h, AOTTestRunFactories.cpp, runtime/AbstractModuleRecord.cpp,
  AbstractModuleRecord.h: +35 -9). Known: in such a test run a barrel of CommonJS stars with many
  importers loads slower with it: +0.7%, +7.9%, +19.6% at 200, 800, 1,600 importers, measured on the
  working tree. Not fixed here.

- Old, silent, test runs with module mocks, an everyday spelling: `vi.doMock("./mid.js", async
  original => ({ ...(await original()), extra: 1 }))` where `mid.js` holds `export * from
  "./tools.cjs"; export * from "./early.js"` and `early.js` holds `export * from "./tools.cjs"`: the
  original had no names (`both=undefined,kept=undefined` for `both=file,kept=1`);
  `vi.importActual()` alike. The record of a CommonJS file and the record of its face name one
  binding (aot/runtime/AOTModules.cpp, one function: +3 -2). 37 files of stored test runs in Bun's
  tree.

- Old, silent, test runs with module mocks: the factory of a mock that requires its own CommonJS
  file, where the build lets that file leave the program (a line of the run names its key in
  `require.cache`): `bun test` runs the file once and the mock lies over the real module; compiled,
  a TypeError (aot/runtime/AOTModuleEvaluation.cpp: +7). 15 files of stored test runs in Bun's tree.

- Old: a build could hang on a program with a very wide switch, object or module
  (aot/facts/AOTFactsRegExpTexts.cpp: +11 -2). 4 stored programs in Bun's tree.

- Old: a build could take much memory and time on a program that makes many long lists as it starts:
  the run that a build makes of the start of a program priced an operation at one, whatever it made.
  A place that is filled books its bytes in the room that stands, and sixteen places cost an
  operation; no new bound and no new number (aot/facts/AOTFactsRegExpTexts.cpp: +22). 2 IR tests, 1
  test file in Bun's tree. It does not end the kind.

- Old, loud: right typed programs were refused with TS100031: an `int32` out of `slice()`,
  `filter()` or `sort()`, and a cast that is only expected, asked where the walk no longer names
  what it casts (aot/walk/AOTWalkInt32Promises.cpp: +52 -2). 10 stored programs in Bun's tree.

- Old, loud, the engine's half: a load under a name that nobody knows threw where `bun <file>`
  answers, though the program writes a library module's name as the key of a literal, of a store, of
  a class member or as a joined key (aot/facts/AOTFactsOfProgram.cpp: +34 -1). The other half is
  Bun's.

- Slower, no answer wrong: in an executable built with `--external` or `--aot-allow-code-from-disk`,
  no module's value stayed in sight, so what one file of the library imports from another was no
  constant any more. What the internal files of the library hand out stays in sight
  (aot/facts/AOTLinkReach.cpp, AOTLink.cpp, AOTLinkFlow.h, AOTLinkTables.h,
  aot/image/AOTModuleTables.cpp, aot/runtime/AOTBuiltinModules.cpp, AOTModuleData.h,
  AOTModuleTable.cpp, AOTModuleTable.h: +93 -5). 3 new IR tests, 1 changed, 131 lines of native
  tests, 1 test file in Bun's tree. No time was measured on this tree.

Outside aot/:

- runtime/AbstractModuleRecord.cpp (+1 -1), AbstractModuleRecord.h (+3): for the crash in test runs,
  above. Both stand inside `#if ENABLE(AOT)`. The first is one more condition in a test that is
  reached for a record of compiled code alone; the second is one protected inline function. No
  member is added. A program that is not compiled runs neither.

- wasm/WasmBBQJIT64.cpp (+1 -1), toward upstream's text: the baseline JIT of WebAssembly asks for
  atomics as upstream asks (`isARM64_LSE()`) where no image is built. On Linux both questions read
  one bit; no test.

- JSTests/stress/intl-datetimeformat-language-change-mid-construction.js (+3),
  JSTests/BUN-TEST-DIFFERENCES.md (+2 -1): upstream's test on timing, which failed once on the arm64
  lto-hardened lane at 3c42aae and passed when its job was run again, is marked `serial!`.

On a build of this commit with the sources of Bun's side of these fixes, Linux x64, release, no LTO:
it compiles and links; the engine's 2,567 IR tests pass (2,562 at 42067fc); the block of
thread-local storage is 23,504 bytes, as before. Nothing else ran on it before this push: the stored
programs and test runs of these fixes run beside CI. Each fix was seen by its author to turn its own
programs on a build of the working tree; whether they turn on this text is what those runs are for.


AOT: three native tests that need Bun's table of entries wait for it

Tests alone. The last commit brought three native tests under exports-that-stay-in-compiled-code/
that name two modules of Bun's library. `testaot` as this repository builds it has the table of the
stand-in host, where their IR text does not parse, so the four test jobs with the compiler failed:
4,307 passed, 3 failed, these three. aot/tests/AOTExportsThatStayInCompiledCodeTests.cpp goes back to
42067fc's text (-131). The fix that they test stays, with its three IR tests and its test file in
Bun's tree.


AOT: mocks in test runs: one more road to a crash; a file that throws below its own factory runs again

On e8741fa. One file changes, aot/runtime/AOTModuleEvaluation.cpp (+3 -4). Nothing outside aot/.

Fixed:

- Old: a test run that mocks a module and ends the mock could crash: one more road (+1 -4).

- New with a864536, silent, test runs with module mocks. That commit let the factory of a mock
  require its own CommonJS file where the build lets that file leave the program. Where the file
  throws on its way, what its run had begun was kept, and the next `require()` of it got the exports
  as far as they were filled, with no error. With `exports.early = "half"; if (..) throw new
  Error("part fails"); exports.late = "whole";` two calls in the factory answered `threw part
  fails`, then `half undefined`, and the file ran once; `bun test` answers `threw part fails` twice
  and runs the file twice; 42067fc answers with a TypeError each time. Seen in three test runs on a
  build of a864536's text. The run that threw is forgotten here too, as on the other road that runs
  an original beside its mock (aot/runtime/AOTTestRunOriginals.cpp) (+2). Three stored test runs (9
  files) for Bun's tree, run by its own harness with the three that a864536's fix brought: 6 pass
  on the build below, 3 on a build of a864536's text, none on a build of 42067fc's.

Corrected:

- a864536's message headed the fault of that factory "Old, silent". It is a TypeError where `bun
  test` has none: loud.

- a864536's message says of the fix for a build that takes much memory and time on many long lists
  "1 test file in Bun's tree". That file is not in Bun's tree: the message of c4d68cd4 in
  oven-sh/bun says why.

On a build of a text that holds this commit's change and one other that is not in it, with Bun's
side of this branch, Linux x64, release, no LTO: it compiles and links; the engine's 2,567 IR tests
pass; the test runs above. This very tree was not built as one: its one changed file was compiled in
that build, all its other files in the build for e8741fa's text.


AOT: a field read in a loop as what the build saw stored; mocks in test runs: one more road to a crash

On a48610b. Three files, +24 -2. One of them lies outside aot/: see "Outside aot/".

Fixed:

- Old, silent, as users build. A field into which the program is only seen to store objects that it
  fills under computed keys: `class Shelf { constructor(names) { const bins = {}; for (let i = 0; i
  < names.length; i++) bins[names[i]] = i; this.bins = bins; } }`. Code made from a text stores a
  list there, `(0, eval)("(holder, value) => { holder.bins = value; }")(shelf, [1, 2, 3])`, and a
  loop of nine turns asks `Array.isArray(shelf.bins)`: false in every turn, where `bun <file>` says
  true. So too with `new Function`, with `Reflect.set` out of a text, and with a function stored and
  `typeof` asked (aot/plan/AOTSlotPlan.cpp: +5). 5 stored programs for Bun's tree. Each built alone:
  all five print what `bun <file>` prints on the build below; none does on a build without these
  five lines, nor on a build of 42067fc's text.

- Old: a test run that mocks a module and ends the mock could crash: one more road.

- No behavior: the three lines of a48610b that forget a run that threw are spelled with a `return`
  of their own (aot/runtime/AOTModuleEvaluation.cpp: +3 -2).

Corrected:

- a864536's message says that an `int32` out of `slice()`, `filter()` or `sort()` was refused with
  TS100031. Of `sort()` that is not so: the stored program for it builds at 42067fc.

Outside aot/:

- runtime/AbstractModuleRecord.cpp (+16), two places, both inside `#if ENABLE(AOT)`, for the crash
  in test runs, above. Each asks first whether the VM holds compiled code and then whether the
  record is one of compiled code; what follows is reached for a record that nobody compiled, in a
  run that holds compiled code. A program that is not compiled runs neither.

On a build of this commit with Bun's side of this branch, Linux x64, release, no LTO: it compiles
and links; the engine's 2,567 IR tests pass; the five programs above. Seven test runs print on it
what they print on a build of a864536's text. The five test runs of the factory that requires its
own file print what `bun test` prints.
Jarred-Sumner added a commit to oven-sh/bun that referenced this pull request Nov 7, 2026
The Bun side of the rewritten ahead-of-time compiler. The engine side is oven-sh/WebKit#997, which
has the design and the numbers, with its follow-ups oven-sh/WebKit#999 and oven-sh/WebKit#1000. This
is #47942 with its follow-ups #48088 and #48112 in it.

`src/aot`: the lowering writes the program that the engine's new scan, link and walk read. Captured
values are copied into closures where nothing stores to them later, straight-line blocks are joined,
and CommonJS and ES module graphs are resolved at build time, cycles included. `bun test --aot`:
module mocks, spies, hoisted factories, re-evaluated modules and `--rerun-each` behave as they do
without `--aot` in many more cases. Type errors stop an `--aot` build, in TypeScript only; `bun test
--aot` prints them as warnings and runs. A computed import no longer embeds data files that its
written name does not ask for. `bun:ffi`: no limit on the number of open callbacks in compiled
programs.

What changes for Bun without `--aot`, by folder and file, is listed in the description of the pull
request; the list below is the short form that the commits carried. In these lists "old" says that
an earlier commit of the branch had it too and "new" that the last commits brought it; neither says
anything of the compiler that main had before. "As users build" is `bun build --compile --aot`; a
stored program or test run is a test that this commit adds. The commits of the three branches, each
with what it fixes and what was run for it, stay readable on the pull requests.

Fixed on the branch since the description of the pull request was written:

- In the engine, each with its JavaScript in the messages of oven-sh/WebKit#999: silent, as users
  build: `receiver.f(swap())` called the function that the argument had just stored; a later source
  of `Object.assign()` or of a spread was read as it was made, not as it is by then, and
  `Object.assign(t, s, t)` laid the old fields over the new; the order of an object's keys could be
  wrong behind a store during which code of the program runs. Silent, test runs with module mocks:
  the original of a mocked barrel had no names where two stars lead to one CommonJS file; the
  factory of a mock that requires its own CommonJS file got a TypeError. A build could hang on a
  program with a very wide switch, object or module. A build could take much memory and time on a
  program that makes many long lists as it starts. Right typed programs were refused with TS100031
  (an `int32` out of `slice()` or `filter()`). Slower, no answer wrong: executables built with
  `--external` or `--aot-allow-code-from-disk` lost sight of what the library's internal files hand
  out. Stored programs, test runs and test files for them come with this commit.

- Old, silent, in executables alone: `module.exports = function () { return [typeof this.children,
  typeof this.loaded].join(); }; console.log(module.exports());` printed `undefined,boolean` where
  `bun <file>` prints `object,boolean`; `this.children.length` threw. What `module.exports` is
  called with is the module object, and it goes where the callee takes it; so does a name that may
  hold the module object (src/aot/builtins/resolve/module_objects.rs, its tests). 6 stored programs
  and IR tests.

- Old, silent, low: an error that `bun <file>` throws was not thrown: `console.log("start"); lib.f;
  var lib = require("./x.mjs"); console.log("end", lib.f());` printed `start`, `end 1` where `bun
  <file>` prints `start` and throws a TypeError: the read was taken out. A member of what
  `require()` gives may go only where the variable holds it already (src/aot/compile/removable.rs).
  12 stored programs.

- Old, silent or loud: one data file loaded under several types, one of them under a name that is
  made at run time: every such site, and every statement behind it, got the form of the site that is
  written first, where `bun <file>` goes by time: with yaml written second and run first, `ENOENT
  reading`, then the string, for `object,object`. A made name takes no part in the forms that the
  build shares (src/sema/program/code_walk.rs, code_load.rs, code_imports.rs). 2 stored projects. It
  is a part of the kind that stands under "Known problems", not all of it.

- Old, an abort as users build: `process.finalization was left out of the executable, because
  nothing seemed to use it`, exit 134, where `dispatchEvent` is read under a computed key and called
  without a receiver and the name stands only in a template or in JSX text. The net that decides
  which later files are asked reads both (src/aot/builtins/resolve/unnamed_uses.rs). 11 stored
  programs. Four spellings are fixed, others of the kind are not.

- Old, loud: a right typed program was refused with TS100031: a whole number that a type lists (`1 |
  2 | 3`), read off an object and reckoned with where the read stands. The type is stated where the
  read is reckoned with; it proves nothing: each guess on it is tested at the run
  (src/aot/lower/convert/edges.rs). 1 stored program. Not fixed here: the same read into a local
  that is reckoned with.

- Old, loud, Bun's half: `const load = [require][JSON.parse("0")]; Object.keys({ "node:zlib": 1,
  "bun:jsc": 1 }).map(load)` threw MODULE_NOT_FOUND where `bun <file>` and a plain executable
  answer. Where a load goes by a name that nobody follows, the executable holds the library modules
  whose names the program writes; a key of a literal, of a store, of a class member, a joined key
  and a key of a data file are heard as a text of that name is, if they are more than one word
  (src/aot/load/contents/load_names.rs, scan.rs, tests.rs). 3 stored programs.

- In the engine, in the messages of oven-sh/WebKit#999. Old: a test run that mocks a module and ends
  the mock could crash.

- docs/compiler/compatibility.mdx: 24 places now say what the compiler does: differences from `bun
  <file>` that are known and not fixed here are written down as differences.

- In the engine, with its JavaScript in the messages of oven-sh/WebKit#999. Old, silent, as users
  build: a field into which the program is only seen to store objects that it fills under computed
  keys; code made from a text stores a list there, and a loop of nine turns asks
  `Array.isArray(shelf.bins)`: false, where `bun <file>` says true. So too where a listener stores
  its argument there: `const lay = bins => { shelf.bins = bins; }; new EventEmitter().on("filled",
  lay).emit("filled", [1, 2, 3]);`. 6 stored programs.

- In the engine. Where the factory of a mock requires its own CommonJS file and that file throws on
  its way, the file runs again at its next `require()`, as under `bun test`; before, the answer was
  a TypeError. 9 files of stored test runs.

- Old; silent where the sources still stand, loud elsewhere: `await import(flag ? "./other.sqlite" :
  "./data.sqlite", { with: { type: "sqlite" } })`, and the same under a name with a hole. An
  executable of `--compile` opens the database of the folder in which it runs; with --aot it opened
  the database of the folder in which it was built, under its whole path; where that is gone,
  "SQLiteError: unable to open database file". Beside it: a name that the build cannot see
  (`import(JSON.parse('"./data.sqlite"'), ..)`) beside a written import of the same database failed
  everywhere. A site with alternatives or a pattern makes the host's module for each name, as a
  written site does (src/sema/resolve/code.rs, code/computed.rs, program/code_imports.rs,
  src/aot/module_keys.rs, load/plugin_modules.rs, and in the engine). 1 test file, 6 cases.

- Old, silent, as users build: `const { default: whole } = helper(require("./part.cjs"));
  whole.default = 5; whole.__esModule = true;`, part.cjs without a marker, and an ES file that
  imports the default later: `bun <file>` and `--compile` print `number true`, compiled `object
  false`. A pattern that takes the default of a helper's answer carries the exports object away, and
  so does a choice on `default` (`||=`, `??=`) (src/aot/modules/commonjs_exports.rs). 49 files of
  stored programs, 1 crate test.

- Old, loud: `require(flag ? "left-out" : "./slow.cjs")` built with `--external left-out`: `bun
  <file>` and `--compile` answer; --aot: exit 1, "Cannot find module './slow.cjs'". So too with an
  address in place of the package, with `import()`, beside a module of the library, out of a table.
  Among alternatives that are written out, a package's name or an address that is left outside no
  longer ends the walk; a path, a name under a query and a pattern end it as before. And `await
  import(flag ? "./NOTICE" : "./LICENSE", { with: { type: "text" } })`: exit 1: a file without an
  ending is a candidate where its name is written out whole and the call names its type
  (src/sema/resolve/code/computed.rs). 2 test files, 14 cases.

- Old, loud: right programs stopped the build: "internal compiler error (Load): the program enters
  functions of Bun's library that the load has left out": `var i = 0; { function i() {} } [7][i]`,
  and `/** @jsx list.at */ <a />`. And `import fs = require("node:fs"); { function fs() {} }` in a
  .cts file: "TypeError: Attempted to assign to readonly property." at the start
  (src/aot/builtins/resolve/unnamed_uses.rs, mentions.rs, src/sema/bind/runtime.rs and three files
  below it, program/code_file.rs). 8 stored programs, crate tests.

- Old, loud: `const uses = { zlib(found) { .. } }; for (const name in uses)
  uses[name](require(name));`: exit 1, "Cannot load 'node:zlib': it isn't in this executable". The
  variable of a `for...in` holds what `Object.keys()` of the object lists, and a call of a member
  leaves the object as written where every property is a function written there that mentions
  neither `this` nor `super` (src/sema/import_sites/alternatives.rs). 5 stored programs, crate
  tests, 1 test file on the time of the build.

- Old, test runs with module mocks, an error where `bun test` answers: index.js `export * from
  "./legacy.js"; export { make } from "./api.js"`, legacy.js `export { make as create } from
  "./index.js"`, `mock.module("./api.js", () => ({ make: () => "mocked" }))`, reader.js `import {
  create, make } from "./index.js"`: `mocked,mocked`; compiled "ReferenceError: Cannot access
  'create' before initialization". A ring on the way of a name is one name asked twice of one file,
  not a file met twice (src/aot/lower/module/test_run_ways.rs). 23 files of stored test runs, 1
  crate test.

- In the engine, the first two with their JavaScript in the messages of oven-sh/WebKit#1000: old,
  right programs that aborted as users build: a name that a statement re-exports from a CommonJS
  file that lacks it, beside an `export *` that has it (53 files of stored programs); old, silent,
  test runs: who was linked under a mock that a second `mock.module()` patches read undefined behind
  its end (16 files of stored test runs); a build that could end at an assertion, seen in the IR
  alone.

- Old, loud, a right program did not build: `class Counter { static #made = 0; static make(by) {
  Counter.#made += by; return Counter.#made; } } namespace Counter { export function twice(by) {
  return Counter.make(by) * 2; } }`: "internal compiler error (ReadAndVerify): StringNotCanonical:
  string 5 is not canonical WTF-8". One private static member of any kind, a field, an accessor or a
  method, beside a namespace of the class's name that holds a value. The two share one table of
  exports, and the private static was listed as a field of the namespace's object. An entry that a
  class's member with a private name declares is no such field
  (src/aot/lower/layouts/containers.rs). 13 stored programs, 1 IR test.

What Bun without `--aot` does otherwise than before ("main" in this list is main before this
commit):

This list is not all. A reading of every hunk from main to an earlier commit of the branch outside
test/, docs/, src/aot/ and src/js/ahead-of-time/ (627 files, 4,555 hunks) finds 1,592 that a run
without --aot passes through: 1,238 in src/sema, which `bun check`, `bun lint`, `bun fmt`, `--check`
and `bun build --dts` run and which this list does not name, and 354 elsewhere, 88 separate changes,
of which it names nine. The new engine also has eight commits of WebKit's main (oven-sh/WebKit#967
to oven-sh/WebKit#983: 99 files outside aot/, B3 and Air among them) that Bun's main, which pinned
4d45755f, had not shipped. The description of #47942 has the whole list, by folder and
file, with what is not by intent and not fixed.

- `Bun.build({ compile })` no longer reads `aotHeat`, `aotDisable`, `aotValidate` and
  `aotLogTypeMismatches`, options of main's compiler. `Bun.build({ compile: { aotHeat: anything }
  })` always throws now, `compile.aotHeat is not a valid option`: every key of `compile` that begins
  with `aot` and is not known is refused before any is read (src/runtime/api/JSBundler.rs,
  src/runtime/cli/compile_options.rs). At the top level `Bun.build({ aotHeat })` threw "goes inside
  compile" on main and is passed over now; `({ aotOut })` and `({ aotHarden })` throw it now. It
  reads `aotHarden` and `aotOut`. `packages/bun-types` follows, but for `aotOut`, which is read and
  not declared. By intent.

- Flags of main's compiler that this one does not have are not known any more, among them
  `--aot-log-type-mismatches`, `--aot-build-test-part` and `--aot-memory-limit`. All begin with
  `--aot`. By intent.

- Bun reads a file of 64 MB or more on several threads, and writes executables the same way. Those
  threads are named "Bun Parallel"; on main they have no name. A program can see it in
  /proc/self/task/*/comm.

- A `bun test --parallel` worker that waits for its next file sleeps. On main it keeps polling.

- Every start of `bun` compares its first argument with the prefix `--aot-program-file`. Nothing
  follows unless BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING is set.

- Native functions whose results are declared to the compiler test a flag before they return.
  Measured it is 3 to 8 instructions a call in plain Bun: `Blob.text` +3.0 of 1,777, `Blob.slice` +6
  of 926, `Blob.type` +8.0 of 342 (exact user instructions a call, Linux x64, a build of main
  against two builds of the tree that the branch was made from, each read twice; only the +8.0 is
  laid to the test by the disassembly: the test behind the call takes the thunk's tail call away;
  the other two are differences of whole builds); about 55 KB of thunks. In a release build the flag
  is false unless compiled code runs, and a native function that answers outside its declared type
  answers as before. A build that asserts (debug, `cargo test`, ASAN, or assertions with canary)
  starts with the flag set: there such an answer throws a TypeError, and a value cached outside its
  type panics.

- In a build of Bun with assertions (debug, ASAN) such a native function throws a TypeError where it
  answers outside what is declared for it: by intent: it holds the declarations to Bun's own tests.
  No released build has it as long as no release-safe canary is published: the switch is
  `Environment::CI_ASSERT` (src/bun_core/env.rs); and a cached value outside what is declared panics
  there, it throws no TypeError (src/jsc/bindgen.rs).

- `bun build --compile --trim` without --aot fills removed code with `hlt` (x64; on macOS `int3`, as
  main) and `udf` (arm64) where main writes `int3` and `brk`, and also removes what only compiled
  code enters. By reading; not run.

- Each step of a `for await` that drives an async generator passes one test more, whether the
  process has compiled code.

- `bun test`: where the runner loads the next test file while a mock's factory has not settled, that
  load, which has no importer, keeps its key. Three lines of this branch in
  `keyOfImportWhileModuleMocksRun()` (src/jsc/bindings/BunPlugin.cpp). By intent.

- Two places in the engine's runtime/AbstractModuleRecord.cpp pass one test more, whether the
  process has compiled code.

The items above were held against `git diff` of main and the branch, file by file. What the diff
holds beside them is what the reading named at the head of this list is about.

Known problems:

- A test run under `--isolate` in which an object that one test file made is stored into by the next
  can crash.

- 236 cases in 134 files are marked as known failures, not fixed; each runs every time and turns red
  the day it passes. 170 of them are bounds on what a program brings of Bun's library and on what
  `--trim` removes, 15 are on how builds grow, 51 are others. test/aot/goals-not-met-yet.md lists
  every one with what was measured, the bound, and what keeps the number from growing worse; `bun
  test/aot/tools/list-goals-not-met-yet.ts` writes that page out of the marks in the tree.

- 4 more marks, in 3 files, stand on wrong answers, not goals. Three are on mocks under `bun test
  --aot`: a mock laid over a file URL reaches the other spelling of the same file too
  (test/aot/mock-file-url.test.ts, two cases: plain prints `one-importer mocked real`,
  `two-importers mocked`, `two-importers real`; compiled `mocked mocked`, `mocked`, `mocked`), and a
  mock that is taken back while a plugin waits is still used (test/aot/unmock-while-loading.test.ts:
  plain `k runs`, `seen real/slow`; compiled `factory runs`, `seen first/slow`). The fourth is
  small: where a test catches the error of a file whose import does not parse, `error.name` is
  `BuildMessage` under `bun test --isolate` and `SyntaxError` under `bun test --aot --isolate`
  (test/aot/modules-in-a-test-run.test.ts). They say so in their names and stand under a head of
  their own on the page.

- 57 cases in 18 files are declared `test.todo` and never run; two of them, on macOS, stand for
  faults (test/aot/fault-inside-a-removed-range.test.ts). 5 stored programs are skipped on one
  platform, because `bun <file>` itself answers now one way, now the other there.

- Each found by tests that failed on a build of an earlier commit of the branch: they do not exit
  and print as `bun <file>` or `bun test` does. Not run again on the last one. Not fixed here; the
  nine items that follow:

- Silent: one data file imported under several `type`s, one of them by a name made at run time
  (`import("./" + name, { with: { type: "text" } })` beside `import("./conf.yaml", { with: { type:
  "yaml" } })`): an import can get what another `type` made of the file, or fail as another `type`
  failed. 7 programs.

- Silent, node:http: code of the program that runs while a header's value is looked at comes too
  late. 2 programs.

- Silent, node:http: another object stored as `req._readableState` between a chunk of the body and
  its event is not looked at; accessors that a program lays above a server, a response or a request
  are called another number of times than under `bun <file>`. 20 programs.

- Silent, streams and EventEmitter: an accessor that a program lays under `emit`, `write`, `push` or
  `__proto__` is called twice where `bun <file>` calls it once. 6 programs.

- Loud: the text of a function that holds JSX, an experimental decorator or `import.meta.glob()`,
  evaluated again: `SyntaxError: Unexpected token '<'`, `Invalid character: '@'`, `import.meta is
  only valid inside modules`; `bun <file>` answers. 5 programs.

- Loud: `require()` of a conditional name with one written arm like "bun:os" and one unknown arm is
  refused where `bun run` loads the written arm. 1 program.

- Silent, `bun test --aot`: a module that one test file mocks partly (`mock.module("./dep.mjs",
  async () => ({ ...(await import("./dep.mjs")), extra }))`) hands its state on to a later file that
  loads it without a mock: `export const list = []`, filled under the mock, is not empty in the next
  file, where `bun test` runs the module again. 11 test runs.

- Loud, `bun test --aot`: a test fails where it passes under `bun test`: two mocks whose async
  factories import each other's module while a third load leads to both; `await
  vi.importActual("./a")` where a.ts and b.ts import each other and the factory of a.ts takes the
  original; `vi.importActual()` inside a factory that is running. 16 test runs.

- `bun test --aot`, other shapes of mocks: 81 more test runs in 14 families, among them: a factory
  that asks for the module that it mocks; a helper that calls `mock.module()` for its caller; a mock
  laid in a test over the mock of a preload, or over a hoisted mock; a mock laid while the module's
  body waits at its top-level await; a mock of vitest's kind over a module whose body threw; the
  entry of `require.cache` of a module that a mock has set aside.

- New, loud, as users build, an unusual program: `const uses = { one(found) { .. }, two(found) { ..
  } }; uses.valueOf``.extra = found => found.name; for (const name of Object.keys(uses))
  console.log(name, uses[name](require(`./${name}.cjs`)));`, so too where the tag hands the object
  to a constant or to `Object.defineProperty()`: `bun <file>` loads all three files, and so did
  earlier commits of the branch, with the warning TS100064 at the build; now it builds without the
  warning and ends, after the first two, with "Cannot find module './extra.cjs'", exit 1. A member
  that is called as a tag is not taken for a call. 3 programs, the first of them run on a build of
  the branch. Not fixed here.

- New, silent, an unusual program: one .sqlite file imported twice under a name made at run time, as
  `{ type: "text" }` and then as `{ type: "sqlite" }`: `bun <file>`, `--compile` and earlier commits
  of the branch hand out the first form again (`string string`; the other way round `object
  object`); compiled, each type gets a form of its own: `string object`, `object string`. 2
  programs. Not fixed here.

- New, silent, small: a plugin that is added at run time, `build.onResolve({ filter: /\.sqlite$/ },
  args => ..)`, is handed the working folder as `args.importer` for a database that is imported
  under a name made at run time; `bun <file>` and `--compile` hand it the file. Earlier commits of
  the branch refused that import: "Cannot find module". 1 program. Not fixed here.

- Old, silent, as users build: `process.chdir("elsewhere"); const db = (await import(__dirname +
  "/data.sqlite", { with: { type: "sqlite" } })).default`, so too `path.join(__dirname,
  "data.sqlite")`: `bun <file>` and an executable of `--compile` open the database beside the file;
  with --aot the one of the working folder is opened. It shows where the program runs in another
  folder than that of its file and that folder holds a database of the same name. Not fixed here.

- Old, silent, as users build: an import for its side effects (`import "kit/register"`) is removed
  where a package has a second package.json: the first says `"sideEffects": false` and a nearer one
  without a name lists the file; or the package's manifest is copied with its list into dist/. 5
  programs. Not fixed here.

- Old, silent, narrow, as users build: the initializer of a decorated field or accessor
  (`context.addInitializer()`) reads the value of a parameter property where `bun <file>` has
  `undefined`: `3 3 1` for `undefined 3 1`. Where it stores into that property, the object keeps the
  initializer's value and not the argument: `9` for `3`. 2 programs. Not fixed here.

- Old, silent, low: a data file of `type: "file"` asked for under a name made at run time in front
  of the statement that names it is two modules. Not fixed here.

- Old, silent, `bun test --aot`: wide.mjs `export * from "./more.cjs"; export * from "./third.cjs"`,
  last.mjs `export { round } from "./wide.mjs"`, outer.mjs `export { round } from "./last.mjs"`,
  `vi.doMock("./last.mjs", () => ({ round: "mocked" }))`: `(await import("./outer.mjs")).round` is
  `5` for `mocked`, and the bodies of both CommonJS files run. Not fixed here.

- Old, loud: a script whose class merges with an interface of a file that it names by `///
  <reference path="./globals.d.ts" />` stops the build with TS2339 where @types/bun is installed. 1
  program. Not fixed here.

- Old, loud, as users build: `require(flag ? "./bin/cli" : "./other.js")`, so with `import()`, where
  ./bin/cli is a file without an ending: "Cannot find module ./bin/cli". 2 programs. Not fixed here.

- Old, loud: `module.require()` on the module object of a CommonJS file that threw while it loaded,
  kept by another file: an error. 1 program. Not fixed here.

- Old, loud, a right program does not build: in untyped JavaScript, where a list written out of what
  a loop left is handed on behind a test, `const list = [left, "x"]; if (..) return
  target.apply(null, list)`: an operation takes a value of the body that nothing was built for. 1
  program. Not fixed here.

- Old, loud, a right program does not build: a loop swaps two texts, `const url = new URL(first)`
  behind it, and a handler reads `url.searchParams`: an operation takes a value of the body that
  nothing was built for. Not fixed here.

- Old, silent, `bun test --aot`, an everyday partial mock: `mock.module("./tax.mjs", async () => ({
  ...(await import("./tax.mjs")), rate }))` and then `vi.importActual("./tax.mjs")`: importActual
  hands out a second instance, whose state is not that of the functions in the mock: `actual 0 real
  1 false` for `actual 2 real 3 true`. 18 test runs. Not fixed here.

- Old, loud, as users build and in test runs: where some file lets a loader out of sight (`require`
  handed on, kept in a record, out of `eval("require")`), a file that is passed as another entry
  point, throws at its first load, is caught and is asked for again: `bun <file>` prints `cold;ran
  2;ran 2`; compiled `cold;cold;cold`, or "error: cold", exit 1, where nothing catches. Not fixed
  here.

- Old, loud, `bun test --aot`: a package hands its own `require` on, a test file gives it the path
  of a CommonJS file of the program, the file throws there and the throw is caught: the written
  `require("./shaky.cjs")` behind it runs the file again under `bun test`; compiled, the test file
  ends with the first error, exit 1. Not fixed here.

- Old, silent, as users build and in test runs: a data file that is imported plainly and under a
  type made at run time is two modules under `bun <file>` and one compiled: what is stored through
  one is read through the other; under "text" the value is the parsed object, not the string. 7
  programs. Not fixed here.

- Old, silent, as users build: `import "./enter.mjs"; import db from "./data.sqlite" with { type:
  "sqlite" }`, where enter.mjs calls `process.chdir("b")` at its top level: under `bun <file>` the
  name meets the folder of the start, with --aot the folder that enter.mjs has changed to. 1
  program. Not fixed here.

- Old, silent, as users build: `require(file, { type: "text" })`: `bun <file>` gives `{ default:
  <the text> }`; with --aot the bare text or the parsed value, and of a .cjs file the file runs. 15
  programs, and 4 of data files. Not fixed here.

- Old, silent, as users build: `createRequire(import.meta.url)("./library")` of a file without an
  ending that does not parse: `bun <file>` throws; with --aot the text of the file is handed out. 7
  programs. Not fixed here.

- Old, silent, low, as users build: an entry laid into `require.cache` under the key of a file of
  the program: `bun <file>` hands it out; with --aot the file runs and answers. 1 program. Not fixed
  here.

- Old, silent, as users build, narrow: what a CommonJS body required before it threw is not among
  the `children` of its module object: `0 true` for `1 true`. 1 program. Not fixed here.

- Old, silent, as users build: a program names `process.mainModule` and runs text that it comes by
  without naming an evaluator (`f.constructor(text)()`): the text does not find every file in
  `process.mainModule.children` that it finds under `bun <file>`. 2 programs. Not fixed here.

- Old, silent, `bun test --aot` with a preload that mocks a package: a test file ends that mock,
  lays its own and takes the original: the next test file gets the mock of the preload (`preload`
  for `real1`). 2 test runs. Not fixed here.

- Old, silent, `bun test --aot` with such a preload: the package ran in one test file behind the end
  of the mock, and the next lays a mock that nobody asks: the third finds it loaded (`listed true
  real1 bumped 2` for `listed false preload`). 2 test runs. Not fixed here.

- Old, loud, `bun test --aot`, narrow: a load is refused because a name is missing, then
  `vi.doMock()` is laid over the importer: the call itself runs the body of the module and the test
  fails with a ReferenceError, where `bun test` goes on. 3 test runs. Not fixed here.

- Old, silent, `bun test --aot`, no mocks: a test lays `enumerable` on `Object.prototype`; Babel's
  helper for classes hands `Object.defineProperty()` a descriptor without that word: `bun test` sees
  the inherited one, the compiled run takes it for absent. Not fixed here.

- Old, loud: the build stops with a panic on a ring of `export *` with two CommonJS files and an
  ambiguous name that is read off the namespace by a written member. Not fixed here.

- `bun test --aot`, five kinds. Each was seen on a build of an earlier commit of the branch, against
  `bun test` by the same binary: 114 small projects in eight families, of which 84 answer otherwise,
  and two programs more. Not fixed here; the five items that follow:

- Old, silent: the original of a mock that takes it (`importOriginal`, a mock without a factory, a
  spy) runs before the modules that its importer imports in front of it. `import "./setup.js";
  import { part } from "./part.js"`, where part.js reads what setup.js sets and a test mocks part.js
  over its original: `mock real undefined` for `mock real true`. 22 of 24 projects.

- Old, silent: once a mock of a CommonJS file has ended, a namespace that passes the file's names on
  by `export *` shows the names that the mock left out, with the file's values, and the file's body
  runs: `kept,leftOut 1 2` for `kept 10 undefined`. Where a second `export *` brings such a name
  too, the namespace loses it: `extra,kept` for `both,extra,kept`. 45 of 70 projects.

- Silent: two mocks whose factories wait, loaded at once: a factory that imports the other mocked
  module gets the mock where `bun test` hands it the file: `mock 1 < mock 2` for `mock 1 < real 2`,
  and the file's body does not run. A mock laid over a mock whose factory has been called and has
  not answered reaches the load that began under the old one: `new x | new x | new x` for `old x |
  old x | new x`. 16 of 20 projects. Not run on older commits.

- Old, loud: beside a mock whose factory never answers, a load that does not lead to the mocked
  module waits for ever: `vi.doMock("./kept.js", () => new Promise(() => {})); try {
  require("./kept.js") } catch {}; (await import("./side.js")).y` times out where `bun test` prints
  `real side`. Beside such a mock the `import()` of a module that imports a name which nobody
  exports waits too, where `bun test` rejects it with a SyntaxError.

- Old, silent: `let fail; vi.doMock("./part.js", () => new Promise((resolve, reject) => { fail =
  reject; })); try { require("./part.js") } catch {}; fail(new RangeError("late"))`: `bun test`
  reports the RangeError and the test fails; compiled, the test passes.

- Old, silent, node:http in an executable: a listener that a program writes into `res._events` is
  not heard: `close/1` for `close/1,close/2,close/3`; of three listeners of `prefinish` written so,
  none. 2 programs, on a build of an earlier commit of the branch. Not fixed here.

- Reported by a user of the branch; each seen on a build of an earlier commit of this branch, each
  program built alone by `bun build --compile --aot` and held against `bun <file>`. Not run again on
  the last one. Not fixed here; the two items that follow:

- The build does not end (40 s given): a type alias that grows where it names itself: `type F<T> = {
  inner: T } & { or?: F<{ inner: T }> }`; `` type F<K extends string> = { key: K; next?: F<`${K}a`>
  } ``. 6 programs.

- Type errors that `tsc` does not report stop the build: TS2322 at `const k: keyof (typeof
  rows)[number] = "y"` over rows out of a .js file; TS7006 at `getRandomValues: array => array` in a
  literal of type `Crypto`; TS2416 at `json(): unknown` in a subclass of `Blob` and at a member
  `count` in a subclass of `Headers`. 4 programs.

- Old, loud: what is left of the crash where `addEventListener` or `dispatchEvent` comes out without
  a receiver (most forms are fixed): the method is read under a name that stands nowhere in the
  program as a string. 9 programs, each built alone, end with exit 134 ("process.finalization was
  left out of the executable, because nothing seemed to use it") where `bun <file>` answers. All
  nine are of the kinds that docs/compiler/compatibility.mdx declares: the name is put together
  while the program runs (`JSON.parse('["dispatch", "Event"]').join("")`, character codes, `atob()`;
  read by `signal[name]`, a pattern or a descriptor), or comes out of `for .. in`, of `Object.keys({
  dispatchEvent: true })` or of the `name` of a function of the program's; or the method is found
  without any name, out of `Object.values()` of the prototype. `void dispatchEvent` once anywhere in
  the program keeps all that the global object leads to. Not fixed here.

- Old, silent, `bun test --aot --isolate` and `--parallel`: a source file that a test file writes
  over behind its first load is read anew by the next test file: `a.test.ts` imports `shared.ts` and
  writes it over, `b.test.ts` and `c.test.ts` import it: `bun test --isolate`, which keeps the text
  of every source file that it has read, prints `as built` twice; compiled, `written over` twice.
  Seen on a build of an earlier commit of the branch. Not fixed here.

- New, loud: a program that finds `addEventListener` and `dispatchEvent` by walking `performance`
  itself and calls them without a receiver: `function both(holder) { let add, send; for (const k in
  holder) { if (k.length === 16) add = holder[k]; if (k.length === 13) send = holder[k]; } return
  [add, send]; } const [add, send] = both(performance);`; so `Object.getPrototypeOf(performance)`,
  `performance.__proto__`, `Object.setPrototypeOf({}, performance)`, `Reflect.get.call(..)`, out of
  a list, through a constructor. 8 programs, each built alone, answered as `bun <file>` at an
  earlier commit of the branch and ended with exit 134 at a later one; not run on the last one.
  `void dispatchEvent` once anywhere in the program keeps all that the global object leads to. Not
  fixed here.

- Old, silent: under `bun test --aot` the factory of `vi.mock()`, `vi.doMock()` or `mock.module()`
  runs inside the `import()` of the mocked module, where `bun test` runs it in a later job: `let
  state = "before"; vi.mock("./x", () => { seen = state; .. }); const p = import("./x"); state =
  "after"; await p;` leaves "before" in `seen` for "after". An import by statement is right. A fix
  was made on the branch and taken back. Not fixed here.

- In an executable `native.dlopen` of bun:ffi is an accessor where plain Bun has a data member:
  nothing that loads machine code is read while the module loads. Stored as a known failure:
  test/aot/parallel/what-bun-ffi-hands-out/native-dlopen-is-a-data-member.mjs. Not fixed here.

- One script that checks by `Bun.build({ check: true })` and then compiles by `Bun.build({ compile:
  { aot: true } })` lowers on 32 MB of stack a thread, not 64. No program is known that is compiled
  otherwise for it; the command line is not touched. Not fixed here.

- A loader's name as a label (`case "require":`) beside a read of the global object under an unknown
  key keeps a program from being closed, so `--trim` is blocked for it. Not fixed here.

- In a folder without a tsconfig.json a build stops with TS2339 at `request.body.text()` (also
  `json()`, `bytes()`, `blob()` of a stream) where the request has a written type `Request`; a
  tsconfig.json as `bun init` writes it gets past it. Not fixed here.

- As docs/compiler/compatibility.mdx says, but silent: under `"useDefineForClassFields": false` one
  computed key that has to be folded (`["ki" + "nd"] = "user"`) makes all fields of the class
  defined: `name!: string` erases what the constructor of the base class has assigned (`undefined
  undefined` for `Ann 3`). Not fixed here.

- Silent: `const p = await import("node:process"); Object.keys(p); process.features = 2`: `typeof
  p.features` is "number" for "object". Not fixed here.

- `bun test --aot`: The original of a partial mock that imports another mocked module:
  `ReferenceError: Cannot access 'o' before initialization` where `bun test` prints `extra,seen
  mocked`. `mock.module()` called through `forEach()` in a helper mocks nothing, in silence (`real`
  for `mocked`). Inside a generator of another folder that a spread steps it resolves `./x.mjs` from
  the folder of the consumer: the run stops (`cannot replace .. because the build didn't see a test
  mock it`). Not fixed here.

- A `.jsonc` file that is no strict JSON (a comment, a comma at the end) beside `import("./" + name,
  { with: { type: "json" } })`: `bun <file>` throws a SyntaxError at the import; the executable
  throws `Cannot load .. from a dynamic path`, and the build, which warned of the file before
  (TS100089), says nothing of it. Loud in both. Not fixed here.

- Loud: `process instanceof Probe` where `Probe` has a static `Symbol.hasInstance` that lists the
  keys of `holder.stdout`: what the method is handed is not seen, and the process ends:
  `process.stdout .. was left out of the executable`. Not fixed here.

- `require(JSON.parse('"./lib"'))` where `lib.js` is a symbolic link and a folder `lib` lies beside
  it throws MODULE_NOT_FOUND where Bun finds the file. Not fixed here.

- Memory, the answers right: a loop that fills a list by `out[at] = at` up to a bound held in a
  variable asks for the room of the whole bound in front of the loop. Where the loop ends early the
  room was asked for nothing: a loop to 150,000,000 that throws a RangeError after about thirty
  turns peaks at 1,195 MB, under `bun <file>` at 23 MB. Not fixed here.

- Type errors stop an ahead-of-time build: still a false stop where the build brings Bun's
  declarations: `timer.toString(36)` on what `setTimeout` returns (TS2554); `case "Linux armv8l":`
  on `navigator.platform` (TS2678); three cases under `"lib": ["es2019"]`. `// @ts-ignore` gets past
  each. What the check misses is in the messages on the pull request; two more true errors are known
  to be forgiven.

- `bun test --aot`: odd shapes of mocks (a late object, a file that throws once) answer otherwise
  than `bun test`; a mock that was taken back while a load waits is used; `vi.doMock()` over an ES
  module whose body threw (eight shapes answer otherwise, one ends the run); vitest's
  `importOriginal()` and a mock without a factory over a setup file's mock; an entry planted in
  `require.cache` makes the next `import()` run the file again; a mock of a barrel does not reach a
  name handed on from `./inner.js?x`; a helper of the tests that names `Object.prototype` by its
  name: writes on other built-ins out of sight are refused; under `--rerun-each` what a test file
  exports stays one object across the runs; `error.name` is "SyntaxError" for "BuildMessage" under
  `--isolate`.

- A store into a typed array at a negative index is slow; `new this.Proxy` in a sloppy function; the
  old spelling of a path above the root written out by hand.

- A plugin that no compiled file names, with code from disk; two sibling modules that both await;
  late private symbols of node:http; text run by `eval` that reads a member of `process` which the
  build left out; an `onResolve` callback that throws at a later name; `routes: { "/*": { dir, style
  } }` is refused; an accessor under "noDeprecation" or "throwDeprecation" on
  `EventEmitter.prototype` ends the process; a folder named `root` beside the folder of the entry
  point; the bytes of an executable hang on whether a file named as the entry point's stem lies
  beside it; accessors on the own names of a request or a socket, or on `IncomingMessage.prototype`,
  that throw once; `const f = true && function () {}`: `f.name` is right in 9 of 12 forms.

- Builds that grow faster than their programs: loops nested hundreds deep (a square); two rows of
  classes whose tables grow by the square; n classes below one base and an object of them out of
  sight (four times the build for twice the classes); N calls of a helper with a loop in one
  straight block (a square); the members of one literal with as many objects created below it (a
  square); a barrel of k `export *` with one `vi.doMock()` on one of its files (7.2, 20.0 and 67.6 G
  instructions for 1,000, 2,000 and 4,000 files); a type that names the one before it twice, `type
  M2 = Map<M1, M1>` and so on down, at a declared field of a class, its initializer, a parameter
  property or a value handed to a function of a JavaScript file (twice the build for each level).

- New, loud, as users build, an unusual program: `const uses = { a(found) { return found.v; } };
  uses.valueOf().b = found => found.v + 1; for (const name in uses) console.log(name,
  uses[name](require(`./rows/${name}.cjs`)));`, so too with `uses.__defineGetter__("b", ..)`: `bun
  <file>` prints `a 1`, `b 3`, and so did earlier commits of the branch with --aot, the last behind
  a warning of the build (an executable of `--compile` does where ./rows lies beside it, and else
  ends with an error); now it builds without a warning and prints `a 1` and "Cannot find module
  './rows/b.cjs'", exit 1. An inherited method sees its object and can change it; the walk that
  follows a name out of the keys of a written object does not ask which member is called. So too
  where the object is added to by a second name, `const uses = module.exports = { .. };
  module.exports.extra = ..` or `const uses = other = { .. }; other.extra = ..`, by another file
  through what the file exports, `part.table.extra = ..`, by a direct `eval` in a method of such an
  object in a list that is walked, or by another of the names that `forEach()` over a Set written in
  place, `find()` or `filter()` gives it: "Cannot find module './extra.cjs'", exit 1. Where the
  names are built-in modules the warning alone is lost. Not fixed here.

- New, loud, `bun test --aot`: where a written object gains a key through `__defineGetter__` and a
  test deletes the entries of `require.cache` whose paths are made of its names in `for (const name
  in made)`, the test run ends with exit 1 and says nothing; `bun test` passes. 1 test run. Not
  fixed here.

- Old, loud: `var uses = { zlib(found) { .. } }; for (const name in uses)
  uses[name](require(name));`: exit 1, "Cannot load 'node:zlib': it isn't in this executable"; with
  `const` and `let` it is the item on the `for...in` above. So too `var uses; uses = { .. }`, `var
  names = Object.keys(uses); for (const name of names) ..`, and keys listed by
  `Object.getOwnPropertyNames()`, `Reflect.ownKeys()` and `Object.entries()`. Not fixed here.
Jarred-Sumner added a commit that referenced this pull request Nov 7, 2026
This is the compiler's tree as it stood a day and a half after the text of #997, less
what was left out or taken back, on #1000: new optimizations, fixes and their tests
together. 1,576 files, +107,853 -10,050: aot/ without its tests 730 files, +58,389 -8,812; aot/tests
829 files, +49,242 -1,177; outside aot/ 17 files, +222 -61. The IR tests go from 2,574 to 3,159
files: 591 new, 6 gone. Bun's side is oven-sh/bun#48120. Known problems, old and new, are in the
message of oven-sh/bun#48120, but for those that are named below.

By folder of aot/, files and lines: walk 136 +25,705 -3,367 . facts 27 +9,076 -1,254 . runtime 89
+6,549 -858 . codegen 121 +5,972 -930 . stubs 85 +4,404 -971 . object 37 +1,396 -215 . machine 40
+1,156 -195 . ir 65 +1,133 -284 . builtins 54 +1,019 -203 . plan 21 +893 -273 . image 43 +811 -218 .
driver 6 +213 -16 . support 4 +44 -27 . in aot/ itself 2 +18 -1.

Outside aot/, file by file. .github, WTF, bmalloc and heap/: nothing.

- runtime/AbstractModuleRecord.cpp (+57 -5), .h (+16 -1): resolveExportImpl() under ENABLE(AOT): a
  compiled record may answer by which module led to it and keeps its whole answer; a record whose
  mock has ended answers every further path itself. Without compiled code: one test more of
  vm.hasCompiledCode() for each query, then the set of queries is asked as before. A task holds one
  pointer more; Resolution::Type is one byte wide and two flags lie in the padding behind it: the
  size of a Resolution is asserted to stay three words.

- runtime/JSONObject.cpp (+83 -13), under ENABLE(AOT) but for the last: the writer of objects of
  compiled classes: a loop of its own for fields that hold any value under short keys; one flag and
  one number that stood for "none" become two bits of one byte; the levels that are watched are
  counted by depth and not by the stack pointer, which a run without compiled code passes too once a
  result has grown large; the elements of a list pass the check of the stack too.

- runtime/InternalFunction.cpp (+14 -2): createSubclassStructure(): on two of its three ways out one
  comparison more, marked unlikely: the new target against the one that a compiled `super()` call
  has noted. Without compiled code none is noted.

- interpreter/CallFrame.cpp (+10 -7): callerSourceOrigin(): with compiled code the walk visits each
  run of compiled frames once. Without it: one test more of vm.hasCompiledCode(), then the walk as
  before.

- runtime/JSTypeInfo.h (+6 -1), Structure.cpp (+2 -3), JSCellInlines.h (+1 -1, an assertion): the
  bit "pristine" that cells copy covers the elements of maps, sets, weak maps and weak sets as it
  covers those of arrays. Outside aot/ JSArray.cpp alone reads the cell's bit, and of arrays.

- runtime/JSModuleLoader.cpp (+3 -8): innerModuleLoading(): the exception for compiled programs
  goes; the two assertions that it had widened stay, and hold for every program again; whether a
  request was loaded inside the call is told by the count alone.

- runtime/CyclicModuleRecord.cpp (+2), under ENABLE(AOT): where an evaluation has thrown, a compiled
  record notes a termination.

- runtime/JSString.cpp (+2 -2): equalResolvingRopes(), which compiled code alone calls: a piece of
  another string takes the characters of its equal only where they are stored as wide as its own.

- runtime/JSDataViewPrototype.cpp (+16 -16), JSPromiseConstructor.cpp, JSPromisePrototype.cpp (+1 -1
  each): 18 host functions are no longer `static`: the compiler's tables name them.

- Tools/Scripts/aot/calls-that-never-collect.txt: +1.

- runtime/ObjectConstructor.cpp (+2 -0): objectConstructorSeal(), objectConstructorFreeze(): inside
  the two blocks on compiled structures the exception is asked for behind the change.

- runtime/ModuleRegistryEntry.cpp (+5 -0): an assertion was narrower than the loader: an entry may
  have failed before its fetch answers. Under USE(BUN_JSC_ADDITIONS) it takes `EvaluationFailed`
  beside `Fetching`. An assertion alone: a build without them is the same.

Two of the optimizations can be seen outside aot/: `JSON.stringify()` writes objects of compiled
classes with a loop of its own where their fields hold any value under short keys, and finding the
source of a caller visits each run of compiled frames once.

Among the optimizations: objects, closures and scopes are created on the path that needs them;
bounds and divisors held in module variables, functions of other files, rows of nested lists and
lookups in a `Map` that a loop leaves alone are read or tested in front of the loop; a remainder by
a divisor from in front of the loop is computed with a reciprocal; the array of a regular expression
match or of a `split()` is not built where it is only taken apart, nor a substring that is only
looked up in a `Map`; a key that is looked up and then stored under is found once; a bound function
is called by its target; `then()` and `catch()` on the promise of an async call are compiled in
line; branches that decide nothing are removed.

Among the fixes:

- A correct program did not build: in untyped JavaScript, where a list written out of what a loop
  left is handed on behind a test, `const list = [left, "x"]; if (..) return target.apply(null,
  list)`: an operation took a value of the body that nothing was built for. The list that is made
  again for the call as written is drafted off what is noted of its elements
  (aot/walk/AOTWalkCallsDoneInPlace.cpp: +2 -2).

- A correct program did not build: a loop swaps two texts, `const url = new URL(first)` behind it,
  and a handler reads `url.searchParams`. The URL is now made from the construction as it was
  drafted at its own place (aot/walk/AOTWalkStringURLs.cpp, AOTWalkStrings.h: +6 -1).

- A test run that mocks a module and ends the mock could crash: one more road
  (aot/runtime/AOTModules.cpp, AOTModules.h: +12 -4).

- A test run under `--isolate` in which an object that one test file made is stored into by the next
  could crash.

- A bound on a table of key orders (aot/object, aot/runtime: 8 files, +13 -10).

- A name that a file's `export *` statements answer for is read off the namespace of the first file
  that lists it; where that file hands the name on from a file whose `export *` leads back, the read
  went in a circle and ended in a RangeError where `bun` says the value. A read that comes back to a
  namespace and a name that are being read asks the resolution, which cuts such a circle
  (aot/runtime/AOTModules.cpp, AOTModules.h: +27 -1).

- Test runs with a preload that mocks; the shapes below answer as under `bun test` now. The host's
  half is in oven-sh/bun#48120 (aot/runtime/AOTModules.cpp, AOTModules.h, AOTModuleHost.h,
  AOTModuleEvaluation.cpp, AOTTestRunMockViews.cpp). Who owns the preload's mock under its key is
  asked anew behind the end of a test file that emptied the key, by a `require()` of a value too:
  two test files each did require, `vi.doMock()`, require, `vi.doUnmock()`, require, and the second
  got the file itself for the preload's mock. `require.cache` and a mock laid over the preload's
  read that the key was emptied, until the file itself has run under it. The run of an original
  beside a mock whose factory answers late is kept where the mock comes to stand in place: the body
  ran a second time. The run time is told what the host knows of whether the preload's mock comes
  back at the end of a mock. Known, new with this: asked by `import()` alone, behind a `vi.doMock()`
  that has ended and then a `mock.module()` that has ended too, the preload's mock answers where
  `bun test` gives the file itself. One test run.

- Silent, in executables, new with #1000: one .sqlite file imported twice under a name
  made at the run, as `{ type: "text" }` and then as `{ type: "sqlite" }`: each type got a form of
  its own (`string object`; the other way round `object string`), where `bun <file>` hands out the
  first form again (`string string`, `object object`). What is found under the written name goes
  through the loader's two questions like every other form: it is the module that came first
  (aot/runtime/AOTModules.cpp, AOTModules.h: +36 -8).

- In executables, old: main.mjs imports first.mjs, second.mjs and shared.mjs, in this order,
  first.mjs imports shared.mjs, shared.mjs imports alpha.cjs, and second.mjs imports beta.cjs. If
  both .cjs files require `fs`, `stream`, `crypto`, `http`, `https`, `net` or `zlib`, the executable
  threw `RangeError: Maximum call stack size exceeded` when it started; in other shapes, and without
  an error, the default import of alpha.cjs was `undefined` or a `require()` in a `try` went without
  the module. Where such a built-in makes the run time hand the graph to the loader, the hand-over
  ran a file inside the file that was running. It runs none there
  (aot/runtime/AOTModuleEvaluation.cpp: +17 -2).

- Known, old: where a CommonJS file calls `import()` at its top level, and is loaded by a
  `require()` of an ES module out of another CommonJS file that has already loaded such a file,
  modules that import it can run inside that call and read `undefined` for what it exports behind
  the call. No error tells you.

- Silent, test runs, old: a CommonJS file that the end of a mock sends back to run anew is captured
  anew for whoever imports it: `(await import("./lib.cjs")).n` said the earlier run's 1 where
  `require("./lib.cjs").n` said 2 (aot/runtime/AOTModuleLinking.cpp, AOTModules.cpp, AOTModules.h:
  +15 -5). Not as under `bun test`, which keeps the old run there: an importer that stays loaded can
  read `undefined`, and the new run once another importer is loaded. 2 test runs.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant