wurk 1.3.0 → 1.4.0

data/lib/wurk/swarm.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'monitor'
+
 require_relative 'component'
 require_relative 'launcher'
 require_relative 'fetcher/reliable'
@@ -42,6 +44,16 @@ module Wurk
     MEMORY_CHECK_INTERVAL = 10
     DEFAULT_SHUTDOWN_TIMEOUT = 25
 
+    # The supervisor's own Redis pool: one connection, disjoint from every
+    # capsule pool. Post-boot the parent's only Redis use is the heartbeat probe
+    # (`heartbeat_seen?`) — one SISMEMBER per restart tick — and routing it
+    # through the capsule main pool reopened, at capsule size (>= 10), the very
+    # sockets step 3 had just closed; the next respawn/restart fork then
+    # inherited them. Dedicated and torn down before every fork, so no child
+    # ever sees a parent socket.
+    SUPERVISOR_POOL_SIZE = 1
+    SUPERVISOR_POOL_NAME = 'swarm-supervisor'
+
     # Children each hard_shutdown after their own drain deadline (bulk_requeue
     # + a 3s ensure window + heartbeat cleanup); the parent must not SIGKILL
     # them mid-tail, so its own wait always extends past theirs by this much.
@@ -52,7 +64,7 @@ module Wurk
     # whole swarm.
     SWARM_SIGNALS = { 'TERM' => :term, 'INT' => :term, 'TSTP' => :tstp, 'USR1' => :usr1, 'USR2' => :usr2 }.freeze
 
-    attr_reader :topology, :children
+    attr_reader :topology
 
     def initialize(topology:, config: Wurk.configuration, memory_limit: config.memory_limit_kb,
                    shutdown_timeout: DEFAULT_SHUTDOWN_TIMEOUT)
@@ -60,15 +72,24 @@ module Wurk
       @config = config
       @memory_limit = memory_limit
       @shutdown_timeout = shutdown_timeout
+      # One reentrant lock covers the child table AND the restart machine: they
+      # are mutually recursive (Restart#advance calls back into `describe` and
+      # `spawn`, which read and write `@children`), so separate locks would be
+      # taken in opposite orders — enqueue holds children→restart, advance holds
+      # restart→children — and deadlock. Monitor's reentrancy is what lets those
+      # callbacks re-enter. Never held across a sleep: `wait_for_children` and
+      # the supervise tick sleep outside it.
+      @lock = ::Monitor.new
       @children = {}
       @assignments = []
+      @owner_pid = nil
       @stopping = false
+      @shutdown_requested = false
       @quieted = false
       @last_memory_check = 0
-      @signal_read = nil
-      @signal_write = nil
       @respawn_backoff = Backoff.new(base: RESPAWN_BACKOFF)
       @restart = build_restart
+      init_fork_unsafe_handles
     end
 
     # `install_signals:` is false in tests so the integration suite can
@@ -85,29 +106,65 @@ module Wurk
       raise ArgumentError, 'Topology has no slots' if @topology.empty?
 
       @assignments = @topology.assignments.freeze
+      @owner_pid = ::Process.pid
       install_signal_handlers if install_signals
       close_parent_sockets
       fork_children
-      @children.keys
+      child_pids
+    end
+
+    # A snapshot, not the live table. Callers read this off the supervise
+    # thread, which inserts (respawn, restart) and deletes (reap) on every tick;
+    # handing out the live Hash lets them iterate it mid-mutation.
+    def children
+      @lock.synchronize { @children.dup }
     end
 
     def supervise
+      return unless owner?
+
       until done?
         drain_signals
+        shutdown if @shutdown_requested && !@stopping
         reap_children
         spawn_due_respawns
-        @restart.advance unless @stopping
+        advance_restart unless @stopping
         check_memory_pressure
         sleep SUPERVISE_TICK
       end
     end
 
     def shutdown(timeout: @shutdown_timeout)
+      return unless owner?
+
       @stopping = true
-      @restart.abort
+      @lock.synchronize { @restart.abort }
       relay_signal('TERM')
       wait_for_children(timeout + SHUTDOWN_GRACE)
       hard_kill_stragglers
+      close_supervisor_pool
+      close_signal_pipe
+    end
+
+    # Cross-thread drain request: raise a flag the supervise loop observes on
+    # its next tick instead of draining on the caller's thread. `shutdown`
+    # walks and clears the child table that the supervise thread is
+    # concurrently mutating (reap, respawn, restart), so two threads inside it
+    # race. Every caller that isn't the supervise thread — rails_boot's
+    # `at_exit`, which fires on the host's main thread — comes through here.
+    def request_shutdown
+      @shutdown_requested = true
+    end
+
+    # Only the process that forked the children may supervise or signal them.
+    # A forked child inherits this object along with the host's `at_exit` hooks
+    # — and rails_boot registers one that drains the swarm — so ChildBoot's
+    # `exit` reaches a full drain inside the child. There `@children` holds the
+    # child's SIBLINGS, not its own children: unguarded, that TERMs them, stalls
+    # the whole shutdown timeout waiting on PIDs it can never reap, then SIGKILLs
+    # whatever survived.
+    def owner?
+      ::Process.pid == @owner_pid
     end
 
     # TSTP quiet is one-way and GLOBAL (spec §21.3): it must survive respawns
@@ -124,17 +181,44 @@ module Wurk
     # heartbeat → TERM the old child → await its drain) without blocking the
     # supervise thread, so TERM stays responsive throughout the cycle.
     def rolling_restart
-      @restart.enqueue(@children.keys)
+      @lock.synchronize { @restart.enqueue(@children.keys) }
     end
 
     private
 
+    # The handles the parent must never let cross a fork: the signal self-pipe
+    # (an inherited trap would write into the PARENT's supervise loop) and the
+    # supervisor's Redis socket. Grouped because they share one rule — opened in
+    # the parent, dropped before or at every fork by `close_supervisor_pool` and
+    # `close_signal_pipe`.
+    def init_fork_unsafe_handles
+      @signal_read = nil
+      @signal_write = nil
+      @supervisor_pool = nil
+    end
+
+    def advance_restart
+      @lock.synchronize { @restart.advance }
+    end
+
+    def child_pids
+      @lock.synchronize { @children.keys }
+    end
+
+    def child_meta(pid)
+      @lock.synchronize { @children[pid] }
+    end
+
+    def any_children?
+      @lock.synchronize { !@children.empty? }
+    end
+
     def build_restart
       Restart.new(Restart::Config.new(
                     spawn: method(:spawn_child),
                     kill: method(:safe_kill),
                     heartbeat: method(:heartbeat_seen?),
-                    describe: ->(pid) { @children[pid] },
+                    describe: ->(pid) { child_meta(pid) },
                     now: method(:monotonic),
                     logger: logger,
                     heartbeat_wait: HEARTBEAT_WAIT,
@@ -168,7 +252,7 @@ module Wurk
     # Returns the child PID; never returns in the child (ChildBoot exits).
     def spawn_child(slot, idx)
       pid = fork_child(slot, idx)
-      @children[pid] = { slot: slot, index: idx, spawned_at: monotonic }
+      @lock.synchronize { @children[pid] = { slot: slot, index: idx, spawned_at: monotonic } }
       pid
     end
 
@@ -176,17 +260,21 @@ module Wurk
     # from the parent, it is race-free even if the parent dies the instant
     # after fork (getppid in the child could already return the reaper). The
     # child's OrphanGuard compares live getppid against it.
+    #
+    # The supervisor pool closes here rather than in `close_parent_sockets`
+    # because that runs once, at boot: every later respawn / rolling-restart
+    # fork happens after the heartbeat probe has reopened it.
     def fork_child(slot, idx)
       parent_pid = ::Process.pid
+      close_supervisor_pool
       pid = ::Process.fork
       return pid if pid
 
       # Drop the parent's self-pipe first: the inherited traps still write to
       # it, so a signal landing in the window before ChildBoot resets them
       # would surface in the PARENT's supervise loop (an operator TERMing one
-      # child pid would drain the whole swarm). Closed, the trap write no-ops.
-      @signal_read&.close
-      @signal_write&.close
+      # child pid would drain the whole swarm). Dropped, the trap write no-ops.
+      close_signal_pipe
       ChildBoot.new(@config, slot, idx, parent_pid: parent_pid, start_quiet: @quieted).run
       exit 0 # unreachable; ChildBoot exits explicitly
     end
@@ -204,12 +292,25 @@ module Wurk
       end
     end
 
+    # Both FDs, once. The traps stay installed and keep firing after a drain, so
+    # clear the ivars BEFORE closing: `emit_signal` then writes to nothing
+    # instead of a dead FD, and a `drain_signals` loop mid-tick (TERM handled,
+    # asking for the next buffered signal) stops instead of reading a closed
+    # pipe. Called on shutdown and, in the child, immediately after fork.
+    def close_signal_pipe
+      read = @signal_read
+      write = @signal_write
+      @signal_read = @signal_write = nil
+      read&.close
+      write&.close
+    end
+
     # Non-blocking self-pipe write from trap context: a blocking `puts` could
     # stall signal delivery if the pipe fills. `exception: false` returns
     # :wait_writable instead of raising when full (drop the coalescible
     # duplicate); a closed pipe during shutdown is ignored too.
     def emit_signal(sig)
-      @signal_write.write_nonblock("#{sig}\n", exception: false)
+      @signal_write&.write_nonblock("#{sig}\n", exception: false)
     rescue ::IOError, ::Errno::EPIPE, ::Errno::EBADF
       nil
     end
@@ -222,17 +323,29 @@ module Wurk
         when :term then shutdown
         when :tstp then quiet_swarm
         when :usr1 then rolling_restart
-        when :usr2 then relay_signal('USR2')
+        when :usr2
+          reopen_logs
+          relay_signal('USR2')
         end
       end
     end
 
     # One buffered line per pending signal, non-blocking (wait_readable(0)).
-    # nil once the pipe is drained, ending the loop for this tick.
+    # nil once the pipe is drained, ending the loop for this tick. Reads through
+    # a local because the pipe can vanish mid-drain: a buffered TERM runs
+    # `shutdown`, which closes it, and the loop then asks for the next signal.
     def read_pending_signal
-      return nil unless @signal_read.wait_readable(0)
+      read = @signal_read
+      return nil unless read&.wait_readable(0)
 
-      @signal_read.gets&.strip
+      read.gets&.strip
+    end
+
+    def reopen_logs
+      log = @config.logger
+      log.reopen if log.respond_to?(:reopen)
+    rescue StandardError
+      nil
     end
 
     # Reap every exited child this tick (not one), so a fleet-wide death
@@ -251,14 +364,16 @@ module Wurk
     end
 
     def on_child_exit(pid, status)
-      meta = @children.delete(pid)
-      return unless meta
-      return if @restart.claim_exit(pid)
-
-      if @stopping
-        logger.info { "swarm: child #{pid} exited (status=#{status.exitstatus})" }
-      else
-        schedule_respawn(pid, status, meta)
+      @lock.synchronize do
+        meta = @children.delete(pid)
+        return unless meta
+        return if @restart.claim_exit(pid)
+
+        if @stopping
+          logger.info { "swarm: child #{pid} exited (status=#{status.exitstatus})" }
+        else
+          schedule_respawn(pid, status, meta)
+        end
       end
     end
 
@@ -305,7 +420,7 @@ module Wurk
       return if now - @last_memory_check < MEMORY_CHECK_INTERVAL
 
       @last_memory_check = now
-      @children.dup.each_key { |pid| recycle_if_bloated(pid) }
+      child_pids.each { |pid| recycle_if_bloated(pid) }
     end
 
     # Route a bloated child through the restart state machine (same path as a
@@ -317,7 +432,7 @@ module Wurk
       return if rss.nil? || rss < @memory_limit
 
       logger.warn { "swarm: child #{pid} RSS #{rss}KB >= #{@memory_limit}KB; recycling" }
-      @restart.enqueue([pid])
+      @lock.synchronize { @restart.enqueue([pid]) }
     end
 
     def pid_rss_kb(pid)
@@ -329,10 +444,15 @@ module Wurk
     end
 
     def relay_signal(sig)
-      @children.each_key { |pid| safe_kill(pid, sig) }
+      child_pids.each { |pid| safe_kill(pid, sig) }
     end
 
+    # The one place the supervisor signals a child: relay_signal,
+    # hard_kill_stragglers and the restart machine's `kill:` callback all funnel
+    # through here, so the owner check covers every path at a single choke point.
     def safe_kill(pid, sig)
+      return unless owner?
+
       ::Process.kill(sig, pid)
     rescue Errno::ESRCH, Errno::EPERM
       nil
@@ -340,15 +460,20 @@ module Wurk
 
     def wait_for_children(timeout)
       deadline = monotonic + timeout
-      while monotonic < deadline && @children.any?
+      while monotonic < deadline && any_children?
         reap_children
         sleep 0.1
       end
     end
 
+    # Kill and forget atomically: a child landing in the table between the walk
+    # and the clear would be dropped from it without ever being signalled —
+    # untracked and still alive.
     def hard_kill_stragglers
-      @children.each_key { |pid| safe_kill(pid, 'KILL') }
-      @children.clear
+      @lock.synchronize do
+        @children.each_key { |pid| safe_kill(pid, 'KILL') }
+        @children.clear
+      end
     end
 
     # Has the child written its first heartbeat yet? One non-blocking SISMEMBER,
@@ -360,17 +485,33 @@ module Wurk
     # forces progress.
     def heartbeat_seen?(pid)
       identity = "#{hostname}:#{pid}:#{Component::PROCESS_NONCE}"
-      @config.redis { |c| c.call('SISMEMBER', Keys::PROCESSES, identity) } == 1
+      supervisor_pool.with { |c| c.call('SISMEMBER', Keys::PROCESSES, identity) } == 1
     rescue StandardError
       false
     end
 
+    def supervisor_pool
+      @supervisor_pool ||= @config.new_redis_pool(SUPERVISOR_POOL_SIZE, SUPERVISOR_POOL_NAME)
+    end
+
+    # ConnectionPool#shutdown is terminal, so the reference has to go with the
+    # socket — the next probe rebuilds. Cleared before disconnecting so a raise
+    # mid-teardown can't leave a shut-down pool wired up, which would make every
+    # later probe raise PoolShuttingDownError instead of reconnecting.
+    def close_supervisor_pool
+      pool = @supervisor_pool
+      @supervisor_pool = nil
+      pool&.disconnect!
+    rescue StandardError => e
+      logger.warn { "swarm: supervisor pool close failed: #{e.class}: #{e.message}" }
+    end
+
     def monotonic
       ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
     end
 
     def done?
-      @stopping && @children.empty?
+      @stopping && !any_children?
     end
   end
 end

data/lib/wurk/timer_loop.rb

@@ -15,6 +15,13 @@ module Wurk
   #   @thread ||= safe_thread('my-loop') { @timer.run { tick } }
   #   def terminate = @timer.terminate
   class TimerLoop
+    # Deadline every periodic component gives its loop thread when stopping.
+    # Bounded rather than an open-ended join: a tick blocked on a wedged Redis
+    # must not hold the process's whole shutdown open. Also used by
+    # Scheduled::Poller, which hand-rolls its wait (the interval is randomized
+    # per iteration) but stops on the same terms.
+    JOIN_TIMEOUT = 5
+
     def initialize(interval)
       @interval = interval
       @done = false
@@ -40,6 +47,13 @@ module Wurk
       end
     end
 
+    # Clears a previous #terminate. Hosts call this before respawning, so a
+    # start-after-stop cycle spawns a thread that ticks instead of one that
+    # sees the stale done flag and exits immediately.
+    def reset
+      @mutex.synchronize { @done = false }
+    end
+
     def wait
       @mutex.synchronize do
         @sleeper.wait(@mutex, @interval) unless @done

data/lib/wurk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wurk
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/lib/wurk/web/enterprise.rb

@@ -22,21 +22,72 @@ module Wurk
       module Limits
         module_function
 
-        # @return [Array<String>] limiter names, optionally filtered to those
-        #   whose name contains the case-insensitive substring `filter`.
+        # Names per sweep round trip. Bounds both halves: the probe's pipeline
+        # (whose replies the client buffers) and the removal script, which is
+        # atomic — an unbatched pass over a set that leaked for months would
+        # block every other Redis client for its whole length. A healthy set
+        # fits in one slice, so the common case still costs one probe.
+        SWEEP_BATCH = 512
+
+        # @return [Array<String>] live limiter names, optionally filtered to
+        #   those whose name contains the case-insensitive substring `filter`.
+        #
+        # Listing is also the sweep. `lmtr-list` membership has no TTL of its
+        # own while `lmtr:<name>` expires with the limiter's ttl, so every
+        # interpolated name (`stripe-#{user_id}`) the spec blesses would leave a
+        # permanent member behind. Names whose metadata is gone are dropped from
+        # the SET and from the result, so the dashboard also stops rendering a
+        # row with nothing behind it. The liveness probe rides along with the
+        # SMEMBERS the listing already pays for — both are O(set) — and once the
+        # sweep has run the set is back down to live limiters.
         def list(filter: nil)
-          names = Wurk.redis { |c| c.call('SMEMBERS', Wurk::Limiter::LIST_KEY) }.sort
+          names = sweep(Wurk.redis(idempotent: true) { |c| c.call('SMEMBERS', Wurk::Limiter::LIST_KEY) }).sort
           return names if filter.nil? || filter.to_s.empty?
 
           needle = filter.to_s.downcase
           names.select { |n| n.downcase.include?(needle) }
         end
 
+        # Drop the names whose metadata is gone, return the ones still live.
+        def sweep(names)
+          names.each_slice(SWEEP_BATCH).flat_map { |slice| sweep_slice(slice) }
+        end
+
+        def sweep_slice(names)
+          live, dead = partition_live(names)
+          sweep_batch(dead) unless dead.empty?
+          live
+        end
+
+        def partition_live(names)
+          flags = Wurk.redis(idempotent: true) do |c|
+            c.pipelined { |pipe| names.each { |n| pipe.call('EXISTS', meta_key(n)) } }
+          end
+          names.partition.with_index { |_, i| flags[i].to_i == 1 }
+        end
+
+        # Claims apply-safety, unlike ProcessSet's comparable prune: the script
+        # re-decides liveness inside its own atomic step, so a replay can only
+        # remove names that are still dead.
+        def sweep_batch(names)
+          Wurk.redis(idempotent: true) do |c|
+            Wurk::Lua::Loader.eval_cached(
+              c, :limiter_list_sweep,
+              keys: [Wurk::Limiter::LIST_KEY],
+              argv: ['lmtr:', *names]
+            )
+          end
+        end
+
         def metadata(name)
-          raw = Wurk.redis { |c| c.call('HGETALL', "lmtr:#{name}") }
+          raw = Wurk.redis(idempotent: true) { |c| c.call('HGETALL', meta_key(name)) }
           raw.is_a?(Array) ? raw.each_slice(2).to_h : raw
         end
 
+        def meta_key(name)
+          "lmtr:#{name}"
+        end
+
         # Stats-key reset: drops every `lmtr-stats:` / state key for the
         # named limiter while keeping its metadata + LIST membership so the
         # row remains in the UI. Mirrors the §1.5 `#reset` surface — the
@@ -51,8 +102,9 @@ module Wurk
         end
 
         # Read-only reconstruction (`register: false`) from the persisted
-        # metadata. Returns nil when the meta HASH is gone or malformed —
-        # LIST membership has no TTL, so a name can outlive its metadata.
+        # metadata. Returns nil when the meta HASH is gone or malformed — the
+        # name a caller holds came from a page `list` rendered earlier, and the
+        # metadata can expire between the two.
         def rebuild(name)
           meta = metadata(name)
           return nil if meta.nil? || meta.empty?

data/lib/wurk/web/extension.rb

@@ -148,7 +148,7 @@ module Wurk
           %(<time class="ltr" dir="ltr" title="#{iso}" datetime="#{iso}">#{iso}</time>)
         end
 
-        def redis(&) = ::Wurk.redis(&)
+        def redis(idempotent: false, &) = ::Wurk.redis(idempotent:, &)
         def product_version = ::Wurk::VERSION
         def number_with_delimiter(num) = num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
       end

data/lib/wurk/web/search.rb

@@ -103,10 +103,12 @@ module Wurk
       # we scan a bounded prefix and never full-walk the LIST from a keystroke.
       def scan_queue_list(queue_name, &)
         key = Keys.queue(queue_name)
-        stop_at = queue_scan_stop(Wurk.redis { |c| c.call('LLEN', key) })
+        stop_at = queue_scan_stop(Wurk.redis(idempotent: true) { |c| c.call('LLEN', key) })
         start = 0
         while start < stop_at
-          slice = Wurk.redis { |c| c.call('LRANGE', key, start, [start + QUEUE_PAGE, stop_at].min - 1) }
+          slice = Wurk.redis(idempotent: true) do |c|
+            c.call('LRANGE', key, start, [start + QUEUE_PAGE, stop_at].min - 1)
+          end
           break if slice.empty?
 
           slice.each(&)
@@ -134,7 +136,7 @@ module Wurk
         set = sorted_set_for(kind)
         cursor = '0'
         loop do
-          cursor, page = Wurk.redis { |c| c.call('ZSCAN', set.name, cursor, 'COUNT', ZSCAN_PAGE) }
+          cursor, page = Wurk.redis(idempotent: true) { |c| c.call('ZSCAN', set.name, cursor, 'COUNT', ZSCAN_PAGE) }
           emit_sorted_hits(kind, set, page, &)
           @scanned += page.size / 2
           break if cursor == '0'

data/lib/wurk.rb

@@ -8,6 +8,7 @@
 require_relative 'wurk/version'
 require_relative 'wurk/keys'
 require_relative 'wurk/redis_pool'
+require_relative 'wurk/pool_checkout'
 require_relative 'wurk/redis_connection'
 require_relative 'wurk/middleware'
 require_relative 'wurk/middleware/chain'
@@ -126,8 +127,15 @@ module Wurk
     end
     alias default_configuration configuration
 
-    def redis(&)
-      redis_pool.with(&)
+    # `idempotent: true` asserts the block is safe to re-run after a command may
+    # already have applied server-side, buying back the full connection backoff
+    # (see RedisPool#with). Every wrapper down the chain — Capsule,
+    # Configuration, Component, middleware, Sidekiq.redis — forwards it, so a
+    # caller can claim apply-safety wherever it holds; PoolCheckout drops the
+    # claim for a host-supplied pool that wouldn't understand it. The zero-arg
+    # shape is the drop-in contract: `Sidekiq.redis { |c| ... }` never changes.
+    def redis(idempotent: false, &)
+      PoolCheckout.with(redis_pool, idempotent, &)
     end
 
     # Capsule-aware pool lookup. Thread-local override wins so per-capsule
@@ -224,6 +232,22 @@ module Wurk
     def ent?
       false
     end
+
+    # Lazily loads the Rails engine the first time something asks for
+    # `Wurk::Engine`. See the note above the `require "wurk/rails"` guard at the
+    # bottom of this file for why the guard alone isn't enough (#282), and why
+    # this loads the engine and not the railtie.
+    def const_missing(name)
+      return super unless name == :Engine
+      return super unless defined?(::Rails::Engine) && defined?(::ActionDispatch::Routing::RouteSet)
+
+      require_relative 'wurk/engine'
+      # If engine.rb somehow didn't define it, fall through to the real NameError
+      # rather than recursing back into here.
+      return super unless const_defined?(:Engine, false)
+
+      const_get(:Engine, false)
+    end
   end
 end
 
@@ -318,3 +342,30 @@ require_relative 'wurk/compat'
 # real Rails host both are loaded by `rails/all` before Bundler.require, so the
 # stricter gate is invisible there.
 require_relative 'wurk/rails' if defined?(Rails::Engine) && defined?(::ActionDispatch::Routing::RouteSet)
+
+# The gate above is evaluated exactly once, when this file is first required —
+# which is too early for the standalone runners (#282). `exe/wurk` and
+# `exe/wurkswarm` require "wurk" before Rails exists (the gate is false, nothing
+# Rails-y loads), then boot the host app themselves via
+# Wurk::CLI#boot_rails_application. By then "wurk" is in $LOADED_FEATURES, so the
+# app's own `Bundler.require` is a no-op and the gate never gets a second look. A
+# host that did exactly what the README says — `mount Wurk::Engine => "/wurk"` in
+# config/routes.rb — then dies during boot with `uninitialized constant
+# Wurk::Engine`, from the worker process only. Web processes are unaffected:
+# there Bundler.require runs after railties, so the gate passes.
+#
+# `Wurk.const_missing` (defined in the class << self block above) closes that
+# window without giving up the lean standalone boot: nothing loads until
+# something actually asks for Wurk::Engine, and even then only when Rails is
+# really present. It reuses the same two-part condition as the guard above, so
+# the ecosystem carve-out (rails/engine/railties without ActionDispatch, per
+# sidekiq-cron's test helper) still falls through to a plain NameError instead of
+# crashing on `isolate_namespace`.
+#
+# It deliberately loads `wurk/engine`, not `wurk/rails`: the railtie's
+# `config.after_initialize` is a *global* ActiveSupport load hook registered at
+# require time, and routes are drawn before those hooks run — so dragging the
+# railtie in there would fork a swarm inside a `wurkswarm` parent that is about
+# to fork its own. The runner owns the swarm; the routes file only needs the
+# constant. `defined?(Wurk::Engine)` stays nil until first use, which is what the
+# "standalone stays Rails-free" tests assert.

data/vendor/assets/dashboard/assets/{BatchDetail-YRymNsrB.js → BatchDetail-OmC5NPgw.js}

@@ -1 +1 @@
-import{A as e,F as t,J as n,M as r,O as i,_ as a,c as o,f as s,k as c,r as l,s as u,v as d,w as f}from"./Skeleton-DzR7XNxz.js";import{o as p,s as m}from"./index-DQu7WY9y.js";import{a as h}from"./utils-DDJC7tJV.js";var g=f(`<div style=display:flex;flex-direction:column;gap:2px><span style=font-size:11px;color:var(--text-muted);text-transform:uppercase;letter-spacing:0.04em></span><span style=font-variant-numeric:tabular-nums>`),_=f(`<div style=margin-top:1.5rem><h2 style="font-size:14px;margin:0 0 0.5rem"> <span class="badge badge-muted"></span></h2><div class=table-wrapper><table><tbody>`),v=f(`<tr><td style=font-family:monospace;font-size:12px>`),y=f(`<div><div class=section-header style=gap:0.75rem></div><div style=margin-top:1rem>`),b=f(`<div class=empty-state style=color:var(--danger)>`),x=f(`<span class="badge badge-success">`),S=f(`<span class="badge badge-danger">`),C=f(`<p style=color:var(--text-muted);margin-top:0>`),w=f(`<div><div class=section-header style=gap:0.75rem><h1 class=page-title style=margin:0;font-family:monospace;font-size:16px></h1></div><div style="display:grid;grid-template-columns:repeat(auto-fill, minmax(140px, 1fr));gap:1rem;margin-top:1rem">`),T=f(`<span class="badge badge-accent">%`);function E(e){return(()=>{var t=g(),n=t.firstChild,r=n.nextSibling;return a(n,()=>e.label),a(r,()=>e.children),t})()}function D(n){return t(e,{get when(){return n.jids.length>0},get children(){var e=_(),r=e.firstChild,o=r.firstChild,s=o.nextSibling,c=r.nextSibling.firstChild.firstChild;return a(r,()=>n.label,o),a(s,()=>n.jids.length),a(c,t(i,{get each(){return n.jids},children:e=>(()=>{var t=v(),n=t.firstChild;return a(n,e),t})()})),e}})}function O(){let i=m(),f=()=>i.bid??``;n(()=>{document.title=`${u(`nav.batches`)} — Wurk`});let g=s(()=>({queryKey:[`batch`,f()],queryFn:()=>fetch(`${o()}/api/batches/${encodeURIComponent(f())}`).then(e=>{if(!e.ok)throw Error(`HTTP ${e.status}`);return e.json()})}));return t(r,{get children(){return[t(c,{get when(){return g.isPending},get children(){var e=y(),n=e.firstChild,r=n.nextSibling;return a(n,t(p,{href:`/batches`,class:`btn btn-sm`,get children(){return[`← `,d(()=>u(`nav.batches`))]}})),a(r,t(l,{count:8})),e}}),t(c,{get when(){return g.isError||!g.data},get children(){var e=b();return a(e,()=>u(`common.error`)),e}}),t(c,{get when(){return g.data},children:n=>{let r=()=>n().total-n().pending,i=()=>n().total>0?Math.round(r()/n().total*100):0;return(()=>{var r=w(),o=r.firstChild,s=o.firstChild,c=o.nextSibling;return a(o,t(p,{href:`/batches`,class:`btn btn-sm`,get children(){return[`← `,d(()=>u(`nav.batches`))]}}),s),a(s,()=>n().bid),a(o,t(e,{get when(){return n().complete},get fallback(){return(()=>{var e=T(),t=e.firstChild;return a(e,i,t),e})()},get children(){var e=x();return a(e,()=>u(`batches.complete`)),e}}),null),a(o,t(e,{get when(){return n().invalidated},get children(){var e=S();return a(e,()=>u(`batches.invalidated`)),e}}),null),a(r,t(e,{get when(){return n().description},get children(){var e=C();return a(e,()=>n().description),e}}),c),a(c,t(E,{get label(){return u(`table.total`)},get children(){return n().total.toLocaleString()}}),null),a(c,t(E,{get label(){return u(`table.pending`)},get children(){return n().pending.toLocaleString()}}),null),a(c,t(E,{get label(){return u(`table.failures`)},get children(){return n().failures.toLocaleString()}}),null),a(c,t(E,{get label(){return u(`batches.children`)},get children(){return n().child_count.toLocaleString()}}),null),a(c,t(E,{get label(){return u(`table.created`)},get children(){return d(()=>!!n().created_at)()?h(n().created_at):`—`}}),null),a(c,t(E,{get label(){return u(`batches.completed`)},get children(){return d(()=>!!n().complete_at)()?h(n().complete_at):`—`}}),null),a(c,t(e,{get when(){return n().parent_bid},get children(){return t(E,{get label(){return u(`batches.parent`)},get children(){return n().parent_bid}})}}),null),a(c,t(e,{get when(){return n().tags.length>0},get children(){return t(E,{get label(){return u(`batches.tags`)},get children(){return n().tags.join(`, `)}})}}),null),a(r,t(D,{get label(){return u(`batches.failed_jobs`)},get jids(){return n().failed_jids}}),null),a(r,t(D,{get label(){return u(`batches.dead_jobs`)},get jids(){return n().dead_jids}}),null),r})()}})]}})}export{O as default};
+import{A as e,F as t,J as n,M as r,O as i,_ as a,c as o,f as s,k as c,r as l,s as u,v as d,w as f}from"./Skeleton-DzR7XNxz.js";import{o as p,s as m}from"./index-D_lSDwKw.js";import{a as h}from"./utils-DDJC7tJV.js";var g=f(`<div style=display:flex;flex-direction:column;gap:2px><span style=font-size:11px;color:var(--text-muted);text-transform:uppercase;letter-spacing:0.04em></span><span style=font-variant-numeric:tabular-nums>`),_=f(`<div style=margin-top:1.5rem><h2 style="font-size:14px;margin:0 0 0.5rem"> <span class="badge badge-muted"></span></h2><div class=table-wrapper><table><tbody>`),v=f(`<tr><td style=font-family:monospace;font-size:12px>`),y=f(`<div><div class=section-header style=gap:0.75rem></div><div style=margin-top:1rem>`),b=f(`<div class=empty-state style=color:var(--danger)>`),x=f(`<span class="badge badge-success">`),S=f(`<span class="badge badge-danger">`),C=f(`<p style=color:var(--text-muted);margin-top:0>`),w=f(`<div><div class=section-header style=gap:0.75rem><h1 class=page-title style=margin:0;font-family:monospace;font-size:16px></h1></div><div style="display:grid;grid-template-columns:repeat(auto-fill, minmax(140px, 1fr));gap:1rem;margin-top:1rem">`),T=f(`<span class="badge badge-accent">%`);function E(e){return(()=>{var t=g(),n=t.firstChild,r=n.nextSibling;return a(n,()=>e.label),a(r,()=>e.children),t})()}function D(n){return t(e,{get when(){return n.jids.length>0},get children(){var e=_(),r=e.firstChild,o=r.firstChild,s=o.nextSibling,c=r.nextSibling.firstChild.firstChild;return a(r,()=>n.label,o),a(s,()=>n.jids.length),a(c,t(i,{get each(){return n.jids},children:e=>(()=>{var t=v(),n=t.firstChild;return a(n,e),t})()})),e}})}function O(){let i=m(),f=()=>i.bid??``;n(()=>{document.title=`${u(`nav.batches`)} — Wurk`});let g=s(()=>({queryKey:[`batch`,f()],queryFn:()=>fetch(`${o()}/api/batches/${encodeURIComponent(f())}`).then(e=>{if(!e.ok)throw Error(`HTTP ${e.status}`);return e.json()})}));return t(r,{get children(){return[t(c,{get when(){return g.isPending},get children(){var e=y(),n=e.firstChild,r=n.nextSibling;return a(n,t(p,{href:`/batches`,class:`btn btn-sm`,get children(){return[`← `,d(()=>u(`nav.batches`))]}})),a(r,t(l,{count:8})),e}}),t(c,{get when(){return g.isError||!g.data},get children(){var e=b();return a(e,()=>u(`common.error`)),e}}),t(c,{get when(){return g.data},children:n=>{let r=()=>n().total-n().pending,i=()=>n().total>0?Math.round(r()/n().total*100):0;return(()=>{var r=w(),o=r.firstChild,s=o.firstChild,c=o.nextSibling;return a(o,t(p,{href:`/batches`,class:`btn btn-sm`,get children(){return[`← `,d(()=>u(`nav.batches`))]}}),s),a(s,()=>n().bid),a(o,t(e,{get when(){return n().complete},get fallback(){return(()=>{var e=T(),t=e.firstChild;return a(e,i,t),e})()},get children(){var e=x();return a(e,()=>u(`batches.complete`)),e}}),null),a(o,t(e,{get when(){return n().invalidated},get children(){var e=S();return a(e,()=>u(`batches.invalidated`)),e}}),null),a(r,t(e,{get when(){return n().description},get children(){var e=C();return a(e,()=>n().description),e}}),c),a(c,t(E,{get label(){return u(`table.total`)},get children(){return n().total.toLocaleString()}}),null),a(c,t(E,{get label(){return u(`table.pending`)},get children(){return n().pending.toLocaleString()}}),null),a(c,t(E,{get label(){return u(`table.failures`)},get children(){return n().failures.toLocaleString()}}),null),a(c,t(E,{get label(){return u(`batches.children`)},get children(){return n().child_count.toLocaleString()}}),null),a(c,t(E,{get label(){return u(`table.created`)},get children(){return d(()=>!!n().created_at)()?h(n().created_at):`—`}}),null),a(c,t(E,{get label(){return u(`batches.completed`)},get children(){return d(()=>!!n().complete_at)()?h(n().complete_at):`—`}}),null),a(c,t(e,{get when(){return n().parent_bid},get children(){return t(E,{get label(){return u(`batches.parent`)},get children(){return n().parent_bid}})}}),null),a(c,t(e,{get when(){return n().tags.length>0},get children(){return t(E,{get label(){return u(`batches.tags`)},get children(){return n().tags.join(`, `)}})}}),null),a(r,t(D,{get label(){return u(`batches.failed_jobs`)},get jids(){return n().failed_jids}}),null),a(r,t(D,{get label(){return u(`batches.dead_jobs`)},get jids(){return n().dead_jids}}),null),r})()}})]}})}export{O as default};