fiber_stream 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6ac2f9ec0d6888789ac2535538124b9057895b52e226d812d002e5d2955d437
-  data.tar.gz: df4722fff9e5020b24e7e23d2d4cc98ea98aa54a3f17dd86ff0825f41f007de4
+  metadata.gz: 2401496eff99cd4792deda8fa927688fc3ba0e97e8a35637db4395895ab04cd9
+  data.tar.gz: 9f9674e2bc7dc9ce49b899727a02b9158ce6c9629c744ec6d626b16923e14160
 SHA512:
-  metadata.gz: 11389c5aaf69a315a9a932ddd06488eb7fe81b72ca265ecf2e45e7d96b4d984a67c2eee49b38dbde267ce35b4e5dfe7dff4d2e61a32330d5e09153058ad2fb22
-  data.tar.gz: e231b92f6c0ddb08aae7e0db1791b17325705705a76ace92b197d626954ae72dd1510359c5ea8f0c5cff19985f01b78cc4e62179699d244afa4d988ed4da9d51
+  metadata.gz: e7237c7c15b66105b09cdccf1e52980f3c030c74acbd2dc7cc3b5cfb720a716836925b5801bdc59351131dcd7ecab72ebdedb6b50593f5258a1cff2d0ebb39a9
+  data.tar.gz: d9bc7c85992c344bef4a36b0f234840c154c06274c450ef0696246d3042a017f8764c22ab1a2df43e3059420c52af7827852e63b4a5e91d668f4c9bb6a191d57

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 0.3.0 - 2026-06-06
+
+### Added
+
+- `Flow.grouped(count)` and `Source#grouped(count)` for fixed-size batches
+  with final partial-group emission.
+- `Source#merge(source)` for scheduler-backed ready-order merging of two
+  sources while preserving each input source's own order.
+- `Source.ractor_merge_ports(ports)` for backpressure-aware merging of
+  multiple producer Ractor ports without requiring a `Fiber.scheduler`.
+- `Flow.split(separator)` and `Source#split(separator)` for delimiter-based
+  framing with optional separator retention and per-frame length limits.
+- Benchmarks and examples for async IO fanout, stream lifecycle probes, and
+  Ractor port merge workflows.
+
+### Changed
+
+- Reworked flow operator tests into focused per-operator test files.
+- Expanded README and repository documentation for source merging, Ractor port
+  merging, split framing, grouped batches, and runtime safety guidance.
+- Clarified that `Flow.lines(max_length: nil)` and
+  `Flow.split(max_length: nil)` may buffer one unterminated frame without
+  bound, and documented explicit `max_length` usage for untrusted streams.
+- Clarified `Source.io` `chunk_size` allocation behavior and Ractor failure
+  metadata exposure.
+
+### Fixed
+
+- Deferred `Source#concat` receiver materialization until downstream demand
+  reaches the concatenated source.
+- Cancelled async and buffer producers when downstream closes early.
+- Removed polling from Ractor map enqueue and cleanup paths.
+- Re-raised background pipeline process-control exceptions instead of treating
+  them as ordinary stream failures.
+- Hardened Ractor map worker teardown notifications so secondary send failures
+  do not cascade during shutdown.
+
 ## 0.2.0 - 2026-06-05
 
 ### Added

data/README.md

@@ -27,11 +27,11 @@ FiberStream currently supports linear pipelines only.
 
 Implemented capabilities:
 
-- in-memory, IO, and backpressure-aware Ractor port sources
-- lazy source concatenation and zipping
+- in-memory, IO, backpressure-aware Ractor port, and Ractor port merge sources
+- lazy source concatenation, zipping, and scheduler-backed merging
 - mapping, filtering, limiting, predicate-based limiting and dropping,
-  fixed-prefix dropping, line splitting, buffering, async boundaries, ordered
-  parallel mapping, and ordered Ractor-backed mapping
+  fixed-prefix dropping, fixed-size grouping, line splitting, buffering, async
+  boundaries, ordered parallel mapping, and ordered Ractor-backed mapping
 - array, first-element, fold, foreach, and IO sinks
 - reusable flow composition and runnable pipelines
 - foreground and scheduler-backed background pipeline execution
@@ -78,7 +78,10 @@ result # => [[1, "a"], [2, "b"]]
 ```
 
 IO sources read chunks on demand and require a scheduler-backed non-blocking
-fiber:
+fiber. The `chunk_size` option is the maximum byte count passed to
+`readpartial` for one downstream pull; very large values may cause the IO
+implementation to attempt large allocations, so choose a bounded value
+appropriate for the workload:
 
 ```ruby
 require "async"
@@ -132,6 +135,25 @@ FiberStream::Source.ractor_port(data_port, ack_port: ack_port)
 producer.value
 ```
 
+`RactorPort::Failure` cause metadata is producer-provided and is surfaced on
+`RactorPortSourceError`. Redact internal paths, secrets, tenant data, or other
+sensitive details before sending failures across trust boundaries.
+
+Multiple producer Ractors can be merged directly without a scheduler-backed
+`Source#merge`. Each producer still receives at most one outstanding ack:
+
+```ruby
+source =
+  FiberStream::Source.ractor_merge_ports(
+    [
+      { port: data_port_a, ack_port: ack_port_a },
+      { port: data_port_b, ack_port: ack_port_b }
+    ]
+  )
+
+values = source.run_with(FiberStream::Sink.to_a)
+```
+
 Streaming HTTP response bodies that implement `#each`, such as
 `async-http` response bodies, can be used with `Source.each` without buffering
 the full body first. Use the HTTP client's block form or an explicit `ensure`
@@ -194,6 +216,30 @@ FiberStream::Source.each([" a ", "", " b "])
 # => ["a", "b"]
 ```
 
+Use `parallel_map` for ordered scheduler-backed mapping when each element
+waits on non-blocking IO. It preserves input order while allowing up to
+`concurrency` mapping operations to be in flight:
+
+```ruby
+require "async"
+require "fiber_stream"
+
+def fetch_profile(user_id)
+  # Example: perform scheduler-aware HTTP, database, or socket IO here.
+  sleep 0.05
+  { id: user_id, name: "user-#{user_id}" }
+end
+
+profiles =
+  Sync do
+    FiberStream::Source.each([1, 2, 3, 4])
+      .parallel_map(concurrency: 4) { |user_id| fetch_profile(user_id) }
+      .run_with(FiberStream::Sink.to_a)
+  end
+
+profiles.map { |profile| profile.fetch(:id) } # => [1, 2, 3, 4]
+```
+
 Use `ractor_map` for ordered CPU-bound mapping in Ractor workers. The mapper
 must be shareable, usually by creating it with `Ractor.shareable_proc`.
 
@@ -326,6 +372,18 @@ tail =
 tail # => [3, 4]
 ```
 
+`Flow.grouped` batches adjacent elements into arrays and emits the final
+partial group:
+
+```ruby
+batches =
+  FiberStream::Source.each([1, 2, 3, 4, 5])
+    .grouped(2)
+    .run_with(FiberStream::Sink.to_a)
+
+batches # => [[1, 2], [3, 4], [5]]
+```
+
 `Flow.take_while` emits the leading prefix while a predicate is truthy, then
 closes upstream at the first false or nil result:
 
@@ -376,11 +434,30 @@ first =
 first # => [1, 2]
 ```
 
+`Source#merge` emits values from either input source in scheduler-observed
+ready order while preserving each input's own order:
+
+```ruby
+merged =
+  Sync do
+    FiberStream::Source.each([1, 2])
+      .merge(FiberStream::Source.each(["a", "b"]))
+      .run_with(FiberStream::Sink.to_a)
+  end
+
+# Example result: [1, "a", 2, "b"]
+```
+
+`merge` does not make scheduler-unaware blocking source work non-blocking and
+does not provide CPU parallelism. Use producer ractors with
+`Source.ractor_port` or `Source.ractor_merge_ports` when producer work needs
+true isolation.
+
 `Flow.buffer(count)` allows bounded prefetch. `Flow.async`, `Flow.buffer`,
-`Flow.parallel_map`, `Source.io`, `Sink.io`, and `Pipeline#run_async` require an
-installed `Fiber.scheduler` and a non-blocking current fiber when demanded or
-started. FiberStream does not install a scheduler and does not depend on Async
-at runtime.
+`Flow.parallel_map`, `Source.io`, `Source#merge`, `Sink.io`, and
+`Pipeline#run_async` require an installed `Fiber.scheduler` and a non-blocking
+current fiber when demanded or started. FiberStream does not install a
+scheduler and does not depend on Async at runtime.
 
 ## API Surface
 
@@ -389,23 +466,27 @@ Sources:
 - `FiberStream::Source.each(enumerable)`
 - `FiberStream::Source.io(io, chunk_size: 16 * 1024, close: false)`
 - `FiberStream::Source.ractor_port(port, ack_port:, ack_transfer: :copy, cancel: true)`
+- `FiberStream::Source.ractor_merge_ports(ports, ack_transfer: :copy, cancel: true)`
 
 Source convenience methods:
 
 - `Source#via(flow)`
 - `Source#concat(source)`
 - `Source#zip(source)`
+- `Source#merge(source)`
 - `Source#map { |element| ... }`
 - `Source#parallel_map(concurrency:) { |element| ... }`
 - `Source#ractor_map(workers:, input_transfer: :copy, output_transfer: :copy) { |element| ... }`
 - `Source#select { |element| ... }`
 - `Source#take(count)`
 - `Source#drop(count)`
+- `Source#grouped(count)`
 - `Source#take_while { |element| ... }`
 - `Source#drop_while { |element| ... }`
 - `Source#async`
 - `Source#buffer(count)`
 - `Source#lines(chomp: true, max_length: nil)`
+- `Source#split(separator, keep_separator: false, max_length: nil)`
 - `Source#to(sink)`
 - `Source#run_with(sink)`
 
@@ -417,14 +498,20 @@ Flows:
 - `FiberStream::Flow.select { |element| ... }`
 - `FiberStream::Flow.take(count)`
 - `FiberStream::Flow.drop(count)`
+- `FiberStream::Flow.grouped(count)`
 - `FiberStream::Flow.take_while { |element| ... }`
 - `FiberStream::Flow.drop_while { |element| ... }`
 - `FiberStream::Flow.async`
 - `FiberStream::Flow.buffer(count)`
 - `FiberStream::Flow.lines(chomp: true, max_length: nil)`
+- `FiberStream::Flow.split(separator, keep_separator: false, max_length: nil)`
 - `Flow#via(flow)`
 - `Flow#to(sink)`
 
+`lines` and `split` default to `max_length: nil`, which allows one
+unterminated line or frame to buffer without bound. Set a positive
+`max_length` for untrusted, network-facing, or otherwise unbounded inputs.
+
 Sinks:
 
 - `FiberStream::Sink.to_a`
@@ -455,6 +542,7 @@ bundle exec ruby examples/backpressure_buffer.rb
 bundle exec ruby examples/background_execution.rb
 bundle exec ruby examples/ractor_map_hashing.rb
 bundle exec ruby examples/ractor_port_source.rb
+bundle exec ruby examples/ractor_merge_ports_and_map.rb
 bundle exec ruby examples/async_http_requests.rb
 bundle exec ruby examples/async_http_streaming_body.rb
 ```
@@ -468,6 +556,10 @@ with a shareable mapper proc and `input_transfer: :move`.
 `examples/ractor_port_source.rb` demonstrates a producer Ractor that waits for
 `RactorPort::Ack` before sending each `RactorPort::Element`.
 
+`examples/ractor_merge_ports_and_map.rb` demonstrates CPU-bound producer
+Ractors merged with `Source.ractor_merge_ports`, followed by CPU-bound
+verification in `ractor_map` workers.
+
 `examples/async_http_requests.rb` starts a local HTTP server and shows
 FiberStream overlapping independent HTTP request waits with `parallel_map`.
 
@@ -480,6 +572,7 @@ Benchmark scripts live under `benchmarks/`.
 ```sh
 bundle exec ruby benchmarks/stream_transform.rb
 bundle exec ruby benchmarks/latency_overlap.rb
+bundle exec ruby benchmarks/async_io_fanout.rb
 bundle exec ruby benchmarks/heavy_cpu_map.rb
 ```
 

data/examples/README.md

@@ -11,6 +11,7 @@ bundle exec ruby examples/backpressure_buffer.rb
 bundle exec ruby examples/background_execution.rb
 bundle exec ruby examples/ractor_map_hashing.rb
 bundle exec ruby examples/ractor_port_source.rb
+bundle exec ruby examples/ractor_merge_ports_and_map.rb
 bundle exec ruby examples/async_http_requests.rb
 bundle exec ruby examples/async_http_streaming_body.rb
 ```
@@ -47,6 +48,10 @@ pipeline runs.
 `RactorPort::Ack`, and sends one typed `RactorPort::Element` per downstream
 demand.
 
+`ractor_merge_ports_and_map.rb` runs CPU-bound work in multiple producer
+Ractors, merges their port outputs with `Source.ractor_merge_ports`, then runs
+another CPU-bound verification stage with `ractor_map`.
+
 `async_http_requests.rb` starts a local HTTP server and compares serial
 requests with FiberStream `parallel_map` requests. It keeps responses ordered
 while overlapping independent network waits.

data/examples/ractor_merge_ports_and_map.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "digest"
+require "fiber_stream"
+
+PRODUCER_JOBS = [
+  [
+    "producer-a",
+    [
+      { name: "alpha.bin", payload: +"A" * 180_000, seed_rounds: 80, verify_rounds: 60 },
+      { name: "bravo.bin", payload: +"B" * 140_000, seed_rounds: 70, verify_rounds: 55 }
+    ]
+  ],
+  [
+    "producer-b",
+    [
+      { name: "charlie.bin", payload: +"C" * 220_000, seed_rounds: 85, verify_rounds: 65 },
+      { name: "delta.bin", payload: +"D" * 120_000, seed_rounds: 75, verify_rounds: 50 }
+    ]
+  ]
+].freeze
+
+VERIFY_RECORD =
+  Ractor.shareable_proc do |record|
+    digest = record.fetch(:seed_sha256)
+
+    record.fetch(:verify_rounds).times do |index|
+      digest = Digest::SHA256.hexdigest("#{digest}:verify:#{index}")
+    end
+
+    record.merge(final_sha256: digest)
+  end
+
+def spawn_digest_producer(data_port, producer_name, jobs)
+  setup_port = Ractor::Port.new
+  producer =
+    Ractor.new(data_port, setup_port, producer_name, jobs) do |outbox, setup, name, producer_jobs|
+      ack_port = Ractor::Port.new
+      setup.send(ack_port)
+
+      enumerator = producer_jobs.to_enum
+      sent = 0
+
+      loop do
+        case ack_port.receive
+        in FiberStream::RactorPort::Ack
+          begin
+            job = enumerator.next
+            digest = job.fetch(:payload)
+
+            job.fetch(:seed_rounds).times do |index|
+              digest = Digest::SHA256.hexdigest("#{digest}:#{name}:#{index}")
+            end
+
+            sent += 1
+            outbox.send(
+              FiberStream::RactorPort::Element.new(
+                {
+                  producer: name,
+                  name: job.fetch(:name),
+                  bytes: job.fetch(:payload).bytesize,
+                  seed_sha256: digest,
+                  verify_rounds: job.fetch(:verify_rounds)
+                }
+              ),
+              move: true
+            )
+          rescue StopIteration
+            outbox.send(FiberStream::RactorPort::Complete.new)
+            break [:completed, name, sent]
+          end
+        in FiberStream::RactorPort::Cancel[reason]
+          break [:cancelled, name, sent, reason]
+        end
+      end
+    end
+
+  [producer, setup_port.receive]
+end
+
+port_pairs = []
+producers =
+  PRODUCER_JOBS.map do |producer_name, jobs|
+    data_port = Ractor::Port.new
+    producer, ack_port = spawn_digest_producer(data_port, producer_name, jobs)
+    port_pairs << { port: data_port, ack_port: ack_port }
+    producer
+  end
+
+records =
+  FiberStream::Source.ractor_merge_ports(port_pairs)
+    .ractor_map(workers: 2, input_transfer: :move, output_transfer: :move, &VERIFY_RECORD)
+    .run_with(FiberStream::Sink.to_a)
+
+puts "Merged producer Ractors, then verified in ractor_map workers"
+records.each do |record|
+  puts format(
+    "- %-10<producer>s %-11<name>s %7<bytes>d bytes  %<final_sha256>s",
+    producer: record.fetch(:producer),
+    name: record.fetch(:name),
+    bytes: record.fetch(:bytes),
+    final_sha256: record.fetch(:final_sha256)
+  )
+end
+
+puts
+puts "Producer statuses:"
+producers.each do |producer|
+  puts "- #{producer.value.inspect}"
+end
+
+puts
+puts "Source.ractor_merge_ports emits producers in ready order."
+puts "ractor_map preserves that merged input order while running verification in Ractor workers."

data/lib/fiber_stream/errors.rb

@@ -9,7 +9,10 @@ module FiberStream
   #
   # Producer failures, invalid protocol messages, and source-side Ractor port
   # failures use this stable error shape so callers do not need to depend on
-  # Ruby's Ractor transport exceptions.
+  # Ruby's Ractor transport exceptions. For producer failures,
+  # `cause_class_name` and `cause_message` come from the producer's
+  # `RactorPort::Failure` envelope and are included in this error's public
+  # message.
   class RactorPortSourceError < RuntimeError
     attr_reader :kind, :cause_class_name, :cause_message, :original_cause
 

data/lib/fiber_stream/flow.rb

@@ -87,6 +87,19 @@ module FiberStream
       new { |upstream| Pull.drop(upstream, count) }
     end
 
+    # Creates a fixed-size grouping flow.
+    #
+    # The flow emits arrays containing up to `count` adjacent upstream elements.
+    # Full groups contain exactly `count` elements; normal upstream completion
+    # emits one final partial group when one exists. `count` must be a positive
+    # Integer.
+    def self.grouped(count)
+      raise TypeError, "count must be an Integer" unless count.is_a?(Integer)
+      raise ArgumentError, "count must be positive" unless count.positive?
+
+      new { |upstream| Pull.grouped(upstream, count) }
+    end
+
     # Creates a predicate-based limiting flow.
     #
     # The flow emits leading elements while the block result is truthy. The
@@ -142,7 +155,9 @@ module FiberStream
     #
     # The flow accepts String chunks and emits lines split on "\n". By default
     # it chomps the trailing newline and one preceding "\r". `max_length` is an
-    # optional per-line bytesize limit.
+    # optional per-line bytesize limit. With `max_length: nil`, one
+    # unterminated line can buffer without bound. Set a positive `max_length`
+    # for untrusted, network-facing, or otherwise unbounded streams.
     def self.lines(chomp: true, max_length: nil)
       raise TypeError, "chomp must be true or false" unless [true, false].include?(chomp)
       unless max_length.nil? || max_length.is_a?(Integer)
@@ -153,6 +168,27 @@ module FiberStream
       new { |upstream| Pull.lines(upstream, chomp, max_length) }
     end
 
+    # Creates a delimiter-splitting flow.
+    #
+    # The flow accepts String chunks and emits frames split on the non-empty
+    # String `separator`. Separator matching is byte-oriented. By default
+    # emitted frames exclude the separator; `keep_separator: true` preserves it
+    # on separator-terminated frames. `max_length` is an optional per-frame body
+    # bytesize limit. With `max_length: nil`, one unterminated frame can buffer
+    # without bound. Set a positive `max_length` for untrusted, network-facing,
+    # or otherwise unbounded streams.
+    def self.split(separator, keep_separator: false, max_length: nil)
+      raise TypeError, "separator must be String" unless separator.is_a?(String)
+      raise ArgumentError, "separator must not be empty" if separator.empty?
+      raise TypeError, "keep_separator must be true or false" unless [true, false].include?(keep_separator)
+      unless max_length.nil? || max_length.is_a?(Integer)
+        raise TypeError, "max_length must be nil or an Integer"
+      end
+      raise ArgumentError, "max_length must be positive" if max_length&.<= 0
+
+      new { |upstream| Pull.split(upstream, separator, keep_separator, max_length) }
+    end
+
     def self.validate_ractor_transfer_policy!(name, value)
       return if [:copy, :move].include?(value)
 

data/lib/fiber_stream/pull/async_boundary.rb

@@ -9,12 +9,18 @@ module FiberStream
     # time back to the downstream caller, so it adds an async boundary without
     # adding prefetch.
     class AsyncBoundary
+      ValueMessage = Data.define(:value)
+      DoneMessage = Data.define
+      ErrorMessage = Data.define(:error)
+      private_constant :ValueMessage, :DoneMessage, :ErrorMessage
+
       def initialize(upstream)
         @upstream = upstream
         @producer = nil
         @started = false
         @closed = false
         @done = false
+        @upstream_closed = false
       end
 
       def next
@@ -23,14 +29,14 @@ module FiberStream
         start
         message = @producer.resume
 
-        case message.fetch(0)
-        when :value
-          message.fetch(1)
-        when :done
+        case message
+        in ValueMessage[value:]
+          value
+        in DoneMessage
           complete
-        when :error
+        in ErrorMessage[error:]
           @done = true
-          raise message.fetch(1)
+          raise error
         end
       end
 
@@ -39,7 +45,7 @@ module FiberStream
 
         @closed = true
         @done = true
-        @upstream.close
+        close_upstream
       ensure
         cancel_producer
       end
@@ -60,16 +66,16 @@ module FiberStream
 
           value = @upstream.next
           if Pull.done?(value)
-            Fiber.yield([:done])
+            Fiber.yield(DoneMessage.new)
             break
           end
 
-          Fiber.yield([:value, value])
+          Fiber.yield(ValueMessage.new(value:))
         end
       rescue StandardError => exception
-        Fiber.yield([:error, exception]) unless @closed
+        Fiber.yield(ErrorMessage.new(error: exception)) unless @closed
       ensure
-        @upstream.close
+        close_upstream
       end
 
       def complete
@@ -77,7 +83,18 @@ module FiberStream
         DONE
       end
 
+      def close_upstream
+        return if @upstream_closed
+
+        @upstream_closed = true
+        @upstream.close
+      end
+
       def cancel_producer
+        return unless @producer&.alive?
+
+        @producer.kill
+      rescue StandardError
         nil
       end
     end

data/lib/fiber_stream/pull/buffer_boundary.rb

@@ -9,10 +9,17 @@ module FiberStream
     # queue capacity plus in-flight producer/consumer work. Close is responsible
     # for closing upstream and waking any producer blocked on a full queue.
     class BufferBoundary
+      CancellationError = Class.new(StandardError)
+      ValueMessage = Data.define(:value)
+      DoneMessage = Data.define
+      ErrorMessage = Data.define(:error)
+      private_constant :CancellationError, :ValueMessage, :DoneMessage, :ErrorMessage
+
       def initialize(upstream, count)
         @upstream = upstream
         @queue = Thread::SizedQueue.new(count)
         @producer = nil
+        @scheduler = nil
         @started = false
         @closed = false
         @done = false
@@ -27,14 +34,14 @@ module FiberStream
         message = @queue.pop
         return complete if message.nil?
 
-        case message.fetch(0)
-        when :value
-          message.fetch(1)
-        when :done
+        case message
+        in ValueMessage[value:]
+          value
+        in DoneMessage
           complete
-        when :error
+        in ErrorMessage[error:]
           @done = true
-          raise message.fetch(1)
+          raise error
         end
       end
 
@@ -58,7 +65,9 @@ module FiberStream
         raise SchedulerRequiredError, "Flow.buffer requires Fiber.scheduler" unless Fiber.scheduler
 
         @started = true
+        @scheduler = Fiber.scheduler
         @producer = Fiber.schedule { run_producer }
+        cancel_producer if @closed
       end
 
       def run_producer
@@ -67,8 +76,10 @@ module FiberStream
 
           message = pull_message
           break unless deliver(message)
-          break unless message.fetch(0) == :value
+          break unless message.is_a?(ValueMessage)
         end
+      rescue CancellationError
+        nil
       ensure
         @upstream_close_error ||= close_upstream unless @upstream_closed
       end
@@ -77,15 +88,17 @@ module FiberStream
         value = @upstream.next
         return terminal_done_message if Pull.done?(value)
 
-        [:value, value]
+        ValueMessage.new(value:)
+      rescue CancellationError
+        raise
       rescue StandardError => error
         close_upstream(record_error: false)
-        [:error, error]
+        ErrorMessage.new(error:)
       end
 
       def terminal_done_message
         close_error = close_upstream
-        close_error ? [:error, close_error] : [:done]
+        close_error ? ErrorMessage.new(error: close_error) : DoneMessage.new
       end
 
       def deliver(message)
@@ -116,6 +129,11 @@ module FiberStream
       end
 
       def cancel_producer
+        return unless @producer&.alive?
+        return unless @scheduler.respond_to?(:fiber_interrupt)
+
+        @scheduler.fiber_interrupt(@producer, CancellationError.new)
+      rescue NotImplementedError, StandardError
         nil
       end
     end

data/lib/fiber_stream/pull/concat.rb

@@ -8,7 +8,7 @@ module FiberStream
       def initialize(left_materializer, right_materializer)
         @left_materializer = left_materializer
         @right_materializer = right_materializer
-        @left = @left_materializer.call
+        @left = nil
         @right = nil
         @phase = :left
         @closed = false
@@ -38,6 +38,7 @@ module FiberStream
       private
 
       def next_left
+        materialize_left
         value = @left.next
         return value unless Pull.done?(value)
 
@@ -56,6 +57,13 @@ module FiberStream
         DONE
       end
 
+      def materialize_left
+        return if @left
+
+        stream = @left_materializer.call
+        @left = stream
+      end
+
       def close_left
         stream = @left
         return unless stream