expect-pty 0.2.0 → 0.3.0

data/lib/expect/{engine.rb → matcher.rb}

@@ -2,7 +2,7 @@
 
 class Expect
   # 驱动一次单会话或多会话匹配，管理模式优先级、EOF 和共享期限，不接管 IO 所有权。
-  class Engine
+  class Matcher
     # 固定本次参与的会话及初始期限；已处理 EOF 的会话仅从本次等待中移除。
     def initialize(patterns, timeout)
       @patterns = patterns
@@ -10,12 +10,24 @@ class Expect
       @timeout = Expect.duration(timeout)
       @deadline = next_deadline
       @handled_eof = []
+      @stalled_matches = {}
       @polled = false
     end
 
     # 运行匹配状态机；内部 :retry 表示继续循环，最终返回一个 Result。
     def run
-      @sessions.each { |session| session.__send__(:reset_result) }
+      @relay_buffers = {}
+      @sessions.each do |session|
+        buffer = session.__send__(:interaction_buffer)
+        if buffer
+          # 转义回调中的显式匹配临时接管读取，先消费转接已经预读的尾部。
+          @relay_buffers[session] = buffer
+          session.__send__(:interaction_buffer=, nil)
+          session.__send__(:restore_relay_buffer, buffer)
+          buffer.clear
+        end
+        session.__send__(:reset_result)
+      end
       loop do
         # 先消费已缓冲的匹配，再处理 EOF，最后读取；避免进程退出时丢失最后一个匹配。
         result = if (matched = find_match)
@@ -27,6 +39,11 @@ class Expect
                  end
         return result unless result == :retry
       end
+    ensure
+      @relay_buffers.each do |session, buffer|
+        buffer.replace(session.clear_buffer)
+        session.__send__(:interaction_buffer=, buffer)
+      end
     end
 
     private
@@ -38,8 +55,15 @@ class Expect
           next if @handled_eof.include?(session)
 
           buffer = session.buffer
+          stalled = @stalled_matches[session]
+          if stalled && stalled[:buffer] != buffer
+            @stalled_matches.delete(session)
+            stalled = nil
+          end
           patterns.each do |pattern|
-            position = pattern.locate(buffer)
+            next if stalled && stalled[:patterns].include?(pattern)
+
+            position = pattern.locate(buffer, final: session.eof?)
             return [session, pattern, position] if position
           end
         end
@@ -49,12 +73,17 @@ class Expect
 
     # 先记录并消费匹配，再执行回调；回调可选择结束、重置期限或保留期限继续。
     def handle_match(session, pattern, position)
+      previous_buffer = session.buffer
       result = session.__send__(:record_match, pattern, position)
       action = pattern.call(session)
       return result unless continuing?(action)
 
+      # 回调未改变缓冲时暂停当前模式，等待缓冲变化后再匹配，避免原地空转。
+      if session.buffer == previous_buffer
+        stalled = (@stalled_matches[session] ||= { buffer: previous_buffer, patterns: [] })
+        stalled[:patterns] << pattern
+      end
       @deadline = next_deadline if action == CONTINUE
-      # 零宽匹配可能不消费字节，必须在继续回调后检查期限，避免只匹配缓冲而永久空转。
       return handle_timeout if action == CONTINUE_WITHOUT_RESET && expired?
 
       :retry
@@ -100,12 +129,14 @@ class Expect
       readable.each do |io|
         session = sessions.find { |candidate| candidate.to_io.equal?(io) }
         begin
-          data = session.__send__(:read_available)
+          # 转接回调消费匹配内容，余下字节交回 Relay，不能在这里提前转发两次。
+          data = session.__send__(:read_available, propagate: !@relay_buffers.key?(session))
         rescue Errno::EINTR
           next
         rescue IOError, SystemCallError => error
           return session.__send__(:record_error, error)
         end
+        @stalled_matches.delete(session) if data
         @deadline = next_deadline if data && session.reset_timeout_on_read?
       end
       :retry
@@ -113,12 +144,16 @@ class Expect
 
     # 返回本次仍需监听的会话，供读取选择和超时回调使用。
     def active_sessions = @sessions.reject { |session| @handled_eof.include?(session) }
+
     # 只有约定的继续符号会驱动下一轮，普通回调返回值不会改变等待流程。
     def continuing?(action) = [CONTINUE, CONTINUE_WITHOUT_RESET].include?(action)
+
     # 使用单调时钟计算期限；nil 一直表示无限等待，不受系统时间调整影响。
     def next_deadline = @timeout && (Expect.monotonic + @timeout)
+
     # 计算传给 select 的非负等待秒数，避免计时跨过边界时产生负数。
     def remaining = @deadline && [@deadline - Expect.monotonic, 0].max
+
     # 判断有限期限是否已到达；无限等待不会触发超时。
     def expired? = @deadline && Expect.monotonic >= @deadline
 

data/lib/expect/pattern.rb

@@ -12,7 +12,7 @@ class Expect
     def eof? = value == :eof
 
     # 在缓冲中定位字符串或正则，返回 [字节偏移, 字节长度, 捕获组]；事件或未匹配返回 nil。
-    def locate(buffer)
+    def locate(buffer, final: false)
       case value
       when String
         offset = buffer.index(value)
@@ -21,8 +21,9 @@ class Expect
         text = buffer.dup
         text.force_encoding(value.encoding) if value.fixed_encoding?
         unless text.valid_encoding?
-          # 一次读取可能截断 UTF-8 字符。仅对完整前缀做本轮匹配，原缓冲保留残片等待后续字节。
-          text = complete_prefix(text)
+          # 不完整的尾字符可能改变锚点或前瞻结果，必须等字符收齐后再匹配。
+          validate_incomplete_suffix!(text, final: final)
+          return nil
         end
         found = value.match(text)
         return unless found
@@ -37,24 +38,15 @@ class Expect
     private
 
     # 仅容忍末尾尚未收全的 UTF-8 字符，其他非法编码直接报错，不静默替换接收字节。
-    def complete_prefix(text)
-      if text.encoding == Encoding::UTF_8
-        # UTF-8 字符最多四字节，不完整后缀最多三字节。逐一验证头字节、续字节及剩余前缀。
-        1.upto([3, text.bytesize].min) do |length|
-          prefix = text.byteslice(0, text.bytesize - length)
-          suffix = text.byteslice(text.bytesize - length, length).b
-          lead = suffix.getbyte(0)
-          expected = case lead
-                     when 0xC2..0xDF then 2
-                     when 0xE0..0xEF then 3
-                     when 0xF0..0xF4 then 4
-                     end
-          if expected && length < expected && suffix.bytes.drop(1).all? do |byte|
-            (0x80..0xBF).cover?(byte)
-          end && prefix.valid_encoding?
-            return prefix
-          end
+    def validate_incomplete_suffix!(text, final:)
+      if !final && text.encoding == Encoding::UTF_8
+        incomplete = begin
+          text.encode(Encoding::UTF_16LE)
+          false
+        rescue Encoding::InvalidByteSequenceError => error
+          error.incomplete_input?
         end
+        return if incomplete
       end
       raise EncodingError, "received invalid #{text.encoding} data; use a binary regexp (/.../n) for binary streams"
     end

data/lib/expect/relay.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+class Expect
+  # 一次转接的共同读写循环；发送游标留在源会话中，调用结束后仍可继续。
+  class Relay
+    def initialize(sessions, timeout)
+      @sessions = sessions.uniq
+      @active = @sessions.dup
+      period = Expect.duration(timeout)
+      @deadline = period && (Expect.monotonic + period)
+      @buffers = @sessions.to_h { |session| [session, session.clear_buffer] }
+      @previous = @sessions.to_h { |session| [session, session.__send__(:interaction_buffer)] }
+    end
+
+    def run
+      @sessions.each { |session| session.__send__(:interaction_buffer=, @buffers.fetch(session)) }
+      outputs.each(&:restart_timeout)
+      polled = false
+      loop do
+        idle = []
+        queued = false
+        @active.dup.each do |session|
+          next if session.pending_output?
+
+          if (callback = session.__send__(:relay_callback))
+            session.__send__(:relay_callback=, nil)
+            return session unless callback.first&.call
+          end
+
+          result = Expect.__send__(:relay_buffer, session, @buffers, final: session.eof?) do |data|
+            session.__send__(:queue_output, data)
+          end
+          return session unless result
+
+          if result == :pending
+            queued = true
+            next
+          end
+
+          idle << session
+          next unless session.eof?
+
+          callback = session.__send__(:sequences)[:eof]
+          return session unless callback&.call
+
+          @active.delete(session)
+        end
+        return nil if @active.empty?
+
+        return finish_timeout(idle) if polled && expired?
+
+        progress = advance_outputs || queued
+
+        pending = outputs
+        readers = read_sources(pending)
+        deadlines = [@deadline, *pending.map(&:deadline)].compact
+        remaining = deadlines.empty? ? nil : [deadlines.min - Expect.monotonic, 0].max
+        # 有进展时轮询输入再继续发送，避免大块输出饿死其他来源。
+        remaining = 0 if progress
+        begin
+          polled = true
+          ready = IO.select(readers.map(&:to_io), pending.filter_map(&:io).uniq, nil, remaining)
+          if ready
+            readers.each do |session|
+              next unless ready[0].include?(session.to_io)
+
+              begin
+                if @buffers.key?(session)
+                  session.__send__(:read_available, propagate: false, buffer: @buffers.fetch(session))
+                else
+                  session.__send__(:read_available, propagate: false)
+                end
+              rescue Errno::EINTR
+                next
+              end
+            end
+          elsif !progress
+            return finish_timeout(idle) if expired?
+
+            pending.each(&:check_timeout!)
+          end
+        rescue Errno::EINTR
+          next
+        end
+      end
+    ensure
+      @previous.each { |session, buffer| session.__send__(:interaction_buffer=, buffer) }
+      @buffers.each { |session, buffer| session.__send__(:restore_relay_buffer, buffer) }
+    end
+
+    private
+
+    def outputs = @sessions.flat_map { |session| session.__send__(:relay_outputs) }.reject(&:done?)
+
+    def advance_outputs(check_timeout: true)
+      progress = false
+      @sessions.each do |session|
+        pending = session.__send__(:relay_outputs)
+        pending.each { |output| progress = output.advance(check_timeout: check_timeout) || progress }
+        pending.reject!(&:done?)
+      end
+      progress
+    end
+
+    def expired? = @deadline && Expect.monotonic >= @deadline
+
+    def read_sources(pending)
+      # 输出目标可能也在等待我们读取；这些来源即使有待发送数据也必须继续排空。
+      targets = pending.map(&:target).grep(Expect)
+      sources = @active.reject { |session| session.pending_output? && !targets.include?(session) }
+      (sources + targets).uniq(&:to_io).reject(&:eof?)
+    end
+
+    def finish_timeout(idle)
+      # 调度延迟可能让两种期限均已到达，仍按先到的期限决定结果。
+      outputs.each { |output| output.check_timeout! if output.deadline && output.deadline < @deadline }
+      idle.each do |session|
+        next if session.pending_output?
+
+        buffer = @buffers.fetch(session)
+        next if buffer.empty?
+
+        session.__send__(:queue_output, buffer.dup)
+        buffer.clear
+      end
+      # 到期后只尝试一次非阻塞写入，剩余游标留给下一次 interconnect。
+      advance_outputs(check_timeout: false)
+      nil
+    end
+  end
+
+  private_constant :Relay
+end

data/lib/expect/relay_writer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Expect
+  # 向单个转接目标写入数据，维护发送进度与期限；恢复时不重放已成功写出的前缀。
+  class RelayWriter
+    attr_reader :target, :deadline
+
+    def initialize(target, data)
+      @target = target
+      @data = data
+      @offset = 0
+      @flushed = false
+      restart_timeout
+    end
+
+    def restart_timeout
+      period = target.write_timeout if target.is_a?(Expect)
+      @deadline = period && (Expect.monotonic + period)
+    end
+
+    def io
+      return target.writer if target.is_a?(Expect)
+
+      target if target.is_a?(IO)
+    end
+
+    def done? = @offset == @data.bytesize && @flushed
+
+    # 每轮每目标至多一次写入；真实 IO 永不在此等待，交给 Relay 的共同 select。
+    def advance(check_timeout: true)
+      return false if done?
+      raise IOError, "closed Expect session" if target.is_a?(Expect) && target.closed?
+
+      if @offset < @data.bytesize
+        bytes = @data.byteslice(@offset, READ_SIZE)
+        count = io ? io.write_nonblock(bytes, exception: false) : target.write(bytes)
+        if count == :wait_writable
+          check_timeout! if check_timeout
+          return false
+        end
+        unless count.is_a?(Integer) && count.positive? && count <= bytes.bytesize
+          raise IOError, "write must return the number of accepted bytes"
+        end
+
+        @offset += count
+      end
+      if @offset == @data.bytesize
+        # write_nonblock 已直接写到底层；普通 write 对象仍遵守自身 flush 协议。
+        target.flush if !io && target.respond_to?(:flush)
+        @flushed = true
+      end
+      true
+    rescue Errno::EINTR
+      check_timeout! if check_timeout
+      true
+    end
+
+    def check_timeout!
+      return unless deadline && Expect.monotonic >= deadline
+
+      raise WriteTimeout.new("relay target write timed out", bytes_written: @offset)
+    end
+  end
+
+  private_constant :RelayWriter
+end

data/lib/expect/result.rb

@@ -6,8 +6,10 @@ class Expect
   Result = Struct.new(:number, :error, :match, :before, :after, :session, :captures, keyword_init: true) do
     # 是否命中文本模式；事件不会返回模式序号。
     def matched? = !number.nil?
+
     # 是否因本次等待期限到达而返回。
     def timeout? = error == :timeout
+
     # 是否读取源已经结束；子进程是否退出仍应查询会话的 process_status。
     def eof? = error == :eof
   end

data/lib/expect/{resources.rb → session_resources.rb}

@@ -2,8 +2,8 @@
 
 class Expect
   # 独立保存句柄、PID 和日志所有权，让终结器无需直接捕获会话即可清理遗弃资源。
-  class Resources
-    attr_accessor :pid, :status, :log, :own_log
+  class SessionResources
+    attr_accessor :pid, :status, :owned_log
     attr_reader :reader, :writer, :slave, :owner, :own
 
     # 记录创建资源的进程；fork 后的副本不能向父进程拥有的子进程发信号。
@@ -43,7 +43,7 @@ class Expect
       return unless owner == Process.pid
 
       close_handles
-      log.close if own_log && log && !log.closed?
+      owned_log.close if owned_log && !owned_log.closed?
       reap
       return unless pid
 

data/lib/expect/version.rb

@@ -2,5 +2,5 @@
 
 class Expect
   # Gem 与库共用的版本号；独立文件使 gemspec 无需加载完整会话实现。
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/expect.rb

@@ -9,10 +9,10 @@ require "forwardable"
 require_relative "expect/version"
 require_relative "expect/configuration"
 require_relative "expect/result"
-require_relative "expect/resources"
+require_relative "expect/session_resources"
 require_relative "expect/pattern"
 require_relative "expect/pattern_list"
-require_relative "expect/engine"
+require_relative "expect/matcher"
 
 # 自动化交互会话：可以拥有一个 PTY 子进程，也可以适配已有可 select 的 IO。
 # 缓冲和匹配统一保留原始字节，配置、匹配结果与资源生命周期分别管理。
@@ -23,7 +23,16 @@ class Expect
   READ_SIZE = 16_384
 
   class SpawnError < StandardError; end
-  class WriteTimeout < IOError; end
+
+  # 已被底层接受的字节不可撤回；调用方可据此只处理尚未写出的后缀。
+  class WriteTimeout < IOError
+    attr_reader :bytes_written
+
+    def initialize(message = "write timed out", bytes_written: 0)
+      @bytes_written = bytes_written
+      super(message)
+    end
+  end
 
   class << self
     # 读取冻结的默认配置；子类未单独配置时继承父类快照。
@@ -78,6 +87,7 @@ class Expect
 
     # 返回继续等待的控制符，reset_timeout 决定是否重新计算匹配期限。
     def continue(reset_timeout: true) = reset_timeout ? CONTINUE : CONTINUE_WITHOUT_RESET
+
     # 读取不受系统时间调整影响的单调时钟，所有相对超时共用此计时基准。
     def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
@@ -99,7 +109,20 @@ class Expect
       active = sessions.uniq.reject(&:closed?)
       return [] if active.empty?
 
-      ready = IO.select(active.map(&:to_io), nil, nil, timeout)
+      deadline = timeout && (monotonic + timeout)
+      polled = false
+      ready = nil
+      loop do
+        remaining = deadline && [deadline - monotonic, 0].max
+        return [] if polled && remaining&.zero?
+
+        begin
+          ready = IO.select(active.map(&:to_io), nil, nil, remaining)
+          break
+        rescue Errno::EINTR
+          polled = true
+        end
+      end
       return [] unless ready
 
       active.select { |session| ready.first.include?(session.to_io) }
@@ -116,7 +139,7 @@ class Expect
       if block
         block.parameters.empty? ? pattern_list.instance_exec(&block) : block.call(pattern_list)
       end
-      Engine.new(pattern_list.validate!, timeout).run
+      Matcher.new(pattern_list.validate!, timeout).run
     end
   end
 
@@ -214,14 +237,21 @@ class Expect
 
   # 暴露底层读写 IO 与终端属性，供 select、终端设置及 IO 适配使用。
   def to_io = @resources.reader
+
   def writer = @resources.writer
+
   def fileno = closed? ? nil : to_io.fileno
+
   def tty? = !closed? && to_io.tty?
+
   # 诊断时仅显示进程和描述符状态，避免默认对象展开泄露缓冲或日志内容。
   def inspect = "#<#{self.class} pid=#{pid.inspect} fd=#{fileno.inspect} closed=#{closed?}>"
+
   def pid = @resources.pid
+
   # 非阻塞回收并缓存子进程状态；未退出或仅适配 IO 时返回 nil。
   def process_status = @resources.reap
+
   def exit_code = process_status&.exitstatus
 
   # 先刷新回收状态，再判断是否仍有未回收的子进程；不以 IO 是否关闭代替进程状态。
@@ -232,14 +262,22 @@ class Expect
 
   # 区分会话关闭和输入结束，已关闭会话也不能继续读取。
   def closed? = @closed || to_io.closed?
+
   def eof? = @eof || closed?
+
   # 以下访问器读取最近一次等待结果；未发生匹配时捕获组返回空数组。
   def before = @last_result&.before
+
   def after = @last_result&.after
+
   def match = @last_result&.match
+
   def match_number = @last_result&.number
+
   def captures = @last_result&.captures || []
+
   def error = @last_result&.error
+
   # 返回缓冲副本，防止调用方原地修改绕过裁剪规则。
   def buffer = @buffer.dup
 
@@ -263,21 +301,38 @@ class Expect
     raise IOError, "closed Expect session" if closed? || writer.closed?
 
     data = objects.map { |object| object.to_s.b }.join
-    trace("sending #{data.inspect}", level: 2)
+    trace("sending #{data.inspect}", level: 2) if debug_level >= 2
     deadline = write_timeout && (Expect.monotonic + write_timeout)
     offset = 0
     while offset < data.bytesize
-      count = writer.write_nonblock(data.byteslice(offset, READ_SIZE), exception: false)
+      begin
+        count = writer.write_nonblock(data.byteslice(offset, READ_SIZE), exception: false)
+      rescue Errno::EINTR
+        raise WriteTimeout.new(bytes_written: offset) if deadline && Expect.monotonic >= deadline
+
+        next
+      end
       if count == :wait_writable
-        raise WriteTimeout, "write timed out after #{write_timeout} seconds" if deadline && Expect.monotonic >= deadline
+        raise WriteTimeout.new(bytes_written: offset) if deadline && Expect.monotonic >= deadline
 
         remaining = deadline && [deadline - Expect.monotonic, 0].max
         # 子进程也可能因输出管道填满而停止读取；等可写时同时排空它的输出，避免双向死锁。
         readers = eof? ? [] : [to_io]
-        ready = IO.select(readers, [writer], nil, remaining)
-        raise WriteTimeout, "write timed out after #{write_timeout} seconds" unless ready
-
-        read_available if ready[0].include?(to_io)
+        begin
+          ready = IO.select(readers, [writer], nil, remaining)
+          raise WriteTimeout.new(bytes_written: offset) unless ready
+
+          if ready[0].include?(to_io)
+            begin
+              read_available
+            rescue WriteTimeout
+              # 日志或监听器可嵌套写入；对外报告本次写入进度，原异常通过 cause 保留。
+              raise WriteTimeout.new("write interrupted by an output timeout", bytes_written: offset)
+            end
+          end
+        rescue Errno::EINTR
+          next
+        end
       else
         offset += count
       end
@@ -316,7 +371,7 @@ class Expect
   end
 
   # 读取当前日志目标，可能为库打开的文件、借用的 IO、回调或 nil。
-  def log_output = @resources.log
+  attr_reader :log_output
 
   # 替换借用的日志目标或停止日志；先校验新目标，失败时保留旧目标。
   def log_output=(target)
@@ -335,8 +390,8 @@ class Expect
     if target.respond_to?(:to_path) || target.is_a?(String)
       raise ArgumentError, "log mode must be a or w" unless %w[a w].include?(mode)
 
-      # 库打开的文件由 Resources 持有，替换日志或关闭会话时释放；外部 IO 只借用。
-      replace_log(File.open(target, "#{mode}b"), owned: true)
+      # 库打开的文件由 SessionResources 持有，替换日志或关闭会话时释放；外部 IO 只借用。
+      replace_log(File.open(target, "#{mode}b", 0o600), owned: true)
     else
       raise ArgumentError, "provide a log target or a block" unless target
 
@@ -445,6 +500,12 @@ class Expect
     # IO 关闭与进程退出独立记录：软关闭可能已经 closed?，但仍保留活跃 PID。
     @resources.close_handles
     @closed = true
+    @interact_inputs&.each_value { |input| input.close(graceful: false) }
+    @interact_inputs&.clear
+    @interact_output = nil
+    @relay_outputs&.clear
+    @relay_history&.clear
+    @relay_callback = nil
     return process_status unless @resources.owner == Process.pid && pid
     return process_status if wait(timeout: timeout)
 
@@ -464,15 +525,16 @@ class Expect
     raise ArgumentError, "reader must be a real IO" unless reader.is_a?(IO) && !reader.closed?
     raise ArgumentError, "writer must be a real IO" unless writer.is_a?(IO) && !writer.closed?
 
-    @resources = Resources.new(reader, writer: writer, slave: slave, own: own)
+    @resources = SessionResources.new(reader, writer: writer, slave: slave, own: own)
     @pty = reader.tty?
     @slave = slave
     @configuration = Configuration.new(**self.class.configuration.to_h, **)
     @buffer = "".b
     @listeners = []
     @sequences = {}
+    @relay_outputs = []
     @closed = @eof = false
-    ObjectSpace.define_finalizer(self, Resources.finalizer(@resources))
+    ObjectSpace.define_finalizer(self, SessionResources.finalizer(@resources))
   end
 
   # 开始新一轮等待时清除旧结果并应用缓冲上限，尚未消费的输入继续保留。
@@ -505,10 +567,16 @@ class Expect
     @last_result
   end
 
-  # 进行一次非阻塞读取并记录日志；accumulate/propagate 决定是否交给匹配缓冲和监听器。
-  def read_available(propagate: true, accumulate: true)
+  # 先将读取字节交给匹配或转接缓冲，再记录日志；日志失败也能恢复输入。
+  def read_available(propagate: true, buffer: @buffer)
     return nil if eof?
 
+    # 写入背压也会读取；转接期间统一交给转义处理器，不能直接转发或另存匹配缓冲。
+    if @interaction_buffer
+      buffer = @interaction_buffer
+      propagate = false
+    end
+
     begin
       data = to_io.read_nonblock(READ_SIZE, exception: false)
     rescue Errno::EIO
@@ -528,12 +596,10 @@ class Expect
       return nil
     end
     data = data.b
-    if accumulate
-      @buffer << data
-      trim_buffer
-    end
-    trace("received #{data.inspect}", level: 2)
-    trace("buffer #{@buffer.inspect}", level: 3)
+    buffer << data
+    trim_buffer if buffer.equal?(@buffer)
+    trace("received #{data.inspect}", level: 2) if debug_level >= 2
+    trace("buffer #{@buffer.inspect}", level: 3) if debug_level >= 3
     # 仅在真实读取时记录日志，后续匹配或人工转接重用缓冲时不会重复记录。
     write_log(data)
     propagate(data) if propagate
@@ -554,7 +620,15 @@ class Expect
 
   # 向目标写入并在支持时立即 flush，使日志和终端输出及时可见。
   def emit(target, data)
-    target.write(data)
+    offset = 0
+    while offset < data.bytesize
+      count = target.write(data.byteslice(offset..))
+      unless count.is_a?(Integer) && count.positive? && count <= data.bytesize - offset
+        raise IOError, "write must return the number of accepted bytes"
+      end
+
+      offset += count
+    end
     target.flush if target.respond_to?(:flush)
   end
 
@@ -569,9 +643,10 @@ class Expect
     # 重复赋值同一目标时保留原所有权，防止将库打开的文件误变成借用资源。
     return target if previous.equal?(target)
 
-    previous.close if @resources.own_log && previous && !previous.closed?
-    @resources.log = target
-    @resources.own_log = owned
+    previous.close if @resources.owned_log && previous && !previous.closed?
+    # 终结器只持有所属文件；借用回调可能捕获会话，不能让它经资源对象成为 GC 根。
+    @resources.owned_log = owned ? target : nil
+    @log_output = target
     target
   rescue Exception # rubocop:disable Lint/RescueException -- 替换失败时仍释放刚打开的文件。
     target.close if owned && target && !target.closed?
@@ -588,4 +663,4 @@ class Expect
   end
 end
 
-require_relative "expect/interconnect"
+require_relative "expect/interaction"