ruby_everywhere 0.4.0 → 0.5.0

data/lib/everywhere/log_filter.rb

@@ -31,6 +31,7 @@ module Everywhere
       when :tebako     then tebako(line)
       when :xcodebuild then xcodebuild(line)
       when :gradle     then gradle(line)
+      when :cargo      then cargo(line)
       end
     end
 
@@ -227,6 +228,42 @@ module Everywhere
     end
     # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
+    # --- `every dev`'s desktop shell (cargo) ----------------------------------
+
+    # A cold `cargo run` compiles ~300 crates, one "Compiling foo v0.1.0" line
+    # each, plus a progress bar it redraws several times a second. None of that
+    # is actionable while you're waiting on your own app — but warnings, errors
+    # and the moment the shell actually starts very much are.
+    #
+    # Unlike xcodebuild and Gradle (which we run with --console=plain), cargo is
+    # talking to a pty here and colors everything, so its status lines start
+    # with SGR codes and carry OSC-8 hyperlinks. Match on the stripped text;
+    # print the original, since that color is cargo's and worth keeping.
+    #
+    # The fall-through returns the line verbatim rather than nil, so it is NOT
+    # dimmed as background detail: once the shell is up, everything arriving on
+    # this stream is the app's own output, and the body of a Rust compile error
+    # is exactly what you need to read in full.
+    def cargo(line)
+      plain = UI.strip_ansi(line)
+      case plain
+      when /\A\s*error(\[E\d+\])?[:\[]/
+        "    #{UI.red(UI.short_path(plain))}"
+      when /\A\s*warning: /
+        "    #{UI.yellow(UI.short_path(plain))}"
+      when /\A\s*Compiling /
+        once(:compiling) { UI.note_line("compiling the desktop shell (first run is slow)") }
+      when /\A\s*(Downloaded|Downloading|Updating|Building \[|Blocking|Locking)/
+        :drop
+      when /\A\s*Finished\b/
+        UI.note_line("desktop shell compiled", marker: "✓", color: :green)
+      when /\A\s*Running\b/
+        UI.note_line("desktop shell running", marker: "✓", color: :green)
+      else
+        line
+      end
+    end
+
     # Show a line only the first time its key is seen; :drop the repeats. Keeps a
     # long notarization from scrolling a wall of identical "waiting" lines (and
     # notarytool's thrice-echoed submission id from showing three times).

data/lib/everywhere/native_helper.rb

@@ -10,25 +10,52 @@ module Everywhere
   # does on the client:
   #
   #   <%= link_to "Install the app", … unless native_app? %>
-  #   <div class="<%= "native-inset" if native_app? %>">
+  #   <div class="<%= "native-inset" if mobile_app? %>">
   #   <% if native_version && native_version >= Gem::Version.new("1.2") %>
   #
   # Detection is by User-Agent: the RubyEverywhere shells prepend
   # "RubyEverywhere/<version> (<os>)" to Hotwire Native's own
   # "Hotwire Native iOS/Android" marker. Included into all Rails views by
   # Everywhere::Engine.
+  #
+  # Pick the narrowest one that's true of what you're branching on. `native_app?`
+  # means "not a browser tab" and covers the desktop shell; `mobile_app?` means
+  # a phone, with a tab bar and safe-area insets; `desktop_app?` means a window,
+  # with a title bar and a menu bar. Safe-area padding is mobile_app?; hiding a
+  # web nav in favour of native chrome is usually mobile_app? too — the desktop
+  # shell has no native navigation to replace it with.
   module NativeHelper
-    # True inside any RubyEverywhere native shell (iOS or Android).
+    # True inside any RubyEverywhere native shell — iOS, Android or desktop.
+    # Mirrors the bridge's `Everywhere.native`.
     def native_app?
       !native_platform.nil?
     end
 
-    # :ios, :android, or nil in a plain browser. Reads Hotwire Native's UA
+    # :ios, :android, :desktop, or nil in a plain browser. Reads the shell's UA
     # marker, so it's correct even before the JS bridge has booted.
     def native_platform
       Everywhere.native_platform_of(_everywhere_user_agent)
     end
 
+    # True in the Tauri desktop shell. Use it for window chrome — reserving room
+    # for an overlay title bar, say — and for anything that assumes a pointer
+    # and a resizable window.
+    def desktop_app?
+      native_platform == :desktop
+    end
+
+    # True in the iOS or Android shell, and the one to reach for when the
+    # affordance is a phone's: safe-area insets, the native tab bar, biometrics,
+    # the OAuth handoff. Mirrors the bridge's `Everywhere.platform === "mobile"`.
+    def mobile_app?
+      !mobile_platform.nil?
+    end
+
+    # :ios, :android, or nil (including in the desktop shell).
+    def mobile_platform
+      Everywhere.mobile_platform_of(_everywhere_user_agent)
+    end
+
     # The shell's version as a Gem::Version (from the "RubyEverywhere/<ver>"
     # UA prefix), or nil outside the shell / when unparseable. Use it to gate
     # features that need a newer shell than some users have installed.
@@ -49,8 +76,11 @@ module Everywhere
     #   redirect_to everywhere_auth_redirect(after_authentication_url)
     #
     # `to` may be a full URL or a path; only the same-origin path is forwarded.
+    # mobile_app?, not native_app?: the reset page exists to rebuild a phone
+    # shell's web views and re-fetch its tab bar. The desktop shell has neither,
+    # so a plain redirect is both correct and what it already did.
     def everywhere_auth_redirect(to)
-      return to unless native_app? && respond_to?(:everywhere_reset_path)
+      return to unless mobile_app? && respond_to?(:everywhere_reset_path)
 
       path = to.to_s.sub(%r{\Ahttps?://[^/]+}, "")
       path = "/" if path.empty? || !path.start_with?("/")
@@ -104,7 +134,10 @@ module Everywhere
                                   wrapper_class: nil, locked_class: nil,
                                   message_class: nil, unlock_class: nil, &block)
       content = respond_to?(:capture) ? capture(&block) : block.call
-      return content unless native_app?
+      # mobile_app?: there's no Face ID on the desktop shell, so emitting the
+      # locked wrapper there would hide the content behind an unlock nothing can
+      # satisfy. Browsers and the desktop shell render it plainly.
+      return content unless mobile_app?
 
       attrs = [%(data-everywhere-biometric-lock="#{_everywhere_attr(name)}")]
       attrs << %(data-everywhere-biometric-reason="#{_everywhere_attr(reason)}") if reason

data/lib/everywhere/paths.rb

@@ -12,24 +12,28 @@ module Everywhere
       File.expand_path("../..", __dir__)
     end
 
-    # The generic Tauri shell bundled inside the gem: support/shell/ holds the
-    # src-tauri app and the splash/ dir it serves. This is the CANONICAL copy of
-    # the shell — external consumers (e.g. the build-runner repo) resolve it via
+    # The generic Tauri shell bundled inside the gem: support/desktop/ holds the
+    # src-tauri app and the splash/ dir it serves, alongside support/mobile/ios
+    # and support/mobile/android. This is the CANONICAL copy of the shell —
+    # external consumers (e.g. the build-runner repo) resolve it via
     # `every shell-dir`. The CLI uses it unless the caller passes --shell-dir.
-    def bundled_shell_dir
-      File.join(gem_root, "support", "shell", "src-tauri")
+    #
+    # The directory is named for the platform; the reader keeps the "shell"
+    # wording because that's what the flag, the command and every caller call it.
+    def bundled_desktop_dir
+      File.join(gem_root, "support", "desktop", "src-tauri")
     end
 
     # Absolute path to the shell's src-tauri directory, or nil if the bundled
     # copy is missing (a corrupt/partial install).
     def shell_dir
-      bundled_shell_dir if File.exist?(File.join(bundled_shell_dir, "tauri.conf.json"))
+      bundled_desktop_dir if File.exist?(File.join(bundled_desktop_dir, "tauri.conf.json"))
     end
 
     # Like #shell_dir but aborts with a helpful message when the shell is
     # missing. The --shell-dir hint covers dev on a modified shell checkout.
     def shell_dir!
-      shell_dir or UI.die!("couldn't find the bundled shell at #{bundled_shell_dir}; " \
+      shell_dir or UI.die!("couldn't find the bundled shell at #{bundled_desktop_dir}; " \
                            "reinstall ruby_everywhere or pass --shell-dir")
     end
 
@@ -126,10 +130,57 @@ module Everywhere
       File.join(cache_dir, "android-fonts")
     end
 
-    # Where cargo writes the shell's build output (CARGO_TARGET_DIR). Redirected
-    # here so cargo never dumps a multi-GB target/ into the installed gem, and so
-    # the shell compiles warm across projects — the shell source is identical for
-    # everyone, so one shared target dir is safe to reuse.
+    # The stamped copy of the Tauri shell for one app, keyed by bundle id.
+    # Only apps that declare `native.desktop` get one — everyone else compiles
+    # the gem's own copy, which is identical for them and stays warm across
+    # projects (see cargo_target_dir). Persistent for the same reason the mobile
+    # work dirs are: cargo's incremental state lives inside it, and a cold Tauri
+    # build is minutes where a warm one is seconds.
+    def desktop_work_dir(bundle_id)
+      File.join(cache_dir, "desktop", bundle_id)
+    end
+
+    # CARGO_TARGET_DIR for a stamped shell. Per-app rather than shared, because
+    # the whole point of stamping is that this app's crate graph differs from
+    # every other app's — pointing them at one target dir would make cargo
+    # rebuild the world on every alternating build.
+    def desktop_target_dir(bundle_id)
+      File.join(cache_dir, "desktop-target", bundle_id)
+    end
+
+    # Where `every dev` keeps the throwaway .app wrapper it runs the shell
+    # inside. macOS reads the application name from CFBundleName, so a bare
+    # `cargo run` binary shows up as the crate name — "example-shell" — in the
+    # menu bar, the About/Hide/Quit items and the Dock. The wrapper exists only
+    # to carry an Info.plist; the binary inside it is a hard link to cargo's.
+    def desktop_dev_app_dir(bundle_id)
+      File.join(cache_dir, "desktop-app", bundle_id)
+    end
+
+    # Where `every dev` stages the app's Dock icon for the running shell. The
+    # shaped master is derived from app.icon, so it's a build product, not the
+    # app's own file — it belongs in the cache next to the rest of them.
+    def desktop_icon_dir(bundle_id)
+      File.join(cache_dir, "desktop-icon", bundle_id)
+    end
+
+    # Where `every dev` stages native/desktop/assets for the running shell.
+    # A staged copy rather than the source tree on purpose: the packaged app
+    # reads ONE flat Resources/assets folder, and pointing dev at the nested
+    # source would quietly resolve assets/branding/logo.png in a build and not
+    # in dev. Staging runs the same DesktopAssets compiler both ways, so the two
+    # can't drift. Keyed by bundle id like the mobile work dirs.
+    def desktop_assets_dir(bundle_id)
+      File.join(cache_dir, "desktop-assets", bundle_id)
+    end
+
+    # Where cargo writes the shell's build output (CARGO_TARGET_DIR) for apps on
+    # the fast path — the ones that declare no `native.desktop`. Redirected here
+    # so cargo never dumps a multi-GB target/ into the installed gem, and so the
+    # shell compiles warm across projects: with no app Rust in it the shell
+    # source really is identical for everyone, so one shared target dir is safe
+    # to reuse. An app that declares extensions gets desktop_target_dir instead,
+    # because that premise stops holding the moment its crate graph differs.
     def cargo_target_dir
       File.join(cache_dir, "shell-target")
     end

data/lib/everywhere/relay.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "console"
+require_relative "line_pump"
+require_relative "ui"
+
+module Everywhere
+  # Reads one child's output off a pty and republishes it, one whole line at a
+  # time, tagged with its source.
+  #
+  # `every dev` used to hand the dev server and desktop shell its own stdout and
+  # let them write straight to the terminal. That made two things impossible:
+  # telling which of four concurrent things printed a line, and keeping anything
+  # pinned to the bottom of the screen. Relaying costs a thread per child and
+  # buys both.
+  #
+  # The full raw stream is also tee'd to a log file, matching what the builders
+  # already do with dist/ios-build.log — so nothing a filter hides is lost.
+  class Relay
+    CHUNK = 4096
+    POLL = 0.1
+
+    # on_line: an optional callback given every settled line before filtering.
+    # `every dev` uses it to notice the moment cargo actually starts the desktop
+    # shell — there is no other signal that the build turned into a running app.
+    def initialize(io, source:, log: nil, filter: nil, on_line: nil)
+      @io = io
+      @source = source
+      @filter = filter
+      @on_line = on_line
+      @log = log && File.open(log, "w")
+    end
+
+    # Blocking; run it in a thread. Returns when the child closes the pty.
+    def run
+      Console.tag = @source
+      pump = LinePump.new
+      loop do
+        if @io.wait_readable(POLL)
+          chunk = @io.read_nonblock(CHUNK, exception: false)
+          break if chunk.nil? # EOF
+
+          publish(pump << chunk) unless chunk == :wait_readable
+        else
+          publish(pump.flush_idle)
+        end
+      end
+      publish(pump.drain)
+    rescue Errno::EIO, IOError, Errno::EBADF
+      # A pty master raises EIO (not EOF) once the last slave closes, which is
+      # simply how a child exiting looks from this side.
+      publish(pump.drain) if pump
+    ensure
+      @log&.close
+      begin
+        @io.close
+      rescue StandardError
+        nil
+      end
+    end
+
+    private
+
+    def publish(lines)
+      lines.each do |line|
+        @log&.puts(line)
+        @on_line&.call(line)
+        shown = @filter ? @filter.call(line) : line
+        case shown
+        when :drop, false then nil
+        when nil          then Console.puts("    #{UI.gray(UI.short_path(line))}")
+        else                   Console.puts(shown)
+        end
+      end
+    end
+  end
+end

data/lib/everywhere/shellout.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "ui"
+require_relative "console"
+require_relative "child_processes"
 
 module Everywhere
   # All external commands (tebako, cargo, the app's own bin/dev) run outside
@@ -8,27 +10,57 @@ module Everywhere
   module Shellout
     module_function
 
-    def unbundled(&block)
-      defined?(Bundler) ? Bundler.with_unbundled_env(&block) : yield
+    # The environment a child should get: this gem's bundle stripped back out,
+    # plus the caller's overrides.
+    #
+    # This is handed to spawn as its env argument rather than swapped into ENV,
+    # which is what Bundler.with_unbundled_env does (ENV.replace, twice, around
+    # the block). That is process-global mutable state, and `every dev` now runs
+    # the iOS and Android builds concurrently: two overlapping swaps race so that
+    # one child inherits the CLI's bundle after all — the exact thing unbundling
+    # exists to prevent — and ENV is left wrong for the rest of the session.
+    #
+    # A nil value tells spawn to REMOVE that key, which is most of what
+    # unbundling is. The resulting child environment is identical to what
+    # with_unbundled_env produced, since Bundler.unbundled_env is derived from
+    # the snapshot taken before Bundler was activated either way.
+    def child_env(overrides = {})
+      base = unbundled_base
+      delta = {}
+      ENV.each_key { |key| delta[key] = nil unless base.key?(key) }
+      base.each { |key, value| delta[key] = value unless ENV[key] == value }
+      delta.merge(overrides.transform_keys(&:to_s))
+    end
+
+    # Bundler.unbundled_env derives from `original_env`, a snapshot frozen at
+    # load time, so this is genuinely constant for the life of the process.
+    def unbundled_base
+      @unbundled_base ||= defined?(Bundler) ? Bundler.unbundled_env : ENV.to_h
     end
 
     def run!(env, *cmd, chdir: Dir.pwd)
-      success = unbundled { system(env, *cmd, chdir: chdir) }
+      success = system(child_env(env), *cmd, chdir: chdir)
       UI.die!("command failed: #{cmd.join(" ")}") unless success
     end
 
+    # quiet also detaches stdin. A quiet command is by definition one that has
+    # nothing to say to the terminal, and `every dev` reads single keystrokes
+    # from that same terminal — a child left holding stdin silently eats the
+    # keypresses the menu is waiting on.
     def run?(*cmd, chdir: Dir.pwd, quiet: false)
       opts = { chdir: chdir }
-      opts.update(out: File::NULL, err: File::NULL) if quiet
-      unbundled { system(*cmd, **opts) }
+      opts.update(in: File::NULL, out: File::NULL, err: File::NULL) if quiet
+      system(child_env, *cmd, **opts)
     end
 
     # Run a command and capture its combined stdout+stderr. Returns
     # [output_string, Process::Status]. For probing tool output (codesign,
-    # stapler, notarytool) rather than driving a build.
+    # stapler, notarytool) rather than driving a build. A leading Hash is env
+    # overrides, matching Open3's own convention.
     def capture(*cmd)
       require "open3"
-      unbundled { Open3.capture2e(*cmd) }
+      overrides = cmd.first.is_a?(Hash) ? cmd.shift : {}
+      Open3.capture2e(child_env(overrides), *cmd)
     rescue Errno::ENOENT
       ["", nil]
     end
@@ -40,18 +72,32 @@ module Everywhere
     # prettify what a human sees; the on-disk log always gets the raw stream, so
     # nothing is lost. Unrecognized lines (filter returns nil) are shown dimmed
     # and indented so they read as background detail under the current step.
+    #
+    # The signature is deliberately unchanged: the builder tests stub this with
+    # fixed-signature lambdas, and cancellation is wired up out of band through
+    # ChildProcesses instead.
     def run_logged!(env, cmd, log:, filter: nil)
       require "open3"
       success = false
-      unbundled do
-        File.open(log, "w") do |logf|
-          Open3.popen2e(env, *cmd) do |stdin, out, wait|
-            stdin.close
+      File.open(log, "w") do |logf|
+        # Inside an `every dev` worker the build leads its own process group,
+        # for two reasons: a Ctrl-C at the terminal no longer reaches
+        # xcodebuild/gradlew behind the CLI's back (the CLI decides when a build
+        # dies), and teardown can TERM the whole compile tree with one signal.
+        # Outside dev this stays off, so Ctrl-C during `every build` still stops
+        # the compiler as it always has.
+        opts = ChildProcesses.isolated? ? { pgroup: true } : {}
+        Open3.popen2e(child_env(env), *cmd, **opts) do |stdin, out, wait|
+          stdin.close
+          ChildProcesses.track(wait.pid)
+          begin
             out.each_line do |raw|
               logf.write(raw)
               emit(raw, filter)
             end
             success = wait.value.success?
+          ensure
+            ChildProcesses.untrack(wait.pid)
           end
         end
       end
@@ -61,13 +107,13 @@ module Everywhere
     # Route one raw line to the console: verbatim when there's no filter, else
     # the filter's rendition (:drop swallows it, nil falls back to dim detail).
     def emit(raw, filter)
-      return $stdout.print(raw) unless filter
+      return Console.print(raw) unless filter
 
       shown = filter.call(raw)
       case shown
       when :drop, false then nil
-      when nil          then $stdout.puts("    #{UI.gray(UI.short_path(raw.rstrip))}")
-      else                   $stdout.puts(shown)
+      when nil          then Console.puts("    #{UI.gray(UI.short_path(raw.rstrip))}")
+      else                   Console.puts(shown)
       end
     end
     private_class_method :emit
@@ -75,7 +121,36 @@ module Everywhere
     # pgroup: the child leads its own process group so teardown can TERM the
     # whole tree (foreman + watchers) without signalling the CLI itself.
     def spawn(env, cmd, chdir:)
-      unbundled { Process.spawn(env, cmd, chdir: chdir, pgroup: true) }
+      Process.spawn(child_env(env), cmd, chdir: chdir, pgroup: true)
+    end
+
+    # Same, but on a pseudo-terminal, returning [master_io, pid].
+    #
+    # `every dev` relays the dev server's and desktop shell's output itself so
+    # it can tag each line with its source and keep the dock pinned at the
+    # bottom. A plain pipe would work, but the children would see a non-TTY and
+    # foreman, cargo and friends would drop their colors and progress output; on
+    # a pty they behave exactly as they do when you run them by hand.
+    #
+    # PTY.spawn calls setsid, so the child leads its own session: a terminal
+    # SIGINT can't reach it, and Process.kill("TERM", -pid) still takes down the
+    # whole tree.
+    def spawn_pty(env, cmd, chdir:)
+      require "pty"
+      # PTY.spawn hands back the read and write ends of the pty MASTER. We never
+      # forward stdin, so the write end is closed immediately — the child keeps
+      # running because the read end still holds the master open.
+      reader, writer, pid = PTY.spawn(child_env(env), cmd, chdir: chdir)
+      writer.close
+      [reader, pid]
+    end
+
+    # PTY is POSIX-only. Callers fall back to spawn + inherited fds.
+    def pty?
+      require "pty"
+      true
+    rescue LoadError
+      false
     end
   end
 end

data/lib/everywhere/task_pool.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "console"
+require_relative "child_processes"
+
+module Everywhere
+  # Named background tasks for the `every dev` key loop.
+  #
+  # Three guarantees, each of which fixes a specific way the old synchronous
+  # command misbehaved:
+  #
+  #   * At most one live task per name. Pressing `i` twice must not run two
+  #     iOS builds over the same staged work dir, which Builders::Ios rm_rf's
+  #     and re-copies on every run.
+  #   * No task failure can reach the main thread. A Swift compile error used to
+  #     unwind through the key loop into Dev#call's `ensure teardown` and take
+  #     the Rails server down with it.
+  #   * Every task is cancellable. Its children lead their own process groups
+  #     and are TERMed (then KILLed) at shutdown.
+  class TaskPool
+    # A task's failure is data, not control flow — hence `rescue Exception`, one
+    # of the few places it is the correct choice. MRI enqueues a SystemExit that
+    # escapes a non-main thread onto the MAIN thread and re-raises it there,
+    # wherever that thread happens to be. Since UI.die! raises Everywhere::Fatal
+    # (a SystemExit), `rescue StandardError` here would leave the original bug
+    # fully intact, just relocated. Verified:
+    #
+    #   ruby -e 'Thread.new { raise SystemExit.new(2) }; sleep 1; puts "alive"'
+    #   # => exits 2, never prints
+    GRACE = 5
+
+    def initialize(on_error: nil)
+      @lock = Mutex.new
+      @threads = {}
+      @failed = []
+      @stopping = false
+      @on_error = on_error
+    end
+
+    # :started, :busy or :stopping.
+    def start(name, &block)
+      @lock.synchronize do
+        return :stopping if @stopping
+        return :busy if @threads[name]&.alive?
+
+        @threads[name] = spawn_worker(name, &block)
+        retag
+        :started
+      end
+    end
+
+    def busy?(name) = @lock.synchronize { !!@threads[name]&.alive? }
+
+    def failed = @lock.synchronize { @failed.dup }
+
+    def any_running? = @lock.synchronize { @threads.each_value.any?(&:alive?) }
+
+    # Join every live task. Used by the headless path, where there is no key
+    # loop to keep the process alive and a failed build still has to be news.
+    def wait_all
+      loop do
+        live = @lock.synchronize { @threads.each_value.select(&:alive?) }
+        break if live.empty?
+
+        live.each(&:join)
+      end
+      Console.multiplexed = false
+    end
+
+    # Kill the tasks' children first, then the threads. Ordering matters: a
+    # worker blocked reading a build's output only unwinds once that build is
+    # gone, so signalling the children is what actually makes the joins return.
+    def shutdown(grace: GRACE)
+      live = @lock.synchronize do
+        @stopping = true
+        @threads.each_value.select(&:alive?)
+      end
+      return if live.empty?
+
+      live.each { |thread| ChildProcesses.terminate(thread, grace: grace) }
+      deadline = now + grace
+      live.each { |thread| thread.join([deadline - now, 0].max) }
+      live.select(&:alive?).each(&:kill)
+      Console.multiplexed = false
+    end
+
+    private
+
+    # Called while holding @lock; the new thread also takes @lock in its ensure.
+    # That is not a deadlock — the worker simply blocks until start returns —
+    # but it is why these two must not be collapsed into one synchronize block.
+    def spawn_worker(name, &block)
+      Thread.new do
+        # Set from inside the thread, as its first statement: assigning it after
+        # Thread.new returns races a task that fails immediately.
+        Thread.current.name = name.to_s
+        Thread.current.report_on_exception = false
+        Console.tag = name
+        ChildProcesses.isolate!
+
+        begin
+          block.call
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          stopping = @lock.synchronize { @failed << name; @stopping }
+          @on_error&.call(name, e, stopping)
+        ensure
+          @lock.synchronize { retag }
+        end
+      end
+    end
+
+    # Tag output by source only while two or more tasks are live: with one build
+    # running, the output is exactly what it has always been. Thread.current is
+    # excluded because a worker calling this from its own ensure is still
+    # #alive? and would keep tagging on for the task that just finished.
+    def retag
+      live = @threads.each_value.count { |t| t.alive? && t != Thread.current }
+      Console.multiplexed = live > 1
+    end
+
+    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end