vm2 has already written its next three advisories. They are in the repository under "considered and deferred," under "monitoring," and under a README heading that tells you not to. The only field vm2 leaves blank is the name of the stranger who will file them.
The Nefarious Plan of vm2
nesting: truewith any non-false require config remains an escape hatch. Constraint propagation from outer to inner NodeVM was considered and deferred. It would change documented nesting semantics substantially, a major-version-shaped change.
That is the commit message for a security fix. It sits under a heading the maintainer typed in capitals: "What this fix does NOT close." The fix shipped on May 1, 2026 with a CVE whose record says the issue is patched.
I have six case files on vm2. I wrote them one CVE at a time, like everyone does, and each one ends in the same place. This week I read all six in a row and stopped reading them as bugs. Read in a row they are a schedule. vm2 keeps a written list of the ways out of its own sandbox, sorted by which ones it has closed, which ones it has decided not to close, and which ones it is waiting for somebody else to find. I did not infer the list. It is checked in.
vm2 is a sandbox for running code you do not trust inside a Node.js process. That sentence is the entire product. Keep it in mind for the next two thousand words, because vm2 does not.
vm2 is not a wall. It is a list.
The mechanism is a Proxy that sits between the host and the guest and wraps what crosses. Wrapping needs a list of things to wrap. The list is written by hand, from the language specification, after the specification ships.
CVE-2026-26332: vm2 Wraps Every Error the Sandbox Throws. SuppressedError Carries the Two V8 Threw. The escape there is two features from ES2024 used exactly as documented. V8 builds two error objects in C++ on the sandbox's behalf, hands them over, and the sandbox walks three properties to the host. No trick. I wrote at the time that the proof of concept reads like somebody learning the feature from the manual, and it does, because the manual is the exploit.
vm2's wrap list is one ECMAScript edition behind by definition. The list is written after the features ship.
By definition. Not by neglect. A list of everything the language can do is always missing whatever the language did last. And when the list is wrong, vm2 is not the one who notices. CVE-2026-45411: vm2's Async Generator Escape Bisects the Stack for a Host RangeError:
AsyncGenerator shipped in V8 in 2018. The wrap list named it eight years later. The list is paced by researchers, not by V8.
Eight years. The feature was in every Node release vm2 supported for that entire stretch. That advisory was published eight days after vm2's previous security release. The one before that came two days after its predecessor. The two before that shipped forty-two minutes apart.
vm2 has three ways to patch, and all three are surrender
When the list fails, vm2 has a small set of moves, and it has named them in its own source.
The first is to add an entry. That is most of the changelog.
The second is to delete the thing. CVE-2026-26956: vm2's Transformer Rewrites Every catch It Parses. WebAssembly's try_table Is Bytecode. WebAssembly can catch a JavaScript exception in bytecode, where vm2's source rewriter never looks, so vm2 removed the WebAssembly feature from the sandbox. The patch is twenty lines. Nineteen are a comment explaining that nothing else is possible.
A defense that takes the form of property removal is a defense that has given up on the bridge.
The third is to lie to the engine. CVE-2026-24118: vm2's Patch Names Its Sibling. resetPromiseSpecies Was 2023. V8 reads an array's constructor in C++, where no Proxy trap fires. vm2 cannot watch that read, so before every call into the host it overwrites the property V8 is about to read, and afterward it puts the real one back. 306 lines. The first attempt at this fix told the lie and never took it back, and broke legitimate code. The comment above the working version says the technique is "analogous to resetPromiseSpecies," which vm2 wrote in 2023 for Promises, against what the comment calls "the same V8-internal-bypass class."
The vocabulary is the inventory of places where the Proxy gave up.
So vm2 knew in 2023 that V8 reads species constructors behind the Proxy's back. It fixed Promise. It left Array for a stranger, who arrived thirty-one months later. The same file of mine lists the typed arrays as doing the identical lookup, and the defense is written one built-in at a time. vm2 has a class, a name for the class, two members, and a queue.
Add, delete, lie. Not one of the three makes the bridge able to see what it could not see before. Each one is a note that says the bridge cannot see this either.
Every vm2 patch is the address of the next one
CVE-2026-24120: vm2's README Already Admits the Bug Class Is the Design is the file where I laid the patches end to end. Five fixes for one escape route across thirty-two months, by three different people, at the same call site. The CVE record says the 2023 fix was insufficient. The function that 2023 fix added is byte-identical before and after the patch. The record blames a defense the patch never touched.
Then the release notes for 3.11.2 describe, in vm2's words, an escape created by the hardening for a previous escape.
That paragraph documents an advisory introduced by an earlier advisory's hardening. The fix for one CVE produced the substrate for the next.
Eighteen advisories closed in four releases between February 17 and May 3. Thirteen of them in a single release. If you maintain something and you close thirteen security advisories on one afternoon, you do not have thirteen bugs. You have one, and thirteen people have told you about it.
The Array species thread makes the same point with a smaller number. Seven proofs of concept arrived in one advisory. Five of them were closed by fixes that never got a CVE.
The advisory thread's seven PoCs were not seven bugs. They were seven addresses for one primitive.
Seven addresses. One record.
"Cannot be honored" is vm2's phrase for a security setting
Everything above is vm2 losing to V8, and I have some patience for losing to V8. This one is vm2 losing to vm2.
CVE-2026-44007: vm2 3.11.1 Rejects One Configuration. The README Is the Patch for the Rest. require: false is the documented setting for a sandbox that may load nothing. nesting: true is a second option. Set both, and sandbox code loads vm2 itself, builds a second sandbox with whatever permissions it likes, and runs shell commands on the host in three lines. Two options in one function, and the function reads the wrong one first.
The patch is one if-statement that refuses that exact pair. Its error message says "the deny-all expectation cannot be honored."
Cannot be honored is the maintainer's word for does not work.
The real fix is in the commit message I opened with. Make the outer sandbox's limits bind the inner one. vm2 named it, weighed it, and declined, because it would change what the documentation promises. The documentation promises the hole. So every other configuration that reaches the same place still runs, the test suite pins them open as regression guards, and the new README section demonstrates one of them with a code sample whose last comment is // RCE.
The README is the patch for every configuration the constructor block does not refuse. The recommendation is: don't.
vm2 shipped a working remote code execution sample in its own README as the mitigation. I have read a lot of bad patches. I had not read one that was a paragraph.
How to read the next vm2 advisory before it is filed
This is the part that is not in any of the six files. You do not need a debugger to find vm2's next escape. You need grep, because vm2 has sorted the queue for you.
Search the commit history for "deferred." You get the nesting escape, with the fix described and declined.
Open docs/ATTACKS.md. It is 1518 lines, 28 attack categories, written by the maintainer. One category, a WebAssembly proposal that has not finished shipping, is not marked closed. It is marked "monitoring." Monitoring is not a defense. It is a calendar entry.
Open the species code and count the built-ins. Promise got a shim in 2023. Array got one in 2026. The typed arrays do the same lookup, and there were two named shims when I last read that file, not three.
Open the language proposals and find the next feature that carries one error inside another. The language has added three since 2021, and each one handed the sandbox a way to the host. The async version of the last one is at stage 3.
That is four entries, each with the mechanism already described in vm2's handwriting. Not one of them has a CVE, because a CVE needs a reporter and vm2 does not report on itself. The disclosure process for this project is that the maintainer writes down what is broken, waits, and credits whoever shows up.
The README tells you to leave, and the CVE record tells you to upgrade
I will be exact about the charge, because vm2 has been more candid than any commercial vendor in my archive. The README says new bypasses will keep coming. It lists isolated-vm, separate processes and containers as what to use instead. It names "arbitrary user submissions" as the case it recommends against, which is the case the library exists for.
That is the README of the library you are considering using telling you to consider not using it.
None of that is the offense. The offense is the other document. By my files' count vm2 closed nineteen advisories this year, each against a version number, and the CVE record I quoted in the README file says "patched in version 3.10.5." A version number is the only thing a dependency scanner reads. No scanner has ever opened a README. The honest document goes to the people who read documentation, and the comforting one goes to the machines that decide whether a build is green. vm2 knows which of those two audiences is larger.
A sandbox that says it cannot hold, and ships anyway, and marks each failure resolved, is not being honest. It is being honest in the one place that costs it nothing.
The seventh file
It will be one of the four. My money is on the typed arrays, because the code to copy is already in the repository and the comment above it already names the class. The record will say "patched." The patch will be a third function with "species" in its name and a comment citing the first two. It will carry the same two labels as the other six files, and that will make seven for seven.
vm2, you are the only vendor I cover whose implementation I do not have to call shit myself. You did it in the README, in the commit message, and in a file called ATTACKS. Then you typed "patched."