Skip to content

resolver: in a directory others can write, read only a tsconfig that is your own plain file - #41797

Closed
robobun wants to merge 7 commits into
mainfrom
robobun/89a2b36f/tsconfig-shared-dir
Closed

robobun wants to merge 7 commits into
mainfrom
robobun/89a2b36f/tsconfig-shared-dir

Conversation

@robobun

@robobun robobun commented Sep 7, 2026 •

Copy link
Copy Markdown
Collaborator

Problem

  • A tsconfig.json or jsconfig.json that another user puts in /tmp applies to every project below it. Its paths beat node_modules, so that user's module runs under the victim's uid.
  • dir_info_uncached reads the config in each ancestor directory, and every child inherits it.

Fix

  • A directory vouches for its configs unless others can add files to it: an untrusted owner, world-writable, or sticky and group-writable.
  • There, read a config only when it opens, without following a symlink, as a regular file with one link and a trusted owner. Read it through that same descriptor.
  • Trusted: the invoking user, root, or the owner of the directory bun started in (a root container over a host-owned bind mount).
  • Verified: resolve.test.ts, 14 new blocks. Eight fail on an unfixed release build, five without a second user.

Background

  • Owner alone is not enough: a user can hard-link someone else's file into /tmp where the OS allows it, and a path check can race the read.
  • A stop at the nearest package.json breaks a monorepo root config, and esbuild and tsc both read past it.
  • No review chose or checked this rule. Every review run ended without a verdict.

Downsides

  • In a directory others can write, a symlinked or hard-linked config is no longer read. Only a debug-level message says so.
  • Cost: one fstat per directory that holds a config, plus one in a shared directory. Not traced: no strace here.
  • Still open: an ancestor package.json browser map rewrites the same import in bun build.
Notes

The rule, exactly

For a tsconfig.json or jsconfig.json found in the listing of directory D during the upward walk (POSIX only):

  1. fstat the descriptor the walk already holds for D. If D's owner is trusted, D is not world-writable, and D is not both sticky and group-writable, read the config as before. Symlinked and hard-linked configs in such a directory behave as they did.
  2. Otherwise open the name relative to that descriptor with O_NOFOLLOW | O_NONBLOCK, fstat the result, and accept it only when it is a regular file, its link count is 1 and its owner is trusted. The config is then read from that descriptor. Anything else is skipped, and the walk tries jsconfig.json next.

A group-writable directory without the sticky bit counts as ordinary. Many distributions give each user a private group and a umask of 002, so most project directories there are group-writable.

--tsconfig-override and extends are not vetted. The person who runs bun, or a config that already passed, names those files.

Repro with two uids

uid 65534 wrote the config and the module into a mode 1777 directory owned by root. Root ran a private project below it, with lib installed in its own node_modules:

config: owner uid=65534, links=1, mode=644, in a directory of mode 1777 owned by uid 0
unfixed release build (367d939d9): victim got: {"evil":true} running as uid 0
this branch (debug build):         victim got: "GENUINE" running as uid 0
node:                              victim got: "GENUINE" running as uid 0

This run is on this commit (4e39797).

Why the owner alone was not enough

The previous revision of this branch trusted any config whose owner was trusted. A config owned by root, hard-linked into the shared directory, with "baseUrl": "." in it, made a lib.js created beside it by uid 65534 win over the installed package. That revision and the unfixed build both printed the other user's value. This commit prints the installed one. On the test kernel the link itself is refused for a user who does not own the file (fs.protected_hardlinks=1, EPERM), so the old rule was only as strong as that setting. Systems that allow such links were not tested.

That revision also called lstat on the path, while the file was opened again later by name. This revision checks the descriptor that it reads.

Tests

test/js/bun/resolve/resolve.test.ts, describe auto-discovered tsconfig in a directory other users can write.

Fail on the unfixed release build (367d939), pass here:

  • a symlinked config in a mode 1777 directory is not followed
  • a config with a second hard link there is not read
  • the same config does not reach a bun build bundle
  • a skipped tsconfig.json does not hide your own jsconfig.json
  • a sticky group-writable directory (1775) counts too
  • root only: a tsconfig.json another user owns there is not read
  • root only: the same for jsconfig.json
  • root only: a directory another user owns does not supply its config

Pass both ways:

  • your own plain config in a mode 1777 directory applies
  • an ordinary ancestor directory supplies its config
  • an ordinary directory still follows a symlinked config
  • a group-writable directory without the sticky bit is ordinary
  • --tsconfig-override loads a config the walk would skip
  • root only: a directory owned by the owner of the working directory supplies its config

Run as uid 65534 on this commit, 10 blocks pass and the 4 root-only blocks skip.

Other runs on this commit

  • CI build 122794: resolve.test.ts passes on macOS x64 and arm64 (104 pass, 0 fail, root-only blocks skipped), and no Linux lane reports a failure in test/js/bun/resolve/. The red jobs are an x64-asan spawn.test.ts failure that other PR builds also show, and one macOS arm64 agent that timed out on bunx, datadog-pprof and expo. Those three pass on macOS x64 in the same build.
  • Local, debug plus ASAN build: test/js/bun/resolve/ passes 414 of 423, with 5 skipped and 3 todo. The one failure is load-same-js-file-a-lot.test.ts, a 5 s timeout. It times out the same way on a debug build without this diff (3 of 3 runs each way, on a host with a load average above 200).
  • test/cli/run/tsconfig-override.test.ts and test/bundler/bundler_jsx.test.ts passed locally one commit earlier. The local rerun on this commit did not finish because the host was overloaded. CI ran both on this commit.
  • cargo clippy and cargo fmt are clean. cargo check -p bun_resolver passes for x86_64-pc-windows-msvc, aarch64-apple-darwin, x86_64-unknown-linux-musl and x86_64-unknown-freebsd.
  • The number of open descriptors at exit is 9 whether the config is read through the shared-directory path, read through the ordinary path, or rejected.
  • Not run on a macOS or Windows machine outside CI.

Limits

  • A directory others can write that has no sticky bit: another user can move your own config from one such directory into another. They can also replace your files there.
  • A config that you own but that others can write. The rule asks who put the file there, not who can edit it. An earlier cut refused such a file. That was removed because it would drop every config in a project tree that someone made world-writable with chmod -R 777.
  • Write access granted through an ACL does not show in the mode bits that the rule reads.
  • A working directory owned by another user makes that user trusted.
  • The upward node_modules walk is unchanged. Node does the same walk.
  • Windows is unchanged.

The ancestor package.json browser map

On a release build at 367d939, {"browser":{"lib":"./evil.js"}} in an ancestor package.json makes bun build ./app.js bundle evil.js. --target bun, --target node and the runtime use the installed package. The scope is inherited two lines above the tsconfig inherit. esbuild 0.25.1 does the same for its default platform, so this change leaves it alone.

Parity

  • esbuild 0.25.1 --bundle applies paths from a config above the project's package.json.
  • tsc 6.0.2 --showConfig, run inside the project, prints that same ancestor config.
  • Node ignores tsconfig.json.

The message level

A skip is recorded with Log::add_debug_fmt, which prints nothing by default. A warning would print on every bun run below a shared directory while the file exists, so any user could add a line to every other user's stderr.

History of this branch

  1. Skip any config in a mode 1777 directory. It ignored who owned the file, so it dropped a user's own /tmp/tsconfig.json.
  2. Trust a config by its owner. A hard link passed it, and the check and the read were two lookups.
  3. This revision.

Earlier versions of this description overstated some results: a build that was never run, a self-review that had returned no result, an ancestor package.json called safe after only imports was tested, and a claim that the owner rule closed cases it did not.

Review status: no review run returned a verdict for any revision of this branch. The design review ended without a pick. The self-reviews of the first two revisions ended without a result. The self-review of this revision was stopped twice by infrastructure restarts. The rule is checked only by the tests and runs listed here.


no test proof · iteration 0 · platform-specific test(s) that do not run on this machine, deferring to CI, which covers all platforms: test/js/bun/resolve/resolve.test.ts

@coderabbitai

coderabbitai Bot commented Sep 7, 2026 •

Copy link
Copy Markdown
Contributor

Review Change Stack

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Essentials

Run ID: 5d1d5ab7-100a-4afc-ad5b-af697cc9e1ab

📥 Commits

Reviewing files that changed from the base of the PR and between a3e0ab6 and 7b168d9.

📒 Files selected for processing (3)
  • docs/runtime/module-resolution.mdx
  • src/resolver/resolver.rs
  • test/js/bun/resolve/resolve.test.ts

Included review availability: Your plan provides up to 10 included reviews per hour; 7 remain after this review.


Walkthrough

Changes

Secure module resolution

Layer / File(s) Summary
Directory security filtering
src/resolver/resolver.rs
Automatic tsconfig.json discovery skips files in world-writable sticky directories. The resolver logs a debug message and supports --tsconfig-override for explicit loading.
Resolution behavior and regression coverage
test/js/bun/resolve/resolve.test.ts, docs/runtime/module-resolution.mdx
Tests cover runtime and bundling behavior, secure ancestor directories, and explicit overrides. Documentation describes upward discovery and security filtering.

Suggested reviewers: jarred-sumner, alii

Merge Risk: ⚪ Minimal · up to 7b168

Automatic tsconfig/jsconfig discovery now ignores world-writable sticky directories on POSIX systems while preserving explicit configuration overrides, preventing untrusted scratch-directory configs from changing module resolution. No current merge-blocking risk remains.

🚥 Pre-merge checks | ✅ 4
✅ Passed checks (4 passed)
Check name Status Explanation
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.
Title check ✅ Passed The title describes the change to config discovery in directories other users can write. It is longer than ideal and does not mention jsconfig.json or the explicit override behavior, but it clearly id…
Description check ✅ Passed The description explains the problem and fix, and provides detailed test and verification results. It does not use the template’s exact headings, but it covers both required topics.

Comment @coderabbitai help to get the list of available commands.

@github-actions github-actions Bot added the claude label Sep 7, 2026
@robobun

robobun commented Sep 7, 2026 •

Copy link
Copy Markdown
Collaborator Author

Status: draft, waiting for a maintainer

The head is 4e39797.

The rule: a directory vouches for the configs in it unless other users can add files to it (its owner is not trusted, it is world-writable, or it is sticky and group-writable). In such a directory a config is read only when it opens, without following a symlink, as a regular file with one link and a trusted owner, and it is read through that same descriptor. Ordinary directories behave as before.

Reproduction with two uids, on this commit: uid 65534 wrote tsconfig.json and a module into a mode 1777 directory owned by root, and root ran a private project below it with the real package installed. An unfixed release build (367d939) printed victim got: {"evil":true} running as uid 0. This branch and Node printed "GENUINE".

Proof: test/js/bun/resolve/resolve.test.ts, describe auto-discovered tsconfig in a directory other users can write, 14 blocks. Eight fail on the unfixed release build and pass here. Five of those need no second user, so they also run on unprivileged CI lanes. In CI build 122794 the file passes on macOS x64 and arm64, and no Linux lane reports a failure in it.

What a maintainer needs to know before looking at the diff:

  • No review chose or checked this rule. Every review run on this branch ended without a verdict, the last one because of infrastructure restarts. The rule is checked only by the tests and runs that the description lists.
  • This is the third rule on the branch. The first two had defects, and the description's Notes say what they were.
  • Whether the resolver should have a rule like this at all is an open question. The other answer is to document the upward walk and change nothing.
  • The description lists the limits, and one related case that this change leaves open (an ancestor package.json browser map in bun build).

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

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.

Beyond the inline findings, I checked that both tsconfig.json and jsconfig.json auto-discovery flow through the single guarded site (the check sits after both filename lookups and before the --tsconfig-override branch, so the explicit-override path is correctly unaffected).

Extended reasoning...

The conventions note asked to confirm both config filenames reach the one patched site — reading dir_info_uncached shows the is_shared_scratch_dir guard is placed after the sequential tsconfig.json / jsconfig.json lookups and inside the tsconfig_override.is_none() arm, so both filenames are covered and --tsconfig-override is untouched. That coverage question is ruled out; the remaining concerns are the inline findings.

Comment thread src/resolver/resolver.rs Resolved
Comment thread test/js/bun/resolve/resolve.test.ts Resolved
Comment thread src/resolver/resolver.rs Resolved
@robobun
robobun force-pushed the robobun/89a2b36f/tsconfig-shared-dir branch from 927aafd to 7b168d9 Compare September 7, 2026 23:41
Comment thread src/resolver/resolver.rs Resolved
@robobun

robobun commented Sep 7, 2026 •

Copy link
Copy Markdown
Collaborator Author
Updated 3:15 AM PT - Oct 2nd, 2026

❌ @robobun, your commit 4e39797 has 3 failures in Build #122794 (All Failures):


🧪   To try this PR locally:

bunx bun-pr 41797

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

bun-41797 --bun

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Re-reviewed after the two follow-up commits — all three earlier points are addressed: the guard now takes the already-open directory FD and fails closed (!dir.is_valid() → true, fstat error → true via map_or(true, …)), the stray SAFETY: comment is gone with the path-buffer code, and the --tsconfig-override test now drains stderr in the same Promise.all. No new issues found. Since this is a security hardening in the resolver's config auto-discovery, a human look is still worthwhile before merge.

What was reviewed:

  • is_shared_scratch_dir fail-closed semantics on both the invalid-FD and fstat-error branches, and that the non-unix arm compiles as a no-op.
  • Placement of the check inside the auto-discovery arm only, so --tsconfig-override (the parent.is_none() branch) is unaffected.
  • The five new tests: pipes drained concurrently, chmodSync(0o1777) vs 0o755 covers both sides of the boundary, describe.skipIf(isWindows) gating.
Extended reasoning...

Overview

The PR hardens dir_info_uncached in src/resolver/resolver.rs so that a tsconfig.json/jsconfig.json auto-discovered in a world-writable + sticky directory (/tmp, /var/tmp, /dev/shm) is ignored, closing a local-attacker import-rewrite hole. Since the prior review, the helper was rewritten to fstat the already-open directory FD instead of stating a path through a pooled buffer, and it now fails closed on every branch where the mode cannot be established. The SAFETY: comment and ZStr::from_buf path went away with that rewrite. In the test file, the --tsconfig-override case now includes proc.stderr.text() in the Promise.all, so all five subprocess tests drain both pipes.

Security risks

This is itself a security fix. The residual risk is scope: the guard sits only in the auto-discovery arm (inside the else if parent.is_none() sibling is the override path, which intentionally bypasses it). Switching to fstat on the FD the resolver already holds removes the path-length and stat-race concerns raised earlier. The map_or(true, …) shape means any fstat failure skips the config rather than trusting it, satisfying the fail-closed rule in REVIEW.md. The non-unix arm returns false, which is the documented no-op on Windows where the sticky-bit model does not exist.

Level of scrutiny

Moderate-to-high. The diff is small (~30 native lines, ~100 test lines, one docs paragraph), but it changes a security-relevant decision in the resolver that runs for every source file. The mechanism is straightforward — one bitmask check on an fstat result — and the test matrix covers runtime, bundler, jsconfig, the negative (0o755) case, and the override escape hatch. Still, resolver behavior changes have wide blast radius, so a maintainer sign-off is appropriate.

Other factors

All three inline concerns from the previous run were addressed by commits 2423584 and 7b168d9, and no new candidate issues surfaced this run. There are no outstanding CHANGES_REQUESTED reviews from human reviewers in the timeline. The PR description's rationale for choosing the sticky-bit boundary over package.json or ownership checks is sound and matches the code.

Comment thread src/resolver/resolver.rs Resolved

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

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.

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

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.

…ectory

The upward walk for tsconfig.json and jsconfig.json read every ancestor
directory and inherited the file into every subdirectory below it. Its
compilerOptions.paths and baseUrl are applied before the node_modules
walk, so a file found that way rewrites bare imports of a project that
installed its own dependencies.

In a world-writable sticky directory (mode 1777: /tmp, /var/tmp,
/dev/shm) every user can create a file, so the file found there can
belong to another user. Skip auto-discovery in such a directory.
--tsconfig-override still loads the file, because the person who runs
bun names it.

Without the sticky bit the same directory lets one user rename another
user's project, so nothing below it is trustworthy either way. That is
why the sticky bit, and not the write bit alone, is the boundary.
…he override test

Use the directory fd the walk already holds instead of a second path
lookup, and treat a directory whose mode cannot be read as shared. Drop
the SAFETY label that sat on a safe call. The --tsconfig-override test
now drains stderr with the other two streams.
@robobun

robobun commented Sep 30, 2026

Copy link
Copy Markdown
Collaborator Author

Rebased onto main bf42a52 for a fresh CI run (was c8d2aff, now 5bc5a49). There was no conflict and the diff is unchanged: the added and removed lines are the same as before.

Checked on a local debug build of bf42a52 with this branch and 12 other rebased branches merged in: the tsconfig in a world-writable sticky directory tests of resolve.test.ts pass (5 pass, 1 skip).

@robobun
robobun force-pushed the robobun/89a2b36f/tsconfig-shared-dir branch from c8d2aff to 5bc5a49 Compare September 30, 2026 22:59

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Beyond the inline findings, I also checked whether the fail-closed !dir.is_valid() branch in is_shared_scratch_dir could drop a legitimate tsconfig: open_dir is only FD::INVALID for a permission-denied ancestor, and that directory's entry set is left empty (src/resolver/resolver.rs, the if open_dir.is_valid() iterate block), so no tsconfig.json is ever found there and the branch cannot fire on a readable directory. With store_fd off the walk re-opens each directory, so fd is still a live descriptor at the fstat call.

Extended reasoning...

The change adds a single fstat-based predicate in Resolver::dir_info_uncached that clears tsconfig_path when the enclosing directory is mode 1777, plus a docs paragraph and five subprocess tests. It touches the module-resolution trust boundary, so it is security-sensitive; three verified findings are posted inline and two more verified findings were withheld, which rules out approval. The ruled-out note covers the one concrete adjacent concern examined this run that is not already an inline finding.

Comment thread src/resolver/resolver.rs Resolved
Comment thread src/resolver/resolver.rs Outdated
}
}
if let Some(found) = tsconfig_path {
if is_shared_scratch_dir(fd) {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

🟣 pre-existing, not blocking: pre-existing, security-relevant: after this merge an attacker-planted package.json in /tmp still rewrites bare imports for bun build (default browser target), which the PR says it closes for bun build. The new guard at src/resolver/resolver.rs:6446 only clears tsconfig_path; the browser map of a package.json in the same 1777 directory is still adopted at resolver.rs:6376-6379 and inherited by every subdirectory. A victim package.json without a browser field does not reset that scope, so {"browser":{"lib":"./evil.js"}} beats the vendored node_modules/lib. Fix: apply the same shared-scratch predicate to every ancestor-supplied remap in dir_info_uncached, at least the browser-scope adoption, so bun build is covered like bun run.
A small fix can ride a push you are already making; otherwise a short reply is enough.

Why this was flagged

Any user writes /tmp/package.json containing {"browser":{"lib":"./evil.js"}} and /tmp/evil.js. A victim runs bun build ./app.js in a private mktemp directory under /tmp that has its own package.json and node_modules/lib. In dir_info_uncached the /tmp DirInfo parses that package.json (src/resolver/resolver.rs:6339-6373) and, because pkg.browser_map.count() > 0, sets enclosing_browser_scope and package_json_for_browser_field to /tmp (resolver.rs:6376-6379); every child DirInfo copies both fields from its parent (resolver.rs:6232-6233) and the victim's package.json only replaces them when it has its own browser map. Default bun build target is Browser, so care_about_browser_field is true (resolver.rs:909) and resolve_without_symlinks consults the enclosing browser scope before the node_modules walk (resolver.rs:2238-2294): check_browser_map matches the bare key "lib" (resolver.rs:6658) and the import is rewritten to ./evil.js resolved from /tmp. The new is_shared_scratch_dir check is only applied to tsconfig_path (resolver.rs:6445-6457), so the attack remains open through package.json for bun build; the base branch behaves identically here.

Verification: Same route on the base branch; the diff does not touch the package.json branch. The new guard (src/resolver/resolver.rs:6445-6456) only resets tsconfig_path; when pkg.browser_map.count() > 0, 6376-6379 adopts /tmp's browser scope, children inherit it at 6230-6233, and check_path("lib") hits map.get(path_to_check) (6658), so import_path = "./evil.js".

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

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

Confirmed on a release build of main at 367d939. With {"browser":{"lib":"./evil.js"}} in the ancestor package.json, bun build ./app.js bundles evil.js. --target bun, --target node and bun app.js use the installed package. esbuild 0.25.1 gives the same result for its default platform. The description said that an ancestor package.json needs no change. That note only tested imports. It is corrected, and this case is now listed as open.

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

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

Not fixed in this PR, and left unresolved on purpose. The description lists it under Downsides and in the Notes. The browser scope is inherited two lines above the tsconfig inherit, so the owner predicate could cover it. I kept it out because esbuild 0.25.1 applies an ancestor browser map the same way for its default platform, so the build leg matches the reference, while the run-time paths leg has no such precedent. A maintainer can ask for it in this change.

Comment thread src/resolver/resolver.rs Resolved
@robobun
robobun marked this pull request as draft September 30, 2026 23:30
…ctory mode

The previous rule in this branch skipped a config in a world-writable
sticky directory. It never looked at who owned the file, so a user's own
tsconfig.json in /tmp was skipped too, with no message. It also missed a
group-writable sticky directory and an ancestor directory that another
user owns.

Read an auto-discovered tsconfig.json or jsconfig.json only when its
owner is one this process already trusts: the invoking user, root, or the
owner of the directory bun was started in. The last clause keeps a
container that runs as root over a bind mount owned by the host user
reading its own config, which an euid-only rule would break.

The check is one lstat of the file, so a symlink another user planted is
judged by who planted it. An owner that cannot be read is not trusted.
POSIX only. --tsconfig-override still loads the named file.
Comment thread src/resolver/resolver.rs Resolved
Comment thread src/resolver/resolver.rs Resolved
@robobun robobun changed the title resolver: skip tsconfig auto-discovery in a world-writable sticky directory resolver: trust an auto-discovered tsconfig by its owner Oct 1, 2026
…can write

The owner check from the previous commit had two defects. A config owned
by a trusted uid but hard-linked into a shared directory by another user
passed it. And it called lstat on the path while the file was opened
again later by name, so the file could be replaced between the two.

A directory now vouches for the configs in it unless other users can add
files to it: its owner is not trusted, it is world-writable, or it is
sticky and group-writable. In such a directory a config is read only
when it opens without following a symlink as a regular file with one
link that a trusted user owns, and it is read through that same
descriptor. A skipped tsconfig.json no longer hides a jsconfig.json in
the same directory.

An ordinary directory costs one fstat of the descriptor the walk already
holds and is otherwise unchanged: symlinked and hard-linked configs in it
are read as before. POSIX only. --tsconfig-override is not affected.
@robobun robobun changed the title resolver: trust an auto-discovered tsconfig by its owner resolver: in a directory others can write, read only a tsconfig that is your own plain file Oct 2, 2026
@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-02.

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.

1 participant