task_progress 0.0.1

data/sig/generated/task_progress/memory_stream_store.rbs

@@ -0,0 +1,83 @@
+# Generated from lib/task_progress/memory_stream_store.rb with RBS::Inline
+
+class TaskProgress
+  # A stream store kept in this process - a stream per tree, each under its own key: what
+  # TaskProgress.stream_store is until told otherwise, and what the tests and the bench run on.
+  # It does what RedisStreamStore does - append-only entries under a
+  # key, read from an id on and waited for, trimmed from the front, plus plain values that
+  # expire - so a tree handed off here behaves as one handed off through Redis, as long as the
+  # job runs in the same process.
+  #
+  # Ids are "n-0", like Redis's, and grow across all keys. Safe to share between threads.
+  #
+  # `set`, `trim`, `delete` and `expire` take a `guard:` - a key and the value it must hold - and
+  # do nothing, returning false, unless it does. Checked and done in one step, which is what keeps
+  # a writer another has replaced from writing over it, see StreamOutput
+  class MemoryStreamStore
+    @namespace: String?
+
+    @appended: Thread::ConditionVariable
+
+    @lock: Thread::Mutex
+
+    @counter: Integer
+
+    @expiries: Hash[String, Float]
+
+    @values: Hash[String, String]
+
+    @entries: Hash[String, Array[[ Integer, String ]]]
+
+    # An empty store. With a `namespace`, its keys go under it - see RedisStreamStore
+    # : (?namespace: String?) -> void
+    def initialize: (?namespace: String?) -> void
+
+    # Adds `data` at the end of the stream at `key`, and returns its id
+    # : (String, String) -> String
+    def append: (String, String) -> String
+
+    # The entries after the id `after` - all of them when it is nil - as `[id, data]` pairs. With
+    # a `timeout`, waits up to that many seconds for one to come when there are none yet
+    # : (String, ?after: String?, ?timeout: (Integer | Float)?) -> Array[[String, String]]
+    def read: (String, ?after: String?, ?timeout: (Integer | Float)?) -> Array[[ String, String ]]
+
+    # The value at `key`, or nil
+    # : (String) -> String?
+    def get: (String) -> String?
+
+    # Keeps `value` at `key`, for `expires_in` seconds if given
+    # : (String, String, ?expires_in: (Integer | Float)?, ?guard: [String, String]?) -> bool
+    def set: (String, String, ?expires_in: (Integer | Float)?, ?guard: [ String, String ]?) -> bool
+
+    # Forgets the streams and values at these keys
+    # : (*String, ?guard: [String, String]?) -> bool
+    def delete: (*String, ?guard: [ String, String ]?) -> bool
+
+    # Drops the entries before the id `before`
+    # : (String, before: String, ?guard: [String, String]?) -> bool
+    def trim: (String, before: String, ?guard: [ String, String ]?) -> bool
+
+    # Forgets what is at `key` - a stream or a value - `seconds` from now
+    # : (String, Integer | Float, ?guard: [String, String]?) -> bool
+    def expire: (String, Integer | Float, ?guard: [ String, String ]?) -> bool
+
+    private
+
+    # Runs the block under the lock if the guard holds, and says whether it did
+    # : ([String, String]?) { () -> void } -> bool
+    def guarded: ([ String, String ]?) { () -> void } -> bool
+
+    # : (String) -> String
+    def ns: (String) -> String
+
+    # : () -> Float
+    def now: () -> Float
+
+    # Always nil, so a reader can `||` past it
+    # : (String) -> nil
+    def expire_locked: (String) -> nil
+
+    # : (String) -> void
+    def forget: (String) -> void
+  end
+end

data/sig/generated/task_progress/mount.rbs

@@ -0,0 +1,200 @@
+# Generated from lib/task_progress/mount.rb with RBS::Inline
+
+class TaskProgress
+  # Grafts a tree that lives elsewhere under one node of this one. The remote root lands on the
+  # mount node itself and its `["x3k0"]` on `[*mount, "x3k0"]`, so mounting is prefixing, and
+  # a relay through several processes prefixes once per hop.
+  #
+  # The mount node is sealed: only its Mount writes under it, so a remote can never touch a
+  # node outside its prefix - nor rename or reweigh the mount, which stay the parent's to set.
+  # Each remote batch is re-committed here as one batch, or dropped whole if it does not apply.
+  # A batch that does not follow the last one (a gap) marks the subtree stale, and it stays so
+  # until a batch with `prev` 0 replaces it whole.
+  #
+  # Fed from a stream (see #follow_stream) it goes by the latest writer instead: a batch with
+  # `prev` 0 from a log it has not seen is a new run - a job retried, a worker that took over -
+  # and replaces the subtree whole, even one that had finished, while what the old writer still
+  # sends is ignored
+  class Mount
+    # The log the mount node lives in
+    attr_reader log: Log
+
+    # The mount node
+    attr_reader path: path
+
+    @control: IO?
+
+    @last_seq: Integer?
+
+    @control_lock: Thread::Mutex
+
+    @pid_lock: Thread::Mutex
+
+    @source: String?
+
+    @stale: bool
+
+    @remote_ended: bool
+
+    @controlled: bool
+
+    @reaped: bool
+
+    @own: bool
+
+    @following: bool
+
+    @forward: (^(String) -> void)?
+
+    @reader: StreamReader?
+
+    @follower: Thread?
+
+    @stopping: bool
+
+    @silent: bool
+
+    @gave_up: bool
+
+    @generation: Integer
+
+    # For the node at `path` - see TaskProgress#mount, which opens one. Unless `own`, the
+    # remote's root names and weighs the mount node too - for a tree that is nothing but a mount,
+    # as TaskProgress.follow makes
+    # : (Log, path, ?own: bool) -> void
+    def initialize: (Log, path, ?own: bool) -> void
+
+    # The mount node, as a task of this tree
+    # : () -> TaskProgress
+    def task: () -> TaskProgress
+
+    # Whether a batch went missing, and the subtree waits for a fresh squash
+    # : () -> bool
+    def stale?: () -> bool
+
+    # Takes a Batch, its Hash form, or a line of NDJSON. Returns :applied, :gap, :rejected, or
+    # :duplicate for one already applied - redelivery is ordinary after a reconnect or a replay.
+    # Following a stream, a batch from a writer another has since replaced is :superseded
+    # : (Batch | Hash[untyped, untyped] | String) -> Symbol
+    def <<: (Batch | Hash[untyped, untyped] | String) -> Symbol
+
+    # Reads NDJSON batches off an IO until EOF
+    # : (IO) -> self
+    def read: (IO) -> self
+
+    # Runs a command with TASK_PROGRESS_FD pointing at a pipe, follows it until it exits, and
+    # returns its Process::Status. A child that exits without finishing its root fails the mount.
+    #
+    # A second pipe, TASK_PROGRESS_CONTROL_FD, carries cancel requests the other way, so tasks in
+    # the child can be canceled from here - see #request_cancel; TaskProgress.cli reads it. When
+    # the mount itself is canceled, the child is asked to cancel its root, and is sent TERM if it
+    # is still running `grace` seconds later. Interrupted (Ctrl-C, a timeout), it terminates the
+    # child at once
+    # : (*untyped command, ?grace: Integer | Float, **untyped options) -> Process::Status?
+    def spawn: (*untyped command, ?grace: Integer | Float, **untyped options) -> Process::Status?
+
+    # Follows the tree a StreamOutput writes to `stream` at `key` - what TaskProgress.handoff and
+    # TaskProgress.adopt write - on a thread of its own, checking every `poll` seconds. Cancel
+    # requests go back to the writer through the stream, and canceling the mount asks the writer
+    # to cancel its root.
+    #
+    # It also minds whether the writer is alive. Once one has been, a writer that stops beating
+    # marks the subtree stale, and fails the mount if it stays silent for `give_up_after`
+    # seconds - unless a new run comes along later and replaces it, as a retried job does. A
+    # tree nobody has taken up yet is waiting, not silent. Following ends once the mount is done
+    # or canceled, or the log is closed - a failed one is kept an eye on, for a retry
+    #
+    # With `watch: false` it takes what is there once, and leaves catching up again to
+    # #catch_up - for a tree read once, see TaskProgress.fetch
+    # : (untyped, String, ?poll: Integer | Float, ?give_up_after: Integer | Float, ?watch: bool) -> self
+    def follow_stream: (untyped, String, ?poll: Integer | Float, ?give_up_after: Integer | Float, ?watch: bool) -> self
+
+    # Takes what the stream has for it - waiting up to `timeout` seconds when it has nothing yet -
+    # and returns how many batches it applied. #follow_stream does this over and over
+    # : (?timeout: (Integer | Float)?) -> Integer
+    def catch_up: (?timeout: (Integer | Float)?) -> Integer
+
+    # Stops following, see #follow_stream - closing the log does it
+    # : () -> void
+    def stop_following: () -> void
+
+    # Passes a cancel request on to the child, for the task at `path` in its own tree. Returns
+    # :forwarded, or :moot when there is no child to ask any more - it has exited, or this mount
+    # was never spawned. Whether the child cancels anything shows up the stream, if it does
+    # : (path, ?String?) -> (:forwarded | :moot)
+    def request_cancel: (path, ?String?) -> (:forwarded | :moot)
+
+    private
+
+    # The parent may still end the subtree - when the remote went away, say. From outside, end
+    # the mount's own task: `mount.task.done!`
+    # : () -> self
+    def done!: () -> self
+
+    # Fails the mount, and cancels what the remote left open under it
+    # : (?(Exception | String)?, **bool | Integer) -> self
+    def fail!: (?(Exception | String)?, **bool | Integer) -> self
+
+    # Cancels the mount, and what the remote left open under it
+    # : (?String?) -> self
+    def cancel!: (?String?) -> self
+
+    # Whether the mount node has ended
+    # : () -> bool
+    def finished?: () -> bool
+
+    # : (Integer | Float, Integer | Float) -> void
+    def watch: (Integer | Float, Integer | Float) -> void
+
+    # Canceling the mount asks the remote to cancel its root - the run there is now, once
+    # : () -> void
+    def arm_cancel: () -> void
+
+    # The writer beats again, and nothing went missing meanwhile
+    # : () -> void
+    def speaks_again: () -> void
+
+    # The mount node as a new run finds it: its own name and weight, nothing done yet
+    # : (State) -> Hash[Symbol, untyped]
+    def fresh: (State) -> Hash[Symbol, untyped]
+
+    # Ending the mount ends what the remote left open under it too, as Task#done! and #fail! do
+    # : (Symbol) { (Transaction) -> void } -> self
+    def finish: (Symbol) { (Transaction) -> void } -> self
+
+    # : (Batch | Hash[untyped, untyped] | String) -> Batch?
+    def coerce: (Batch | Hash[untyped, untyped] | String) -> Batch?
+
+    # In the transaction given, or one of its own
+    # : (?Transaction?) -> void
+    def mark_stale: (?Transaction?) -> void
+
+    # The remote's events, moved under the mount - or nil if one would land too deep
+    # : (Array[Event], Float) -> Array[Event]?
+    def translate: (Array[Event], Float) -> Array[Event]?
+
+    # Asks the child to cancel its root, and sends TERM if it has not exited `grace` seconds on
+    # : (Integer, Integer | Float) -> void
+    def stop: (Integer, Integer | Float) -> void
+
+    # The pid is only ever signaled while it is still ours: reaping and signaling share a lock, so
+    # a signal can never reach another process that was given the pid after ours exited
+    # : (Integer, Symbol) -> void
+    def signal: (Integer, Symbol) -> void
+
+    # : (Integer) -> Process::Status?
+    def reap: (Integer) -> Process::Status?
+
+    TIMES: Array[Symbol]
+
+    ENDINGS: Array[Symbol]
+
+    FINISHED: Array[Symbol]
+
+    # : (Hash[Symbol, untyped], Float) -> Hash[Symbol, untyped]
+    def rebased: (Hash[Symbol, untyped], Float) -> Hash[Symbol, untyped]
+
+    # : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+    def own_put: (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+  end
+end

data/sig/generated/task_progress/ndjson_output.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/task_progress/ndjson_output.rb with RBS::Inline
+
+class TaskProgress
+  # One batch per line, for a Mount at the other end of a pipe. Each line goes out in one
+  # write, so a reader never sees a batch half-written unless the writer died writing it -
+  # and Wire.each_batch drops that one
+  class NDJSONOutput
+    @io: IO | StringIO
+
+    # Writes to `io`, which it makes sync
+    # : (IO | StringIO) -> void
+    def initialize: (IO | StringIO) -> void
+
+    # Writes the batch as one line
+    # : (Batch, Log) -> void
+    def call: (Batch, Log) -> void
+  end
+end

data/sig/generated/task_progress/node.rbs

@@ -0,0 +1,66 @@
+# Generated from lib/task_progress/node.rb with RBS::Inline
+
+class TaskProgress
+  # One task, as the tree holds it, see below
+  class Node < Struct[String | Integer? | Integer | Integer | Float | Float | bool? | String? | Symbol | Hash[Symbol, untyped]? | Float? | Array[String] | Mount?]
+    attr_accessor name(): String
+
+    attr_accessor total(): Integer?
+
+    attr_accessor count(): Integer
+
+    attr_accessor percent(): Integer | Float
+
+    attr_accessor weight(): Float
+
+    attr_accessor expect(): Integer?
+
+    attr_accessor indeterminate(): bool?
+
+    attr_accessor unit(): String?
+
+    attr_accessor cancelable(): bool?
+
+    attr_accessor attempt(): Integer?
+
+    attr_accessor message(): String?
+
+    attr_accessor status(): Symbol
+
+    attr_accessor error(): Hash[Symbol, untyped]?
+
+    attr_accessor stale(): bool?
+
+    attr_accessor opened_at(): Float
+
+    attr_accessor started_at(): Float?
+
+    attr_accessor finished_at(): Float?
+
+    attr_accessor children(): Array[String]
+
+    attr_accessor sealed(): Mount?
+
+    attr_accessor autofinish(): bool?
+
+    def self.new: (?String name, ?Integer? total, ?Integer count, ?Integer | Float percent, ?Float weight, ?Integer? expect, ?bool? indeterminate, ?String? unit, ?bool? cancelable, ?Integer? attempt, ?String? message, ?Symbol status, ?Hash[Symbol, untyped]? error, ?bool? stale, ?Float opened_at, ?Float? started_at, ?Float? finished_at, ?Array[String] children, ?Mount? sealed, ?bool? autofinish) -> instance
+                | (?name: String, ?total: Integer?, ?count: Integer, ?percent: Integer | Float, ?weight: Float, ?expect: Integer?, ?indeterminate: bool?, ?unit: String?, ?cancelable: bool?, ?attempt: Integer?, ?message: String?, ?status: Symbol, ?error: Hash[Symbol, untyped]?, ?stale: bool?, ?opened_at: Float, ?started_at: Float?, ?finished_at: Float?, ?children: Array[String], ?sealed: Mount?, ?autofinish: bool?) -> instance
+  end
+
+  # One task, as the tree holds it - what an output or a renderer reads: its name, status, count
+  # and the rest of State::FIELDS. `children` (their ids), `sealed` (the Mount that feeds it) and
+  # `autofinish` are the tree's own bookkeeping, and never go over the wire
+  class Node
+    # Ended by a `done`, `fail` or `cancel` of its own - whatever is still open under it
+    # : () -> bool
+    def finished?: () -> bool
+
+    # As a `put` carries it: State::FIELDS, without what is at its default
+    # : () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+
+    # A copy whose list of children can change without changing this one
+    # : () -> Node
+    def deep_dup: () -> Node
+  end
+end

data/sig/generated/task_progress/poll.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/task_progress/poll.rb with RBS::Inline
+
+class TaskProgress
+  # The tree over plain GETs, for where Server-Sent Events do not get through - a proxy that
+  # buffers, a host that cuts long responses, a client that is not a browser. Every answer is
+  # the whole tree, squashed into one batch with `prev` 0, and its ETag says which tree that is:
+  # a client that sends it back in `If-None-Match` gets a 304 until something changes.
+  #
+  # Asked with `?wait=N`, it holds the request up to N seconds (`max_wait` at most) for a change
+  # before saying 304 - long polling, which holds a server thread for that long, but answers
+  # the moment there is news. `followPollingAt` in `task_tree.js` does all of this.
+  #
+  #     # Rack
+  #     TaskProgress::Poll.response(task, env)
+  #     # Rails
+  #     status, headers, body = TaskProgress::Poll.response(task, request.env)
+  #     render json: body.first, status:, headers:
+  #
+  # Given a key instead of a task - a tree handed off with TaskProgress.handoff - it reads that
+  # tree from the stream, following it for as long as a long poll waits, and answers 404 for a
+  # key with nothing at it
+  module Poll
+    # What a poll is answered with
+    HEADERS: Hash[String, String]
+
+    # A whole Rack response for the task's tree - its subtree, for a subtask - or for the tree
+    # handed off at a key, in `stream`
+    # : (TaskProgress | String, ?Hash[String, untyped], ?stream_store: untyped, ?max_wait: Integer | Float) -> [Integer, Hash[String, String], Array[String]]
+    def self.response: (TaskProgress | String, ?Hash[String, untyped], ?stream_store: untyped, ?max_wait: Integer | Float) -> [ Integer, Hash[String, String], Array[String] ]
+
+    # : (TaskProgress, Hash[String, untyped], Float) -> [Integer, Hash[String, String], Array[String]]
+    def self.answer: (TaskProgress, Hash[String, untyped], Float) -> [ Integer, Hash[String, String], Array[String] ]
+
+    # Which tree a squash is: the same tree, however many batches it took, gets the same tag. Times
+    # are left out - a tree read from a stream has them moved onto this clock, a little differently
+    # every read, and they never change without something else changing with them
+    # : (Batch) -> String
+    def self.etag: (Batch) -> String
+
+    TIMES: Array[Symbol]
+
+    # The tags a client already has. A proxy that compresses the answer makes the tag weak, W/"..."
+    # : (Hash[String, untyped]) -> Array[String]
+    def self.seen: (Hash[String, untyped]) -> Array[String]
+
+    # The seconds asked for in `?wait=`, up to `max_wait`
+    # : (Hash[String, untyped], Integer | Float) -> Float
+    def self.wait: (Hash[String, untyped], Integer | Float) -> Float
+  end
+end

data/sig/generated/task_progress/publishing_output.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/task_progress/publishing_output.rb with RBS::Inline
+
+class TaskProgress
+  # Hands each batch, as its JSON-ready Hash, to anything with `publish(event_name, payload)`
+  # - a Sossego::Stream, for one. A reader turns it back into a Batch with Wire.from_h, or
+  # feeds it to a Mount as it is
+  class PublishingOutput
+    interface _Publisher
+      def publish: (String event_name, Hash[Symbol, untyped] payload) -> void
+    end
+
+    @target: _Publisher
+
+    @event_name: String
+
+    # Publishes to `target` - a Sossego stream, or anything with `publish(event_name, payload)`
+    # : (_Publisher, ?event_name: String) -> void
+    def initialize: (_Publisher, ?event_name: String) -> void
+
+    # Publishes the batch as a JSON-ready Hash
+    # : (Batch, Log) -> void
+    def call: (Batch, Log) -> void
+  end
+end

data/sig/generated/task_progress/ractor_output.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/task_progress/ractor_output.rb with RBS::Inline
+
+class TaskProgress
+  # Sends each batch to a Ractor::Port, as a deep frozen copy - for a tree built inside a
+  # Ractor and mounted outside it: `mount << port.receive`. Ruby 4.0 and up only
+  class RactorOutput
+    @port: untyped
+
+    # Sends to a `Ractor::Port`. Raises NotImplementedError before Ruby 4.0
+    # : (untyped) -> void
+    def initialize: (untyped) -> void
+
+    # Sends a deep frozen copy of the batch to the port
+    # : (Batch, Log) -> void
+    def call: (Batch, Log) -> void
+  end
+end

data/sig/generated/task_progress/rails_defaults.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/task_progress/rails_defaults.rb with RBS::Inline
+
+class TaskProgress
+  # What TaskProgress.broadcast and the `task_progress_tree` helper use when Rails is there and
+  # nothing else is given: the record's dom_id, Turbo::StreamsChannel, Rails.cache, and tokens
+  # signed with a key the app's secret_key_base derives. Without Rails, nothing - and the caller
+  # says what to broadcast to. The record is streamed to as `[record, :task_progress]`
+  module RailsDefaults
+    # The id the tree's element has, for a record or a string
+    # : (untyped) -> String
+    def self.id: (untyped) -> String
+
+    # The store key the latest frame is kept under
+    # : (untyped) -> String
+    def self.key: (untyped) -> String
+
+    # The defaults for what is not given, or nothing outside Rails
+    # : (untyped) -> Hash[Symbol, untyped]
+    def self.for: (untyped) -> Hash[Symbol, untyped]
+
+    # Tokens for the cancel buttons, signed with a key derived from the app's secret
+    # : () -> Token
+    def self.tokens: () -> Token
+
+    # Where the cancel buttons post, or nil when the app has turned that off
+    # : () -> String?
+    def self.cancellations_path: () -> String?
+
+    # Whether this runs in a Rails app
+    # : () -> bool
+    def self.rails?: () -> bool
+  end
+end

data/sig/generated/task_progress/recording_output.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/task_progress/recording_output.rb with RBS::Inline
+
+class TaskProgress
+  # Keeps every batch it gets, for a test to look through:
+  #
+  #     recording = TaskProgress::RecordingOutput.new
+  #     Importer.new(progress: TaskProgress.new("Import", outputs: [recording])).run
+  #     assert_includes recording.said, "Skipped 3 rows"
+  #     assert_equal 1, recording.events(:fail).length
+  #
+  # Safe to share between threads
+  class RecordingOutput
+    @batches: Array[Batch]
+
+    @lock: Thread::Mutex
+
+    # Nothing recorded yet
+    # : () -> void
+    def initialize: () -> void
+
+    # Records the batch
+    # : (Batch, Log) -> void
+    def call: (Batch, Log) -> void
+
+    # Every batch so far, in order
+    # : () -> Array[Batch]
+    def batches: () -> Array[Batch]
+
+    # Every event so far, in order - only those with the op `op`, if given
+    # : (?Symbol?) -> Array[Event]
+    def events: (?Symbol?) -> Array[Event]
+
+    # What the tree was told to `puts`, in order
+    # : () -> Array[String]
+    def said: () -> Array[String]
+
+    # The tree the batches make, as an outline - see TaskProgress#outline
+    # : () -> Hash[Symbol, untyped]?
+    def outline: () -> Hash[Symbol, untyped]?
+  end
+end

data/sig/generated/task_progress/redis_stream_store.rbs

@@ -0,0 +1,75 @@
+# Generated from lib/task_progress/redis_stream_store.rb with RBS::Inline
+
+class TaskProgress
+  # A stream store in Redis: each tree a Redis stream of its own (XADD, XREAD, XTRIM), its values in plain keys. It
+  # takes a redis-client connection or pool (`RedisClient.config(url:).new_pool`), or a redis-rb
+  # `Redis` - neither is a dependency of this gem, and nothing here loads one.
+  #
+  #     TaskProgress.stream_store = TaskProgress::RedisStreamStore.new(RedisClient.config(url: ENV["REDIS_URL"]).new_pool)
+  #
+  # Needs Redis 6.2 or later, for trimming by id. A reader that waits holds its connection for
+  # as long as it waits - a pool sized for the readers that follow at once keeps the rest moving.
+  # A redis-rb `Redis` is a single connection, so everything else on it waits too: give one that
+  # follows trees a client of its own.
+  #
+  # A write with a `guard:` - a key and the value it must hold - runs as a Lua script, so the
+  # check and the write are one step, see MemoryStreamStore.
+  #
+  # Every tree is under its own key already, so two users' trees never meet. A `namespace` puts
+  # all the keys under it as well - `tenant-42:task_progress:{...}` - for apps, or tenants, that
+  # share a Redis and must stay apart even so
+  class RedisStreamStore
+    # The guarded writes. KEYS[1] is the guard, ARGV[1] the value it must hold
+    GUARDED: Hash[Symbol, String]
+
+    @redis: untyped
+
+    @namespace: String?
+
+    # For a redis-client connection or pool, or a redis-rb client
+    # : (untyped, ?namespace: String?) -> void
+    def initialize: (untyped, ?namespace: String?) -> void
+
+    # Adds `data` at the end of the stream at `key`, and returns its id
+    # : (String, String) -> String
+    def append: (String, String) -> String
+
+    # The entries after the id `after` - all of them when it is nil - as `[id, data]` pairs. With
+    # a `timeout`, waits up to that many seconds for one to come when there are none yet
+    # : (String, ?after: String?, ?timeout: (Integer | Float)?) -> Array[[String, String]]
+    def read: (String, ?after: String?, ?timeout: (Integer | Float)?) -> Array[[ String, String ]]
+
+    # The value at `key`, or nil
+    # : (String) -> String?
+    def get: (String) -> String?
+
+    # Keeps `value` at `key`, for `expires_in` seconds if given
+    # : (String, String, ?expires_in: (Integer | Float)?, ?guard: [String, String]?) -> bool
+    def set: (String, String, ?expires_in: (Integer | Float)?, ?guard: [ String, String ]?) -> bool
+
+    # Forgets the streams and values at these keys
+    # : (*String, ?guard: [String, String]?) -> bool
+    def delete: (*String, ?guard: [ String, String ]?) -> bool
+
+    # Drops the entries before the id `before`
+    # : (String, before: String, ?guard: [String, String]?) -> bool
+    def trim: (String, before: String, ?guard: [ String, String ]?) -> bool
+
+    # Forgets what is at `key` - a stream or a value - `seconds` from now
+    # : (String, Integer | Float, ?guard: [String, String]?) -> bool
+    def expire: (String, Integer | Float, ?guard: [ String, String ]?) -> bool
+
+    private
+
+    # : (Symbol, [String, String], Array[String], Array[String]) -> bool
+    def guarded: (Symbol, [ String, String ], Array[String], Array[String]) -> bool
+
+    # : (String) -> String
+    def ns: (String) -> String
+
+    # XREAD answers in one of three shapes - RESP3 a Hash, RESP2 nested Arrays, redis-rb a Hash
+    # of Hashes - and nil when nothing came
+    # : (untyped, String) -> Array[[String, String]]
+    def entries: (untyped, String) -> Array[[ String, String ]]
+  end
+end

data/sig/generated/task_progress/squasher.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/task_progress/squasher.rb with RBS::Inline
+
+class TaskProgress
+  # Squashes runs of batches into one. It mirrors the tree they build, so for a run it can
+  # send the prunes it saw and then a put for every node the run touched - which lands any
+  # reader that had the tree up to the run's `prev` exactly where the run left it, times
+  # and all, without replaying the steps in between. What was said is not in the tree, so
+  # it goes along after the puts
+  class Squasher
+    @state: State
+
+    # Starts from an empty tree
+    # : () -> void
+    def initialize: () -> void
+
+    # One batch that lands a reader where the run of batches would have
+    # : (Array[Batch]) -> Batch
+    def squash: (Array[Batch]) -> Batch
+  end
+end