proscenium 0.25.3 → 0.26.1

data/lib/proscenium/importer.rb

@@ -1,12 +1,19 @@
 # frozen_string_literal: true
 
 require 'active_support/current_attributes'
+require 'concurrent/map'
 
 module Proscenium
   class Importer < ActiveSupport::CurrentAttributes
     JS_EXTENSIONS = %w[.tsx .ts .jsx .js].freeze
     CSS_EXTENSIONS = %w[.module.css .css].freeze
 
+    # The readable suffix of a CSS module class name, by absolute path - or by URL, for a remote
+    # module, which has no file. It is a pure function of that identity, but `import` runs once per
+    # class name a view emits and `relative_path_from` is most of its cost, so it is built once per
+    # file for the life of the process.
+    SUFFIXES = Concurrent::Map.new
+
     # Holds the JS and CSS files to include in the current request.
     #
     # Example:
@@ -21,59 +28,45 @@ module Proscenium
     class << self
       # Import the given `filepath`. This is idempotent - it will never include duplicates.
       #
-      # @param filepath [String] Absolute URL path (relative to Rails root) of the file to import.
-      #   Should be the actual asset file, eg. app.css, some/component.js.
+      # @param filepath [String] Absolute URL path (relative to Rails root) of the file to import,
+      #   or a URL, which has no file on disk. Should be the actual asset file, eg. app.css,
+      #   some/component.js.
       # @return [String|nil] the digest of the imported file path if a css module (*.module.css).
       def import(filepath = nil, sideloaded: false, **)
         self.imported ||= {}
 
-        digest = nil
-
         if filepath.end_with?('.module.css')
-          if imported.key?(filepath)
-            digest = imported[filepath][:digest]
-            abs_path = imported[filepath][:abs_path]
-          else
-            manifest_path, non_manifest_path, abs_path = Resolver.resolve(filepath, as_array: true)
-            digest = Utils.css_module_digest(abs_path)
-            filepath = Array(manifest_path || non_manifest_path)[0]
-
-            if sideloaded
-              ActiveSupport::Notifications.instrument 'sideload.proscenium', identifier: filepath,
-                                                                             sideloaded: do
-                imported[filepath] = { ** }
-                imported[filepath][:digest] = digest
-                imported[filepath][:abs_path] = abs_path
-              end
-            else
-              imported[filepath] = { ** }
-              imported[filepath][:digest] = digest
-              imported[filepath][:abs_path] = abs_path
-            end
-          end
+          manifest_path, non_manifest_path, abs_path = Resolver.resolve(filepath, as_array: true)
+          filepath = Array(manifest_path || non_manifest_path)[0]
+
+          # A URL has no file on disk, so the URL is the module's identity. Taken after the
+          # reassignment above, so the digest and the suffix cache below agree on it. An entry the
+          # stylesheet got as a plain file has no digest of its own.
+          digest = imported.dig(filepath, :digest) ||
+                   Utils.css_module_digest(abs_path.presence || filepath)
+          store(filepath, sideloaded, **, digest:)
 
           transformed_path = ''
           # Mirrors ConfigT#ShouldMinify - the suffix exists whenever identifiers are not
           # minified, and a class name the stylesheet does not define is worse than a long one.
           if Proscenium.config.debug || !Rails.env.production?
-            rel_path = Pathname.new(abs_path).relative_path_from(Rails.root).sub_ext('')
-            transformed_path = "_#{rel_path.to_s.gsub(%r{[@/.+]}, '-')}"
+            # Keyed and built from the file's path under the app, or from the URL when there is
+            # no file: `Pathname.new('').relative_path_from(Rails.root)` raises.
+            identity = abs_path.presence || filepath
+            transformed_path = SUFFIXES.compute_if_absent(identity) do
+              relative = if abs_path.present?
+                           Utils.css_module_relative_path(abs_path)
+                         else
+                           identity
+                         end
+
+              "_#{Utils.css_module_suffix(relative)}"
+            end
           end
 
           "#{digest}#{transformed_path}"
         else
-          return if imported.key?(filepath)
-
-          Array(Resolver.resolve(filepath)).each do |fp|
-            if sideloaded
-              ActiveSupport::Notifications.instrument 'sideload.proscenium', identifier: fp,
-                                                                             sideloaded: do
-                imported[fp] = { ** }
-              end
-            else
-              imported[fp] = { ** }
-            end
-          end
+          Array(Resolver.resolve(filepath)).each { |fp| store(fp, sideloaded, **) }
         end
       end
 
@@ -118,9 +111,8 @@ module Proscenium
 
       # @param filepath [Pathname] Absolute file system path of the Ruby file to sideload.
       # @param extensions [Array<String>] Supported file extensions to sideload.
-      # @param options [Hash] Options to pass to `import`.
       # @raise [ArgumentError] if `filepath` is not an absolute file system path.
-      private def _sideload(filepath, extensions, **options) # rubocop:disable Style/AccessModifierDeclarations
+      private def _sideload(filepath, extensions, **) # rubocop:disable Style/AccessModifierDeclarations
         return unless Proscenium.config.side_load
 
         if !filepath.is_a?(Pathname) || !filepath.absolute?
@@ -133,7 +125,7 @@ module Proscenium
         extensions.find do |x|
           next unless (fp = filepath.sub_ext(x)).exist?
 
-          import(fp.to_s, sideloaded: filepath, **options)
+          import(fp.to_s, sideloaded: filepath, **)
         end
       end
 
@@ -173,6 +165,25 @@ module Proscenium
       def imported?(filepath = nil)
         filepath ? imported&.key?(filepath) : !imported.blank?
       end
+
+      private
+
+      # Keyed by the resolved path, never the path given: a sideload passes an absolute file
+      # system path. A repeat import merges its options in, later ones winning key by key, and does
+      # not notify again; proscenium-ui's Select sideloads itself `lazy: true` over an eager
+      # sideload of the same file.
+      def store(key, sideloaded, **options)
+        if (existing = imported[key])
+          existing.merge!(options)
+        elsif sideloaded
+          ActiveSupport::Notifications.instrument 'sideload.proscenium', identifier: key,
+                                                                         sideloaded: do
+            imported[key] = options
+          end
+        else
+          imported[key] = options
+        end
+      end
     end
   end
 end

data/lib/proscenium/manifest.rb

@@ -3,51 +3,46 @@
 module Proscenium
   module Manifest
     mattr_accessor :manifest, default: {}
-    mattr_accessor :loaded, default: false
 
     module_function
 
-    def loaded?
-      loaded
-    end
-
+    # Built aside and assigned once, so a resolve during a load never sees a half-built manifest,
+    # and a manifest that fails to parse leaves the previous one in place.
     def load!
       public_path = Rails.configuration.paths['public'].first
-      self.manifest = {}
-      self.loaded = false
+      entries = {}
 
       if Proscenium.config.manifest_path.exist?
-        self.loaded = true
-
         JSON.parse(Proscenium.config.manifest_path.read)['outputs'].each do |outpath, details|
           next if !details.key?('entryPoint')
 
-          outpath = outpath.delete_prefix "#{public_path}/"
+          outpath = fs_path(outpath).delete_prefix "#{public_path}/"
 
-          ep = details['entryPoint']
-          ep = if (gem = BundledGems.paths.find { |_, v| ep.start_with? "#{v}/" })
-                 "@rubygems/#{gem[0]}#{ep.delete_prefix(gem[1])}"
-               else
-                 ep.delete_prefix(Rails.root.to_s)
-               end
+          ep = fs_path(details['entryPoint'])
+          ep = BundledGems.virtual_path(ep) || ep.delete_prefix(Rails.root.to_s)
 
-          manifest[ep] = [
+          entries[ep] = [
             "/#{outpath}",
-            details['cssBundle']&.delete_prefix(public_path)
+            details['cssBundle'] && fs_path(details['cssBundle']).delete_prefix(public_path)
           ].compact
         end
       end
 
-      manifest
+      self.manifest = entries
     end
 
+    # esbuild records absolute paths in the metafile in the form the platform produced. Left in
+    # Windows form, every delete_prefix above failed, the manifest was keyed by full Windows
+    # paths, and every lookup missed: the app served source paths instead of the digest URLs it
+    # had just compiled, silently.
+    def fs_path(path) = Utils.fs_path(path)
+
+    # Empty, not nil or a lazy re-read: the runtime daemon relies on a reset manifest staying
+    # empty until `load!`.
     def reset!
       self.manifest = {}
-      self.loaded = false
     end
 
-    def [](key)
-      loaded? ? manifest[key] : nil
-    end
+    def [](key) = manifest[key]
   end
 end

data/lib/proscenium/mapping_generation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'bundled_gems'
+require_relative 'context_map'
+require_relative 'stale_contexts'
+
+module Proscenium
+  # Which mapping generation a build uses (#154). A generation is the context map and the
+  # staleness verdict, read once and kept, so every build sees one consistent view. In production
+  # a generation lasts the process: restart after a deploy. In development and test, `refresh`
+  # looks at most once a second for a change to the files the map is built from, and starts a new
+  # generation when one changed, such as `proscenium install` finishing.
+  #
+  # Gemfile.lock is watched, but a gem added or upgraded still needs a restart: Bundler loads the
+  # bundle once per process.
+  module MappingGeneration
+    # The lockfiles too: with contexts adopted, resolved paths carry each package's version.
+    WATCHED = ['Gemfile.lock', 'package.json', 'pnpm-workspace.yaml', '.npmrc',
+               'bunfig.toml', 'pnpm-lock.yaml', 'bun.lock', ContextMap::INSTALLING].freeze
+    EVERY = 1.0
+    LOCK = Mutex.new
+
+    module_function
+
+    # The current generation number, starting a new one first if a watched file changed and the
+    # last look was at least `every` seconds ago. Returns [number, whether it just changed].
+    def refresh(root, every: EVERY)
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      LOCK.synchronize do
+        @looked ||= {}
+        @number ||= 0
+        at, before = @looked[root]
+        return [@number, false] if at && now - at < every
+
+        after = signature(root)
+        @looked[root] = [now, after]
+        return [@number, false] if before.nil? || before == after
+
+        ContextMap.reset!
+        StaleContexts.reset!
+        [@number += 1, true]
+      end
+    end
+
+    # The modification time of every file the map is built from, by path, nil for a missing one.
+    def signature(root)
+      files = WATCHED.map { File.join(root, it) } +
+              Dir.glob(File.join(root, ContextMap::CONTEXTS, '*', 'package.json')) +
+              manifests(root)
+      files.sort.to_h { [it, File.exist?(it) ? File.mtime(it).to_f : nil] }
+    end
+
+    # Each participating gem's package.json: editing a path gem's manifest makes its context stale.
+    def manifests(root)
+      BundledGems.participating(BundledGems.installed_specs, overrides: BundledGems.overrides(root))
+                 .values.filter_map { BundledGems.manifest_root(it) }
+                 .map { File.join(it, 'package.json') }
+    rescue BundledGems::ConfigError
+      []
+    end
+
+    def reset! = LOCK.synchronize { @looked = {} }
+  end
+end

data/lib/proscenium/middleware/base.rb

@@ -48,9 +48,12 @@ module Proscenium
         file_readable?
       end
 
+      # Probes the path exactly as it will be built. `real_path` is already decoded and cleaned, so
+      # decoding it again here - as this once did - probed a different file than the one built
+      # whenever the request was double-encoded: `%252e%252e` was built as a literal `%2e%2e`
+      # segment but probed as `..`.
       def file_readable?
-        return false unless (path = clean_path(sourcemap? ? real_path[0...-4] : real_path))
-
+        path = sourcemap? ? real_path[0...-4] : real_path
         file_stat = File.stat(root_for_readable.join(path.delete_prefix('/').b).to_s)
       rescue SystemCallError
         false
@@ -62,14 +65,6 @@ module Proscenium
         Rails.root
       end
 
-      # Secondary to `Middleware.normalise_path`, which every path here has already been through
-      # - this is idempotent on that output, and earns its keep by stripping the leading slash
-      # that the `join` above needs, and by handling the `.map`-stripped variant.
-      def clean_path(file)
-        path = Rack::Utils.unescape_path file.chomp('/').delete_prefix('/')
-        Rack::Utils.clean_path_info path if Rack::Utils.valid_path? path
-      end
-
       def content_type
         case ::File.extname(path_to_build)
         when '.js', '.mjs', '.ts', '.tsx', '.jsx' then 'application/javascript'

data/lib/proscenium/middleware/chunks.rb

@@ -22,7 +22,12 @@ module Proscenium
         # The path also has to yield a content hash, not just match the prefix - `CHUNKS_PATH`
         # checks only the latter, and `/_asset_chunks/nohash.js` used to index the nil match and
         # return a 500 from here.
+        #
+        # FileHandler decodes `PATH_INFO` again, and that cannot be switched off, so a path still
+        # holding a `%` after the first decode is refused: the handler would resolve it to a
+        # different file than the one checked here. esbuild never puts a `%` in a chunk name.
         return @app.call(env) unless (path = Middleware.normalise_path(request.path)) &&
+                                     !path.include?('%') &&
                                      path.match?(CHUNKS_PATH) &&
                                      (etag = path[/-\$([a-z0-9]+)\$/i, 1])
 

data/lib/proscenium/monkey.rb

@@ -2,47 +2,39 @@
 
 module Proscenium
   module Monkey
-    module TemplateRenderer
-      private
-
-      def render_template(view, template, layout_name, locals)
-        result = super
-        return result if !view.controller || !Proscenium.config.side_load
-
-        to_sideload = if template.respond_to?(:identifier) &&
-                         template.respond_to?(:type) && template.type == :html
-                        template
-                      end
-        if to_sideload && view.controller.respond_to?(:sideload_assets_options)
-          options = view.controller.sideload_assets_options
-          layout = find_layout(layout_name, locals.keys, [formats.first])
-          sideload_template_assets layout, view.controller, options if layout
-          sideload_template_assets to_sideload, view.controller, options
-        end
-
-        result
+    # A template ActionView pushes onto `@current_template` is not the body of a partial rendered
+    # with a block, so `Helper#sideload_assets` must not see that partial while one renders. Rails
+    # caches template objects, so the pushed template can be the very one that rendered the partial.
+    #
+    # Overrides ActionView's private `ActionView::Base#_run(method, template, locals, buffer,
+    # add_to_stack: true, ...)`, unchanged from Rails 7.2 to 8.1. `@proscenium_block_partial` is
+    # set by `Helper#proscenium_render_block_partial`. Every template render runs through here, so
+    # arguments are forwarded with `...`, which allocates nothing. Reading `add_to_stack` does
+    # allocate, so it is only read while a block partial is rendering.
+    module Base
+      def _run(...)
+        return super unless @proscenium_block_partial && proscenium_pushes_template?(...)
+
+        owner = @proscenium_block_partial
+        @proscenium_block_partial = nil
+        super
+      ensure
+        @proscenium_block_partial = owner if owner
       end
 
-      def sideload_template_assets(tpl, controller, options)
-        return unless (tpl_path = Pathname.new(tpl.identifier)).file?
+      private
 
-        options = {} if options.nil?
-        options = { js: options, css: options } unless options.is_a?(Hash)
+      def proscenium_pushes_template?(*, add_to_stack: true, **) = add_to_stack
+    end
 
-        if tpl.instance_variable_defined?(:@sideload_assets_options)
-          tpl_options = tpl.instance_variable_get(:@sideload_assets_options)
-          options = case tpl_options
-                    when Hash then options.deep_merge(tpl_options)
-                    else
-                      { js: tpl_options, css: tpl_options }
-                    end
-        end
+    module TemplateRenderer
+      private
 
-        %i[css js].each do |k|
-          options[k] = controller.instance_eval(&options[k]) if options[k].is_a?(Proc)
-        end
+      def render_template(view, template, layout_name, locals)
+        return super unless SideLoad.sideloadable?(view, template)
 
-        Importer.sideload tpl_path, **options
+        layout = find_layout(layout_name, locals.keys, [formats.first])
+        SideLoad.sideload_templates(view, [layout, template]) { super }
       end
     end
 
@@ -50,45 +42,35 @@ module Proscenium
       private
 
       def render_partial_template(view, locals, template, layout, block)
-        result = super
-
-        return result if !view.controller || !Proscenium.config.side_load
-
-        if template.respond_to?(:identifier) &&
-           template.respond_to?(:type) && template.type == :html &&
-           view.controller.respond_to?(:sideload_assets_options)
-          options = view.controller.sideload_assets_options
-          sideload_template_assets layout, view.controller, options if layout
-          sideload_template_assets template, view.controller, options
+        return super unless SideLoad.sideloadable?(view, template)
+
+        SideLoad.sideload_templates(view, [layout, template]) do
+          # A view rendered before Proscenium::Helper is included cannot call `sideload_assets`.
+          if block && view.respond_to?(:proscenium_render_block_partial)
+            view.proscenium_render_block_partial(template, block) do |wrapped|
+              super(view, locals, template, layout, wrapped)
+            end
+          else
+            super
+          end
         end
-
-        result
       end
+    end
 
-      # `controller` is passed in rather than read off `self`: unlike TemplateRenderer, an
-      # ActionView::PartialRenderer has no `controller` - so a Proc option reaching a partial
-      # raised NameError until it was threaded through here, as its TemplateRenderer twin
-      # already did.
-      def sideload_template_assets(tpl, controller, options)
-        return unless (tpl_path = Pathname.new(tpl.identifier)).file?
-
-        options = {} if options.nil?
-        options = { js: options, css: options } unless options.is_a?(Hash)
-
-        if tpl.instance_variable_defined?(:@sideload_assets_options)
-          tpl_options = tpl.instance_variable_get(:@sideload_assets_options)
-          options = if tpl_options.is_a?(Hash)
-                      options.deep_merge tpl_options
-                    else
-                      { js: tpl_options, css: tpl_options }
-                    end
-        end
+    # A collection renders each item with `Template#render`, so never reaches
+    # `PartialRenderer#render_partial_template`. Hooked above the collection cache, which skips
+    # rendering entirely on a full hit. A mixed collection has no single template, and is not side
+    # loaded.
+    module CollectionRenderer
+      private
 
-        %i[css js].each do |k|
-          options[k] = controller.instance_eval(&options[k]) if options[k].is_a?(Proc)
-        end
+      # `args` is `path, template, layout, block`. `collection` is ActionView's CollectionIterator,
+      # which has `length` but no `empty?`.
+      def render_collection(collection, view, *args)
+        _path, template, layout, = args
+        return super unless collection.length.positive? && SideLoad.sideloadable?(view, template)
 
-        Importer.sideload tpl_path, **options
+        SideLoad.sideload_templates(view, [layout, template]) { super }
       end
     end
   end

data/lib/proscenium/railtie.rb

@@ -36,6 +36,20 @@ module Proscenium
 
       Proscenium::Manifest.load!
 
+      project = Proscenium::ContextMap.project_root
+      if (notice = Proscenium::ContextMap.adoption_notice(project))
+        Rails.logger.info "[Proscenium] #{notice}"
+      end
+      # Production finds stale contexts at assets:precompile, which refuses to compile. Elsewhere
+      # the first mapping generation starts here, so a change after boot, such as running
+      # `proscenium install`, starts the next one. No Go call: Puma may fork after boot.
+      unless Rails.env.production?
+        generation, = Proscenium::MappingGeneration.refresh(project)
+        if (stale = Proscenium::StaleContexts.message(project, generation))
+          Rails.logger.warn "[Proscenium] #{stale}"
+        end
+      end
+
       if config.proscenium.logging
         require 'proscenium/log_subscriber'
         Proscenium::LogSubscriber.attach_to :proscenium
@@ -78,8 +92,10 @@ module Proscenium
 
     initializer 'proscenium.monkey_patches' do
       ActiveSupport.on_load(:action_view) do
+        ActionView::Base.prepend Monkey::Base
         ActionView::TemplateRenderer.prepend Monkey::TemplateRenderer
         ActionView::PartialRenderer.prepend Monkey::PartialRenderer
+        ActionView::CollectionRenderer.prepend Monkey::CollectionRenderer
       end
     end
 

data/lib/proscenium/railties/assets.rake

@@ -5,7 +5,8 @@ namespace :assets do
   task precompile: :environment do
     puts "\nPre-compiling assets..."
 
-    raise 'Assets pre-compilation failed!' unless Proscenium::Builder.compile
+    # Raises Proscenium::Builder::CompileError, with esbuild's messages, when the build fails.
+    Proscenium::Builder.compile
 
     puts "\nAssets pre-compiled successfully."
 

data/lib/proscenium/resolver.rb

@@ -11,21 +11,53 @@ module Proscenium
     #   absolute file system path as an array. Only returns the resolved path if false (default).
     # @return [String, Array<String>]
     def self.resolve(path, as_array: false)
+      # Normalised before anything reads it, the guard and the cache key included. The bun test
+      # harness hands this Bun's own spelling of a module path, which on Windows is `D:\...`;
+      # matched against a slash-form Rails.root it fell through to the Go resolver and came back
+      # as the url path unchanged - a backslash path the harness then refused to build.
+      path = Utils.fs_path(path)
+
       if path.start_with?('./', '../')
         raise ArgumentError, '`path` must be an absolute file system or URL path'
       end
 
-      resolved[path] ||= if (gem = BundledGems.paths.find { |_, v| path.start_with? "#{v}/" })
-                           vpath = path.sub(/^#{gem.last}/, "@rubygems/#{gem.first}")
-                           [Proscenium::Manifest[vpath], "/node_modules/#{vpath}", path]
-                         elsif path.start_with?("#{Rails.root}/")
-                           vpath = path.delete_prefix(Rails.root.to_s)
-                           [Proscenium::Manifest[vpath], vpath, path]
-                         else
-                           [Proscenium::Manifest[path], *Builder.resolve(path)]
-                         end
-
-      as_array ? resolved[path] : resolved[path][0] || resolved[path][1]
+      # A new mapping generation forgets cached resolutions (#154): polled here too, so a path
+      # resolved before an install does not keep its old URL when no Builder is made after it.
+      generation
+
+      # Caches the manifest key, not its value, so a manifest loaded or reset later is still
+      # honoured. Every string is frozen: the URL path is handed back to callers, and in the
+      # Rails.root branch it is the key itself, so mutating it would redirect later lookups.
+      key, url_path, abs_path = resolved[path] ||= entry_for(path).map(&:-@).freeze
+      manifest_path = Proscenium::Manifest[key]
+
+      as_array ? [manifest_path, url_path, abs_path] : manifest_path || url_path
+    end
+
+    # The manifest key, URL path and absolute file system path for `path`. In the gem branch the
+    # key differs from the URL path, so it is kept rather than derived.
+    def self.entry_for(path)
+      if (vpath = BundledGems.virtual_path(path))
+        [vpath, "/node_modules/#{vpath}", path]
+      elsif path.start_with?("#{Rails.root}/")
+        vpath = path.delete_prefix(Rails.root.to_s)
+        [vpath, vpath, path]
+      else
+        [path, *Builder.resolve(path)]
+      end
+    end
+    private_class_method :entry_for
+
+    # The mapping generation builds and resolutions use now (#154). Development and test start a
+    # new one when the files the context map is built from change, and forget resolved paths with
+    # it; production keeps one for the process. Here rather than on Builder, which loads the Go
+    # library when first referenced, so resolving a path never needs it.
+    def self.generation
+      return 0 if Rails.env.production?
+
+      number, changed = MappingGeneration.refresh(ContextMap.project_root)
+      reset if changed
+      number
     end
 
     def self.reset

data/lib/proscenium/runtime/bootstrap.js

@@ -15,6 +15,13 @@ class Daemon {
   #buffer = "";
   #nextId = 1;
 
+  // Null while the connection is usable, and the error that ended it once it is not. A closed
+  // socket does not refuse a write - Bun's `write` returns -1 and throws nothing - so without this
+  // a request sent after the daemon died registered a promise nothing would ever settle, and every
+  // later module load hung, outside any per-test timeout. A reply that does not parse ends it too:
+  // the stream is no longer line-aligned, so nothing read from it after that can be trusted.
+  #failure = null;
+
   // Decodes across chunk boundaries. `chunk.toString()` decodes each chunk on its own, so a
   // multi-byte character split by the socket becomes U+FFFD on both sides - a module whose bytes
   // silently differ from the ones Rails served, which is the one thing this harness exists to
@@ -32,8 +39,8 @@ class Daemon {
       unix: socketPath,
       socket: {
         data: (_sock, chunk) => daemon.#onData(chunk),
-        close: () => daemon.#rejectAll(new Error("proscenium daemon closed the connection")),
-        error: (_sock, error) => daemon.#rejectAll(error),
+        close: () => daemon.#fail(new Error("proscenium daemon closed the connection")),
+        error: (_sock, error) => daemon.#fail(error),
       },
     });
     daemon = new Daemon(socket);
@@ -41,6 +48,8 @@ class Daemon {
   }
 
   send(op, args = {}) {
+    if (this.#failure) return Promise.reject(this.#failure);
+
     return new Promise((resolve, reject) => {
       const id = this.#nextId++;
       this.#pending.set(id, { resolve, reject });
@@ -65,7 +74,7 @@ class Daemon {
       try {
         reply = JSON.parse(line);
       } catch (error) {
-        this.#rejectAll(error);
+        this.#fail(error);
         return;
       }
 
@@ -78,8 +87,11 @@ class Daemon {
     }
   }
 
-  #rejectAll(error) {
-    for (const { reject } of this.#pending.values()) reject(error);
+  // The first error wins, so a parse failure is still what callers see once the close that
+  // usually follows it arrives.
+  #fail(error) {
+    this.#failure ??= error;
+    for (const { reject } of this.#pending.values()) reject(this.#failure);
     this.#pending.clear();
   }
 }
@@ -123,8 +135,13 @@ async function spawnDaemon({ env, timeoutMs }) {
   // Must match Server::SOCKET_NAME. The daemon is handed the directory, not the path.
   const socketPath = join(socketDir, "d.sock");
 
+  // On Windows `bundle` is `bundle.bat`, and a batch file's arguments are re-parsed by cmd.exe.
+  // Bun 1.4 refuses that outright for an argument holding a cmd.exe special character, which the
+  // Ruby code below always does ("The argument 'args[6]' contains a cmd.exe special character").
+  // `ruby -S bundle` runs the same `bundle` script from PATH with ruby.exe, so no batch file and
+  // no cmd.exe are involved and the argument arrives exactly as written.
   const command = [
-    "bundle",
+    ...(process.platform === "win32" ? ["ruby", "-S", "bundle"] : ["bundle"]),
     "exec",
     "rails",
     "runner",
@@ -244,3 +261,6 @@ export async function register(options = {}) {
 }
 
 export default register;
+
+// Exported for its tests, which drive it against a fake daemon.
+export { Daemon };