rivulet 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f36b4a53bbbe5ad4bf8fff267c5128bd891cbc6e822a5ddac9daf14d04226e1
+  data.tar.gz: 0da92be9908be413dffd62252cdc416f896f2ddf7bfad45acd8cdbc72d659b7a
+SHA512:
+  metadata.gz: 4f209850a7d9eeb8e227c32cac41e5f3c567744744b8e83fc261958b88c2866cac947875a09fb0012b7887f15dc53926a1772525a1bde32fc406541852b852eb
+  data.tar.gz: e86115172c2281b4dfa9dedaa74dbf6780e9de4a78b3b7965a6fbd6ae2389af4de83048323b3a4cd990afffcfd13d394e43681a5bfff1dc461f3150194a95ec2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-05-30
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Brandon Weaver
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,165 @@
+# Rivulet
+
+A small stream with a bit of state flowing through it.
+
+Rivulet gives Ruby a vocabulary for sliding window operations — the grow-shrink-emit pattern that `Enumerable` never named. It sits between `each_cons` (fixed windows, no state) and hand-rolled pointer loops (flexible but noisy).
+
+Near-zero allocations on the hot path. 200k items, single-digit object count.
+
+## Installation
+
+```ruby
+gem "rivulet"
+```
+
+## Usage
+
+### Moving average
+
+```ruby
+Rivulet.sum(latencies).windows(3) { |w| w.average }
+# => [20.0, 30.0, 40.0]
+```
+
+### Batch records under a byte budget
+
+```ruby
+Rivulet.sum(records, &:bytesize)
+  .max_size_while { |w| w.sum <= 1024 }
+# => 12  (max records that fit)
+```
+
+### Minimum subarray meeting a target
+
+```ruby
+Rivulet.sum(nums).min_size_where { |w| w.sum >= target }
+# => 2  (smallest window with sum >= target)
+```
+
+### Longest non-repeating run
+
+```ruby
+Rivulet.count(events)
+  .max_window { |w| !w.repeats? }
+  .max_by { |w| w.size }
+# => 5
+```
+
+### Sliding window maximum (O(n) via monotonic deque)
+
+```ruby
+Rivulet.minmax(prices).windows(20) { |w| w.max }
+# => [103, 105, 105, ...]
+```
+
+### Top-k windows
+
+```ruby
+Rivulet.sum(data).windows(5).max_by(3) { |w| w.average }
+# => [98.2, 95.1, 93.7]
+```
+
+### Minimum window containing all target characters
+
+```ruby
+target = Hash.new(0)
+t.each_char { |c| target[c] += 1 }
+
+Rivulet.count(s.chars)
+  .min_window { |w| w.covers?(target) }
+  .min_by { |w| w.size }
+# => 4  (smallest window covering all of t)
+```
+
+### Early termination
+
+```ruby
+Rivulet.sum(data)
+  .max_window { |w| w.sum <= budget }
+  .first { |w| w.size }
+# => 1  (first valid window's size)
+```
+
+## Window Types
+
+| Entry point | Tracks | Window methods |
+|---|---|---|
+| `Rivulet.sum(source)` | Running total | `sum`, `average`, `size` |
+| `Rivulet.sum(source) { \|item\| ... }` | Derived metric sum | `sum`, `average`, `size` |
+| `Rivulet.count(source)` | Item frequencies | `distinct`, `repeats?`, `max_count`, `covers?`, `sum`, `counts`, `size` |
+| `Rivulet.minmax(source)` | Rolling min/max | `min`, `max`, `range`, `size` |
+| `Rivulet.stats(source)` | All of the above | `sum`, `average`, `min`, `max`, `range`, `distinct`, `repeats?`, `max_count`, `covers?`, `counts`, `size` |
+
+## API
+
+### Building a window stream
+
+```ruby
+stream = Rivulet.sum(data)        # or .count, .minmax
+stream = Rivulet.sum(data) { |item| item.bytesize }  # with mapper
+```
+
+### Fixed-size windows
+
+```ruby
+stream.windows(n)                 # => WindowBuilder
+stream.windows(n) { |w| ... }    # => Array (filter_map semantics)
+```
+
+### Variable-size windows (grow/shrink)
+
+```ruby
+stream.max_window { |w| rule }      # => WindowBuilder (maximize: shrink when invalid)
+stream.min_window { |w| goal }  # => WindowBuilder (minimize: shrink while still valid)
+```
+
+`max_window` grows the window and evicts from the front when the rule fails — use it to find the **largest** window under a constraint.
+
+`min_window` grows the window and shrinks from the front while the goal holds — use it to find the **smallest** window meeting a goal.
+
+### Terminal methods on WindowBuilder
+
+All terminals yield the **live window** — no snapshots allocated.
+
+```ruby
+builder.each_window { |w| ... }   # filter_map: collect non-nil block results
+builder.max_by { |w| ... }        # single best score
+builder.max_by(k) { |w| ... }    # top-k scores (descending)
+builder.min_by { |w| ... }        # single smallest score
+builder.min_by(k) { |w| ... }    # bottom-k scores (ascending)
+builder.first { |w| ... }         # first non-nil result
+builder.first(k) { |w| ... }     # first k non-nil results
+builder.take(k) { |w| ... }      # alias for first(k)
+builder.count                     # number of valid windows
+```
+
+### Reducers (single-value shortcuts)
+
+```ruby
+stream.max_size_while { |w| rule }     # largest window size under constraint
+stream.max_sum_while { |w| rule }      # largest sum under constraint (sum only)
+stream.min_size_where { |w| goal }     # smallest window size meeting goal (sum only)
+stream.max_distinct_while { |w| rule } # most distinct items (count only)
+stream.max_range_while { |w| rule }    # largest range (minmax only)
+```
+
+## Performance
+
+Rivulet's builder path allocates near-zero objects regardless of input size:
+
+```
+200k items, budget 500:
+  max_window.max_by { size }       39 objects
+  max_size_while (reducer)          13 objects
+  windows(5) { average }            18 objects
+```
+
+The `minmax` window uses monotonic deques for O(1) amortized min/max per step. All window types maintain O(1) incremental state updates.
+
+## Requirements
+
+- Ruby >= 3.2
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lefthook.yml

@@ -0,0 +1,13 @@
+pre-commit:
+  commands:
+    rspec:
+      glob: "**/*.rb"
+      run: bundle exec rspec
+    rubyfmt:
+      glob: "**/*.rb"
+      run: rubyfmt --check {staged_files}
+
+pre-push:
+  commands:
+    rspec:
+      run: bundle exec rspec

data/lib/rivulet/count_stream.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class CountStream < Stream
+    def max_distinct_while(&rule)
+      best = 0
+      each_max_window(rule) { |w| best = w.distinct if w.distinct > best }
+      best
+    end
+
+    private
+
+    def new_window = CountWindow.new
+  end
+end

data/lib/rivulet/count_window.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class CountWindow < Window
+    def initialize
+      super
+      @counts = Hash.new(0)
+      @items = []
+      @front = 0
+    end
+
+    def add(item)
+      @counts[item] += 1
+      @items.push(item)
+      super
+    end
+
+    def evict
+      if @front < @items.size
+        item = @items[@front]
+        @counts[item] -= 1
+        @counts.delete(item) if @counts[item].zero?
+        @front += 1
+        super
+        item
+      else
+        super
+        nil
+      end
+    end
+
+    def repeats? = @counts.any? { |_, n| n > 1 }
+    def distinct = @counts.size
+    def max_count = @counts.values.max || 0
+    def counts = @counts
+
+    def covers?(target_counts)
+      target_counts.all? { |k, v| @counts[k] >= v }
+    end
+  end
+end

data/lib/rivulet/deque.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rivulet
+  # A double-ended queue with O(1) push/pop at both ends.
+  # Backed by a growing array with a front index; no element is ever shifted.
+  class Deque
+    def initialize
+      @data  = []
+      @front = 0
+    end
+
+    def push(val) = @data.push(val)
+
+    def pop
+      @data.pop unless empty?
+    end
+
+    def shift
+      @front += 1 unless empty?
+    end
+
+    def first     = @data[@front]
+    def last      = @data.last
+    def any?      = @front < @data.size
+    def empty?    = @front >= @data.size
+  end
+end

data/lib/rivulet/minmax_stream.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class MinMaxStream < Stream
+    def max_range_while(&rule)
+      best = 0
+      each_max_window(rule) { |w| best = w.range if w.range && w.range > best }
+      best
+    end
+
+    private
+
+    def new_window = MinMaxWindow.new
+  end
+end

data/lib/rivulet/minmax_window.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class MinMaxWindow < Window
+    def initialize
+      super
+      @items = []
+      @min_deque = Deque.new
+      @max_deque = Deque.new
+      @front = 0
+    end
+
+    def add(item)
+      idx = @items.size
+      @min_deque.pop while @min_deque.any? && @items[@min_deque.last] >= item
+      @max_deque.pop while @max_deque.any? && @items[@max_deque.last] <= item
+      @min_deque.push(idx)
+      @max_deque.push(idx)
+      @items.push(item)
+      super
+    end
+
+    def evict
+      return super if @front >= @items.size
+
+      @min_deque.shift if @min_deque.first == @front
+      @max_deque.shift if @max_deque.first == @front
+      @front += 1
+      super
+    end
+
+    def min
+      @items[@min_deque.first] unless empty?
+    end
+
+    def max
+      @items[@max_deque.first] unless empty?
+    end
+
+    def range
+      max - min unless empty?
+    end
+  end
+end

data/lib/rivulet/stats_stream.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class StatsStream < Stream
+    private
+
+    def new_window = StatsWindow.new
+  end
+end

data/lib/rivulet/stats_window.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class StatsWindow < MinMaxWindow
+    def initialize
+      super
+      @sum = 0
+      @counts = Hash.new(0)
+    end
+
+    def add(item)
+      @sum += item
+      @counts[item] += 1
+      super
+    end
+
+    def evict
+      if @front < @items.size
+        item = @items[@front]
+        @sum -= item
+        @counts[item] -= 1
+        @counts.delete(item) if @counts[item].zero?
+      end
+      super
+    end
+
+    def sum = @sum
+    def average = empty? ? nil : @sum.fdiv(size)
+
+    def distinct = @counts.size
+    def repeats? = @counts.any? { |_, n| n > 1 }
+    def max_count = @counts.values.max || 0
+    def counts = @counts
+    def covers?(target_counts)
+      target_counts.all? { |k, v| @counts[k] >= v }
+    end
+  end
+end

data/lib/rivulet/stream.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class Stream
+    def initialize(source)
+      @source = source
+    end
+
+    def windows(size, step: 1, &block)
+      raise ArgumentError, "size must be positive" unless size.positive?
+      raise ArgumentError, "step must be positive" unless step.positive?
+
+      builder = WindowBuilder.new(stream: self, mode: :fixed, size: size, step: step)
+      block ? builder.each_window(&block) : builder
+    end
+
+    def tumbling(size, &block)
+      windows(size, step: size, &block)
+    end
+
+    def max_window(&rule)
+      WindowBuilder.new(stream: self, mode: :variable, rule: rule)
+    end
+
+    def min_window(&goal)
+      WindowBuilder.new(stream: self, mode: :satisfied, rule: goal)
+    end
+
+    # @api private — used by WindowBuilder
+    def iterate_windows(mode:, size: nil, rule: nil, step: 1, &block)
+      case mode
+      when :fixed     then iterate_fixed(size: size, step: step, &block)
+      when :variable  then iterate_variable(rule: rule, &block)
+      when :satisfied then iterate_satisfied(rule: rule, &block)
+      # :nocov:
+      else raise ArgumentError, "unknown mode: #{mode}"
+      # :nocov:
+      end
+    end
+
+    private
+
+    def iterate_fixed(size:, step:)
+      window = new_window
+      emit_count = 0
+      @source.each do |item|
+        window.add(item)
+        window.evict while window.size > size
+
+        if window.size == size
+          yield window if (emit_count % step).zero?
+          emit_count += 1
+        end
+      end
+    end
+
+    def iterate_variable(rule:)
+      window = new_window
+      @source.each do |item|
+        window.add(item)
+        window.evict until window.empty? || rule.call(window)
+
+        yield window unless window.empty?
+      end
+    end
+
+    def iterate_satisfied(rule:)
+      window = new_window
+      @source.each do |item|
+        window.add(item)
+
+        until window.empty? || !rule.call(window)
+          yield window
+          window.evict
+        end
+      end
+    end
+
+    def each_max_window(rule)
+      iterate_windows(mode: :variable, rule: rule) { |w| yield w }
+    end
+
+    def new_window = Window.new
+  end
+end

data/lib/rivulet/sum_stream.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class SumStream < Stream
+    def initialize(source, mapper: nil)
+      super(mapper ? source.lazy.map(&mapper) : source)
+    end
+
+    def max_size_while(&rule)
+      best = 0
+      each_max_window(rule) { |w| best = w.size if w.size > best }
+      best
+    end
+
+    def max_sum_while(&rule)
+      best = 0
+      each_max_window(rule) { |w| best = w.sum if w.sum > best }
+      best
+    end
+
+    def min_size_where(&goal)
+      best = nil
+      iterate_windows(mode: :satisfied, rule: goal) do |w|
+        best = w.size if best.nil? || w.size < best
+      end
+      best
+    end
+
+    private
+
+    def new_window = SumWindow.new
+  end
+end

data/lib/rivulet/sum_window.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class SumWindow < Window
+    def initialize
+      super
+      @sum = 0
+      @items = []
+      @front = 0
+    end
+
+    def add(value)
+      @sum += value
+      @items.push(value)
+      super
+    end
+
+    def evict
+      if @front < @items.size
+        @sum -= @items[@front]
+        @front += 1
+      end
+      super
+    end
+
+    def sum = @sum
+
+    def average
+      @sum.fdiv(size) unless empty?
+    end
+  end
+end

data/lib/rivulet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rivulet
+  VERSION = "0.1.0"
+end

data/lib/rivulet/window.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class Window
+    def initialize
+      @size = 0
+    end
+
+    def size = @size
+    def empty? = @size.zero?
+
+    def add(item)
+      @size += 1
+      self
+    end
+
+    def evict
+      @size -= 1 if @size > 0
+    end
+  end
+end

data/lib/rivulet/window_builder.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Rivulet
+  class WindowBuilder
+    def initialize(stream:, mode:, size: nil, rule: nil, step: 1)
+      @stream = stream
+      @mode = mode
+      @size = size
+      @rule = rule
+      @step = step
+    end
+
+    def each_window(&block)
+      results = []
+      iterate do |window|
+        value = block.call(window)
+        results << value if value
+      end
+      results
+    end
+
+    def max_by(k = nil, &block)
+      if k
+        top = []
+        iterate do |window|
+          score = block.call(window)
+          top << score
+          top.sort!.shift if top.size > k
+        end
+        top.sort.reverse
+      else
+        best = nil
+        iterate do |window|
+          score = block.call(window)
+          best = score if best.nil? || score > best
+        end
+        best
+      end
+    end
+
+    def min_by(k = nil, &block)
+      if k
+        top = []
+        iterate do |window|
+          score = block.call(window)
+          top << score
+          top.sort!.pop if top.size > k
+        end
+        top.sort
+      else
+        best = nil
+        iterate do |window|
+          score = block.call(window)
+          best = score if best.nil? || score < best
+        end
+        best
+      end
+    end
+
+    def first(k = nil, &block)
+      if k
+        results = []
+        iterate do |window|
+          value = block ? block.call(window) : window
+          results << value if value
+          break if results.size == k
+        end
+        results
+      else
+        result = nil
+        iterate do |window|
+          result = block ? block.call(window) : window
+          break if result
+        end
+        result
+      end
+    end
+
+    def take(k, &block) = first(k, &block)
+
+    def count
+      n = 0
+      iterate { |_| n += 1 }
+      n
+    end
+
+    private
+
+    def iterate(&block)
+      @stream.iterate_windows(mode: @mode, size: @size, rule: @rule, step: @step, &block)
+    end
+  end
+end

data/lib/rivulet.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "rivulet/version"
+require_relative "rivulet/deque"
+require_relative "rivulet/window"
+require_relative "rivulet/window_builder"
+require_relative "rivulet/stream"
+require_relative "rivulet/sum_window"
+require_relative "rivulet/sum_stream"
+require_relative "rivulet/count_window"
+require_relative "rivulet/count_stream"
+require_relative "rivulet/minmax_window"
+require_relative "rivulet/minmax_stream"
+require_relative "rivulet/stats_window"
+require_relative "rivulet/stats_stream"
+
+module Rivulet
+  def self.sum(source, &mapper) = SumStream.new(source, mapper: mapper || nil)
+  def self.count(source) = CountStream.new(source)
+  def self.minmax(source) = MinMaxStream.new(source)
+  def self.stats(source) = StatsStream.new(source)
+end

data/sig/rivulet.rbs

@@ -0,0 +1,4 @@
+module Rivulet
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: rivulet
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brandon Weaver
+bindir: exe
+cert_chain: []
+date: 2026-06-01 00:00:00.000000000 Z
+dependencies: []
+description: A small stream with a bit of state flowing through it. Rivulet gives
+  Ruby a vocabulary for sliding window operations — the grow-shrink-emit pattern that
+  Enumerable never named.
+email:
+- keystonelemur@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lefthook.yml
+- lib/rivulet.rb
+- lib/rivulet/count_stream.rb
+- lib/rivulet/count_window.rb
+- lib/rivulet/deque.rb
+- lib/rivulet/minmax_stream.rb
+- lib/rivulet/minmax_window.rb
+- lib/rivulet/stats_stream.rb
+- lib/rivulet/stats_window.rb
+- lib/rivulet/stream.rb
+- lib/rivulet/sum_stream.rb
+- lib/rivulet/sum_window.rb
+- lib/rivulet/version.rb
+- lib/rivulet/window.rb
+- lib/rivulet/window_builder.rb
+- sig/rivulet.rbs
+homepage: https://github.com/baweaver/rivulet
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/baweaver/rivulet
+  source_code_uri: https://github.com/baweaver/rivulet
+  changelog_uri: https://github.com/baweaver/rivulet/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.6
+specification_version: 4
+summary: Sliding window operations for Ruby collections
+test_files: []