tailwindcss

What version of Tailwind CSS are you using? v4.3.3 What build tool (or framework if it abstracts the build tool) are you using? preact@11.0.0-rc.0 or preact@10.29.8, vite@8.2.1 and tailwindcss@4.3.3, @tailwindcss/vite@4.3.3 What version of Node.js are you using? bun@1.3.14 What browser are you using? Edge What operating system are you using? Ubuntu Reproduction URL Describe your issue** The error is very similar to #19903, causing a full page reload and loss of all state periodically, even without any interaction. It's closely related to , and the behavior disappears if I disable on the . I also tried and and encountered the same problem.

(Sorry for creating this PR without opening an issue first) This PR implements a Bun plugin that makes TailwindCSS fast in Bun. (bundling 2048 html + react + tailwind files) Overview This plugins is comprised of two parts: A regular Bun bundler plugin which is the main driver of everything and invokes the native bundler plugin A native bundler plugin which parallelizes the module graph scanning of candidates. Tailwind was part of the motivation for implementing this API. Native bundler plugin The native bundler plugin is used to scan the module graph in parallel with the struct from . The main logic for this code is in the function. Native bundler plugins run in parallel on Bun's bundler threads and do not need to do UTF-16 UTF-8 string conversions. This speeds up the plugin a lot. Native bundler plugins are NAPI modules which export additional symbols (since NAPI modules themselves are dynamically loaded libraries which can be 'd). The crate handles the boilerplate for creating one. I placed the Bun plugin inside the existing (the package). This reduces the need to create more compiled artifacts at the cost of a relatively small binary size change: Please let me know if you would like me to split it out into its own separate package if you don't like the binary size change. Sharing state between the native plugin and JS The scanned candidates and other state are held inside a NAPI External. The struct in the code that does this is called . A NAPI External is a NAPI value which can be given to JS and which holds a data pointer. This data is inaccessible to JS, but a NAPI module can dereference the data and convert it to NAPI values. This looks a bit like this on the Rust side: And the JS side: version bump The crate was updated to version so we can use the function to turn an 's pointer back into . JS plugin The JS plugin uses logic copied over from the vite plugin implementation but modified to work with Bun's plugin API. It invokes the native bundler plugin using the plugin API function: One thing to note is that Bun's bundler currently does not have an API that is analogous to , so there is currently no way to add additional files to the module graph. Testing I added a file, please let me know if you would like more tests

Summary A concrete file that sits inside an auto detection root scans the file's entire parent directory: With the project root as an auto source, every sibling of is scanned and their classes end up in the output. The same directive works correctly when it points outside the root (since #20263). This is the remaining half of #20255. skips the + restriction when the pattern's base is inside an unrestricted root, because everything under that root is walked anyway. But that's not true when the base hides behind a directory the auto walk prunes, like or a git-ignored folder. In that case the pattern's own walk root is the only thing reaching the file, and its ignore rules are just: so all the siblings are walked and included too. To fix this, an auto root only counts as covering a pattern base when its walk actually reaches it: the path down to the base doesn't cross a default-ignored directory and the base isn't git-ignored. The git-ignored check reuses the ancestor walk (and cache) that already promotes auto sources to external sources. External roots and patterns still cover everything under them, and patterns in ordinary subdirectories behave like before, restricting those would hide siblings the auto source should pick up. The walk now follows git's precedence: the nearest with a definitive answer wins, so a directory re-included by a deeper pattern is not treated as ignored. Because that walk is shared, re-included directory sources also stay auto sources instead of being promoted to external ones. For context, I ran into this in Nuxt UI: we emit per-component lines into , and the narrowed list produced byte-identical CSS to sourcing the whole directory (nuxt/ui#6731). Test plan Three new integration tests: concrete file sources behind and behind a git-ignored directory (both failed before with the sibling's candidates included), and a re-included directory where the siblings must stay. Three new unit tests for , including a control for patterns in ordinary covered subdirectories. passes, clean, no new clippy warnings. Verified end to end with on Vite 8 by patching the built oxide binary into a reproduction project: a file inside the root now only ships that file's classes; whole-directory sources and auto detection are unchanged. 🤖 Generated with Claude Code