cohere-transcribe 0.1.1 → 0.1.2

data/lib/cohere/transcribe/dense_converter.rb

@@ -28,6 +28,7 @@ module Cohere
         ▁ <|startofcontext|> <|startoftranscript|> <|emo:undefined|>
         <|ar|> <|pnc|> <|noitn|> <|notimestamp|> <|nodiarize|> <|endoftext|>
       ].freeze
+      MAX_VOCABULARY_SIZE = (1 << 32) - 1
       OUTPUT_TYPES = %i[f16 f32 bf16].freeze
       REQUIRED_ARTIFACT_FILENAMES = %w[config.json tokenizer.json].freeze
       WEIGHT_ARTIFACT_FILENAMES = %w[
@@ -291,7 +292,9 @@ module Cohere
 
       def load_vocabulary
         embedding = fetch_source_tensor("transf_decoder._embedding.token_embedding.weight")
-        unless embedding.shape.length == 2 && embedding.shape[0].positive?
+        unless embedding.shape.length == 2 &&
+               embedding.shape.all? { |dimension| dimension.is_a?(Integer) && dimension.positive? } &&
+               embedding.shape[0] <= MAX_VOCABULARY_SIZE
           raise Error, "Tensor #{embedding.name.inspect} has an invalid vocabulary shape #{embedding.shape.inspect}"
         end
 
@@ -320,13 +323,35 @@ module Cohere
           )
         end
 
-        missing = (0...expected_size).reject { |id| tokens_by_id.key?(id) }
-        raise Error, "tokenizer.json vocabulary has missing token IDs: #{missing.first(8).inspect}" unless missing.empty?
+        ordered_ids = tokens_by_id.keys.sort
+        if ordered_ids.length != expected_size
+          missing = first_missing_vocabulary_ids(ordered_ids, expected_size, limit: 8)
+          raise Error, "tokenizer.json vocabulary has missing token IDs: #{missing.inspect}"
+        end
 
         missing_prompt = REQUIRED_PROMPT_TOKENS.reject { |token| ids_by_token.key?(token) }
         raise Error, "tokenizer.json is missing Cohere prompt tokens: #{missing_prompt.join(", ")}" unless missing_prompt.empty?
 
-        (0...expected_size).map { |id| tokens_by_id.fetch(id) }
+        ordered_ids.map { |id| tokens_by_id.fetch(id) }
+      end
+
+      def first_missing_vocabulary_ids(ordered_ids, expected_size, limit:)
+        missing = []
+        expected_id = 0
+        ordered_ids.each do |id|
+          while expected_id < id && missing.length < limit
+            missing << expected_id
+            expected_id += 1
+          end
+          break if missing.length == limit
+
+          expected_id = id + 1
+        end
+        while expected_id < expected_size && missing.length < limit
+          missing << expected_id
+          expected_id += 1
+        end
+        missing
       end
 
       def add_vocabulary_entry!(tokens_by_id, ids_by_token, token, id, expected_size:)

data/lib/cohere/transcribe/doctor.rb

@@ -282,7 +282,7 @@ module Cohere
         library = native_library || ASR::NativeLibrary.load
         results.ok("native Cohere ASR runtime: #{library.path}")
         report_native_device_capabilities(results, library)
-      rescue StandardError => e
+      rescue LoadError, StandardError => e
         results.fail("native Cohere ASR runtime: #{e.class}: #{e.message}")
       end
 
@@ -347,7 +347,7 @@ module Cohere
           "word aligner: #{Alignment::ModelProvider::REPOSITORY}@#{Alignment::ModelProvider::REVISION}, " \
           "FP32 SHA-256 #{fp32.sha256}, bounded per-segment uniform fallback"
         )
-      rescue StandardError => e
+      rescue LoadError, StandardError => e
         results.fail("word alignment: #{e.class}: #{e.message}")
       end
 

data/lib/cohere/transcribe/hub.rb

@@ -14,6 +14,7 @@ module Cohere
     # clients are reused without copying multi-gigabyte model weights.
     class Hub
       class Error < StandardError; end
+      class ConnectionError < Error; end
       class AuthenticationError < Error; end
       class NotFoundError < Error; end
 
@@ -22,12 +23,17 @@ module Cohere
 
       attr_reader :cache_dir, :endpoint
 
-      def initialize(cache_dir: nil, endpoint: nil, token: nil)
+      def initialize(cache_dir: nil, endpoint: nil, token: nil, offline: nil)
         hf_home = ENV.fetch("HF_HOME", File.expand_path("~/.cache/huggingface"))
         @cache_dir = Pathname(cache_dir || ENV.fetch("HF_HUB_CACHE", File.join(hf_home, "hub"))).expand_path
         @endpoint = (endpoint || ENV.fetch("HF_ENDPOINT", DEFAULT_ENDPOINT)).sub(%r{/+\z}, "")
         @endpoint_uri = URI(@endpoint)
         @token = token || ENV["HF_TOKEN"] || cached_token(hf_home)
+        @offline = offline.nil? ? truthy_environment?(ENV.fetch("HF_HUB_OFFLINE", nil)) : !!offline
+      end
+
+      def offline?
+        @offline
       end
 
       def resolve_revision(repo_id, revision = nil, filename: "config.json")
@@ -36,13 +42,23 @@ module Cohere
         validate_revision!(requested)
         return requested.downcase if COMMIT_PATTERN.match?(requested)
 
-        if (cached = cached_revision(repo_id, requested, filename: filename))
-          return cached
+        cached = cached_revision(repo_id, requested, filename: filename)
+        if offline?
+          return cached if cached
+
+          raise Error,
+                "Hub offline mode has no cached #{filename} snapshot for #{repo_id.inspect} at #{requested.inspect}"
         end
 
         encoded_repo = repo_id.split("/").map { |part| URI.encode_www_form_component(part) }.join("/")
         encoded_revision = URI.encode_www_form_component(requested)
-        response = request(URI("#{endpoint}/api/models/#{encoded_repo}/revision/#{encoded_revision}"))
+        begin
+          response = request(URI("#{endpoint}/api/models/#{encoded_repo}/revision/#{encoded_revision}"))
+        rescue ConnectionError
+          raise unless cached
+
+          return cached
+        end
         payload = JSON.parse(response.body)
         commit = payload["sha"]
         unless commit.is_a?(String) && COMMIT_PATTERN.match?(commit)
@@ -132,6 +148,7 @@ module Cohere
       private
 
       def request(uri, stream: nil, redirects: 0)
+        raise Error, "Hub offline mode prevents a request to #{uri}" if offline?
         raise Error, "Too many redirects while fetching #{uri}" if redirects > 8
 
         request = Net::HTTP::Get.new(uri)
@@ -185,7 +202,7 @@ module Cohere
         raise_http_error!(response, uri)
       rescue Timeout::Error, SocketError, SystemCallError, EOFError,
              Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, OpenSSL::SSL::SSLError => e
-        raise Error, "Cannot reach Hugging Face Hub at #{uri}: #{e.class}: #{e.message}"
+        raise ConnectionError, "Cannot reach Hugging Face Hub at #{uri}: #{e.class}: #{e.message}"
       end
 
       def response_content_length(response, uri)
@@ -382,6 +399,10 @@ module Cohere
         nil
       end
 
+      def truthy_environment?(value)
+        %w[1 ON YES TRUE].include?(value.to_s.upcase)
+      end
+
       def cache_repo_name(repo_id)
         "models--#{repo_id.gsub("/", "--")}"
       end

data/lib/cohere/transcribe/input.rb

@@ -34,12 +34,12 @@ module Cohere
           raise TranscriptionInputError, "#{label} must not be empty" if PythonText.blank?(text)
 
           text.dup.freeze
-        rescue TypeError, ArgumentError, SystemCallError => e
+        rescue EncodingError, TypeError, ArgumentError, SystemCallError => e
           raise e if e.is_a?(TranscriptionInputError)
 
           raise TranscriptionInputError, "#{label} is not a valid text path: #{e.message}"
         end.freeze
-      rescue TypeError, ArgumentError, SystemCallError => e
+      rescue EncodingError, TypeError, ArgumentError, SystemCallError => e
         raise e if e.is_a?(TranscriptionInputError)
 
         raise TranscriptionInputError, "audio is not a valid ordered path sequence: #{e.message}"
@@ -86,7 +86,7 @@ module Cohere
         paths.sort_by { |path| path.to_s.downcase(:fold) }.map do |path|
           [strict_realpath(path), path.relative_path_from(source)]
         end
-      rescue SystemCallError, ArgumentError => e
+      rescue EncodingError, SystemCallError, ArgumentError => e
         raise TranscriptionInputError, "Cannot inspect input #{source}: #{e.message}"
       end
       private_class_method :directory_candidates
@@ -95,7 +95,7 @@ module Cohere
         Pathname(value).expand_path.realpath
       rescue Errno::ENOENT
         raise TranscriptionInputError, "Input does not exist: #{Pathname(value).expand_path}"
-      rescue SystemCallError, ArgumentError => e
+      rescue EncodingError, SystemCallError, ArgumentError => e
         detail = e.is_a?(Errno::ELOOP) ? "Symlink loop" : e.message
         raise TranscriptionInputError, "Invalid input path #{value.inspect}: #{detail}"
       end

data/lib/cohere/transcribe/python_text.rb

@@ -10,6 +10,10 @@ module Cohere
       LEADING_WHITESPACE = /\A#{WHITESPACE_CLASS}+/u
       TRAILING_WHITESPACE = /#{WHITESPACE_CLASS}+\z/u
       WHITESPACE_RUN = /#{WHITESPACE_CLASS}+/u
+      BINARY_WHITESPACE_CLASS = "[\x09-\x0D\x1C-\x20]"
+      BINARY_LEADING_WHITESPACE = /\A#{BINARY_WHITESPACE_CLASS}+/n
+      BINARY_TRAILING_WHITESPACE = /#{BINARY_WHITESPACE_CLASS}+\z/n
+      BINARY_WHITESPACE_RUN = /#{BINARY_WHITESPACE_CLASS}+/n
       # Python 3.12 uses Unicode 15.0. Ruby 4 recognizes a small Unicode 16
       # set whose newly assigned case/compatibility mappings would otherwise
       # make the same input normalize differently from the reference package.
@@ -21,12 +25,15 @@ module Cohere
         *(0x1CCD6..0x1CCF9)
       ].to_h { |codepoint| [codepoint, true] }.freeze
       private_constant :WHITESPACE_CLASS, :LEADING_WHITESPACE, :TRAILING_WHITESPACE, :WHITESPACE_RUN,
+                       :BINARY_WHITESPACE_CLASS, :BINARY_LEADING_WHITESPACE, :BINARY_TRAILING_WHITESPACE,
+                       :BINARY_WHITESPACE_RUN,
                        :UNICODE_15_NORMALIZATION_BOUNDARIES
 
       module_function
 
       def strip(value)
-        value.sub(LEADING_WHITESPACE, "").sub(TRAILING_WHITESPACE, "")
+        leading, trailing, = whitespace_patterns(value)
+        value.sub(leading, "").sub(trailing, "")
       end
 
       def blank?(value)
@@ -35,11 +42,13 @@ module Cohere
 
       def split(value)
         stripped = strip(value)
-        stripped.empty? ? [] : stripped.split(WHITESPACE_RUN)
+        _, _, run = whitespace_patterns(stripped)
+        stripped.empty? ? [] : stripped.split(run)
       end
 
       def collapse(value)
-        strip(value.gsub(WHITESPACE_RUN, " "))
+        _, _, run = whitespace_patterns(value)
+        strip(value.gsub(run, " "))
       end
 
       def nfkc_lower(value)
@@ -64,6 +73,15 @@ module Cohere
       def whitespace_class
         WHITESPACE_CLASS
       end
+
+      def whitespace_patterns(value)
+        if value.encoding == Encoding::ASCII_8BIT
+          [BINARY_LEADING_WHITESPACE, BINARY_TRAILING_WHITESPACE, BINARY_WHITESPACE_RUN]
+        else
+          [LEADING_WHITESPACE, TRAILING_WHITESPACE, WHITESPACE_RUN]
+        end
+      end
+      private_class_method :whitespace_patterns
     end
     private_constant :PythonText
   end

data/lib/cohere/transcribe/pytorch_checkpoint.rb

@@ -25,11 +25,14 @@ module Cohere
       ZIP_CENTRAL_LIMIT = 256 * 1024 * 1024
       ZIP_COMPRESSED_OVERHEAD = 1024 * 1024
       ZIP_INFLATE_CHUNK = 16 * 1024
+      STORAGE_CRC_CHUNK_BYTES = 4 * 1024 * 1024
       ZIP_EOCD = 0x0605_4b50
       ZIP64_EOCD = 0x0606_4b50
       ZIP64_LOCATOR = 0x0706_4b50
       ZIP_CENTRAL = 0x0201_4b50
       ZIP_LOCAL = 0x0403_4b50
+      ZIP64_UINT16_MARKER = 0xffff
+      ZIP64_UINT32_MARKER = 0xffff_ffff
 
       STORAGE_DTYPES = {
         "FloatStorage" => ["F32", 4],
@@ -41,6 +44,7 @@ module Cohere
 
       Global = Data.define(:module_name, :name)
       StorageRef = Data.define(:dtype, :key, :elements, :base_offset)
+      StoragePayload = Data.define(:data_offset, :size, :crc32)
       TensorSpec = Data.define(:storage, :storage_offset, :shape, :stride)
       Entry = Data.define(
         :name, :compression_method, :flags, :crc32, :compressed_size, :size,
@@ -176,10 +180,12 @@ module Cohere
             raise Error, "Multi-disk PyTorch ZIP archives are not supported"
           end
 
-          if [disk_entries, total_entries].include?(0xffff) ||
-             [central_size, central_offset].include?(0xffff_ffff)
-            total_entries, central_size, central_offset = zip64_directory(eocd_offset)
-          end
+          zip64_marker = disk_entries == ZIP64_UINT16_MARKER ||
+                         total_entries == ZIP64_UINT16_MARKER ||
+                         central_size == ZIP64_UINT32_MARKER ||
+                         central_offset == ZIP64_UINT32_MARKER
+          total_entries, central_size, central_offset = zip64_directory(eocd_offset) if
+            zip64_marker && zip64_locator_present?(eocd_offset)
           if total_entries > ZIP_ENTRY_LIMIT || central_size > ZIP_CENTRAL_LIMIT ||
              central_size > size || central_offset > size - central_size
             raise Error, "PyTorch archive #{path} has invalid central-directory bounds"
@@ -215,6 +221,12 @@ module Cohere
           [total_entries, central_size, central_offset]
         end
 
+        def zip64_locator_present?(eocd_offset)
+          return false if eocd_offset < 20
+
+          read_range(eocd_offset - 20, 4).unpack1("V") == ZIP64_LOCATOR
+        end
+
         def parse_central_directory(bytes, expected_entries:, archive_size:, data_limit:)
           offset = 0
           result = {}
@@ -301,9 +313,8 @@ module Cohere
             cursor += length
           end
 
-          required = [size, compressed_size, local_offset, disk].count do |value|
-            [0xffff_ffff, 0xffff].include?(value)
-          end
+          required = [size, compressed_size, local_offset].count(ZIP64_UINT32_MARKER)
+          required += 1 if disk == ZIP64_UINT16_MARKER
           return [size, compressed_size, local_offset, disk] if required.zero?
           raise Error, "PyTorch archive #{path} lacks required ZIP64 size data" unless values
 
@@ -322,10 +333,10 @@ module Cohere
             cursor += 4
             value
           end
-          size = take_qword.call if size == 0xffff_ffff
-          compressed_size = take_qword.call if compressed_size == 0xffff_ffff
-          local_offset = take_qword.call if local_offset == 0xffff_ffff
-          disk = take_dword.call if disk == 0xffff
+          size = take_qword.call if size == ZIP64_UINT32_MARKER
+          compressed_size = take_qword.call if compressed_size == ZIP64_UINT32_MARKER
+          local_offset = take_qword.call if local_offset == ZIP64_UINT32_MARKER
+          disk = take_dword.call if disk == ZIP64_UINT16_MARKER
           [size, compressed_size, local_offset, disk]
         end
 
@@ -771,6 +782,9 @@ module Cohere
         def initialize(path)
           @path = Pathname(path).expand_path
           @storages = {}
+          @storage_payloads = {}
+          @verified_storage_payloads = {}
+          @storage_verification_mutex = Mutex.new
           @tensors = read_checkpoint.freeze
         end
 
@@ -798,6 +812,8 @@ module Cohere
           end
           raise ArgumentError, "chunk_bytes must be positive" unless chunk_bytes.positive?
 
+          verify_storage_payload!(tensor)
+
           source_width = Safetensors::DTYPE_BYTES.fetch(tensor.dtype)
           elements_per_chunk = [chunk_bytes / source_width, 1].max
           bytes_per_chunk = elements_per_chunk * source_width
@@ -874,6 +890,12 @@ module Cohere
               raise Error, "PyTorch storage #{storage.key.inspect} has #{entry.size} bytes; expected #{expected}"
             end
 
+            @storage_payloads[storage.key] ||= StoragePayload.new(
+              data_offset: entry.data_offset,
+              size: entry.size,
+              crc32: entry.crc32
+            )
+
             entry.data_offset
           end
         end
@@ -1013,6 +1035,41 @@ module Cohere
           true
         end
 
+        def verify_storage_payload!(tensor)
+          payload = @storage_payloads[tensor.storage_key]
+          return unless payload
+
+          @storage_verification_mutex.synchronize do
+            return if @verified_storage_payloads.key?(tensor.storage_key)
+
+            verify_storage_crc!(tensor.storage_key, payload)
+            @verified_storage_payloads[tensor.storage_key] = true
+          end
+        end
+
+        def verify_storage_crc!(storage_key, payload)
+          crc32 = 0
+          remaining = payload.size
+          File.open(path, "rb") do |source|
+            source.seek(payload.data_offset)
+            while remaining.positive?
+              requested = [remaining, STORAGE_CRC_CHUNK_BYTES].min
+              chunk = source.read(requested)
+              if chunk.nil? || chunk.bytesize != requested
+                raise Error, "Unexpected end of #{path} while checking storage #{storage_key.inspect}"
+              end
+
+              crc32 = Zlib.crc32(chunk, crc32)
+              remaining -= requested
+            end
+          end
+          return if crc32 == payload.crc32
+
+          raise Error, "PyTorch tensor storage #{storage_key.inspect} failed its CRC check"
+        rescue Errno::ENOENT, Errno::EACCES => e
+          raise Error, "Cannot read PyTorch checkpoint #{path}: #{e.message}"
+        end
+
         # General strided tensors occur in legitimate torch state dictionaries
         # (notably transposed projection weights). A read-only file mapping
         # keeps heap usage bounded while preserving logical row-major order.

data/lib/cohere/transcribe/runtime/engine.rb

@@ -249,12 +249,22 @@ module Cohere
             nil
           end
           memory_byte_limit = [(resolved_options.audio_memory_gb * (1024**3)).to_i, 1].max
+          estimate_bytes = if @decoder.respond_to?(:estimate_decoded_bytes)
+                             lambda do |item|
+                               @decoder.estimate_decoded_bytes(
+                                 item.entry.path,
+                                 backend: resolved_options.audio_backend,
+                                 sample_rate: SAMPLE_RATE
+                               )
+                             end
+                           end
           pipeline = Preparation::Pipeline.new(
             preparation_items,
             memory_byte_limit: memory_byte_limit,
             requested_workers: resolved_options.preprocess_workers,
             enabled: resolved_options.pipeline_preparation,
-            worker_limit: vad_file_concurrency_limit(resolved_options)
+            worker_limit: vad_file_concurrency_limit(resolved_options),
+            estimate_bytes: estimate_bytes
           ) do |item, decoded_byte_limit, worker_slot|
             prepare_entry(
               item,

data/lib/cohere/transcribe/runtime/preparation.rb

@@ -10,6 +10,7 @@ module Cohere
       module Preparation
         MAX_PIPELINE_GROUP_BYTES = 512 * (1024**2)
         MAX_GROUP_JOBS = 128
+        ESTIMATE_HEADROOM = 0.05
 
         # The result of decode and VAD preparation. Timings are accumulated by
         # the engine on the consuming thread, keeping statistics deterministic.
@@ -29,13 +30,17 @@ module Cohere
         # Bounded ordered preparation with at most one group ahead of ASR.
         #
         # A pipelined group receives at most half of the configured decoded-PCM
-        # budget (and never more than 512 MiB). Jobs inside it divide that cap,
-        # so the current and one in-flight next group cannot together exceed the
-        # configured PCM budget. Native decoder implementation transients are
-        # outside this retained-PCM accounting, as they are in the Python path.
+        # budget (and never more than 512 MiB). Estimated decode sizes determine
+        # group membership and per-file ceilings. A file that cannot fit that cap
+        # is prepared alone with the full configured ceiling and without overlap.
+        # Native decoder implementation transients are outside this retained-PCM
+        # accounting, as they are in the Python path.
         class Pipeline
           include Enumerable
 
+          Group = Data.define(:items, :limits, :exclusive)
+          private_constant :Group
+
           class WorkerPool
             STOP = Object.new.freeze
 
@@ -60,10 +65,10 @@ module Cohere
               end
             end
 
-            def prepare(group, per_file_limit)
-              responses = group.each_with_index.map do |item, slot|
+            def prepare(group)
+              responses = group.items.each_with_index.map do |item, slot|
                 response = Queue.new
-                @queues.fetch(slot) << [item, per_file_limit, response]
+                @queues.fetch(slot) << [item, group.limits.fetch(slot), response]
                 response
               end
               responses.map do |response|
@@ -88,7 +93,8 @@ module Cohere
 
           attr_reader :effective_workers, :group_byte_limit, :memory_byte_limit, :wait_seconds
 
-          def initialize(items, memory_byte_limit:, requested_workers:, enabled:, worker_limit: nil, &prepare)
+          def initialize(items, memory_byte_limit:, requested_workers:, enabled:, worker_limit: nil,
+                         estimate_bytes: nil, &prepare)
             raise ArgumentError, "prepare block is required" unless prepare
 
             @items = items.to_a.freeze
@@ -96,6 +102,7 @@ module Cohere
             raise ArgumentError, "memory_byte_limit must be positive" unless @memory_byte_limit.positive?
 
             @prepare = prepare
+            @estimate_bytes = estimate_bytes
             @wait_seconds = 0.0
             @enabled = enabled && @items.length > 1
             @worker_limit = worker_limit.nil? ? nil : Integer(worker_limit)
@@ -122,14 +129,16 @@ module Cohere
               return
             end
 
-            groups = @items.each_slice(@effective_workers).to_a
+            groups = build_groups
             pool = WorkerPool.new(@effective_workers, &@prepare)
             pending = submit(groups.first, 0, pool)
-            groups.each_with_index do |_group, group_index|
+            groups.each_with_index do |group, group_index|
               prepared = resolve(pending)
               pending = nil
-              pending = submit(groups.fetch(group_index + 1), group_index + 1, pool) if group_index + 1 < groups.length
+              next_group = groups[group_index + 1]
+              pending = submit(next_group, group_index + 1, pool) if next_group && !group.exclusive && !next_group.exclusive
               consume(prepared, &block)
+              pending ||= submit(next_group, group_index + 1, pool) if next_group
             end
             completed = true
           ensure
@@ -179,8 +188,67 @@ module Cohere
           end
 
           def prepare_group(group, pool)
-            per_file_limit = [@group_byte_limit / group.length, 1].max
-            pool.prepare(group, per_file_limit)
+            pool.prepare(group)
+          end
+
+          def build_groups
+            return equal_groups unless @estimate_bytes
+
+            groups = []
+            items = []
+            estimates = []
+            @items.each do |item|
+              estimate = estimated_reservation(item)
+              if estimate.nil? || estimate > @group_byte_limit
+                groups << bounded_group(items, estimates) unless items.empty?
+                groups << Group.new(items: [item].freeze, limits: [@memory_byte_limit].freeze, exclusive: true)
+                items = []
+                estimates = []
+                next
+              end
+
+              if items.length >= @effective_workers || estimates.sum + estimate > @group_byte_limit
+                groups << bounded_group(items, estimates)
+                items = []
+                estimates = []
+              end
+              items << item
+              estimates << estimate
+            end
+            groups << bounded_group(items, estimates) unless items.empty?
+            groups
+          end
+
+          def equal_groups
+            @items.each_slice(@effective_workers).map do |items|
+              limit = [@group_byte_limit / items.length, 1].max
+              Group.new(items: items.freeze, limits: Array.new(items.length, limit).freeze, exclusive: false)
+            end
+          end
+
+          def estimated_reservation(item)
+            value = @estimate_bytes.call(item)
+            return if value.nil?
+
+            bytes = Integer(value)
+            return unless bytes.positive?
+
+            [(bytes * (1.0 + ESTIMATE_HEADROOM)).ceil, 1].max
+          rescue ArgumentError, TypeError, SystemCallError
+            nil
+          end
+
+          def bounded_group(items, estimates)
+            limits = estimates.dup
+            remaining = @group_byte_limit - limits.sum
+            if remaining.positive?
+              weight = limits.sum
+              extras = limits.map { |limit| (remaining * limit).div(weight) }
+              leftover = remaining - extras.sum
+              extras[limits.each_index.max_by { |index| limits.fetch(index) }] += leftover
+              limits = limits.each_index.map { |index| limits.fetch(index) + extras.fetch(index) }
+            end
+            Group.new(items: items.freeze, limits: limits.freeze, exclusive: false)
           end
 
           def consume(prepared, &block)