rails_vite 0.2.2 → 0.3.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65246e1c68cbefab2638785dcb3f9b28290922e2826ba1af7c2f48b00d4edc8e
-  data.tar.gz: 2fba5e05a532396f04fda7e64cf20e5d07e85776309b09a170d3ec8925f8a95f
+  metadata.gz: 8e7210773488e0deadb365f2fb2ab6782d1b347d77ca2f63007eada5cbe6c59f
+  data.tar.gz: 687c142b64c7eb24431696f56c105be88b06c68686689d40005f773f8d70aebf
 SHA512:
-  metadata.gz: 532d10ec22f6e0e4a0fefaed1216ad04efc618b3979365a47b9278be4c03d5ae24488b5fdb5bdce93ecbe963ed0a214483c22d673daa76bc1bb1af355b20850a
-  data.tar.gz: 16f20d8f3ee96046f57b12f81671d094fef7d057cc0f8b8d4ae82fb2ab848a44db2d8fcbdc8bed01246a8351433d2874c63f7f041ab8471e0db8f4c8907f40dc
+  metadata.gz: d4a84d843acb2feb2c9f80d26386b5071ca8c4a8093332d8e71880cddbbf608351709f30fb7cef147b25f7114818eb2b09b8d35ea0808affdf19b67594574446
+  data.tar.gz: e483f34f03fed33786db337c84b5cb290e7ce2ad65e3c73b7294f5e75b77aabffe934dac00b2cb55d79517b65181b699b43f7c4ef9feedadf2ea1190ec1781a6

data/CHANGELOG.md

@@ -5,6 +5,54 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog],
 and this project adheres to [Semantic Versioning].
 
+## rails_vite@0.3.0.rc1 / rails-vite-plugin@0.3.0-rc.1 - 2026-10-11
+
+### Added
+
+- `refreshDelay` plugin option for `rails()` and `jsbundling()`. It waits the given milliseconds after the last `refresh` change before the full-page reload, and sends one reload for a burst of changes. Use it when Rails sees template changes late, e.g. with `EventedFileUpdateChecker`. Default: `0`, which reloads at once as before (#45) ([@olivier-thatch])
+- The install generator sets `"type": "module"` in package.json — Vite and rails-vite-plugin are ESM-only, and without it Node fails to load `vite.config.ts` under npm/pnpm/yarn. When package.json pins another `type`, the generator emits `vite.config.mts` instead (#38) ([@skryukov])
+- [aube](https://github.com/aubepkg/aube) package manager support: an `aube-lock.yaml` makes the rake tasks, auto build and the install generator use aube, even next to another lockfile left over from `aube import` (#41) ([@beauraF])
+- `config.rails_vite.vite_executable` sets the executable for `rake vite:build`, test builds and auto builds, so Vite-compatible CLIs with another name, such as Vite+'s `vp`, work. The default is `vite` (#42) ([@cole-robertson])
+- `auto_build_paths` config option: extra paths and globs, relative to `Rails.root`, that auto build checks for changes besides `sourceDir` (for example `app/views` for Tailwind). It defaults to the root-level Vite, PostCSS, Tailwind and TypeScript configs, `package.json`, and the lockfile, so changes to them now trigger a rebuild (#46) ([@olivier-thatch])
+- `config.rails_vite.build_mode` sets the `--mode` for `vite build` in `rake vite:build` and auto builds. The default is unchanged (`"test"` in the test environment, no `--mode` elsewhere); set it to `nil` to pass no `--mode`. The gem now passes its `build_dir` to the plugin in `RAILS_VITE_BUILD_DIR`, so the build directory no longer depends on the mode. Upgrade `rails-vite-plugin` together with the gem: older plugin versions ignore `RAILS_VITE_BUILD_DIR`. With `build_mode` set, `vite:build` runs `vite build --mode` directly instead of the package.json `build` script (#49) ([@olivier-thatch])
+- `vite_asset_url(name)` returns a full URL for a Vite asset, like Rails' `asset_url`, for mailers and other places that need an absolute URL (#36) ([@skryukov])
+
+### Changed
+
+- **Breaking:** `rails-vite-plugin` requires Vite 7 or newer and Node.js 20.19+ or 22.12+, like Vite 7 itself. It failed to load on Vite 5 and 6 already ([@skryukov])
+- Vite asset URLs are built with Rails' `path_to_asset`, so `asset_host` works as it does for other Rails assets: procs that take the request, `%d` hosts and per-controller hosts. Mailers now use `config.action_mailer.asset_host` (or `config.asset_host`) instead of the controller's. With `relative_url_root`, tags now include the prefix; set Vite's `base` to match (#36) ([@skryukov])
+- `rake vite:build` loads the Rails environment first, so `config.rails_vite` settings from initializers (such as `vite_executable`) also apply to it and to `bin/rails test` (#42) ([@cole-robertson])
+- The install generator writes `vite dev` instead of `vite` to `Procfile.dev` (#42) ([@cole-robertson])
+- **Breaking:** `vite:build` (and therefore `assets:precompile`) runs the package.json `build` script when one exists, so `"build": "vite build && vite build --ssr"` produces both client and SSR bundles on deploy. Apps without a `build` script keep the bare `vite build`. If package.json already has a `build` script (e.g. one left over from jsbundling-rails), make sure it builds with Vite before upgrading. Test builds and auto-builds always use the bare command, since their extra flags (`--mode test`, `--logLevel warn`) would only reach the last command of a compound script (#38) ([@skryukov])
+
+### Fixed
+
+- Vite commands from the rake tasks and auto build run in `Rails.root`, so they work when Rails is started from another directory (#39) ([@janko])
+- The package manager is detected from lockfiles in `Rails.root`, not the current directory ([@skryukov])
+- Chunks loaded at runtime (dynamic `import()` and their preloads) now come from a string `config.action_controller.asset_host`, like the tags: `rake vite:build` and auto builds pass it to the plugin in `RAILS_VITE_ASSET_HOST`, which prepends it to Vite's `base`. Set the variable yourself for a proc or `%d` `asset_host`. Needs both the updated gem and plugin (#35) ([@skryukov])
+- Allow Vitest's internal Vite server to start in CI. `rails()` and `jsbundling()` now skip the dev-server environment guard and dev server setup under Vitest (#43) ([@cole-robertson])
+- Production tags now link the CSS of chunks an entry imports, including nested and shared chunks, not just the entry's own CSS. Chunk CSS comes before the entry's CSS, matching Vite's HTML output, and CSS shared by several entries in one `vite_tags` call is linked once (#40) ([@madogiwa0124])
+- Watch the base directories of the `refresh` globs, so template and helper changes trigger a full reload on Linux. Vite's watcher disables globbing, so the globs were watched as literal paths that don't exist. On Linux this also stopped change events for the nested view directories (#44) ([@olivier-thatch])
+- Ignore a dev metadata file whose Vite process is gone. After a hard kill (SIGKILL, OOM killer), `vite_tags` no longer link to a dead dev server, and Rails started afterwards runs auto builds again. The plugin now records its hostname, and the pid is only checked when Vite runs on the same host, so Vite in another container still counts as running. Needs both the updated gem and plugin (#48) ([@olivier-thatch])
+
+## rails_vite@0.2.3 / rails-vite-plugin@0.2.5 - 2026-06-09
+
+### Added
+
+- `RailsVite.dev_server_csp_source` returns a Content Security Policy source for the running Vite dev server, resolved per request so it tracks the real (possibly auto-incremented) port and adds nothing when the server is down. Pass `websocket: true` for the HMR socket (#25) ([@skryukov])
+- `prependSourceDirToEntries` plugin option for `rails()` and `jsbundling()`. Set it to `false` to use Vite's `root` as your `sourceDir` — entries are then resolved by their bare, root-relative names instead of being prefixed with `sourceDir` (#22) ([@skryukov])
+
+### Changed
+
+- Auto builds now run quietly (`vite build --logLevel warn`) to keep system-test output clean; warnings and errors are still shown ([@skryukov])
+
+### Fixed
+
+- The development `@vite/client` and React Fast Refresh tags now derive their nonce from the request (`content_security_policy_nonce`) instead of inheriting whatever nonce the first `vite_*` call passed. A nonce-less first call (e.g. a stylesheet) no longer ships a nonce-less client script under a `strict-dynamic` CSP (#25) ([@skryukov])
+- Persist auto-build freshness across process restarts so repeated local system-test runs no longer rebuild unchanged assets. Freshness now derives from the build manifest's timestamp instead of in-memory state (#21) ([@skryukov], [@brodienguyen])
+- Don't delete the dev metadata file owned by another Vite process on exit, so concurrent Vite servers no longer clobber each other's dev server info (#27) ([@brodienguyen])
+- Allow Vite config to resolve in CI environments without weakening the dev-server environment guard (#28) ([@brodienguyen])
+
 ## rails_vite@0.2.2 / rails-vite-plugin@0.2.4 - 2026-04-09
 
 ### Added
@@ -74,6 +122,12 @@ and this project adheres to [Semantic Versioning].
 - Initial release ([@skryukov])
 
 [@skryukov]: https://github.com/skryukov
+[@brodienguyen]: https://github.com/brodienguyen
+[@olivier-thatch]: https://github.com/olivier-thatch
+[@beauraF]: https://github.com/beauraF
+[@cole-robertson]: https://github.com/cole-robertson
+[@madogiwa0124]: https://github.com/madogiwa0124
+[@janko]: https://github.com/janko
 
 [Keep a Changelog]: https://keepachangelog.com/en/1.0.0/
 [Semantic Versioning]: https://semver.org/spec/v2.0.0.html

data/README.md

@@ -89,7 +89,8 @@ Short names are automatically prefixed with `sourceDir` (default: `app/javascrip
 | `vite_javascript_tag(*entries, **options)` | Same as `vite_tags`, appends `.js` to extensionless names |
 | `vite_stylesheet_tag(*entries, **options)` | Same as `vite_tags`, appends `.css` to extensionless names |
 | `vite_typescript_tag(*entries, **options)` | Same as `vite_tags`, appends `.ts` to extensionless names |
-| `vite_asset_path(name)` | Returns the fingerprinted path from the manifest |
+| `vite_asset_path(name)` | Returns the fingerprinted path from the manifest, with `asset_host` applied like Rails' `asset_path` |
+| `vite_asset_url(name)` | Same as `vite_asset_path`, as a full URL like Rails' `asset_url`. In mailers, set `asset_host` to get a full URL |
 | `vite_image_tag(name, **options)` | Image tag with manifest-resolved src |
 
 All tag helpers accept arbitrary HTML attributes:
@@ -107,12 +108,27 @@ CSS files are detected by extension and emit `<link rel="stylesheet">`:
 <%= vite_tags "application.css" %>
 ```
 
-### CSP Nonces
+### Content Security Policy
+
+Pass a `nonce` to any tag helper; it's applied to every tag it emits:
 
 ```erb
 <%= vite_tags "application.js", nonce: content_security_policy_nonce %>
 ```
 
+The dev server's `@vite/client` and React Fast Refresh tags pick up the request nonce automatically, so they work under `strict-dynamic` even when your first `vite_*` call is a nonce-less stylesheet.
+
+Running a CSP in development? Allow the dev server's origin with `RailsVite.dev_server_csp_source` — it resolves per request, so it tracks Vite's actual port and adds nothing when the server is down:
+
+```ruby
+# config/initializers/content_security_policy.rb — inside your `policy` block
+if Rails.env.development?
+  policy.script_src(*policy.script_src, RailsVite.dev_server_csp_source)
+  policy.style_src(*policy.style_src, RailsVite.dev_server_csp_source)
+  policy.connect_src(*policy.connect_src, RailsVite.dev_server_csp_source(websocket: true)) # HMR
+end
+```
+
 ### Subresource Integrity (SRI)
 
 [SRI](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity) lets browsers verify that fetched assets haven't been tampered with by checking cryptographic hashes. Install the [`vite-plugin-manifest-sri`](https://github.com/nicolo-ribaudo/vite-plugin-manifest-sri) plugin:
@@ -151,6 +167,19 @@ Then reference them in views:
 <%= vite_image_tag "app/assets/images/logo.png", alt: "Logo" %>
 ```
 
+**Migrating from Propshaft?** Vite resolves asset references itself, so you don't need Propshaft's `RAILS_ASSET_URL(...)` — swap the logical path for a path relative to the referencing file, and Vite fingerprints it:
+
+```css
+/* Propshaft */
+background: url(RAILS_ASSET_URL("logo.svg"));
+/* Vite */
+background: url(../assets/images/logo.svg);
+```
+
+- In CSS: works for any stylesheet Vite processes — an entry point, or imported from one.
+- In JS: `import logoUrl from '../assets/images/logo.svg'` (or pull in a whole folder with `import.meta.glob`).
+- In views: `vite_asset_path` / `vite_image_tag`, which read the Vite manifest.
+
 ## Vite Config
 
 The install generator creates a minimal `vite.config.ts`:
@@ -166,6 +195,23 @@ export default defineConfig({
 });
 ```
 
+### Custom Vite Executable
+
+The gem runs Vite through the detected package manager (`npx vite`, `yarn vite`, `pnpm vite`, `bun run vite` or `aube exec vite`). To use a Vite-compatible executable with a different name, set `vite_executable`:
+
+```ruby
+# config/initializers/rails_vite.rb
+Rails.application.config.rails_vite.vite_executable = "vp"
+```
+
+`rake vite:build`, `assets:precompile`, test builds and auto builds then run `vp build` (for example, `npx vp build`). A package.json `build` script runs as written, so use `vp build` in it too. In your `Procfile.dev`, run the dev server with `vp dev`:
+
+```
+js: npx vp dev
+```
+
+[Vite+](https://viteplus.dev) installs `vp`, not `vite`, so set `vite_executable = "vp"`. Without it, the package manager may still find a plain Vite (installed by another package, or downloaded by `npx`) and build without Vite+. Package managers may also warn that the plugin's `vite` peer dependency is not met, because Vite+ replaces `vite` with its own package and version.
+
 ### Plugin Options
 
 | Option | Default | Description |
@@ -175,9 +221,11 @@ export default defineConfig({
 | `ssr` | — | SSR entry point |
 | `ssrOutDir` | `'ssr'` | SSR output directory |
 | `devMetaFile` | `'tmp/rails-vite.json'` | Dev metadata file path |
-| `buildDir` | `'vite'` | Build output subdirectory inside `public/` |
+| `buildDir` | `$RAILS_VITE_BUILD_DIR`, else `'vite-test'` in `test` mode, else `'vite'` | Build output subdirectory inside `public/`. The gem sets `RAILS_VITE_BUILD_DIR` from `config.rails_vite.build_dir` when it runs a build |
 | `publicDir` | `'public'` | Public directory |
 | `refresh` | `true` | Paths to watch for full-page reload. `true` watches `app/views/**` and `app/helpers/**` |
+| `refreshDelay` | `0` | Milliseconds to wait after the last `refresh` change before the full-page reload. Changes within the delay send one reload. Set it (e.g. `300`) when Rails sees template changes late, as with `config.file_watcher = ActiveSupport::EventedFileUpdateChecker`, so the reload does not get the old HTML |
+| `prependSourceDirToEntries` | `true` | When `false`, entries are resolved without the `sourceDir` prefix. Set this when Vite's `root` is your `sourceDir` (see below) |
 
 ### Multiple Entry Points
 
@@ -208,6 +256,26 @@ rails({
 <%= vite_tags "entrypoints/application.ts" %>
 ```
 
+### Setting Vite's `root` to your source directory
+
+By default, `root` is the Rails project root, so `import.meta.glob` keys and manifest entries are prefixed with `sourceDir` (e.g. `app/frontend/components/Foo.jsx`). If you prefer `vite_ruby`-style root-relative names (`components/Foo.jsx`), set Vite's `root` to your source directory and tell the plugin not to prepend `sourceDir`:
+
+```typescript
+import { fileURLToPath } from 'node:url'
+
+export default defineConfig({
+  root: fileURLToPath(new URL('./app/frontend', import.meta.url)),
+  plugins: [
+    rails({ sourceDir: 'app/frontend', prependSourceDirToEntries: false }),
+  ],
+  build: {
+    outDir: fileURLToPath(new URL('./public/vite', import.meta.url)),
+  },
+})
+```
+
+With `root` set to the source directory, Vite emits bare manifest keys, and `prependSourceDirToEntries: false` makes the Rails helpers look them up by those bare names. Set both together. (Don't point `root` at a symlinked path — Vite resolves symlinks and emits keys that escape the root.)
+
 ## Adding Frameworks
 
 ### React
@@ -267,10 +335,36 @@ npx vite build && npx vite build --ssr
 node ssr/ssr.js
 ```
 
+To build the SSR bundle during `assets:precompile`, define a `build` script — `vite:build` runs it when present:
+
+```json
+"scripts": {
+  "build": "vite build && vite build --ssr"
+}
+```
+
 ## Auto Build
 
 When the Vite dev server is not running, rails_vite automatically rebuilds assets on the first request if sources have changed. This is useful for system tests and quick checks without running `bin/dev`.
 
+Freshness is determined by comparing your source files' timestamps against the build manifest's timestamp. Since the manifest lives on disk, unchanged assets are not rebuilt across process restarts — for example, on repeated local system-test runs.
+
+Besides `sourceDir`, auto build checks these files at the app root by default: `vite.config.*`, `postcss.config.*`, `tailwind.config.*`, `tsconfig*.json`, `package.json`, and the package manager lockfile. Use `auto_build_paths` to add other build inputs. Each entry is a path or glob relative to `Rails.root`. Directories are checked recursively, and paths that do not exist are ignored. For example, Tailwind generates CSS from class names in your views, so add the directories it scans:
+
+```ruby
+# config/initializers/rails_vite.rb
+Rails.application.config.rails_vite.auto_build_paths += %w[
+  app/views
+  app/components
+  app/helpers
+  app/assets/stylesheets
+]
+```
+
+Assign the option (`=`) instead of appending to replace the defaults.
+
+Auto builds run quietly (`vite build --logLevel warn`), so they don't clutter your test output; warnings and errors are still shown. Run `rake vite:build` directly for the full build log.
+
 Disable it:
 
 ```ruby
@@ -282,6 +376,31 @@ By default, auto build is enabled in development and test (`Rails.env.local?`).
 
 Note: for parallel test runners, disable auto build and use `rake vite:build` before the suite instead.
 
+## CDN
+
+Tags follow `config.action_controller.asset_host`. `rake vite:build` and auto builds also pass a string `asset_host` to the plugin in `RAILS_VITE_ASSET_HOST`, and the plugin prepends it to Vite's `base`, so chunks Vite loads at runtime (dynamic `import()` and their preloads) come from the same host. With a proc or `%d` `asset_host`, set `RAILS_VITE_ASSET_HOST` in the build's environment yourself (`.env` files are not read for it).
+
+The host is fixed at build time, so build with the same `asset_host` you deploy with. jsbundling mode doesn't use this.
+
+## Build Mode
+
+`rake vite:build` and auto builds pass `--mode test` to `vite build` in the test environment, and no `--mode` elsewhere. This sets `import.meta.env.MODE` and chooses which `.env.[mode]` files Vite loads. If `MODE === 'test'` means "running under Vitest" in your app, a Rails system-test bundle then includes Vitest-only code. Choose another mode, or no mode:
+
+```ruby
+# config/initializers/rails_vite.rb
+if Rails.env.test?
+  Rails.application.config.rails_vite.build_mode = nil     # no --mode, so Vite uses "production"
+  # or
+  Rails.application.config.rails_vite.build_mode = "e2e"   # --mode e2e
+end
+```
+
+The build mode does not change the build directory: the test environment still builds to `public/vite-test/`. The gem passes its `build_dir` to the plugin in the `RAILS_VITE_BUILD_DIR` environment variable, so the gem and the plugin always use the same directory. If you run `vite build` yourself, set `RAILS_VITE_BUILD_DIR` or the plugin's `buildDir` option to match.
+
+Upgrade `rails-vite-plugin` together with the gem: older plugin versions ignore `RAILS_VITE_BUILD_DIR` and build every mode other than `test` into `public/vite/`.
+
+With `build_mode` set, `vite:build` runs `vite build --mode` directly instead of your package.json `build` script, because `--mode` would only reach the last command of a compound script. Build other bundles, such as SSR, in a separate step.
+
 ## Testing the Build
 
 To verify your production build works in development:
@@ -291,7 +410,7 @@ rake vite:build         # build assets
 bin/rails s             # start Rails without Vite dev server
 ```
 
-Without the Vite dev server running (no `tmp/rails-vite.json`), Rails serves built assets from `public/vite/`. To switch back to dev mode, start Vite again — the dev metadata takes priority.
+Without the Vite dev server running (no `tmp/rails-vite.json`, or its Vite process is gone), Rails serves built assets from `public/vite/`. To switch back to dev mode, start Vite again — the dev metadata takes priority.
 
 Clean up built assets with `rake vite:clobber`.
 
@@ -317,6 +436,14 @@ Defaults match the plugin defaults — no config needed if you follow convention
 
 `vite:build` hooks into `assets:precompile` and `test:prepare` automatically. Skip with `SKIP_VITE_BUILD=1`.
 
+`vite:build` prefers your package.json `build` script when one exists (like jsbundling-rails), falling back to a bare `vite build`. Test builds, and builds with `build_mode` set, skip the script and run `vite build` directly.
+
+### Package Manager
+
+The rake tasks, auto build and the install generator run your JS package manager, picked by lockfile in this order: `aube-lock.yaml`, `bun.lockb` or `bun.lock`, `yarn.lock`, `pnpm-lock.yaml`, `package-lock.json`. Without a lockfile, the first of bun, yarn, pnpm, npm and aube found on `PATH` is used.
+
+[aube](https://github.com/aubepkg/aube) can also use an existing pnpm, yarn, npm or bun lockfile in place, without writing `aube-lock.yaml`. Such a project is detected as the tool that owns the lockfile, so keep that tool installed, or run `aube import` to create `aube-lock.yaml`.
+
 
 ## jsbundling Mode
 
@@ -350,6 +477,7 @@ export default defineConfig({
 | `outputDir` | `'public/assets'` | Public directory for the full Vite build output |
 | `ssr` | — | SSR entry point. String or `{ entry, outDir }` |
 | `refresh` | — | Paths to watch for full-page reload. `true` watches `app/views/**` and `app/helpers/**` |
+| `refreshDelay` | `0` | Milliseconds to wait after the last `refresh` change before the full-page reload. Changes within the delay send one reload. Set it (e.g. `300`) when Rails sees template changes late, as with `config.file_watcher = ActiveSupport::EventedFileUpdateChecker`, so the reload does not get the old HTML |
 | `devMetaFile` | `'tmp/rails-vite.json'` | Dev metadata file path. Set to `false` to disable |
 
 ### Replacing esbuild

data/lib/generators/rails_vite/install/install_generator.rb

@@ -10,8 +10,26 @@ module RailsVite
         run RailsVite::Tasks.add_command("vite", "rails-vite-plugin")
       end
 
+      def ensure_esm_package
+        return unless File.exist?("package.json")
+
+        package_json = JSON.parse(File.read("package.json"))
+        @esm_package = package_json["type"] == "module"
+        return if @esm_package
+
+        if package_json.key?("type")
+          say %(package.json sets "type": "#{package_json["type"]}", but Vite and rails-vite-plugin are ESM-only — generating vite.config.mts instead.), :yellow
+        else
+          package_json["type"] = "module"
+          create_file "package.json", JSON.pretty_generate(package_json) + "\n", force: true
+          @esm_package = true
+          say %(Added "type": "module" to package.json (Vite and rails-vite-plugin are ESM-only).)
+          warn_about_commonjs_configs
+        end
+      end
+
       def create_vite_config
-        template "vite.config.ts.tt", "vite.config.ts"
+        template "vite.config.ts.tt", @esm_package ? "vite.config.ts" : "vite.config.mts"
       end
 
       def create_entrypoint
@@ -65,6 +83,13 @@ module RailsVite
 
       private
 
+      def warn_about_commonjs_configs
+        commonjs_configs = Dir["*.config.js"].select { |f| File.read(f).match?(/\bmodule\.exports\b|\brequire\(/) }
+        return if commonjs_configs.empty?
+
+        say "These files use CommonJS and will break under \"type\": \"module\": #{commonjs_configs.join(", ")}. Rename them to .cjs.", :yellow
+      end
+
       def vite_dev_command
         RailsVite::Tasks.dev_command
       end

data/lib/rails_vite/auto_build.rb

@@ -9,7 +9,6 @@ module RailsVite
       @app = app
       @config = config
       @mutex = Mutex.new
-      @last_build_at = NEVER
       @cached_source_mtime = nil
       @source_mtime_checked_at = nil
     end
@@ -25,16 +24,20 @@ module RailsVite
       @mutex.synchronize do
         return unless stale?
 
-        Rails.logger.error("rails-vite: build failed") unless system(RailsVite::Tasks.build_command)
-        @last_build_at = Time.now
+        # Build quietly: vite's per-build summary is noise on every auto-build
+        # (e.g. each local system-test run). Warnings and errors still stream.
+        Rails.logger.error("rails-vite: build failed") unless system(RailsVite::Tasks.build_env, "#{RailsVite::Tasks.build_command} --logLevel warn", chdir: Rails.root)
         @cached_source_mtime = nil
         @source_mtime_checked_at = nil
       end
     end
 
     def stale?
+      # The manifest file's mtime is our persisted "last build" timestamp: it
+      # lives on disk, so freshness survives process restarts (e.g. a new Rails
+      # process per local system-test run) without any extra state.
       !File.exist?(@config.manifest_path) ||
-        latest_source_mtime > @last_build_at
+        latest_source_mtime > File.mtime(@config.manifest_path)
     end
 
     def latest_source_mtime
@@ -51,7 +54,7 @@ module RailsVite
       latest = NEVER
       source_path = Rails.root.join(@config.source_dir).to_s
 
-      Find.find(source_path) do |path|
+      Find.find(source_path, *auto_build_path_matches) do |path|
         next unless File.file?(path)
         mtime = File.mtime(path)
         latest = mtime if mtime > latest
@@ -61,5 +64,18 @@ module RailsVite
     rescue Errno::ENOENT
       Time.now # source dir missing — trigger build to surface the error
     end
+
+    def auto_build_path_matches
+      root = Rails.root.to_s
+      @config.auto_build_paths.flat_map do |pattern|
+        Dir.glob(pattern.to_s, base: root).filter_map { |match| existing_realpath(match, root) }
+      end
+    end
+
+    def existing_realpath(path, root)
+      File.realpath(path, root)
+    rescue SystemCallError
+      nil
+    end
   end
 end

data/lib/rails_vite/config.rb

@@ -2,7 +2,7 @@ module RailsVite
   class Config
     META_FILENAME = "rails-vite.json"
 
-    attr_writer :dev_meta_path, :manifest_path, :asset_prefix, :auto_build, :build_dir
+    attr_writer :dev_meta_path, :manifest_path, :asset_prefix, :auto_build, :build_dir, :vite_executable, :auto_build_paths, :build_mode
 
     def dev_meta_path
       @dev_meta_path || Rails.root.join("tmp", META_FILENAME)
@@ -12,6 +12,16 @@ module RailsVite
       @build_dir || (Rails.env.test? ? "vite-test" : "vite")
     end
 
+    # The `--mode` for `vite build`. nil or false passes no `--mode`, so Vite uses its default.
+    def build_mode
+      return @build_mode.presence if defined?(@build_mode)
+      "test" if Rails.env.test?
+    end
+
+    def vite_executable
+      @vite_executable || "vite"
+    end
+
     def manifest_path
       @manifest_path || Rails.root.join("public", build_dir, "manifest.json")
     end
@@ -33,6 +43,19 @@ module RailsVite
       Rails.env.local?
     end
 
+    # Paths or globs relative to Rails.root that auto build checks for changes,
+    # in addition to source_dir. Directories are walked recursively.
+    def auto_build_paths
+      @auto_build_paths ||= [
+        "vite.config.*",
+        "postcss.config.*",
+        "tailwind.config.*",
+        "tsconfig*.json",
+        "package.json",
+        *Tasks::LOCKFILES.values.flatten
+      ]
+    end
+
     def dev_server_running?
       return false if Rails.env.test?
       !!dev_server_url
@@ -61,14 +84,37 @@ module RailsVite
     end
 
     def load_plugin_meta
-      JSON.parse(dev_meta_path.read)
+      meta = JSON.parse(dev_meta_path.read)
+      return meta if dev_server_alive?(meta)
+
+      load_build_meta
     rescue Errno::ENOENT
-      build_meta_path = manifest_path.dirname.join(META_FILENAME)
-      begin
-        JSON.parse(build_meta_path.read)
-      rescue Errno::ENOENT, JSON::ParserError
-        {}
+      load_build_meta
+    end
+
+    def load_build_meta
+      JSON.parse(manifest_path.dirname.join(META_FILENAME).read)
+    rescue Errno::ENOENT, JSON::ParserError
+      {}
+    end
+
+    # A hard kill of Vite (SIGKILL, OOM) does not remove the dev meta file.
+    # Ignore the file when its process is gone.
+    def dev_server_alive?(meta)
+      pid = meta["pid"]
+      return true unless pid.is_a?(Integer) && pid.positive?
+      return true unless meta["hostname"] == Socket.gethostname
+
+      Process.kill(0, pid)
+      true
+    rescue Errno::EPERM
+      true
+    rescue Errno::ESRCH
+      unless @stale_dev_meta_pid == pid
+        @stale_dev_meta_pid = pid
+        Rails.logger&.warn("rails-vite: ignoring #{dev_meta_path}, Vite process #{pid} is not running")
       end
+      false
     end
   end
 end

data/lib/rails_vite/manifest.rb

@@ -14,11 +14,16 @@ module RailsVite
       entry = manifest[name] || resolve_with_extension(name, manifest) ||
         raise(MissingEntryError.new(name, @path))
 
+      imports = []
+      css = []
+      walk_imports(entry, Set.new, manifest, imports, css)
+      css.concat(entry.fetch("css", []))
+
       {
         file: entry["file"],
         integrity: entry["integrity"],
-        css: resolve_css(entry, manifest),
-        imports: resolve_imports(entry, Set.new, manifest)
+        css: resolve_css(css.uniq, manifest),
+        imports: imports
       }
     end
 
@@ -58,23 +63,24 @@ module RailsVite
       nil
     end
 
-    def resolve_css(entry, manifest)
-      entry.fetch("css", []).map do |css_file|
-        integrity = manifest.values.find { |e| e["file"] == css_file }&.dig("integrity")
-        {file: css_file, integrity: integrity}
-      end
+    def resolve_css(css_files, manifest)
+      return [] if css_files.empty?
+
+      by_file = {}
+      manifest.each_value { |e| by_file[e["file"]] ||= e }
+      css_files.map { |css_file| {file: css_file, integrity: by_file[css_file]&.dig("integrity")} }
     end
 
-    def resolve_imports(entry, seen, manifest)
-      entry.fetch("imports", []).flat_map do |import_key|
-        next [] if seen.include?(import_key)
-        seen.add(import_key)
+    def walk_imports(chunk, seen, manifest, imports, css)
+      chunk.fetch("imports", []).each do |import_key|
+        next unless seen.add?(import_key)
 
         imported = manifest[import_key]
-        next [] unless imported
+        next unless imported
 
-        [{file: imported["file"], integrity: imported["integrity"]}] +
-          resolve_imports(imported, seen, manifest)
+        imports << {file: imported["file"], integrity: imported["integrity"]}
+        walk_imports(imported, seen, manifest, imports, css)
+        css.concat(imported.fetch("css", []))
       end
     end
   end

data/lib/rails_vite/tag_helper.rb

@@ -33,10 +33,14 @@ module RailsVite
       if config.dev_server_running?
         "#{config.dev_server_url}/#{resolved}"
       else
-        vite_asset_url(RailsVite.manifest.path_for(resolved))
+        vite_build_path(RailsVite.manifest.path_for(resolved))
       end
     end
 
+    def vite_asset_url(name)
+      url_to_asset(vite_asset_path(name))
+    end
+
     def vite_image_tag(name, **options)
       image_tag(vite_asset_path(name), **options)
     end
@@ -47,8 +51,14 @@ module RailsVite
       tags = []
 
       unless @_vite_client_emitted
+        # The client/react-refresh tags are emitted once, on the first vite_*
+        # call. Their nonce must come from the request — not from whichever call
+        # happened to be first — so a nonce-less first call (e.g. a stylesheet)
+        # doesn't ship a nonce-less @vite/client under a `strict-dynamic` CSP.
+        client_nonce = nonce || (content_security_policy_nonce if respond_to?(:content_security_policy_nonce))
+
         if RailsVite.config.react_refresh?
-          tags << tag.script(type: "module", nonce: nonce) {
+          tags << tag.script(type: "module", nonce: client_nonce) {
             <<~JS.squish.html_safe
               import{injectIntoGlobalHook}from'#{dev_url}/@react-refresh';
               injectIntoGlobalHook(window);
@@ -57,7 +67,7 @@ module RailsVite
             JS
           }
         end
-        tags << tag.script(src: "#{dev_url}/@vite/client", type: "module", nonce: nonce)
+        tags << tag.script(src: "#{dev_url}/@vite/client", type: "module", nonce: client_nonce)
         @_vite_client_emitted = true
       end
 
@@ -71,6 +81,7 @@ module RailsVite
     def vite_prod_tags(entries, nonce: nil, **options)
       tags = []
       preloaded = Set.new
+      linked_css = Set.new
 
       entries.each do |entry|
         result = RailsVite.manifest.lookup(entry)
@@ -78,15 +89,16 @@ module RailsVite
         Array(result[:imports]).each do |import_entry|
           next if preloaded.include?(import_entry[:file])
           preloaded.add(import_entry[:file])
-          tags << tag.link(rel: "modulepreload", href: vite_asset_url(import_entry[:file]),
+          tags << tag.link(rel: "modulepreload", href: vite_build_path(import_entry[:file]),
             nonce: nonce, **sri_attrs(import_entry[:integrity]))
         end
 
-        tags << build_asset_tag(entry, vite_asset_url(result[:file]),
+        tags << build_asset_tag(entry, vite_build_path(result[:file]),
           nonce: nonce, integrity: result[:integrity], **options)
 
         Array(result[:css]).each do |css_entry|
-          tags << tag.link(rel: "stylesheet", href: vite_asset_url(css_entry[:file]),
+          next unless linked_css.add?(css_entry[:file])
+          tags << tag.link(rel: "stylesheet", href: vite_build_path(css_entry[:file]),
             nonce: nonce, **sri_attrs(css_entry[:integrity]), **options)
         end
       end
@@ -111,38 +123,21 @@ module RailsVite
     end
 
     def resolve_vite_entry(entry, source_dir, entrypoints_dir)
-      return entry if entry.start_with?("#{source_dir}/", "/")
+      return entry if entry.start_with?("/")
+      return entry if !source_dir.empty? && entry.start_with?("#{source_dir}/")
 
-      prefix = entrypoints_dir ? "#{source_dir}/#{entrypoints_dir}" : source_dir
-      "#{prefix}/#{entry}"
+      # source_dir is empty when the plugin's `root` is the source directory
+      # (prependSourceDirToEntries: false) — entries are then looked up by their
+      # bare, manifest-relative names.
+      [source_dir, entrypoints_dir, entry].reject { |part| part.nil? || part.empty? }.join("/")
     end
 
-    def vite_asset_url(file)
-      vite_prefix_asset_host("#{RailsVite.config.asset_prefix}/#{file}")
+    def vite_build_path(file)
+      path_to_asset("#{RailsVite.config.asset_prefix}/#{file}")
     end
 
     def css_entry?(entry)
       CSS_EXTENSIONS.match?(entry)
     end
-
-    def vite_prefix_asset_host(path)
-      host = vite_resolve_asset_host
-      host ? "#{host}#{path}" : path
-    end
-
-    # Memoized per view instance (one per request). Safe for Proc hosts
-    # since each request gets a fresh ActionView::Base instance.
-    def vite_resolve_asset_host
-      return @_vite_asset_host if defined?(@_vite_asset_host)
-
-      @_vite_asset_host = begin
-        case (asset_host = Rails.application.config.action_controller.asset_host)
-        when String then asset_host.chomp("/")
-        when Proc then asset_host.call("")&.chomp("/")
-        end
-      rescue NoMethodError
-        nil
-      end
-    end
   end
 end

data/lib/rails_vite/tasks.rb

@@ -1,3 +1,5 @@
+require "shellwords"
+
 module RailsVite
   module Tasks
     extend self
@@ -5,13 +7,15 @@ module RailsVite
     BUN_CMD = defined?(Bundlebun) ? Bundlebun::Runner.binstub_or_binary_path : "bun"
 
     COMMANDS = {
-      bun: {install: "#{BUN_CMD} install", add: "#{BUN_CMD} add -D", dev: "#{BUN_CMD} run vite", build: "#{BUN_CMD} run vite build"},
-      yarn: {install: "yarn install", add: "yarn add -D", dev: "yarn vite", build: "yarn vite build"},
-      pnpm: {install: "pnpm install", add: "pnpm add -D", dev: "pnpm vite", build: "pnpm vite build"},
-      npm: {install: "npm install", add: "npm install -D", dev: "npx vite", build: "npx vite build"}
+      bun: {install: "#{BUN_CMD} install", add: "#{BUN_CMD} add -D", exec: "#{BUN_CMD} run", run: "#{BUN_CMD} run"},
+      yarn: {install: "yarn install", add: "yarn add -D", exec: "yarn", run: "yarn run"},
+      pnpm: {install: "pnpm install", add: "pnpm add -D", exec: "pnpm", run: "pnpm run"},
+      npm: {install: "npm install", add: "npm install -D", exec: "npx", run: "npm run"},
+      aube: {install: "aube install", add: "aube add -D", exec: "aube exec", run: "aube run"}
     }.freeze
 
     LOCKFILES = {
+      aube: %w[aube-lock.yaml],
       bun: %w[bun.lockb bun.lock],
       yarn: %w[yarn.lock],
       pnpm: %w[pnpm-lock.yaml],
@@ -27,29 +31,55 @@ module RailsVite
     end
 
     def dev_command
-      command_for(:dev)
+      "#{vite_command} dev"
     end
 
     def build_command
-      cmd = command_for(:build)
-      cmd += " --mode test" if Rails.env.test?
+      cmd = "#{vite_command} build"
+      mode = RailsVite.config.build_mode
+      cmd += " --mode #{Shellwords.escape(mode)}" if mode
       cmd
     end
 
+    def precompile_command
+      return build_command if Rails.env.test? || RailsVite.config.build_mode || !package_json_build_script?
+      "#{command_for(:run)} build"
+    end
+
+    # Use with build_command. The plugin builds into this dir, so the gem and
+    # the plugin use the same dir for all build modes.
+    def build_env
+      env = {"RAILS_VITE_BUILD_DIR" => RailsVite.config.build_dir}
+      asset_host = Rails.application.config.action_controller.asset_host
+      env["RAILS_VITE_ASSET_HOST"] = asset_host if asset_host.is_a?(String) && asset_host.present? && !asset_host.include?("%d")
+      env
+    end
+
     def tool
       tool_determined_by_lockfile || tool_determined_by_executable
     end
 
     private
 
+    def vite_command
+      "#{command_for(:exec)} #{RailsVite.config.vite_executable}"
+    end
+
+    def package_json_build_script?
+      path = Rails.root.join("package.json")
+      path.exist? && JSON.parse(path.read).dig("scripts", "build").present?
+    rescue JSON::ParserError
+      false
+    end
+
     def command_for(key)
       COMMANDS.dig(tool, key) ||
-        raise("rails_vite: No suitable JS package manager found for '#{key}'. Ensure npm, yarn, pnpm, or bun is available.")
+        raise("rails_vite: No suitable JS package manager found for '#{key}'. Ensure npm, yarn, pnpm, bun, or aube is available.")
     end
 
     def tool_determined_by_lockfile
       LOCKFILES.each do |tool_name, files|
-        return tool_name if files.any? { |f| File.exist?(f) }
+        return tool_name if files.any? { |f| Rails.root.join(f).exist? }
       end
       nil
     end

data/lib/rails_vite/version.rb

@@ -1,3 +1,3 @@
 module RailsVite
-  VERSION = "0.2.2"
+  VERSION = "0.3.0.rc1"
 end

data/lib/rails_vite.rb

@@ -1,5 +1,6 @@
 require "json"
 require "digest"
+require "socket"
 
 require_relative "rails_vite/errors"
 require_relative "rails_vite/manifest"
@@ -24,6 +25,20 @@ module RailsVite
       manifest.digest
     end
 
+    # A Content Security Policy source for the running Vite dev server. Returns
+    # a lambda so the URL resolves per request: it tracks the dev server's real
+    # (possibly auto-incremented) port and contributes nothing when the server
+    # isn't running. Pass websocket: true for the HMR socket (http -> ws).
+    #
+    # RailsVite.config is qualified explicitly because Rails resolves CSP Proc
+    # sources via instance_exec, which rebinds self to the controller.
+    def dev_server_csp_source(websocket: false)
+      -> {
+        url = RailsVite.config.dev_server_url
+        url && (websocket ? url.sub(/\Ahttp/, "ws") : url)
+      }
+    end
+
     def reset!
       @config = nil
       @manifest = nil

data/lib/tasks/rails_vite/build.rake

@@ -2,13 +2,13 @@ namespace :vite do
   desc "Install JavaScript dependencies"
   task :install do
     command = RailsVite::Tasks.install_command
-    system(command) || raise("rails_vite: Command install failed, ensure #{command.split.first} is installed")
+    system(command, chdir: Rails.root) || raise("rails_vite: Command install failed, ensure #{command.split.first} is installed")
   end
 
   desc "Build Vite assets for production"
-  task :build do
-    command = RailsVite::Tasks.build_command
-    system(command) || raise("rails_vite: Command build failed, ensure `#{command}` runs without errors")
+  task build: :environment do
+    command = RailsVite::Tasks.precompile_command
+    system(RailsVite::Tasks.build_env, command, chdir: Rails.root) || raise("rails_vite: Command build failed, ensure `#{command}` runs without errors")
   end
 
   Rake::Task["vite:build"].prereqs << :install unless ENV["SKIP_VITE_INSTALL"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_vite
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0.rc1
 platform: ruby
 authors:
 - Svyatoslav Kryukov
@@ -71,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Vite integration for Rails
 test_files: []