jrf 0.1.13 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2862eaf6bd5f2486ea2c6aebf5caa4fbc2de56f419625bf8bb462392a3ea5dd9
-  data.tar.gz: 3f29e7024f4e33606d78ad01ce4c45f37c9cd652ba94ac490866cd877368037a
+  metadata.gz: de85d7a03d58baee4c931d10869a824a1ff5c2eec121cd15e63ec23805203676
+  data.tar.gz: ce3c53475e13d41e3a176ef7c9ea840145fbbf826612457386cc0899c28a1af0
 SHA512:
-  metadata.gz: 04f55e0ea8c24f70126964beffbe80bee1800e1e210da2f96186bb8ebdf5542e5dfbab9c06b48624da4ec35912d02456561ec6c0d2c66c094de001ecf7f4096f
-  data.tar.gz: '093821f35539be4561867b711664a31d3441052fe53e1c0f73489cd8b11fdf845bfb5573375f880ce07cd73ffc2f1d0514b55b760227c01ab515afd39d8ac08a'
+  metadata.gz: ded54cff09febe7fe02c585f30a702cd82cd11aeb563f840b9f182cd8a6e94c090ba5e71fbd6cad7f377816c14de41c12f5fed449b2b8f7c1d682513db2f19ee
+  data.tar.gz: bdd4f9ee2ff809cc718b497a39783027f9c7322582dfdaebc8cae8b6bf4cb1d56b9639a356f2239be66b6ee39693c1da994b4fa9b9db5ecfb6c10d66ede021d9

data/lib/jrf/cli/runner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "zlib"
 require_relative "../pipeline"
 require_relative "../pipeline_parser"
 
@@ -9,6 +10,7 @@ module Jrf
     class Runner
       RS_CHAR = "\x1e"
       DEFAULT_OUTPUT_BUFFER_LIMIT = 4096
+      PARALLEL_FRAME_HEADER_BYTES = 4
 
       class RsNormalizer
         def initialize(input)
@@ -19,7 +21,7 @@ module Jrf
           chunk = @input.read(length)
           return nil if chunk.nil?
 
-          chunk = chunk.tr(RS_CHAR, "\n")
+          chunk.tr!(RS_CHAR, "\n")
           if outbuf
             outbuf.replace(chunk)
           else
@@ -28,61 +30,360 @@ module Jrf
         end
       end
 
-      def initialize(inputs:, out: $stdout, err: $stderr, lax: false, output_format: :json, atomic_write_bytes: DEFAULT_OUTPUT_BUFFER_LIMIT)
-        @inputs = inputs
+      class ParallelFrameReader
+        def initialize
+          @buf = +""
+          @offset = 0
+        end
+
+        def append(chunk)
+          @buf << chunk
+        end
+
+        def each_payload
+          while (payload = next_payload)
+            yield payload
+          end
+        end
+
+        def has_partial?
+          @offset != @buf.bytesize
+        end
+
+        private
+
+        def next_payload
+          if @buf.bytesize - @offset < PARALLEL_FRAME_HEADER_BYTES
+            compact!
+            return nil
+          end
+
+          payload_len = @buf.byteslice(@offset, PARALLEL_FRAME_HEADER_BYTES).unpack1("N")
+          frame_len = PARALLEL_FRAME_HEADER_BYTES + payload_len
+          if @buf.bytesize - @offset < frame_len
+            compact!
+            return nil
+          end
+
+          payload = @buf.byteslice(@offset + PARALLEL_FRAME_HEADER_BYTES, payload_len)
+          @offset += frame_len
+          payload
+        end
+
+        def compact!
+          if @offset > 0
+            @buf.slice!(0, @offset)
+            @offset = 0
+          end
+        end
+      end
+
+      def initialize(input: $stdin, out: $stdout, err: $stderr, lax: false, output_format: :json, atomic_write_bytes: DEFAULT_OUTPUT_BUFFER_LIMIT)
+        if input.is_a?(Array)
+          @file_paths = input
+          @stdin = nil
+        else
+          @file_paths = []
+          @stdin = input
+        end
         @out = out
         @err = err
         @lax = lax
         @output_format = output_format
         @atomic_write_bytes = atomic_write_bytes
         @output_buffer = +""
+        @input_errors = false
+      end
+
+      def input_errors?
+        @input_errors
       end
 
-      def run(expression, verbose: false)
+      def run(expression, parallel: 1, verbose: false)
+        blocks = build_stage_blocks(expression, verbose: verbose)
+        if @output_format == :tsv
+          values = []
+          process_values(blocks, parallel: parallel, verbose: verbose) do |value|
+            values << value
+          end
+          emit_tsv(values)
+        else
+          process_values(blocks, parallel: parallel, verbose: verbose) do |value|
+            emit_output(value)
+          end
+        end
+      ensure
+        write_output(@output_buffer)
+      end
+
+      private
+
+      def build_stage_blocks(expression, verbose:)
         parsed = PipelineParser.new(expression).parse
         stages = parsed[:stages]
         dump_stages(stages) if verbose
-
-        blocks = stages.map { |stage|
+        stages.map { |stage|
           eval("proc { #{stage[:src]} }", nil, "(jrf stage)", 1) # rubocop:disable Security/Eval
         }
+      end
+
+      def apply_pipeline(blocks, input_enum)
         pipeline = Pipeline.new(*blocks)
+        Enumerator.new do |y|
+          pipeline.call(input_enum) { |value| y << value }
+        end
+      end
 
-        input_enum = Enumerator.new { |y| each_input_value { |v| y << v } }
+      def each_input_enum
+        Enumerator.new { |y| each_input_value { |v| y << v } }
+      end
 
-        if @output_format == :tsv
-          values = []
-          pipeline.call(input_enum) { |value| values << value }
-          emit_tsv(values)
+      def process_values(blocks, parallel:, verbose:, &block)
+        if parallel <= 1 || @file_paths.length <= 1
+          # Single file or no parallelism requested — serial is the only option.
+          # This also covers the all-files-empty case: no files means no workers to spawn.
+          dump_parallel_status("disabled", verbose: verbose)
+          return apply_pipeline(blocks, each_input_enum).each(&block)
+        end
+
+        split_index, probe_stage = classify_parallel_stages(blocks)
+        if split_index.nil?
+          dump_parallel_status("disabled", verbose: verbose)
+          return apply_pipeline(blocks, each_input_enum).each(&block)
+        end
+
+        # If the first reducer stage is decomposable, workers run everything up to
+        # and including it (map prefix + reducer), emit partial accumulators, and the
+        # parent merges. This covers both pure reducers (split_index == 0, e.g. `sum(_)`)
+        # and map-then-reduce (split_index > 0, e.g. `select(...) >> sum(...)`).
+        if probe_stage&.decomposable?
+          worker_blocks = blocks[0..split_index]
+          rest_blocks = blocks[(split_index + 1)..]
+          return process_decomposable_parallel(worker_blocks, rest_blocks, probe_stage,
+                                               parallel: parallel, verbose: verbose, &block)
+        end
+
+        if split_index == 0
+          dump_parallel_status("disabled", verbose: verbose)
+          return apply_pipeline(blocks, each_input_enum).each(&block)
+        end
+
+        map_blocks = blocks[0...split_index]
+        reduce_blocks = blocks[split_index..]
+        dump_parallel_status("enabled workers=#{parallel} files=#{@file_paths.length} split=#{split_index}/#{blocks.length}", verbose: verbose)
+        input_enum = parallel_map_enum(map_blocks, parallel)
+        (reduce_blocks.empty? ? input_enum : apply_pipeline(reduce_blocks, input_enum)).each(&block)
+      end
+
+      def dump_parallel_status(status, verbose:)
+        @err.puts "parallel: #{status}" if verbose
+      end
+
+      # Returns [split_index, probe_stage] where split_index is the index of the
+      # first reducer stage (or blocks.length if all are passthrough), and probe_stage
+      # is the Stage object of that first reducer (nil if all passthrough or no input).
+      def classify_parallel_stages(blocks)
+        # Read the first row from the first file to probe stage modes
+        first_value = nil
+        open_file(@file_paths.first) do |stream|
+          each_stream_value(stream) do |value|
+            first_value = value
+            break
+          end
+        end
+        return [nil, nil] if first_value.nil?
+
+        # Run the value through each stage independently to classify
+        split_index = nil
+        probe_stage = nil
+        blocks.each_with_index do |block, i|
+          probe_pipeline = Pipeline.new(block)
+          probe_pipeline.call([first_value]) { |_| }
+          stage = probe_pipeline.instance_variable_get(:@stages).first
+          if stage.instance_variable_get(:@mode) == :reducer
+            split_index = i
+            probe_stage = stage
+            break
+          end
+        end
+
+        [split_index || blocks.length, probe_stage]
+      end
+
+      def process_decomposable_parallel(worker_blocks, rest_blocks, probe_stage, parallel:, verbose:, &block)
+        dump_parallel_status("enabled workers=#{parallel} files=#{@file_paths.length} decompose=#{worker_blocks.length}/#{worker_blocks.length + rest_blocks.length}", verbose: verbose)
+
+        # Workers run map prefix + reducer stage per file and emit partial accumulators.
+        partials_list = []
+        reducer_stage_index = worker_blocks.length - 1
+        spawner = ->(path) do
+          spawn_worker(worker_blocks, path) do |pipeline, input|
+            pipeline.call(input) { |_| }
+            # If the file was empty, the stage was never initialized (no reducers),
+            # so skip emitting — the parent will simply not receive a partial for this worker.
+            stage = pipeline.instance_variable_get(:@stages)[reducer_stage_index]
+            partials = stage.partial_accumulators
+            emit_parallel_frame(partials) unless partials.empty?
+          end
+        end
+        children = run_parallel_worker_pool(parallel, spawner) { |v| partials_list << v }
+        wait_for_parallel_children(children) if children
+        return if partials_list.empty?
+
+        # Reuse the probe stage (already initialized with reducer structure from classify).
+        # Replace its accumulators with the first worker's partials, then merge the rest.
+        probe_stage.replace_accumulators!(partials_list.first)
+        partials_list.drop(1).each { |partials| probe_stage.merge_partials!(partials) }
+
+        # Finish the reducer stage and pass results through any remaining stages.
+        results = probe_stage.finish
+        if rest_blocks.empty?
+          results.each(&block)
         else
-          pipeline.call(input_enum) { |value| emit_output(value) }
+          apply_pipeline(rest_blocks, results.each).each(&block)
         end
-      ensure
-        write_output(@output_buffer)
       end
 
-      private
+      # Forks a worker process that reads `path`, builds a pipeline from `blocks`,
+      # and yields [pipeline, input_enum] to the caller's block for custom behavior.
+      # Returns [read_io, pid].
+      def spawn_worker(blocks, path)
+        read_io, write_io = IO.pipe
+        pid = fork do
+          read_io.close
+          @out = write_io
+          @output_buffer = +""
+          pipeline = Pipeline.new(*blocks)
+          input_enum = Enumerator.new do |y|
+            open_file(path) { |stream| each_stream_value(stream) { |v| y << v } }
+          end
+          worker_failed = false
+          begin
+            yield pipeline, input_enum
+          rescue => e
+            @err.puts "#{path}: #{e.message} (#{e.class})"
+            worker_failed = true
+          end
+          write_output(@output_buffer)
+          write_io.close
+          exit!(worker_failed ? 1 : 0)
+        end
+        write_io.close
+        [read_io, pid]
+      end
 
-      def each_input_value
-        return each_input_value_lax { |value| yield value } if @lax
+      # Runs a pool of up to `num_workers` concurrent workers across all input files.
+      # `spawner` is called with a file path and must return [read_io, pid].
+      # Yields each decoded JSON value from worker output frames.
+      def run_parallel_worker_pool(num_workers, spawner)
+        file_queue = @file_paths.dup
+        workers = {} # read_io => [reader, pid]
+        children = []
+
+        # Fill initial pool
+        while workers.size < num_workers && !file_queue.empty?
+          read_io, pid = spawner.call(file_queue.shift)
+          workers[read_io] = [ParallelFrameReader.new, pid]
+          children << pid
+        end
+
+        read_ios = workers.keys.dup
+
+        until read_ios.empty?
+          ready = IO.select(read_ios)
+          ready[0].each do |io|
+            reader = workers[io][0]
+            chunk = io.read_nonblock(65536, exception: false)
+            if chunk == :wait_readable
+              next
+            elsif chunk.nil?
+              raise IOError, "truncated parallel frame from worker" if reader.has_partial?
+              read_ios.delete(io)
+              io.close
+              workers.delete(io)
+
+              # Spawn next worker if files remain
+              unless file_queue.empty?
+                read_io, pid = spawner.call(file_queue.shift)
+                workers[read_io] = [ParallelFrameReader.new, pid]
+                children << pid
+                read_ios << read_io
+              end
+            else
+              reader.append(chunk)
+              reader.each_payload do |payload|
+                yield JSON.parse(payload)
+              end
+            end
+          end
+        end
+
+        children
+      end
+
+      def parallel_map_enum(map_blocks, num_workers)
+        children = nil
+        spawner = ->(path) do
+          spawn_worker(map_blocks, path) do |pipeline, input|
+            pipeline.call(input) { |value| emit_parallel_frame(value) }
+          end
+        end
+        Enumerator.new do |y|
+          children = run_parallel_worker_pool(num_workers, spawner) { |value| y << value }
+        ensure
+          wait_for_parallel_children(children) if children
+        end
+      end
+
+      def wait_for_parallel_children(children)
+        failed = false
+        children.each do |pid|
+          _, status = Process.waitpid2(pid)
+          failed = true unless status.success?
+        end
+        exit(1) if failed
+      end
 
-        each_input_value_ndjson { |value| yield value }
+      def emit_parallel_frame(value)
+        payload = JSON.generate(value)
+        buffer_output([payload.bytesize].pack("N") << payload)
       end
 
-      def each_input_value_ndjson
+      def each_input_value
         each_input do |source|
-          source.each_line do |raw_line|
-            line = raw_line.strip
-            next if line.empty?
+          each_stream_value(source) { |value| yield value }
+        end
+      end
 
-            yield JSON.parse(line)
-          end
+      def each_stream_value(stream)
+        return each_stream_value_lax(stream) { |value| yield value } if @lax
+
+        stream.each_line do |line|
+          line.strip!
+          next if line.empty?
+          yield JSON.parse(line)
+        end
+      end
+
+      def open_file(path)
+        if path.end_with?(".gz")
+          Zlib::GzipReader.open(path) { |source| yield source }
+        else
+          File.open(path, "rb") { |source| yield source }
         end
       end
 
-      def each_input_value_lax
+      def each_stream_value_lax(stream)
         require "oj"
-        handler = Class.new(Oj::ScHandler) do
+        Oj.sc_parse(streaming_json_handler_class.new { |value| yield value }, RsNormalizer.new(stream))
+      rescue LoadError
+        raise "oj is required for --lax mode (gem install oj)"
+      rescue Oj::ParseError => e
+        raise JSON::ParserError, e.message
+      end
+
+      def streaming_json_handler_class
+        @streaming_json_handler_class ||= Class.new(Oj::ScHandler) do
           def initialize(&emit)
             @emit = emit
           end
@@ -94,13 +395,6 @@ module Jrf
           def array_append(array, value) = array << value
           def add_value(value) = @emit.call(value)
         end
-        each_input do |source|
-          Oj.sc_parse(handler.new { |value| yield value }, RsNormalizer.new(source))
-        end
-      rescue LoadError
-        raise "oj is required for --lax mode (gem install oj)"
-      rescue Oj::ParseError => e
-        raise JSON::ParserError, e.message
       end
 
       def dump_stages(stages)
@@ -109,8 +403,25 @@ module Jrf
         end
       end
 
-      def each_input
-        @inputs.each { |source| yield source }
+      def each_input(&block)
+        if @file_paths.empty?
+          with_error_handling("<stdin>") { block.call(@stdin) }
+        else
+          @file_paths.each do |path|
+            if path == "-"
+              with_error_handling("<stdin>") { block.call(@stdin) }
+            else
+              with_error_handling(path) { open_file(path, &block) }
+            end
+          end
+        end
+      end
+
+      def with_error_handling(name)
+        yield
+      rescue IOError, SystemCallError, Zlib::GzipFile::Error, JSON::ParserError => e
+        @err.puts "#{name}: #{e.message} (#{e.class})"
+        @input_errors = true
       end
 
       def emit_output(value)
@@ -171,7 +482,13 @@ module Jrf
       end
 
       def write_output(str)
-        @out.syswrite(str)
+        return if str.empty?
+
+        total = 0
+        while total < str.bytesize
+          written = @out.syswrite(str.byteslice(total..))
+          total += written
+        end
       end
     end
   end

data/lib/jrf/cli.rb

@@ -18,6 +18,7 @@ module Jrf
         --lax          allow multiline JSON texts; split inputs by whitespace (also detects JSON-SEQ RS 0x1e)
         -o, --output FORMAT
                        output format: json (default), pretty, tsv
+        -P N           opportunistically parallelize across N workers
         -r, --require LIBRARY
                        require LIBRARY before evaluating stages
         --no-jit       do not enable YJIT, even when supported by the Ruby runtime
@@ -45,6 +46,7 @@ module Jrf
       verbose = false
       lax = false
       output_format = :json
+      parallel = 1
       jit = true
       required_libraries = []
       atomic_write_bytes = Runner::DEFAULT_OUTPUT_BUFFER_LIMIT
@@ -54,6 +56,7 @@ module Jrf
           opts.on("-v", "--verbose", "print parsed stage expressions") { verbose = true }
           opts.on("--lax", "allow multiline JSON texts; split inputs by whitespace (also detects JSON-SEQ RS 0x1e)") { lax = true }
           opts.on("-o", "--output FORMAT", %w[json pretty tsv], "output format: json, pretty, tsv") { |fmt| output_format = fmt.to_sym }
+          opts.on("-P N", Integer, "opportunistically parallelize the map-prefix across N workers") { |n| parallel = n }
           opts.on("-r", "--require LIBRARY", "require LIBRARY before evaluating stages") { |library| required_libraries << library }
           opts.on("--no-jit", "do not enable YJIT, even when supported by the Ruby runtime") { jit = false }
           opts.on("--atomic-write-bytes N", Integer, "group short outputs into atomic writes of up to N bytes") do |value|
@@ -89,34 +92,20 @@ module Jrf
       enable_yjit if jit
       required_libraries.each { |library| require library }
 
-      inputs = Enumerator.new do |y|
-        if argv.empty?
-          y << input
-        else
-          argv.each do |path|
-            if path == "-"
-              y << input
-            elsif path.end_with?(".gz")
-              require "zlib"
-              Zlib::GzipReader.open(path) do |source|
-                y << source
-              end
-            else
-              File.open(path, "rb") do |source|
-                y << source
-              end
-            end
-          end
-        end
-      end
-      Runner.new(
-        inputs: inputs,
+      file_paths = argv.dup
+
+      runner = Runner.new(
+        input: file_paths.empty? ? input : file_paths,
         out: out,
         err: err,
         lax: lax,
         output_format: output_format,
         atomic_write_bytes: atomic_write_bytes
-      ).run(expression, verbose: verbose)
+      )
+
+      runner.run(expression, parallel: parallel, verbose: verbose)
+
+      exit 1 if runner.input_errors?
     end
 
     def self.enable_yjit

data/lib/jrf/reducers.rb

@@ -20,8 +20,37 @@ module Jrf
       end
     end
 
+    # A reducer whose partial accumulators can be merged across parallel workers.
+    #
+    # Contract:
+    # - `identity` is the neutral element for `merge_fn`: merge(identity, x) == x
+    # - `initial` is always set to `identity` (the accumulator starts from the neutral element)
+    # - Any bias (e.g. sum's `initial:` keyword) is applied in `finish_fn`, not in the starting accumulator
+    class DecomposableReduce < Reduce
+      attr_reader :merge_fn
+
+      def initialize(identity, merge:, finish_fn: nil, &step_fn)
+        super(identity, finish_fn: finish_fn, &step_fn)
+        @merge_fn = merge
+      end
+
+      # Returns the raw accumulator without applying finish_fn.
+      def partial
+        @acc
+      end
+
+      # Merges another partial accumulator into this one.
+      def merge_partial(other_acc)
+        @acc = @merge_fn.call(@acc, other_acc)
+      end
+    end
+
     def reduce(initial, finish: nil, &step_fn)
       Reduce.new(initial, finish_fn: finish, &step_fn)
     end
+
+    def decomposable_reduce(identity, merge:, finish: nil, &step_fn)
+      DecomposableReduce.new(identity, merge: merge, finish_fn: finish, &step_fn)
+    end
   end
 end

data/lib/jrf/row_context.rb

@@ -17,6 +17,7 @@ module Jrf
             spec.fetch(:value),
             initial: reducer_initial_value(spec.fetch(:initial)),
             finish: spec[:finish],
+            merge: spec[:merge],
             &spec.fetch(:step)
           )
         end
@@ -48,27 +49,38 @@ module Jrf
     end
 
     define_reducer(:sum) do |_ctx, value, initial: 0, block: nil|
-      { value: value, initial: initial, step: ->(acc, v) { v.nil? ? acc : (acc + v) } }
+      step = ->(acc, v) { v.nil? ? acc : (acc + v) }
+      if initial.is_a?(Numeric)
+        # Numeric — decomposable. Bias applied once in finish.
+        finish = initial == 0 ? nil : ->(acc) { [acc + initial] }
+        { value: value, initial: 0, step: step, finish: finish, merge: ->(a, b) { a + b } }
+      else
+        # Non-numeric (e.g. string concat) — not decomposable.
+        { value: value, initial: initial, step: step }
+      end
     end
 
     define_reducer(:count) do |_ctx, value = MISSING, block: nil|
+      merge = ->(a, b) { a + b }
       if value.equal?(MISSING)
-        { value: nil, initial: 0, step: ->(acc, _v) { acc + 1 } }
+        { value: nil, initial: 0, step: ->(acc, _v) { acc + 1 }, merge: merge }
       else
-        { value: value, initial: 0, step: ->(acc, v) { v.nil? ? acc : (acc + 1) } }
+        { value: value, initial: 0, step: ->(acc, v) { v.nil? ? acc : (acc + 1) }, merge: merge }
       end
     end
 
     define_reducer(:count_if) do |_ctx, condition, block: nil|
-      { value: condition, initial: 0, step: ->(acc, v) { v ? (acc + 1) : acc } }
+      { value: condition, initial: 0, step: ->(acc, v) { v ? (acc + 1) : acc }, merge: ->(a, b) { a + b } }
     end
 
     define_reducer(:min) do |_ctx, value, block: nil|
-      { value: value, initial: nil, step: ->(acc, v) { v.nil? ? acc : (acc.nil? || v < acc ? v : acc) } }
+      min_merge = ->(a, b) { a.nil? ? b : b.nil? ? a : (a < b ? a : b) }
+      { value: value, initial: nil, step: ->(acc, v) { v.nil? ? acc : (acc.nil? || v < acc ? v : acc) }, merge: min_merge }
     end
 
     define_reducer(:max) do |_ctx, value, block: nil|
-      { value: value, initial: nil, step: ->(acc, v) { v.nil? ? acc : (acc.nil? || v > acc ? v : acc) } }
+      max_merge = ->(a, b) { a.nil? ? b : b.nil? ? a : (a > b ? a : b) }
+      { value: value, initial: nil, step: ->(acc, v) { v.nil? ? acc : (acc.nil? || v > acc ? v : acc) }, merge: max_merge }
     end
 
     define_reducer(:average) do |_ctx, value, block: nil|
@@ -82,7 +94,8 @@ module Jrf
           acc[0] += v
           acc[1] += 1
           acc
-        }
+        },
+        merge: ->(a, b) { [a[0] + b[0], a[1] + b[1]] }
       }
     end
 
@@ -136,7 +149,7 @@ module Jrf
 
     define_reducer(:group) do |ctx, value = MISSING, block: nil|
       resolved_value = value.equal?(MISSING) ? ctx.send(:current_input) : value
-      { value: resolved_value, initial: -> { [] }, step: ->(acc, v) { acc << v } }
+      { value: resolved_value, initial: -> { [] }, step: ->(acc, v) { acc << v }, merge: ->(a, b) { a + b } }
     end
 
     define_reducer(:percentile) do |ctx, value, percentage, block: nil|

data/lib/jrf/stage.rb

@@ -51,13 +51,17 @@ module Jrf
       (@mode == :reducer) ? Control::DROPPED : result
     end
 
-    def step_reduce(value, initial:, finish: nil, step_fn: nil, &step_block)
+    def step_reduce(value, initial:, finish: nil, merge: nil, step_fn: nil, &step_block)
       idx = @cursor
       step_fn ||= step_block
 
       if @reducers[idx].nil?
         finish_rows = finish || ->(acc) { [acc] }
-        @reducers[idx] = Reducers.reduce(initial, finish: finish_rows, &step_fn)
+        @reducers[idx] = if merge
+          Reducers.decomposable_reduce(initial, merge: merge, finish: finish_rows, &step_fn)
+        else
+          Reducers.reduce(initial, finish: finish_rows, &step_fn)
+        end
         result = ReducerToken.new(idx)
       else
         result = Control::DROPPED
@@ -167,6 +171,32 @@ module Jrf
       end
     end
 
+    # Returns true if all reducers in this stage are DecomposableReduce instances,
+    # meaning partial accumulators from parallel workers can be merged.
+    def decomposable?
+      @mode == :reducer && @reducers.any? &&
+        @reducers.all? { |r| r.is_a?(Reducers::DecomposableReduce) }
+    end
+
+    # Returns an array of raw accumulator values, one per reducer.
+    def partial_accumulators
+      @reducers.map(&:partial)
+    end
+
+    # Replaces all reducer accumulators with the given values.
+    def replace_accumulators!(partials)
+      @reducers.each_with_index do |reducer, i|
+        reducer.instance_variable_set(:@acc, partials[i])
+      end
+    end
+
+    # Merges an array of partial accumulators (from another worker) into this stage's reducers.
+    def merge_partials!(other_partials)
+      @reducers.each_with_index do |reducer, i|
+        reducer.merge_partial(other_partials[i])
+      end
+    end
+
     private
 
     def with_scoped_reducers(reducer_list)

data/lib/jrf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jrf
-  VERSION = "0.1.13"
+  VERSION = "0.1.15"
 end

data/test/cli_parallel_test.rb

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class CliParallelTest < JrfTestCase
+  def test_parallel_map_only
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 3}, {"x" => 4}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", '_["x"]', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel map only")
+      assert_equal([1, 2, 3, 4], lines(stdout).map(&:to_i).sort, "parallel map only output")
+      assert_includes(stderr, "parallel: enabled workers=2 files=2 split=1/1", "parallel verbose summary")
+    end
+  end
+
+  def test_parallel_map_only_pretty_output
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 2}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-P", "2", "-o", "pretty", '_["x"]', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel pretty map only")
+      assert_equal(["1", "2"], stdout.lines.map(&:strip).reject(&:empty?).sort, "parallel pretty map only output")
+    end
+  end
+
+  def test_parallel_map_only_tsv_output
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"a" => 1, "b" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"a" => 3, "b" => 4}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-P", "2", "-o", "tsv", "_", *ndjson_files(dir))
+      assert_success(status, stderr, "parallel tsv map only")
+      assert_equal(["a\t1", "a\t3", "b\t2", "b\t4"], lines(stdout).sort, "parallel tsv map only output")
+    end
+  end
+
+  def test_parallel_map_reduce
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 3}, {"x" => 4}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-P", "2", 'sum(_["x"])', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel map reduce")
+      assert_equal(%w[10], lines(stdout), "parallel sum output")
+    end
+  end
+
+  def test_parallel_split_map_and_reduce
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 10}, {"x" => 20}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 30}, {"x" => 40}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'select(_["x"] > 10) >> sum(_["x"])', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel split map+reduce")
+      assert_includes(stderr, "decompose=2/2", "select+sum decomposed")
+      assert_equal(%w[90], lines(stdout), "parallel split map+reduce output")
+    end
+  end
+
+  def test_parallel_group_by
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"k" => "a", "v" => 1}, {"k" => "b", "v" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"k" => "a", "v" => 3}, {"k" => "b", "v" => 4}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-P", "2", 'group_by(_["k"]) { |r| sum(r["v"]) }', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel group_by")
+      result = JSON.parse(lines(stdout).first)
+      assert_equal(4, result["a"], "parallel group_by a")
+      assert_equal(6, result["b"], "parallel group_by b")
+    end
+  end
+
+  def test_parallel_decomposable_reducer
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 3}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'sum(_["x"])', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel decomposable reducer")
+      assert_equal(%w[6], lines(stdout), "parallel decomposable reducer output")
+      assert_includes(stderr, "parallel: enabled", "parallel enabled for decomposable reducer")
+      assert_includes(stderr, "decompose=", "decompose mode indicated")
+    end
+  end
+
+  def test_parallel_with_gz_files
+    Dir.mktmpdir do |dir|
+      gz_path_a = File.join(dir, "a.ndjson.gz")
+      Zlib::GzipWriter.open(gz_path_a) { |io| io.write("{\"x\":10}\n{\"x\":20}\n") }
+      gz_path_b = File.join(dir, "b.ndjson.gz")
+      Zlib::GzipWriter.open(gz_path_b) { |io| io.write("{\"x\":30}\n") }
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-P", "2", 'sum(_["x"])', gz_path_a, gz_path_b)
+      assert_success(status, stderr, "parallel with gz")
+      assert_equal(%w[60], lines(stdout), "parallel with gz output")
+    end
+  end
+
+  def test_parallel_matches_serial_output
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", (1..50).map { |i| {"v" => i, "g" => i % 3} })
+      write_ndjson(dir, "b.ndjson", (51..100).map { |i| {"v" => i, "g" => i % 3} })
+
+      files = ndjson_files(dir)
+      expr = 'group_by(_["g"]) { |r| sum(r["v"]) }'
+
+      serial_stdout, serial_stderr, serial_status = Open3.capture3("./exe/jrf", expr, *files)
+      assert_success(serial_status, serial_stderr, "serial baseline")
+
+      parallel_stdout, parallel_stderr, parallel_status = Open3.capture3("./exe/jrf", "-P", "2", expr, *files)
+      assert_success(parallel_status, parallel_stderr, "parallel run")
+
+      assert_equal(JSON.parse(serial_stdout), JSON.parse(parallel_stdout), "parallel matches serial")
+    end
+  end
+
+  def test_parallel_worker_error_handling
+    Dir.mktmpdir do |dir|
+      good_path = File.join(dir, "a.ndjson")
+      File.write(good_path, "{\"x\":1}\n{\"x\":2}\n")
+
+      # Create a truncated gz file (valid header, truncated body)
+      bad_gz_path = File.join(dir, "b.ndjson.gz")
+      full_gz = StringIO.new
+      Zlib::GzipWriter.wrap(full_gz) { |io| io.write("{\"x\":10}\n" * 100) }
+      # Write only the first half to simulate truncation
+      File.binwrite(bad_gz_path, full_gz.string[0, full_gz.string.bytesize / 2])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-P", "2", '_["x"]', good_path, bad_gz_path)
+      assert_failure(status, "worker error causes non-zero exit")
+      assert_includes(stderr, bad_gz_path, "error message includes filename")
+      # Good file data should still be present
+      output_values = lines(stdout).map(&:to_i)
+      assert_includes(output_values, 1, "good file data preserved")
+      assert_includes(output_values, 2, "good file data preserved")
+    end
+  end
+
+  def test_parallel_requires_multiple_files
+    # With single file and -P, should still work (falls back to serial)
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-P", "2", 'sum(_["x"])', *ndjson_files(dir))
+      assert_success(status, stderr, "single file with -P")
+      assert_equal(%w[3], lines(stdout), "single file with -P output")
+    end
+  end
+
+  def test_parallel_select_then_sum
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 20}, {"x" => 3}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 40}, {"x" => 5}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'select(_["x"] > 10) >> sum(_["x"])', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel select then sum")
+      assert_includes(stderr, "decompose=2/2", "select+sum fully decomposed in workers")
+      assert_equal(%w[60], lines(stdout), "parallel select then sum output")
+    end
+  end
+
+  def test_parallel_decomposable_multi_reducer
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 3}, {"x" => 4}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", '{s: sum(_["x"]), n: count(), mn: min(_["x"]), mx: max(_["x"])}', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel multi reducer")
+      assert_includes(stderr, "decompose=", "multi reducer decomposed")
+      result = JSON.parse(lines(stdout).first)
+      assert_equal(10, result["s"], "sum")
+      assert_equal(4, result["n"], "count")
+      assert_equal(1, result["mn"], "min")
+      assert_equal(4, result["mx"], "max")
+    end
+  end
+
+  def test_parallel_decomposable_average
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 10}, {"x" => 20}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 30}, {"x" => 40}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'average(_["x"])', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel average")
+      assert_includes(stderr, "decompose=", "average decomposed")
+      assert_equal(["25.0"], lines(stdout), "parallel average output")
+    end
+  end
+
+  def test_parallel_decomposable_group
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 3}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'group(_["x"])', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel group")
+      assert_includes(stderr, "decompose=", "group decomposed")
+      result = JSON.parse(lines(stdout).first)
+      assert_equal([1, 2, 3], result.sort, "parallel group output")
+    end
+  end
+
+  def test_parallel_decomposable_sum_with_initial
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 3}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'sum(_["x"], initial: 100)', *ndjson_files(dir))
+      assert_success(status, stderr, "sum with numeric initial")
+      assert_includes(stderr, "decompose=", "numeric initial decomposes")
+      assert_equal(%w[106], lines(stdout), "sum with initial output")
+    end
+  end
+
+  def test_parallel_sum_with_non_numeric_initial_falls_back
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => "a"}, {"x" => "b"}])
+      write_ndjson(dir, "b.ndjson", [{"x" => "c"}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'sum(_["x"], initial: "")', *ndjson_files(dir))
+      assert_success(status, stderr, "sum with string initial")
+      assert_includes(stderr, "parallel: disabled", "non-numeric initial falls back to serial")
+      assert_equal(['"abc"'], lines(stdout), "sum with string initial output")
+    end
+  end
+
+  def test_sum_with_string_initial
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => "hello "}, {"x" => "world"}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", 'sum(_["x"], initial: "")', *ndjson_files(dir))
+      assert_success(status, stderr, "sum with string initial")
+      assert_equal(['"hello world"'], lines(stdout), "sum with string initial output")
+    end
+  end
+
+  def test_parallel_decomposable_reducer_then_passthrough
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 3}, {"x" => 4}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'sum(_["x"]) >> _ * 2', *ndjson_files(dir))
+      assert_success(status, stderr, "parallel decomposable then passthrough")
+      assert_includes(stderr, "decompose=", "reducer then passthrough decomposed")
+      assert_equal(%w[20], lines(stdout), "parallel decomposable then passthrough output")
+    end
+  end
+
+  def test_parallel_mixed_decomposable_reducers
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 10}, {"x" => 20}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 30}, {"x" => 40}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", '[sum(_["x"]), average(_["x"]), min(_["x"]), max(_["x"]), count()]', *ndjson_files(dir))
+      assert_success(status, stderr, "mixed decomposable")
+      assert_includes(stderr, "decompose=", "mixed decomposable used decompose")
+      result = JSON.parse(lines(stdout).first)
+      assert_equal([100, 25.0, 10, 40, 4], result, "mixed decomposable output")
+    end
+  end
+
+  def test_parallel_mixed_decomposable_and_non_decomposable_falls_back
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 10}, {"x" => 20}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 30}, {"x" => 40}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", '[sum(_["x"]), percentile(_["x"], 0.5)]', *ndjson_files(dir))
+      assert_success(status, stderr, "mixed with non-decomposable")
+      assert_includes(stderr, "parallel: disabled", "mixed with non-decomposable falls back to serial")
+      result = JSON.parse(lines(stdout).first)
+      assert_equal([100, 20], result, "mixed with non-decomposable output")
+    end
+  end
+
+  def test_parallel_select_sum_passthrough_decomposes
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 20}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 40}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'select(_["x"] > 10) >> sum(_["x"]) >> _ * 2', *ndjson_files(dir))
+      assert_success(status, stderr, "select+sum+passthrough")
+      assert_includes(stderr, "decompose=2/3", "select+sum decomposed, passthrough in parent")
+      assert_equal(%w[120], lines(stdout), "select+sum+passthrough output")
+    end
+  end
+
+  def test_parallel_select_non_decomposable_uses_split
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 3}, {"x" => 1}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 2}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'select(_["x"] > 0) >> sort(_["x"]) >> _["x"]', *ndjson_files(dir))
+      assert_success(status, stderr, "select+sort uses split")
+      assert_includes(stderr, "split=1/3", "non-decomposable sort uses map-prefix split")
+      assert_equal([1, 2, 3], lines(stdout).map { |l| JSON.parse(l) }, "select+sort output")
+    end
+  end
+
+  def test_parallel_decomposable_with_empty_file
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      File.write(File.join(dir, "b.ndjson"), "")
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", '{s: sum(_["x"]), n: count(), mn: min(_["x"])}', *ndjson_files(dir))
+      assert_success(status, stderr, "decomposable with empty file")
+      assert_includes(stderr, "decompose=", "decomposable with empty file used decompose")
+      result = JSON.parse(lines(stdout).first)
+      assert_equal(3, result["s"], "sum ignores empty file")
+      assert_equal(2, result["n"], "count ignores empty file")
+      assert_equal(1, result["mn"], "min ignores empty file")
+    end
+  end
+
+  def test_parallel_decomposable_all_files_empty
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "a.ndjson"), "")
+      File.write(File.join(dir, "b.ndjson"), "")
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'sum(_["x"])', *ndjson_files(dir))
+      assert_success(status, stderr, "all files empty")
+      # All files empty means first_value is nil, so classify returns nil → serial fallback
+      assert_includes(stderr, "parallel: disabled", "all files empty falls back to serial")
+      assert_equal([], lines(stdout), "no output for empty input")
+    end
+  end
+
+  def test_parallel_non_decomposable_falls_back_to_serial
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", [{"x" => 1}, {"x" => 2}])
+      write_ndjson(dir, "b.ndjson", [{"x" => 3}])
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", "-v", "-P", "2", 'sort(_["x"]) >> _["x"]', *ndjson_files(dir))
+      assert_success(status, stderr, "non-decomposable serial fallback")
+      assert_equal([1, 2, 3], lines(stdout).map { |l| JSON.parse(l) }, "sort output")
+      assert_includes(stderr, "parallel: disabled", "non-decomposable falls back to serial")
+    end
+  end
+
+  def test_parallel_decomposable_matches_serial
+    Dir.mktmpdir do |dir|
+      write_ndjson(dir, "a.ndjson", (1..50).map { |i| {"v" => i} })
+      write_ndjson(dir, "b.ndjson", (51..100).map { |i| {"v" => i} })
+
+      files = ndjson_files(dir)
+      expr = '{s: sum(_["v"]), n: count(), mn: min(_["v"]), mx: max(_["v"]), avg: average(_["v"])}'
+
+      serial_stdout, serial_stderr, serial_status = Open3.capture3("./exe/jrf", expr, *files)
+      assert_success(serial_status, serial_stderr, "serial baseline")
+
+      parallel_stdout, parallel_stderr, parallel_status = Open3.capture3("./exe/jrf", "-v", "-P", "2", expr, *files)
+      assert_success(parallel_status, parallel_stderr, "parallel run")
+      assert_includes(parallel_stderr, "decompose=", "decomposable matches serial used decompose")
+
+      assert_equal(JSON.parse(serial_stdout), JSON.parse(parallel_stdout), "parallel decomposable matches serial")
+    end
+  end
+
+  def test_serial_error_includes_filename
+    Dir.mktmpdir do |dir|
+      good_path = File.join(dir, "a.ndjson")
+      File.write(good_path, "{\"x\":1}\n{\"x\":2}\n")
+
+      bad_gz_path = File.join(dir, "b.ndjson.gz")
+      full_gz = StringIO.new
+      Zlib::GzipWriter.wrap(full_gz) { |io| io.write("{\"x\":10}\n" * 100) }
+      File.binwrite(bad_gz_path, full_gz.string[0, full_gz.string.bytesize / 2])
+
+      good_path2 = File.join(dir, "c.ndjson")
+      File.write(good_path2, "{\"x\":3}\n")
+
+      stdout, stderr, status = Open3.capture3("./exe/jrf", '_["x"]', good_path, bad_gz_path, good_path2)
+      assert_failure(status, "serial error causes non-zero exit")
+      assert_includes(stderr, bad_gz_path, "serial error message includes filename")
+      refute_includes(stderr, "from ", "serial error does not include stacktrace")
+      # Data from good files should still be present
+      output_values = lines(stdout).map(&:to_i)
+      assert_includes(output_values, 1, "data before bad file preserved")
+      assert_includes(output_values, 3, "data after bad file preserved")
+    end
+  end
+
+  private
+
+  def write_ndjson(dir, name, rows)
+    File.write(File.join(dir, name), rows.map { |r| JSON.generate(r) + "\n" }.join)
+  end
+
+  def ndjson_files(dir)
+    Dir.glob(File.join(dir, "*.ndjson")).sort
+  end
+end

data/test/cli_runner_test.rb

@@ -106,24 +106,23 @@ class CliRunnerTest < JrfTestCase
 
   def test_runner_buffering_and_require_option
     threshold_input = StringIO.new((1..4).map { |i| "{\"foo\":\"#{'x' * 1020}\",\"i\":#{i}}\n" }.join)
-    buffered_runner = RecordingRunner.new(inputs: [threshold_input], out: StringIO.new, err: StringIO.new)
+    buffered_runner = RecordingRunner.new(input: threshold_input, out: StringIO.new, err: StringIO.new)
     buffered_runner.run('_')
     expected_line = JSON.generate({"foo" => "x" * 1020, "i" => 1}) + "\n"
     assert_equal(2, buffered_runner.writes.length, "default atomic write limit buffers records until the configured threshold")
     assert_equal(expected_line.bytesize * 3, buffered_runner.writes.first.bytesize, "default atomic write limit flushes before the next record would exceed the threshold")
     assert_equal(expected_line.bytesize, buffered_runner.writes.last.bytesize, "final buffer flush emits the remaining record")
 
-    small_limit_runner = RecordingRunner.new(inputs: [StringIO.new("{\"foo\":1}\n{\"foo\":2}\n")], out: StringIO.new, err: StringIO.new, atomic_write_bytes: 1)
+    small_limit_runner = RecordingRunner.new(input: StringIO.new("{\"foo\":1}\n{\"foo\":2}\n"), out: StringIO.new, err: StringIO.new, atomic_write_bytes: 1)
     small_limit_runner.run('_["foo"]')
     assert_equal(["1\n", "2\n"], small_limit_runner.writes, "small atomic write limit emits oversized records directly")
 
-    error_runner = RecordingRunner.new(inputs: [StringIO.new("{\"foo\":1}\n{\"foo\":")], out: StringIO.new, err: StringIO.new)
-    begin
-      error_runner.run('_["foo"]')
-      flunk("expected parse error for buffered flush test")
-    rescue JSON::ParserError
-      assert_equal(["1\n"], error_runner.writes, "buffer flushes pending output before parse errors escape")
-    end
+    err_io = StringIO.new
+    error_runner = RecordingRunner.new(input: StringIO.new("{\"foo\":1}\n{\"foo\":"), out: StringIO.new, err: err_io)
+    error_runner.run('_["foo"]')
+    assert_equal(["1\n"], error_runner.writes, "buffer flushes pending output before parse errors")
+    assert_includes(err_io.string, "JSON::ParserError", "parse error reported to stderr")
+    assert(error_runner.input_errors?, "input_errors? is true after parse error")
 
     input_hello = <<~NDJSON
       {"hello":123}
@@ -648,7 +647,7 @@ class CliRunnerTest < JrfTestCase
     assert_equal(%w[9], lines(stdout), "lax trailing separator output")
 
     chunked_lax_out = RecordingRunner.new(
-      inputs: [ChunkedSource.new("{\"foo\":1}\n\x1e{\"foo\":2}\n\t{\"foo\":3}\n")],
+      input: ChunkedSource.new("{\"foo\":1}\n\x1e{\"foo\":2}\n\t{\"foo\":3}\n"),
       out: StringIO.new,
       err: StringIO.new,
       lax: true
@@ -691,6 +690,7 @@ class CliRunnerTest < JrfTestCase
     assert_failure(status, "broken input should fail")
     assert_equal(%w[3], lines(stdout), "reducers flush before parse error")
     assert_includes(stderr, "JSON::ParserError")
+    refute_includes(stderr, "from ", "no stacktrace for parse errors")
   end
 
   def test_map

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jrf
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.15
 platform: ruby
 authors:
 - kazuho
@@ -75,6 +75,7 @@ files:
 - lib/jrf/row_context.rb
 - lib/jrf/stage.rb
 - lib/jrf/version.rb
+- test/cli_parallel_test.rb
 - test/cli_runner_test.rb
 - test/library_api_test.rb
 - test/readme_examples_test.rb