vite_ruby 3.9.0 → 4.0.0.alpha1

data/lib/vite_ruby/builder.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'digest/sha1'
 
 # Public: Keeps track of watched files and triggers builds as needed.
@@ -11,13 +12,9 @@ class ViteRuby::Builder
   # Public: Checks if the watched files have changed since the last compilation,
   # and triggers a Vite build if any files have changed.
   def build(*args)
-    last_build = last_build_metadata(ssr: args.include?('--ssr'))
-
-    if args.delete('--force') || last_build.stale? || config.manifest_paths.empty?
-      stdout, stderr, status = build_with_vite(*args)
-      log_build_result(stdout, stderr, status)
-      record_build_metadata(last_build, errors: stderr, success: status.success?)
-      status.success?
+    last_build = last_build_metadata
+    if args.delete('--force') || last_build.stale?
+      build_with_vite(*args).tap { |success| record_build_metadata(success, last_build) }
     elsif last_build.success
       logger.debug "Skipping vite build. Watched files have not changed since the last build at #{ last_build.timestamp }"
       true
@@ -28,8 +25,8 @@ class ViteRuby::Builder
   end
 
   # Internal: Reads the result of the last compilation from disk.
-  def last_build_metadata(ssr: false)
-    ViteRuby::Build.from_previous(last_build_path(ssr: ssr), watched_files_digest)
+  def last_build_metadata
+    ViteRuby::Build.from_previous(last_build_attrs, watched_files_digest)
   end
 
 private
@@ -38,35 +35,44 @@ private
 
   def_delegators :@vite_ruby, :config, :logger, :run
 
+  # Internal: Reads metadata recorded on the last build, if it exists.
+  def last_build_attrs
+    last_build_path.exist? ? JSON.parse(last_build_path.read.to_s) : {}
+  rescue JSON::JSONError, Errno::ENOENT, Errno::ENOTDIR
+    {}
+  end
+
   # Internal: Writes a digest of the watched files to disk for future checks.
-  def record_build_metadata(build, **attrs)
+  def record_build_metadata(success, build)
     config.build_cache_dir.mkpath
-    build.with_result(**attrs).write_to_cache
+    last_build_path.write build.with_result(success).to_json
   end
 
   # Internal: The file path where metadata of the last build is stored.
-  def last_build_path(ssr:)
-    config.build_cache_dir.join("last#{ '-ssr' if ssr }-build-#{ config.mode }.json")
+  def last_build_path
+    config.build_cache_dir.join("last-build-#{ config.mode }.json")
   end
 
   # Internal: Returns a digest of all the watched files, allowing to detect
   # changes, and skip Vite builds if no files have changed.
   def watched_files_digest
-    return @last_digest if @last_digest_at && Time.now - @last_digest_at < 1
-
-    config.within_root do
+    Dir.chdir File.expand_path(config.root) do
       files = Dir[*config.watched_paths].reject { |f| File.directory?(f) }
       file_ids = files.sort.map { |f| "#{ File.basename(f) }/#{ Digest::SHA1.file(f).hexdigest }" }
-      @last_digest_at = Time.now
-      @last_digest = Digest::SHA1.hexdigest(file_ids.join('/'))
+      Digest::SHA1.hexdigest(file_ids.join('/'))
     end
   end
 
   # Public: Initiates a Vite build command to generate assets.
+  #
+  # Returns true if the build is successful, or false if it failed.
   def build_with_vite(*args)
     logger.info 'Building with Vite ⚡️'
 
-    run(['build', *args])
+    stdout, stderr, status = run(['build', *args])
+    log_build_result(stdout, stderr.to_s, status)
+
+    status.success?
   end
 
   # Internal: Outputs the build results.
@@ -75,10 +81,9 @@ private
   def log_build_result(_stdout, stderr, status)
     if status.success?
       logger.info "Build with Vite complete: #{ config.build_output_dir }"
-      logger.error stderr unless stderr.empty?
+      logger.error stderr.to_s unless stderr.empty?
     else
       logger.error stderr
-      logger.error status
       logger.error 'Build with Vite failed! ❌'
       logger.error '❌ Check that vite and vite-plugin-ruby are in devDependencies and have been installed. ' if stderr.include?('ERR! canceled')
     end

data/lib/vite_ruby/cli/build.rb

@@ -5,10 +5,8 @@ class ViteRuby::CLI::Build < ViteRuby::CLI::Vite
 
   desc 'Bundle all entrypoints using Vite.'
   shared_options
-  option(:ssr, desc: 'Build the SSR entrypoint instead', type: :boolean)
   option(:force, desc: 'Force the build even if assets have not changed', type: :boolean)
   option(:watch, desc: 'Start the Rollup watcher and rebuild on files changes', type: :boolean)
-  option(:profile, desc: 'Gather performance metrics from the build ', type: :boolean)
 
   def call(**options)
     super { |args| ViteRuby.commands.build_from_task(*args) }

data/lib/vite_ruby/cli/install.rb

@@ -1,16 +1,11 @@
 # frozen_string_literal: true
 
 require 'stringio'
-require 'json'
 
 class ViteRuby::CLI::Install < Dry::CLI::Command
   desc 'Performs the initial configuration setup to get started with Vite Ruby.'
 
-  option(:package_manager, values: %w[npm pnpm yarn bun], aliases: %w[package-manager with], desc: 'The package manager to use when installing JS dependencies.')
-
-  def call(package_manager: nil, **)
-    ENV['VITE_RUBY_PACKAGE_MANAGER'] ||= package_manager if package_manager
-
+  def call(**)
     $stdout.sync = true
 
     say 'Creating binstub'
@@ -84,20 +79,9 @@ private
   # Internal: Installs vite and vite-plugin-ruby at the project level.
   def install_js_dependencies
     package_json = root.join('package.json')
-    unless package_json.exist?
-      write package_json, <<~JSON
-        {
-          "private": true,
-          "type": "module"
-        }
-      JSON
-    end
-
-    if (JSON.parse(package_json.read)['type'] != 'module' rescue nil)
-      FileUtils.mv root.join('vite.config.ts'), root.join('vite.config.mts'), force: true, verbose: true
-    end
-
-    install_js_packages js_dependencies.join(' ')
+    write(package_json, '{}') unless package_json.exist?
+    deps = js_dependencies.join(' ')
+    run_with_capture("#{ npm_install } -D #{ deps }", stdin_data: "\n")
   end
 
   # Internal: Adds compilation output dirs to git ignore.
@@ -107,7 +91,9 @@ private
     append(gitignore_file, <<~GITIGNORE)
 
       # Vite Ruby
-      /public/vite*
+      /public/vite
+      /public/vite-dev
+      /public/vite-test
       node_modules
       # Vite uses dotenv and suggests to ignore local-only env files. See
       # https://vitejs.dev/guide/env-and-mode.html#env-files
@@ -127,12 +113,16 @@ private
   def run_with_capture(*args, **options)
     Dir.chdir(root) do
       _, stderr, status = ViteRuby::IO.capture(*args, **options)
-      say(stderr) unless status.success? || stderr.empty?
+      say(stderr) unless status.success? || stderr.to_s.empty?
     end
   end
 
-  def install_js_packages(deps)
-    run_with_capture("#{ config.package_manager } add -D #{ deps }", stdin_data: "\n")
+  # Internal: Support all popular package managers.
+  def npm_install
+    return 'yarn add' if root.join('yarn.lock').exist?
+    return 'pnpm install' if root.join('pnpm-lock.yaml').exist?
+
+    'npm install'
   end
 
   # Internal: Avoid printing warning about missing vite.json, we will create one.
@@ -144,3 +134,8 @@ private
     $stderr = old_stderr
   end
 end
+
+# NOTE: This allows framework-specific variants to extend the installation.
+ViteRuby.framework_libraries.each do |_framework, library|
+  require "#{ library.name.tr('-', '/') }/installation"
+end

data/lib/vite_ruby/cli/upgrade_packages.rb

@@ -5,6 +5,7 @@ class ViteRuby::CLI::UpgradePackages < ViteRuby::CLI::Install
 
   def call(**)
     say 'Upgrading npm packages'
-    install_js_packages js_dependencies.join(' ')
+    deps = js_dependencies.join(' ')
+    run_with_capture("#{ npm_install } -D #{ deps }")
   end
 end

data/lib/vite_ruby/cli/vite.rb

@@ -3,33 +3,18 @@
 class ViteRuby::CLI::Vite < Dry::CLI::Command
   CURRENT_ENV = ENV['RACK_ENV'] || ENV['RAILS_ENV']
 
-  def self.executable_options
+  def self.shared_options
     option(:mode, default: self::DEFAULT_ENV, values: %w[development production test], aliases: ['m'], desc: 'The build mode for Vite')
-    option(:node_options, desc: 'Node options for the Vite executable', aliases: ['node-options'])
+    option(:clobber, desc: 'Clear cache and previous builds', type: :boolean, aliases: %w[clean clear])
+    option(:debug, desc: 'Run Vite in verbose mode, printing all debugging output', aliases: ['verbose'], type: :boolean)
     option(:inspect, desc: 'Run Vite in a debugging session with node --inspect-brk', aliases: ['inspect-brk'], type: :boolean)
     option(:trace_deprecation, desc: 'Run Vite in debugging mode with node --trace-deprecation', aliases: ['trace-deprecation'], type: :boolean)
   end
 
-  def self.shared_options
-    executable_options
-    option(:debug, desc: 'Run Vite in verbose mode, printing all debugging output', aliases: ['verbose'], type: :boolean)
-    option(:clobber, desc: 'Clear cache and previous builds', type: :boolean, aliases: %w[clean clear])
-  end
-
-  def call(mode:, args: [], clobber: false, node_options: nil, inspect: nil, trace_deprecation: nil, **boolean_opts)
+  def call(mode:, args: [], clobber: false, **boolean_opts)
     ViteRuby.env['VITE_RUBY_MODE'] = mode
     ViteRuby.commands.clobber if clobber
-
-    node_options = [
-      node_options,
-      ('--inspect-brk' if inspect),
-      ('--trace-deprecation' if trace_deprecation),
-    ].compact.join(' ')
-
-    args << %(--node-options="#{ node_options }") unless node_options.empty?
-
     boolean_opts.map { |name, value| args << "--#{ name }" if value }
-
     yield(args)
   end
 end

data/lib/vite_ruby/cli.rb

@@ -11,20 +11,7 @@ class ViteRuby::CLI
   register 'clobber', Clobber, aliases: %w[clean clear]
   register 'dev', Dev, aliases: %w[d serve]
   register 'install', Install
-  register 'ssr', SSR
   register 'version', Version, aliases: ['v', '-v', '--version', 'info']
   register 'upgrade', Upgrade, aliases: ['update']
   register 'upgrade_packages', UpgradePackages, aliases: ['update_packages']
-
-  # Internal: Allows framework-specific variants to extend the CLI.
-  def self.require_framework_libraries(path = 'cli')
-    ViteRuby.framework_libraries.each do |_framework, library|
-      require [library.name.tr('-', '/').to_s, path].compact.join('/')
-    end
-  rescue LoadError
-    require_framework_libraries 'installation' unless path == 'installation'
-  end
 end
-
-# NOTE: This allows framework-specific variants to extend the CLI.
-ViteRuby::CLI.require_framework_libraries('cli')

data/lib/vite_ruby/commands.rb

@@ -23,25 +23,47 @@ class ViteRuby::Commands
 
   # Public: Removes all build cache and previously compiled assets.
   def clobber
-    dirs = [config.build_output_dir, config.ssr_output_dir, config.build_cache_dir, config.vite_cache_dir]
+    dirs = [config.build_output_dir, config.build_cache_dir, config.vite_cache_dir]
     dirs.each { |dir| dir.rmtree if dir.exist? }
     $stdout.puts "Removed vite cache and output dirs:\n\t#{ dirs.join("\n\t") }"
   end
 
-  # Internal: Installs the binstub for the CLI in the appropriate path.
-  def install_binstubs
-    `bundle binstub vite_ruby --path #{ config.root.join('bin') }`
-    `bundle config --delete bin`
+  # Public: Receives arguments from a rake task.
+  def clean_from_task(args)
+    ensure_log_goes_to_stdout {
+      clean(keep_up_to: Integer(args.keep || 2), age_in_seconds: Integer(args.age || 3600))
+    }
   end
 
-  # Internal: Checks if the npm version is 6 or lower.
-  def legacy_npm_version?
-    `npm --version`.to_i < 7 rescue false
+  # Public: Cleanup old assets in the output directory.
+  #
+  # keep_up_to - Max amount of backups to preserve.
+  # age_in_seconds - Amount of time to look back in order to preserve them.
+  #
+  # NOTE: By default keeps the last version, or 2 if created in the past hour.
+  #
+  # Examples:
+  #   To force only 1 backup to be kept: clean(1, 0)
+  #   To only keep files created within the last 10 minutes: clean(0, 600)
+  def clean(keep_up_to: 2, age_in_seconds: 3600)
+    return false unless may_clean?
+
+    versions
+      .each_with_index
+      .drop_while { |(mtime, _), index|
+        max_age = [0, Time.now - Time.at(mtime)].max
+        max_age < age_in_seconds || index < keep_up_to
+      }
+      .each do |(_, files), _|
+        clean_files(files)
+      end
+    true
   end
 
-  # Internal: Checks if the yarn version is 1.x.
-  def legacy_yarn_version?
-    `yarn --version`.to_i < 2 rescue false
+  # Internal: Installs the binstub for the CLI in the appropriate path.
+  def install_binstubs
+    `bundle binstub vite_ruby --path #{ config.root.join('bin') }`
+    `bundle config --delete bin`
   end
 
   # Internal: Verifies if ViteRuby is properly installed.
@@ -68,7 +90,7 @@ class ViteRuby::Commands
 
   # Internal: Prints information about ViteRuby's environment.
   def print_info
-    config.within_root do
+    Dir.chdir(config.root) do
       $stdout.puts "bin/vite present?: #{ File.exist? 'bin/vite' }"
 
       $stdout.puts "vite_ruby: #{ ViteRuby::VERSION }"
@@ -77,11 +99,11 @@ class ViteRuby::Commands
         $stdout.puts "#{ framework }: #{ Gem.loaded_specs[framework]&.version }"
       end
 
-      $stdout.puts "ruby: #{ `ruby --version` }"
       $stdout.puts "node: #{ `node --version` }"
-
-      pkg = config.package_manager
-      $stdout.puts "#{ pkg }: #{ `#{ pkg } --version` rescue nil }"
+      $stdout.puts "npm: #{ `npm --version` }"
+      $stdout.puts "yarn: #{ `yarn --version` rescue nil }"
+      $stdout.puts "pnpm: #{ `pnpm --version` rescue nil }"
+      $stdout.puts "ruby: #{ `ruby --version` }"
 
       $stdout.puts "\n"
       packages = `npm ls vite vite-plugin-ruby`
@@ -98,6 +120,29 @@ private
 
   def_delegators :@vite_ruby, :config, :builder, :manifest, :logger, :logger=
 
+  def may_clean?
+    config.build_output_dir.exist? && config.manifest_path.exist?
+  end
+
+  def clean_files(files)
+    files.select { |file| File.file?(file) }.each do |file|
+      File.delete(file)
+      logger.info("Removed #{ file }")
+    end
+  end
+
+  def versions
+    all_files = Dir.glob("#{ config.build_output_dir }/**/*")
+    entries = all_files - [config.manifest_path] - current_version_files
+    entries.reject { |file| File.directory?(file) }
+      .group_by { |file| File.mtime(file).utc.to_i }
+      .sort.reverse
+  end
+
+  def current_version_files
+    Dir.glob(manifest.refresh.values.map { |value| config.build_output_dir.join("#{ value['file'] }*") })
+  end
+
   def with_node_env(env)
     original = ENV['NODE_ENV']
     ENV['NODE_ENV'] = env

data/lib/vite_ruby/compatibility_check.rb

@@ -24,7 +24,7 @@ module ViteRuby::CompatibilityCheck
         raise ArgumentError, <<~ERROR
           vite-plugin-ruby@#{ npm_req } might not be compatible with vite_ruby-#{ ViteRuby::VERSION }
 
-          You may disable this check if needed: https://vite-ruby.netlify.app/config/#skipcompatibilitycheck
+          You may disable this check if needed: https://vite-ruby.netlify.app/config/#skipCompatibilityCheck
 
           You may upgrade both by running:
 

data/lib/vite_ruby/config.rb

@@ -5,10 +5,6 @@ require 'json'
 # Public: Allows to resolve configuration sourced from `config/vite.json` and
 # environment variables, combining them with the default options.
 class ViteRuby::Config
-  def origin
-    "#{ protocol }://#{ host_with_port }"
-  end
-
   def protocol
     https ? 'https' : 'http'
   end
@@ -17,20 +13,14 @@ class ViteRuby::Config
     "#{ host }:#{ port }"
   end
 
-  # Internal: Path to the manifest files generated by Vite and vite-plugin-ruby.
-  def known_manifest_paths
-    [
-      # NOTE: Generated by Vite when `manifest: true`, which vite-plugin-ruby enables.
-      build_output_dir.join('.vite/manifest.json'),
-
-      # NOTE: Path where vite-plugin-ruby outputs the assets manifest file.
-      build_output_dir.join('.vite/manifest-assets.json'),
-    ]
+  # Internal: Path where Vite outputs the manifest file.
+  def manifest_path
+    build_output_dir.join('manifest.json')
   end
 
-  # Internal: Path to the manifest files generated by Vite and vite-plugin-ruby.
-  def manifest_paths
-    known_manifest_paths.select(&:exist?)
+  # Internal: Path where vite-plugin-ruby outputs the assets manifest file.
+  def assets_manifest_path
+    build_output_dir.join('manifest-assets.json')
   end
 
   # Public: The directory where Vite will store the built assets.
@@ -60,12 +50,12 @@ class ViteRuby::Config
   end
 
   # Public: Sets additional environment variables for vite-plugin-ruby.
-  def to_env(env_vars = ViteRuby.env)
+  def to_env
     CONFIGURABLE_WITH_ENV.each_with_object({}) do |option, env|
       unless (value = @config[option]).nil?
         env["#{ ViteRuby::ENV_PREFIX }_#{ option.upcase }"] = value.to_s
       end
-    end.merge(env_vars)
+    end.merge(ViteRuby.env)
   end
 
   # Internal: Files and directories that should be watched for changes.
@@ -80,11 +70,6 @@ class ViteRuby::Config
     ].freeze
   end
 
-  # Internal: Changes the current directory to the root dir.
-  def within_root(&block)
-    Dir.chdir(File.expand_path(root), &block)
-  end
-
 private
 
   # Internal: Coerces all the configuration values, in case they were passed
@@ -92,11 +77,9 @@ private
   def coerce_values(config)
     config['mode'] = config['mode'].to_s
     config['port'] = config['port'].to_i
-    config['root'] = root = Pathname.new(config['root'])
-    config['build_cache_dir'] = root.join(config['build_cache_dir'])
-    config['ssr_output_dir'] = root.join(config['ssr_output_dir'])
-    coerce_booleans(config, 'auto_build', 'hide_build_console_output', 'https', 'skip_compatibility_check', 'skip_proxy')
-    config['package_manager'] ||= detect_package_manager(root)
+    config['root'] = Pathname.new(config['root'])
+    config['build_cache_dir'] = config['root'].join(config['build_cache_dir'])
+    coerce_booleans(config, 'auto_build', 'hide_build_console_output', 'https', 'skip_compatibility_check')
   end
 
   # Internal: Coerces configuration options to boolean.
@@ -104,15 +87,6 @@ private
     names.each { |name| config[name] = [true, 'true'].include?(config[name]) }
   end
 
-  def detect_package_manager(root)
-    return 'npm' if root.join('package-lock.json').exist?
-    return 'pnpm' if root.join('pnpm-lock.yaml').exist?
-    return 'bun' if root.join('bun.lockb').exist?
-    return 'yarn' if root.join('yarn.lock').exist?
-
-    'npm'
-  end
-
   def initialize(attrs)
     @config = attrs.tap { |config| coerce_values(config) }.freeze
     ViteRuby::CompatibilityCheck.verify_plugin_version(root) unless skip_compatibility_check
@@ -147,7 +121,7 @@ private
         'config_path' => option_from_env('config_path') || DEFAULT_CONFIG.fetch('config_path'),
         'mode' => option_from_env('mode') || mode,
         'root' => option_from_env('root') || root,
-      }.select { |_, value| value }
+      }
     end
 
     # Internal: Used to load a JSON file from the specified path.
@@ -195,15 +169,12 @@ private
 
   # Internal: If any of these files is modified the build won't be skipped.
   DEFAULT_WATCHED_PATHS = %w[
-    bun.lockb
     package-lock.json
     package.json
     pnpm-lock.yaml
     postcss.config.js
     tailwind.config.js
     vite.config.js
-    vite.config.mjs
-    vite.config.mts
     vite.config.ts
     windi.config.ts
     yarn.lock

data/lib/vite_ruby/dev_server_proxy.rb

@@ -38,7 +38,7 @@ private
     uri
       .sub(HOST_WITH_PORT_REGEX, '/') # Hanami adds the host and port.
       .sub('.ts.js', '.ts') # Hanami's javascript helper always adds the extension.
-      .sub(/\.(sass|scss|styl|stylus|less|pcss|postcss)\.css$/, '.\1') # Rails' stylesheet_link_tag always adds the extension.
+      .sub(/(\.(?!min|module)\w+)\.css$/, '\1') # Rails' stylesheet_link_tag always adds the extension.
   end
 
   def forward_to_vite_dev_server(env)
@@ -54,22 +54,17 @@ private
 
   def vite_should_handle?(env)
     path = normalize_uri(env['PATH_INFO'])
-    return true if path.start_with?(vite_url_prefix) # Vite asset
+    return true if path.start_with?(vite_asset_url_prefix) # Vite asset
+    return true if path.start_with?(VITE_DEPENDENCY_PREFIX) # Packages and imports
     return true if file_in_vite_root?(path) # Fallback if Vite can serve the file
   end
 
-  # NOTE: When using an empty 'public_output_dir', we need to rely on a
-  # filesystem check to check whether Vite should serve the request.
   def file_in_vite_root?(path)
     path.include?('.') && # Check for extension, avoid filesystem if possible.
       config.vite_root_dir.join(path.start_with?('/') ? path[1..-1] : path).file?
   end
 
-  # NOTE: Vite is configured to use 'public_output_dir' as the base, which can
-  # be customized by the user in development to not match any of the routes.
-  #
-  # If the path starts with that prefix, it will be redirected to Vite.
-  def vite_url_prefix
-    @vite_url_prefix ||= config.public_output_dir.empty? ? VITE_DEPENDENCY_PREFIX : "/#{ config.public_output_dir }/"
+  def vite_asset_url_prefix
+    @vite_asset_url_prefix ||= config.public_output_dir.empty? ? "\0" : "/#{ config.public_output_dir }/"
   end
 end

data/lib/vite_ruby/io.rb

@@ -15,7 +15,7 @@ module ViteRuby::IO
         stdin.close
         out = Thread.new { read_lines(stdout, &with_output) }
         err = Thread.new { stderr.read }
-        [out.value, err.value.to_s, wait_threads.value]
+        [out.value, err.value, wait_threads.value]
       }
     end
 

data/lib/vite_ruby/manifest.rb

@@ -7,7 +7,7 @@
 #   lookup_entrypoint('calendar', type: :javascript)
 #   => { "file" => "/vite/assets/calendar-1016838bab065ae1e314.js", "imports" => [] }
 #
-# NOTE: Using `"autoBuild": true` in `config/vite.json` file will trigger a build
+# NOTE: Using "autoBuild": true` in `config/vite.json` file will trigger a build
 # on demand as needed, before performing any lookup.
 class ViteRuby::Manifest
   def initialize(vite_ruby)
@@ -22,16 +22,15 @@ class ViteRuby::Manifest
     lookup!(name, **options).fetch('file')
   end
 
-  # Public: Returns scripts, imported modules, and stylesheets for the specified
+  # Public: Returns entries, imported modules, and stylesheets for the specified
   # entrypoint files.
   def resolve_entries(*names, **options)
     entries = names.map { |name| lookup!(name, **options) }
-    script_paths = entries.map { |entry| entry.fetch('file') }
 
     imports = dev_server_running? ? [] : entries.flat_map { |entry| entry['imports'] }.compact.uniq
     {
-      scripts: script_paths,
-      imports: imports.map { |entry| entry.fetch('file') }.uniq,
+      main: entries.map(&TO_ENTRY),
+      imports: imports.map(&TO_ENTRY).uniq,
       stylesheets: dev_server_running? ? [] : (entries + imports).flat_map { |entry| entry['css'] }.compact.uniq,
     }
   end
@@ -51,27 +50,21 @@ class ViteRuby::Manifest
     if dev_server_running?
       <<~REACT_REFRESH
         <script type="module">
-          #{ react_preamble_code }
+          import RefreshRuntime from '#{ prefix_asset_with_host('@react-refresh') }'
+          RefreshRuntime.injectIntoGlobalHook(window)
+          window.$RefreshReg$ = () => {}
+          window.$RefreshSig$ = () => (type) => type
+          window.__vite_plugin_react_preamble_installed__ = true
         </script>
       REACT_REFRESH
     end
   end
 
-  # Public: Source script for the React Refresh plugin.
-  def react_preamble_code
-    if dev_server_running?
-      <<~REACT_PREAMBLE_CODE
-        import RefreshRuntime from '#{ prefix_asset_with_host('@react-refresh') }'
-        RefreshRuntime.injectIntoGlobalHook(window)
-        window.$RefreshReg$ = () => {}
-        window.$RefreshSig$ = () => (type) => type
-        window.__vite_plugin_react_preamble_installed__ = true
-      REACT_PREAMBLE_CODE
-    end
-  end
-
 protected
 
+  # Internal: Returns a [src, attrs] entry.
+  TO_ENTRY = ->(entry) { [entry.fetch('file'), entry.slice('integrity').symbolize_keys] }
+
   # Internal: Strict version of lookup.
   #
   # Returns a relative path for the asset, or raises an error if not found.
@@ -87,7 +80,7 @@ protected
   #   manifest.lookup('calendar.js')
   #   => { "file" => "/vite/assets/calendar-1016838bab065ae1e122.js", "imports" => [] }
   def lookup(name, **options)
-    @build_mutex.synchronize { builder.build || (return nil) } if should_build?
+    @build_mutex.synchronize { builder.build } if should_build?
 
     find_manifest_entry resolve_entry_name(name, **options)
   end
@@ -128,24 +121,19 @@ private
 
   # Internal: Loads and merges the manifest files, resolving the asset paths.
   def load_manifest
-    files = config.manifest_paths
+    files = [config.manifest_path, config.assets_manifest_path].select(&:exist?)
     files.map { |path| JSON.parse(path.read) }.inject({}, &:merge).tap(&method(:resolve_references))
   end
 
   # Internal: Scopes an asset to the output folder in public, as a path.
   def prefix_vite_asset(path)
-    File.join(vite_asset_origin || '/', config.public_output_dir, path)
+    File.join("/#{ config.public_output_dir }", path)
   end
 
   # Internal: Prefixes an asset with the `asset_host` for tags that do not use
   # the framework tag helpers.
   def prefix_asset_with_host(path)
-    File.join(vite_asset_origin || config.asset_host || '/', config.public_output_dir, path)
-  end
-
-  # Internal: The origin of assets managed by Vite.
-  def vite_asset_origin
-    config.origin if dev_server_running? && config.skip_proxy
+    File.join(config.asset_host || '/', config.public_output_dir, path)
   end
 
   # Internal: Resolves the paths that reference a manifest entry.
@@ -212,7 +200,7 @@ private
 
   # Internal: Raises a detailed message when an entry is missing in the manifest.
   def missing_entry_error(name, **options)
-    raise ViteRuby::MissingEntrypointError.new(
+    raise ViteRuby::MissingEntrypointError, OpenStruct.new(
       file_name: resolve_entry_name(name, **options),
       last_build: builder.last_build_metadata,
       manifest: @manifest,