Skip to content

node:vm: module.evaluate() runs one Evaluate() of the module record - #46004

Closed
robobun wants to merge 1 commit into
mainfrom
robobun/f48be7fb/vm-one-evaluate-per-call
Closed

robobun wants to merge 1 commit into
mainfrom
robobun/f48be7fb/vm-one-evaluate-per-call

Conversation

@robobun

@robobun robobun commented Oct 19, 2026 •

Copy link
Copy Markdown
Collaborator

Problem

  • Since 1.4.0 a vm.SourceTextModule import cycle fails: ReferenceError: Cannot access 'x' before initialization. Vitest's vm pools hit it (arktype, configstore). A caught throw after a top-level await exits with code 1.
  • NodeVMModule::evaluateDependencies (src/jsc/bindings/NodeVMModule.cpp:262) calls Evaluate() once per dependency (node:vm: pass the Node v26.3.0 vm test suite (+25 tests, ~65% → 97%) #32018), and nothing handles those promises.

Fix

  • evaluate() calls JSC's Evaluate() once, as Node calls V8's. Status and error come from the module record. A timeout or SIGINT gives its error to the modules it stopped.
  • A vm.SyntheticModule gets a JSModuleRecord without code. The moduleLoaderEvaluate hook runs its evaluateCallback in the walk.
  • Verified: test/js/node/vm/vm-module-graph-evaluation.test.ts (Node v26.3.0 passes it) and vm-module-graph-evaluation-bun.test.ts. Also test/js/node/vm/, test/js/bun/resolve/, Node's test-vm-*.
  • Self-reviewed: 37 concerns raised, 33 addressed. Notes name the other four.

Background

Downsides

Notes

Questions for a maintainer.

  1. A module that imports a vm.SyntheticModule whose evaluateCallback threw, and is evaluated later, rejects with that error and does not run. That is the rule of ECMA-262 for a module that failed, and the rule of SyntheticModuleRecord in ec68522d83 ([JSC] FFI: compile C modules lowered to BIR with B3 WebKit#653). Node v26.3.0 and main run the importer with the exports that the callback set, and Node then reports a rejected promise of V8 that no program can reach. Keep the rule: yes or no?
  2. Worker teardown, round 3: node:vm timeout on TerminationDeadline; take-at-landing termination; exit/streams/serve/valkey/Bun.build fixes #38660 made a module "errored" when the timeout or SIGINT of its own evaluate() stopped it. This PR keeps that for the module of the call, and gives the same error to every other node:vm module that the termination stopped: a module on the stack of the walk, a module that a job of the checkpoint was running, a module of another graph that the same checkpoint resumed, the checkpoint of a Script, a deferred module that a Script reads first. The alternative for those is Node's state (below). Keep the extension: yes or no?
  3. A 13-line patch fixes the two programs below without this PR ("Considered"). Ship it first for 1.4.x: yes or no?

Landing order. The JavaScriptCore half is oven-sh/WebKit#832 (+168 -5 in CyclicModuleRecord.cpp and AbstractModuleRecord.cpp, under USE(BUN_JSC_ADDITIONS), with a JSTests/stress file of 20 graphs). WEBKIT_VERSION is its preview build, which cannot merge. When #832 has merged, the pin and the five plain ES module tests of this PR can land first as their own WebKit bump: they fix an import() that never settles and a segfault that need no node:vm. This PR then rebases without the pin. oven-sh/WebKit#840 (a module error does not keep the module record alive) belongs in the same bump. #41654 (oven-sh/WebKit#670) and #44833 (oven-sh/WebKit#781) change the same line. If oven-sh/WebKit#781 merges first, the bump also takes its change.

The regression. No user reported it. A fuzz run found it, and these two programs show it (Node needs --experimental-vm-modules):

const vm = require("node:vm");
const a = new vm.SourceTextModule('import { x } from "b"; console.log("a sees", x);', { identifier: "a" });
const b = new vm.SourceTextModule('import "a"; export const x = 1;', { identifier: "b" });
(async () => {
  await a.link(specifier => ({ a, b })[specifier]);
  await a.evaluate();
})().catch(error => console.log(String(error)));

Node v26.3.0, Bun 1.3.14 and this PR print a sees 1. Bun 1.4.0, 1.4.3 and main print ReferenceError: Cannot access 'x' before initialization.: they run a before b.

const vm = require("node:vm");
const a = new vm.SourceTextModule('import "b";', { identifier: "a" });
const b = new vm.SourceTextModule('await 0; throw new Error("from b");', { identifier: "b" });
(async () => {
  await a.link(() => b);
  await a.evaluate().catch(error => console.log("caught:", error.message));
})();

Node and this PR print caught: from b and exit with code 0. Bun 1.4.0, 1.4.3 and main print the same line, then error: from b, and exit with code 1. Bun 1.3.14 prints nothing: it lost the error.

Who it reaches. Vitest's vm pools make a vm.SourceTextModule for each file of a dependency. A test file that imports a package with a two-file import cycle, with Vitest 4.1.9 and --pool=vmForks: Bun 1.3.14, Node and this PR pass. Bun 1.4.0, 1.4.3 and main fail with ReferenceError: Cannot access 'helper' before initialization. (--pool=vmThreads is the same on 1.4.x. Bun 1.3.14 does not start a worker of that pool.) A loader that does what those pools do was run over the ES module entry of 1,245 packages: 8 fail on 1.4.0, 1.4.3 and main, and none on 1.3.14, Node and this PR. They are arktype, @ark/schema, @prisma/cli-engine, atomically, configstore, stubborn-fs, @solid-primitives/storage and alchemy. The errors include TypeError: undefined is not an object (evaluating 'this.resolvedConfig.name') and Cannot access 'Handlers' before initialization. A build with assertions could not run a Vitest vm pool until #46270 (ASSERTION FAILED: More attributes nodes than requests). With it the Vitest test of this PR also passes on a debug build, under the ASAN lane's environment.

Considered.

  • node:vm: do not report a top-level-await dependency's rejection as unhandled #40939 marks the promise of each dependency's Evaluate() as handled. It hides a rejection that the program dropped (a two-module cycle with an a.evaluate() that nobody awaits), and the order stays wrong.
  • A 13-line patch on main's WebKit (+13 -1 in NodeVMModule.cpp): the same mark, and the importer's record is set to EVALUATING by hand while its dependencies run as roots of their own, so a dependency that imports it back runs first.
the 13-line patch this PR
the two programs above, Vitest's vm pools, the 8 packages fixed fixed
vm-module-graph-evaluation.test.ts (204 tests, main: 109 fail) 67 fail 0 fail
vm-module-graph-evaluation-bun.test.ts (72 tests, main: 46 fail) 40 fail 0 fail
random graphs that differ from Node, of 400 for each kind of context (main: 184, 184 and 161) 95, 95 and 77 1, 1 and 1
Evaluate() calls for a root with 1,000 dependencies 1,001 1

The rows are release builds on ed68082, with the two test files as they were then (204 and 72 tests). 36, 36 and 40 of the patch's random graphs differ only by the text "errored mod", which one more line fixes. With the patch each dependency is still a root of its own Evaluate(): evaluate() of a member of a cycle fulfils while the cycle still waits at a top-level await, a member of a failed cycle that ran stays "evaluated", and status and error stay copies. The patch is not run on a debug build or on Node's test-vm-* files yet. This PR deletes the lines that the patch changes, so the patch is not in its way.

Random graphs. test/js/node/vm/vm-module-graph-random-fixture.js makes a module graph from a seed (imports, cycles, top-level awaits, throws before and after the await, SyntheticModules), evaluates some of its modules, and prints the order, the statuses, the errors, each evaluate() result and the unhandled rejections. scripts/vm-module-graph-random.ts compares a binary with the node on PATH. For seeds 0 to 11,999 in each kind of context (main, a context, an afterEvaluate context):

differs from Node v26.3.0
main 5,135, 5,137 and 4,599 of 12,000 (686, 686 and 734 of them only by the text "errored mod")
this PR 110, 110 and 110 of 12,000

In 81 of the 110, Node ran the rest of a body that waited at a top-level await when its cycle failed (the first bullet of "Not fixed"). In 41, a module imports a SyntheticModule whose evaluateCallback threw (question 1). 12 have both. Node aborts on a V8 CHECK for 39 of the 36,000 runs, where Bun gives a result. The generator has limits: a module never reads a binding, never calls evaluate() from its code, and the program handles every promise. The two test files have those shapes by hand.

Changes that a node:vm program can see. Each has a test. Where Node is not named, the new result is Node's.

  • A cycle runs in the order of ECMA-262, and evaluate() of a graph with a module that throws after a top-level await reports nothing that the program handled (the two programs above).
  • A module that waits for a top-level await, its own or one of a module it imports, is "evaluated". A second evaluate() gives the same pending promise. On main it was "evaluating" and the second call rejected with ERR_VM_MODULE_STATUS.
  • evaluate() of a SourceTextModule that failed as the root of an evaluate() gives the promise of that call, so a later call that the program drops is not reported. Any other module with an error gives a new rejection for each call, as on main. The promises are of the realm of the module. On main some were of the main realm.
  • In an afterEvaluate context, the jobs that the bodies queue run in one checkpoint after the walk, and a top-level await can finish inside that evaluate(). main did a checkpoint after each dependency. That checkpoint runs only the jobs of the context. On main it could also run the process.nextTick queue and the jobs of the main queue.
  • evaluate({ timeout }) can reject with ERR_SCRIPT_EXECUTION_TIMEOUT while its module is "evaluated": the deadline passed in a plain job of the checkpoint, or after the last body. The next evaluate() fulfils. On main the module became "errored".
  • import defer in a vm module is lazy, as the proposal says. The module runs at the first read of its namespace. main ran it with the importer. Node v26.3.0 does not parse import defer.
  • An evaluateCallback runs in the AsyncLocalStorage context of the evaluate() call. main ran it in the context of the SyntheticModule constructor call.
  • After a link() that fails in the instantiation, the dependencies that linked are "linked" and can be evaluated. main left every module "unlinked".
  • A link() that ends after an importer linked the module resolves and changes nothing. main rejected it with ERR_VM_MODULE_STATUS.
  • The message of ERR_VM_MODULE_LINK_FAILURE ends with "errored module". It ended with "errored mod".
  • A chain of imports that is too long for the stack: on linux-x64 release the longest chain that evaluates has about 10,630 modules, and a longer one rejects with a RangeError while the modules behind the limit stay "linked". On main the limit is about 15,960, a longer chain gives a RangeError that marks every module, and 30,000 modules end in a segfault. The walk is now JSC's, the one that plain ES modules use.

Differences from Node that stay. Each has a test in vm-module-graph-evaluation-bun.test.ts.

  • The two rules of questions 1 and 2. For a module that a timeout or a SIGINT stopped, Node v26.3.0 leaves the state of V8. A module on the stack of the walk is "errored" with the error null, and evaluate() of the module the call was on never settles. A module that a job resumed after a top-level await stays "evaluated", and its evaluate() never settles. When a job started the body, Node aborts on a V8 CHECK (Check failed: !is_null().).
  • Two cases stay as in Node: the module is "evaluated" and its evaluate() never settles. The first is a module that waits at a top-level await when the termination drops the job that was to resume it: JSC clears the queue and does not say which jobs it dropped. The module of the call gets the error (question 2), a module that it imports does not. The second is a module of the main context, or of a context without its own queue, that a job of the main queue was running inside the run: node:vm starts no checkpoint of that queue, so it does not see one that is stopped.
  • A job that finishes a module while a module that imports it is being evaluated: the importer runs ([JSC] A job that finishes a module from inside a module body does not strand or start its importers early WebKit#832). In Node v26.3.0 the importer never runs and its evaluate() does not settle.
  • A body with a top-level await that evaluates a root that imports its own module: the root runs at once. JSC takes a module on the stack of an outer walk as a dependency that is done (depInOuterSCC, which require() of an ES module needs). In Node the root waits for the module. main does the same as this PR.
  • evaluate() of a member of a cycle that ran as a dependency, after the cycle failed, rejects with the error of the cycle. Node aborts on a V8 CHECK. So does an evaluateCallback that evaluates a module that imports its own SyntheticModule, which Bun runs.
  • initializeImportMeta is called before the body of its module, as on main. Node calls it when the code first evaluates import.meta.

Not fixed.

How a run that was cut short finds the modules. NodeVMRunTermination::finish() of the run that the termination belongs to calls NodeVMModule::errorModulesCutShort with the error that it throws. JSC keeps no list of the records that a termination stopped, and the walk that a deferred namespace starts has no caller in Bun. So that function looks at the module records in the heap. A record that a walk had on its stack has JSC's termination value as its error, no cycle root, and a promise that is pending or absent. A record that a job was running is found by its state, in a context whose checkpoint the termination unwound. Only a run that was cut short pays for that, and only in a VM that made a node:vm module.

What Bun keeps after this PR. Bun calls asyncExecutionRejected, asyncExecutionFulfilled and setEvaluationError of JSC for the modules of a run that was cut short (NodeVMModule.cpp), which no code of Bun did before. The record of a SyntheticModule is a JSModuleRecord without code, set to LINKED by hand. The two new test files take about 70 to 100 s on a debug build.

Measured costs. Release builds on linux-x64: main at ed68082 against the src/ of this PR on that commit, before the rebase. An instruction count is the user-space instructions of the main thread (perf_event_open), as the slope between N and 2N operations, with BUN_JSC_useConcurrentJIT=0, BUN_JSC_useConcurrentGC=0, BUN_JSC_numberOfGCMarkers=1, BUN_GC_TIMER_DISABLE=1 and no ASLR. Two runs agree to 0.1 percent. A line with "gdb" is a single-step count.

  • A plain ES module body (gdb): 136 to 146 instructions from Zig::GlobalObject::moduleLoaderEvaluate to JSModuleRecord::evaluate (the hook asks whether node:vm made the module), and 218 to 221 in innerModuleEvaluation before the body of a leaf module (the WebKit change).
  • script.runInThisContext(): 3,557 to 3,569 instructions for each run. script.runInContext(): 3,682 to 3,694. Of the 12, 9 are in NodeVMRunTermination: its constructor, finish() and the code after it (gdb). Its size on the stack: 72 to 176 bytes.
  • new vm.SyntheticModule(["a"], fn): 2,594 to 2,522. With evaluate(): 6,549 to 7,113. Heap for each evaluated module: 834 to 930 bytes.
  • new vm.SourceTextModule("") with link(): 18,376 to 18,162. With evaluate(): 22,688 to 22,385.
  • A root that imports 16 modules, made, linked and evaluated: 285,920 to 277,376 for SyntheticModules, and 519,790 to 502,712 for SourceTextModules.
  • Promises that evaluate() of a root with 1,000 dependencies makes: 1,001 to 1 (2,002 to 2 in an afterEvaluate context).
  • A run that a timeout cuts short: 16,000 to 21,000 instructions on main, and the same with this PR in a VM that never made a vm module. In a VM that made one: about 320,000, plus about 75 for each module record in the heap (322,000, 426,000, 471,000 and 1,066,000 for 1, 1,001, 3,001 and 10,001 records).
  • A kept Error of a graph that failed: 15 KB to 1,115 KB of heap for each kept error, for a graph of 22 modules with 100 KB each. A context whose SyntheticModule root threw a host Error: 0 of 20 to 20 of 20 stay alive while the errors are kept. With [JSC] A module error does not keep the module record of its Evaluate() alive WebKit#840: 18 KB, and 0 of 20.
  • sizeof: NodeVMModule 104 to 80, NodeVMSourceTextModule 168 to 136, NodeVMSyntheticModule 128 to 112, JSVMClientData 6,248 to 6,256. NodeVMScriptFetcher, NodeVMGlobalObject and Zig::GlobalObject are unchanged.
  • Binary: .text +704 bytes, .bun_builtins -577 bytes. .rodata, .data and .bss are unchanged. The functions of the WebKit change are 282 bytes smaller in total: a heap replaces a sort.

Tests.

  • vm-module-graph-evaluation.test.ts uses node:test, and Node runs the identical file: 203 pass. Bun: 204 pass (one more test starts Node on the file). With the src/ of main and this PR's WebKit, on a debug build: 109 of 204 fail.
  • vm-module-graph-evaluation-bun.test.ts: 73 tests. A debug build skips 4 of them: two long chains, and the two Vitest runs, which need 30 to 40 s each there. With the src/ of main: 38 fail. The code that a timeout must stop runs in child processes (vm-module-graph-cut-short-fixture.js), and every scenario tries again until its deadline passed where the scenario needs it. The file is out of the parallel batch of the test runner (test/parallel-allowlist.json): its children need a processor. It also has the plain ES module tests for the WebKit change, which hang or segfault on main.
  • sourcetextmodule-link-gc.test.ts no longer accepts the unhandled rejection of this bug. With the src/ of main: 1 of 3 fails.
  • The two Vitest tests are todo on Windows: Vitest's vm pools do not find Vitest's own packages there (Cannot find package '@vitest/spy', import.meta.resolve(specifier, parent) fails for bare package names #40931). The random-graph tests have the digests of 12 seeds for each kind of context.
  • Five tests have a timeout of their own: the two Vitest runs (90 s, as in test/js/third_party/vitest/vitest.test.ts), the two collectContinuously rows (30 s) and Node's run of the whole file (30 s).
  • Run on a debug build of the pushed tree (on f2de590, with the preview of [JSC] A job that finishes a module from inside a module body does not strand or start its importers early WebKit#832 at ab1eb44180): the three changed test files, the other files of test/js/node/vm/ (vm.test.ts: 337 pass), test/js/bun/resolve/ (421 pass) and Node's test-vm-* files (98 of 98).
  • Run on a debug build before the rebases (ae752b5):
    • test/js/node/vm/: all pass but two files that need more than the default 5 s there, and do not use the code of this PR to need it: script-leak.test.ts (a loop of 35 s) and four collectContinuously tests of vm-script-fetcher-leak.test.ts.
    • test/js/bun/resolve/: 407 pass. Node's test-vm-* files: 98 of 98 pass.
    • test/js/bun/module-graph/: 2,150 pass and 51 fail, in module-graph-workers.test.ts (48, file descriptors of a Worker that was terminated), module-graph-isolation.test.ts (2) and module-graph-compile.test.ts (1, a hook that times out). Those three files pass on a release build of this PR and of main.
    • The three changed test files with BUN_JSC_validateExceptionChecks=1.
    • vm-module-graph-evaluation.test.ts in the batch form of the test runner (--parallel=7 on 8 processors, the environment of the ASAN lane, 54 files): 204 pass in 2 of 2 rounds, one of them beside 8 busy loops.

Self-review. Four of the 37 concerns are open.

  • The 13-line patch as a first step for 1.4.x: question 3.
  • An issue for the regression: this account cannot open issues. "The regression" and "Who it reaches" above have its text.
  • A random generator whose modules read bindings and call evaluate() from their code: not built. The two test files have those shapes by hand.
  • A bit in JSC for the records that a termination unwound, in the place of the heap scan: not built. The scan needs no engine change and runs only in a run that was cut short.

Other PRs. The rebase onto f2de590 keeps what #46270 added to NodeVMSourceTextModule.cpp: after a failed Link(), replaceUnlinkedRecords() gives the modules that did not link new records, which fixes the crash of a second link() that these Notes listed as not fixed. Here it walks the modules of m_linkedModules, which this PR has in the place of m_resolveCache. #46129 is an open PR for the same crash. This PR replaces #40939, which can close when this one merges. Earlier attempts that this PR does again: #33346, #33562, #33851 and the static half of #33853 (all closed). #45551 (draft) makes the same change to NodeVMGlobalObject::drainOwnMicrotasks and edits the same two hook functions in ZigGlobalObject.cpp: the one that lands second must keep the moduleRecordOfNodeVM branch.


no test proof · iteration 2 · platform-specific test(s) that do not run on this machine, deferring to CI, which covers all platforms: test/js/node/vm/vm-module-graph-evaluation-bun.test.ts, test/js/node/vm/sourcetextmodule-link-gc.test.ts

@robobun

robobun commented Oct 19, 2026 •

Copy link
Copy Markdown
Collaborator Author
Updated 3:04 AM PT - Oct 22nd, 2026

❌ @robobun, your commit 264782d has 1 failures in Build #130669 (All Failures):


🧪   To try this PR locally:

bunx bun-pr 46004

That installs a local version of the PR into your bun-46004 executable, so you can run:

bun-46004 --bun

@robobun

robobun commented Oct 19, 2026

Copy link
Copy Markdown
Collaborator Author

Status

Reproduced on Bun 1.4.0, 1.4.3 and main with the two programs under "The regression" in the Notes of the PR body:

  • A two-module vm.SourceTextModule cycle prints ReferenceError: Cannot access 'x' before initialization. Node v26.3.0 and Bun 1.3.14 print a sees 1.
  • A module that throws after a top-level await ends the process with exit code 1, although the program caught the rejection of evaluate().

With this PR both programs give Node's result.

PR: #46004. It is a draft because it pins the preview build of oven-sh/WebKit#832.

@robobun

robobun commented Oct 19, 2026

Copy link
Copy Markdown
Collaborator Author

The engine change that oven-sh/WebKit#281 was for is now oven-sh/WebKit#845. oven-sh/WebKit#281 is closed. When WEBKIT_VERSION has that commit, a module that waits at a top-level await when a later member of its cycle throws runs the rest of its body, as in Node.js. The expectations in vm-module-graph-evaluation-bun.test.ts that pin the old result change then.

@robobun

robobun commented Oct 20, 2026

Copy link
Copy Markdown
Collaborator Author

#46129 fixes the crash that the Notes of this PR list under "Not fixed": a second link() with another module after a failed link() of a cycle. Two places overlap.

@robobun
robobun force-pushed the robobun/f48be7fb/vm-one-evaluate-per-call branch from ae752b5 to 7038705 Compare October 20, 2026 17:55
Comment thread src/js/node/vm.ts Resolved
Comment thread src/js/node/vm.ts Resolved
Comment thread src/jsc/bindings/NodeVM.cpp Resolved
Comment thread src/jsc/bindings/NodeVM.cpp Resolved
Comment thread src/jsc/bindings/NodeVM.h Resolved
Comment thread src/jsc/bindings/NodeVM.h Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.cpp Resolved
Comment thread src/jsc/bindings/NodeVMModule.h Resolved
Comment thread src/jsc/bindings/NodeVMScriptFetcher.h Resolved
Comment thread src/jsc/bindings/NodeVMScriptFetcher.h Resolved
Comment thread src/jsc/bindings/ZigGlobalObject.cpp Resolved
@robobun
robobun force-pushed the robobun/f48be7fb/vm-one-evaluate-per-call branch from 7038705 to 0597933 Compare October 20, 2026 18:24
@robobun

robobun commented Oct 20, 2026

Copy link
Copy Markdown
Collaborator Author

The comment check flagged 39 groups of comment lines in src/. In 0597933 each of them is one line, or removed. No code changed. The detail that those comments had is in the PR body and in the tests.

module.evaluate() called Evaluate() once for each dependency and then for
the module. A legal import cycle failed with a TDZ ReferenceError, and a
module that threw after a top-level await ended the process with an
unhandled rejection that the program could not catch.

evaluate() now calls JSC's Evaluate() once, and JSC walks the graph. A
vm.SyntheticModule has a JSModuleRecord without code, and the
moduleLoaderEvaluate hook runs its evaluateCallback where the walk reaches
the record. A module reads its status and its error from its record.

A vm run that a timeout or a SIGINT cuts short gives its error to the
node:vm modules that it stopped.

The checkpoint of an afterEvaluate context runs once, after the walk, and
runs only the jobs of that context.

The WebKit version is the preview build of oven-sh/WebKit#832: a job that
finishes a module from inside a module body does not strand its importers
and does not start them early.
@robobun

robobun commented Nov 17, 2026

Copy link
Copy Markdown
Collaborator Author

Closing as stale: this PR conflicts with main, and its last commit is from 2026-10-22.

The branch stays, so the work is not lost. To pick it up again, rebase the branch on main and reopen this PR.

@robobun robobun closed this Nov 17, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants