task_progress 0.0.1

data/sig/generated/task_progress/sse.rbs

@@ -0,0 +1,73 @@
+# Generated from lib/task_progress/sse.rb with RBS::Inline
+
+class TaskProgress
+  # A Rack response body streaming a tree as Server-Sent Events: first the tree so far, squashed
+  # into one batch with `prev` 0, then every batch as it commits - each in a `batch` event whose
+  # `id:` is its seq. A browser that reconnects starts over from a fresh squash, which is always
+  # right and costs a few puts. The stream ends once the root is finished. Given a subtask, it
+  # streams only that task's subtree, with the subtask as the root.
+  #
+  #     # Rack
+  #     TaskProgress::SSE.response(task)
+  #     # Rails
+  #     headers.merge!(TaskProgress::SSE::HEADERS)
+  #     self.response_body = TaskProgress::SSE.new(task)
+  #
+  # Given a key instead of a task - a tree handed off with TaskProgress.handoff - it follows that
+  # tree from the stream for as long as it streams, and stops following when the stream ends or
+  # the server closes it. `response` answers 404 for a key with nothing at it
+  class SSE
+    # What an SSE response is sent with
+    HEADERS: Hash[String, String]
+
+    @source: TaskProgress | Log
+
+    @heartbeat: Integer | Float
+
+    @reconnect: Integer | Float
+
+    @close: bool
+
+    # A whole Rack response: status, headers and this body - or a 404, for a key with nothing at it
+    # : (TaskProgress | Log | String, **untyped) -> [Integer, Hash[String, String], SSE | Array[String]]
+    def self.response: (TaskProgress | Log | String, **untyped) -> [ Integer, Hash[String, String], SSE | Array[String] ]
+
+    # One batch as an SSE event
+    # : (Batch) -> String
+    def self.frame: (Batch) -> String
+
+    # Streams the task - its subtree only, for a subtask - or the tree handed off at a key, from
+    # `stream`. It pings every `heartbeat` seconds of quiet, and tells the browser to reconnect
+    # after `reconnect` seconds
+    # : (TaskProgress | Log | String, ?stream_store: untyped, ?heartbeat: Integer | Float, ?reconnect: Integer | Float) -> void
+    def initialize: (TaskProgress | Log | String, ?stream_store: untyped, ?heartbeat: Integer | Float, ?reconnect: Integer | Float) -> void
+
+    # Stops following a tree it followed by its key - Rack calls it when the response is over
+    # : () -> void
+    def close: () -> void
+
+    # Yields the stream a chunk at a time, until the task finishes - as a Rack body does
+    # : () { (String) -> void } -> void
+    def each: () { (String) -> void } -> void
+
+    # How many batches wait for a slow client before it gets a squash instead
+    BACKLOG: Integer
+
+    private
+
+    # : () -> Log
+    def log: () -> Log
+
+    # : () -> path
+    def path: () -> path
+
+    # : () -> bool
+    def present?: () -> bool
+
+    # Judged by what was sent, never by the snapshot: that runs ahead of delivery, and ending on
+    # it could cut the stream before the batch that finished the root went out. An empty reset
+    # is a branch whose task was pruned, which will not come back either
+    # : (Batch) -> bool
+    def finishes_root?: (Batch) -> bool
+  end
+end

data/sig/generated/task_progress/state.rbs

@@ -0,0 +1,165 @@
+# Generated from lib/task_progress/state.rb with RBS::Inline
+
+class TaskProgress
+  # The tree as it stands after a run of events: what `apply` folds them into. It checks every
+  # event before it changes anything, so a bad one raises and leaves the state as it was. Not
+  # thread-safe on its own - the Log holds its lock around every apply
+  class State
+    # What an `open` or a `meta` may set
+    ATTRIBUTES: Array[Symbol]
+
+    CHILD_IDS: Integer
+
+    # Siblings past this many are folded by `rows`...
+    FOLD_OVER: Integer
+
+    # ...keeping this many of the done ones, the latest to finish, and of the ones waiting, the first
+    FOLD_KEEP: Integer
+
+    ENDINGS: Hash[Symbol, Symbol]
+
+    # What a `put` carries - a Node, less what never goes over the wire
+    FIELDS: Array[Symbol]
+
+    @nodes: Hash[path, Node]
+
+    # A new node, opened at `at`, before its attributes are set
+    # : (Float) -> Node
+    def self.blank_node: (Float) -> Node
+
+    # Folding the squash of a state gives that state back, which is what makes a squashed log
+    # interchangeable with the one it came from
+    # : (Array[Event], ?at: Float) -> State
+    def self.fold: (Array[Event], ?at: Float) -> State
+
+    # An empty tree - or one made of these nodes
+    # : (?Hash[path, Node]) -> void
+    def initialize: (?Hash[path, Node]) -> void
+
+    # The node at `path`, or nil
+    # : (path) -> Node?
+    def []: (path) -> Node?
+
+    # Whether there is a node at `path`
+    # : (path) -> bool
+    def key?: (path) -> bool
+
+    # Whether it has no root yet
+    # : () -> bool
+    def empty?: () -> bool
+
+    # How many nodes it has
+    # : () -> Integer
+    def size: () -> Integer
+
+    # The paths of the nodes directly under `path`
+    # : (path) -> Array[path]
+    def children: (path) -> Array[path]
+
+    # A path for a new child of `path`. A child is named by a random id rather than its position,
+    # so a pruned task's path never turns up again on another one - not after a prune here, nor
+    # when a restarted remote replaces its tree. Ids only have to differ between siblings, since
+    # the path tells cousins apart, and a draw that hits a sibling is drawn again
+    # : (path, Random) -> path
+    def new_child: (path, Random) -> path
+
+    # Pre-order, children in the order they opened - the order a renderer wants and the order
+    # puts replay in, so a reader rebuilding from a squash ends up with the same order
+    # : (?path) { (path, Node) -> void } -> void
+    # : (?path) -> Enumerator[[path, Node], void]
+    def each: (?path) { (path, Node) -> void } -> void
+            | (?path) -> Enumerator[[ path, Node ], void]
+
+    # What to draw, in the order of `each` - but where a task has more than `fold_over` children,
+    # the ones that are done (save the last `keep` to finish) are one Fold row ahead of the rest,
+    # and the ones still waiting (save the first `keep`) one Fold row after them. What is
+    # running, failed or canceled is always drawn. A Fold comes with its parent's path and
+    # `~done` or `~pending` after it, which no task id can be
+    # : (?path, ?fold_over: Integer, ?keep: Integer) { (path, Node | Fold) -> void } -> void
+    # : (?path, ?fold_over: Integer, ?keep: Integer) -> Enumerator[[path, Node | Fold], void]
+    def rows: (?path, ?fold_over: Integer, ?keep: Integer) { (path, Node | Fold) -> void } -> void
+            | (?path, ?fold_over: Integer, ?keep: Integer) -> Enumerator[[ path, Node | Fold ], void]
+
+    # Folds one event in, or raises ArgumentError and leaves the state as it was
+    # : (Event, at: Float, ?journal: Journal?) -> self
+    def apply: (Event, at: Float, ?journal: Journal?) -> self
+
+    # The tasks under `path` that have not ended, in pre-order - so reversed, every task comes
+    # before the one it is under. A mounted subtree is left out unless `mounts` - a remote that
+    # has not finished may yet, so a `done` from here would be a guess, but calling it off is not
+    # : (path, ?mounts: bool) -> Array[path]
+    def open_under: (path, ?mounts: bool) -> Array[path]
+
+    # The state as a list of puts, one per node, in pre-order - or just the subtree at `path`
+    # : (?path) -> Array[Event]
+    def squash: (?path) -> Array[Event]
+
+    # Done, and everything under it ended - each task by a `done`, `fail` or `cancel` of its own.
+    # Children that are all through do not finish their parent, which may have more to do after
+    # them; a failed or canceled one does not hold back a parent that went on to finish regardless
+    # : (?path, ?Node?) -> bool
+    def complete?: (?path, ?Node?) -> bool
+
+    # 0.0..1.0, unrounded. Children decide a parent's progress, by weight, and children it was
+    # told to expect but has not got yet count as zero. A leaf goes by its count when it has a
+    # total, and by its percent otherwise
+    # : (?path, ?Node?) -> Float
+    def fraction: (?path, ?Node?) -> Float
+
+    # A whole percent, and 100 only once everything under it is done: 99.5 does not round up
+    # into a bar that reads as finished while work is still running
+    # : (?path) -> Integer
+    def percent: (?path) -> Integer
+
+    # Every node, as a `put` carries it
+    # : () -> Hash[path, Hash[Symbol, untyped]]
+    def to_h: () -> Hash[path, Hash[Symbol, untyped]]
+
+    # A frozen copy, safe to read from any thread. Given an earlier snapshot of this state and the
+    # paths changed since, it copies only those, and takes the rest from the earlier one
+    # : (?State?, ?Enumerable[path]?) -> State
+    def snapshot: (?State?, ?Enumerable[path]?) -> State
+
+    # A copy that can change without changing this one
+    # : () -> State
+    def dup: () -> State
+
+    # Undoes what one transaction did
+    # : (Journal) -> void
+    def rollback: (Journal) -> void
+
+    # The nodes themselves, for an earlier snapshot to lend a new one what has not changed
+    # : () -> Hash[path, Node]
+    attr_reader nodes: Hash[path, Node]
+
+    private
+
+    # : (Node) -> Node
+    def frozen: (Node) -> Node
+
+    # : (Node) -> Integer
+    def missing: (Node) -> Integer
+
+    # : (path) -> Node?
+    def parent_of!: (path) -> Node?
+
+    # : (path, Node?) -> Node
+    def existing!: (path, Node?) -> Node
+
+    # : (path, Node?) -> Node
+    def updatable!: (path, Node?) -> Node
+
+    # Work started anywhere starts everything above it too
+    # : (path, Float, Journal?) -> void
+    def start: (path, Float, Journal?) -> void
+
+    # : (Node, Hash[Symbol, untyped]) -> void
+    def assign: (Node, Hash[Symbol, untyped]) -> void
+
+    # : (path) -> path
+    def up: (path) -> path
+
+    # : (Node, path) -> void
+    def adopt: (Node, path) -> void
+  end
+end

data/sig/generated/task_progress/stream_output.rbs

@@ -0,0 +1,142 @@
+# Generated from lib/task_progress/stream_output.rb with RBS::Inline
+
+class TaskProgress
+  # Writes a tree to a stream - a MemoryStreamStore, a RedisStreamStore - for readers anywhere to follow
+  # with StreamReader. What TaskProgress.handoff and TaskProgress.adopt write through. Under one
+  # key it keeps:
+  #
+  #     key            every batch, one entry each
+  #     key:run        the log id of the run that writes the tree now
+  #     key:snapshot   the tree squashed into one batch, and the id of the entry it is as of -
+  #                    where a reader starts, so the stream before it can be trimmed away
+  #     key:beat       there while the run is alive, and gone a few seconds after it is not
+  #     key:control    cancel requests, the other way - see Mount#follow_stream
+  #
+  # **One run at a time.** Each writer is a run, named by its log id, and claims `key:run` with its
+  # first batch. A run that a later one has taken over from - a job retried while the first
+  # attempt still limps on, two workers that adopted at once - may still append, and readers
+  # ignore what it appends; but every snapshot, trim, beat and expiry is written only while
+  # `key:run` still names the run that writes it, checked and written in one step. So a run that
+  # was replaced can never take the tree back.
+  #
+  # A snapshot is taken at the first batch, every `snapshot_every` seconds after, and when the
+  # root finishes, and each one trims the stream back to the one before it. Every key expires
+  # `retain` seconds after the last snapshot - a run that dies leaves nothing behind for good.
+  #
+  # With `heartbeat`, every so many seconds it marks itself alive and takes the cancel requests that
+  # came for it, on a thread of its own - from the first batch until the root finishes or it is
+  # closed. A request names the run it is for; a run also takes those for the run it took over
+  # from (`took_over`), so a cancel sent while a job still waited in the queue reaches whoever
+  # takes it up.
+  #
+  # A write that fails - Redis went away for a moment - is not lost: the next batch goes out as
+  # the whole tree, squashed, and readers start over from it
+  class StreamOutput
+    # The key it writes under
+    attr_reader key: String
+
+    @log: Log?
+
+    @replaced: bool
+
+    @covered: Integer
+
+    @broken: bool
+
+    @stop: Thread::Queue
+
+    @beating: Thread?
+
+    @snapped_at: Float
+
+    @snapshot_id: String?
+
+    @state: State
+
+    @run: String?
+
+    @took_over: String?
+
+    @retain: Integer | Float
+
+    @snapshot_every: Integer | Float
+
+    @heartbeat: (Integer | Float)?
+
+    @stream: untyped
+
+    # The key of the squashed tree a reader starts from
+    # : (String) -> String
+    def self.snapshot_key: (String) -> String
+
+    # The key that is there while the writer is alive
+    # : (String) -> String
+    def self.beat_key: (String) -> String
+
+    # The key cancel requests are appended to
+    # : (String) -> String
+    def self.control_key: (String) -> String
+
+    # Whether a cancel request is for one of these runs. A request names the run it was sent to -
+    # the one its sender saw writing the tree; one from a parent's control pipe names none
+    # : (String, *String?) -> bool
+    def self.for_run?: (String, *String?) -> bool
+
+    # The key that names the run writing the tree now
+    # : (String) -> String
+    def self.run_key: (String) -> String
+
+    # A key for a new tree. The braces make it a Redis Cluster hash tag, so all five keys of a
+    # tree land on the same node
+    # : (String) -> String
+    def self.key_for: (String) -> String
+
+    # Writes to `stream` under `key`. `took_over` is the run it takes the tree over from
+    # : (untyped, String, ?heartbeat: (Integer | Float)?, ?snapshot_every: Integer | Float, ?retain: Integer | Float, ?took_over: String?) -> void
+    def initialize: (untyped, String, ?heartbeat: (Integer | Float)?, ?snapshot_every: Integer | Float, ?retain: Integer | Float, ?took_over: String?) -> void
+
+    # Appends the batch, and takes a snapshot when one is due
+    # : (Batch, Log) -> void
+    def call: (Batch, Log) -> void
+
+    # Stops beating, and taking cancel requests - the work is over, one way or another. If the
+    # last write failed, the tree goes out whole once more, so readers do not stop short of the end
+    # : () -> void
+    def close: () -> void
+
+    # Whether a later run has taken the tree over, so this one writes no more
+    # : () -> bool
+    def replaced?: () -> bool
+
+    private
+
+    # : () -> Float
+    def now: () -> Float
+
+    # : () -> void
+    def stop: () -> void
+
+    # : (String) -> [String, String]
+    def guard: (String) -> [ String, String ]
+
+    # The run starts: from now on the tree is this run's to snapshot, trim and beat for
+    # : (String) -> String
+    def claim: (String) -> String
+
+    # The whole tree as one batch, in place of what failed to go out
+    # : (Log) -> Batch
+    def resync: (Log) -> Batch
+
+    # : (String, Batch, String) -> void
+    def snapshot: (String, Batch, String) -> void
+
+    # : (String) -> void
+    def finish: (String) -> void
+
+    # : () -> void
+    def replaced: () -> void
+
+    # : (Log) -> void
+    def beat: (Log) -> void
+  end
+end

data/sig/generated/task_progress/stream_reader.rbs

@@ -0,0 +1,46 @@
+# Generated from lib/task_progress/stream_reader.rb with RBS::Inline
+
+class TaskProgress
+  # Reads a tree a StreamOutput writes: the snapshot first, as one batch with `prev` 0, then
+  # every batch after it as it comes. Each read picks up where the last one left off.
+  #
+  # It hands on what it reads, and judges none of it - Mount does that, see Mount#follow_stream.
+  # After a gap, `resync!` makes the next read start over from the latest snapshot
+  class StreamReader
+    # The key it reads
+    attr_reader key: String
+
+    @stream: untyped
+
+    @after: String?
+
+    @started: bool
+
+    # Reads `stream` at `key`
+    # : (untyped, String) -> void
+    def initialize: (untyped, String) -> void
+
+    # The batches since the last read - starting from the snapshot. With a `timeout`, waits up
+    # to that many seconds for one when there are none yet
+    # : (?timeout: (Integer | Float)?) -> Array[Batch]
+    def read: (?timeout: (Integer | Float)?) -> Array[Batch]
+
+    # The next read starts over, from the latest snapshot
+    # : () -> void
+    def resync!: () -> void
+
+    # The tree as of the latest snapshot, as one batch - or nil when nothing was ever written
+    # here, or it has expired
+    # : () -> Batch?
+    def snapshot: () -> Batch?
+
+    # Whether the writer said lately that it is alive
+    # : () -> bool
+    def alive?: () -> bool
+
+    private
+
+    # : () -> [String, Batch]?
+    def snapshot_entry: () -> [ String, Batch ]?
+  end
+end

data/sig/generated/task_progress/summary_output.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/task_progress/summary_output.rb with RBS::Inline
+
+class TaskProgress
+  # The tree boiled down to the root's percent and the latest thing said, for a progress
+  # column in a database or a single status line. A batch that changes neither is not passed on
+  class SummaryOutput
+    @block: ^(percent: Integer, message: String?) -> void
+
+    @percent: Integer
+
+    # Calls the block with `percent:` and `message:` whenever either changes
+    # : () { (percent: Integer, message: String?) -> void } -> void
+    def initialize: () { (percent: Integer, message: String?) -> void } -> void
+
+    # Takes one batch, see Log#add_output
+    # : (Batch, Log) -> void
+    def call: (Batch, Log) -> void
+  end
+end

data/sig/generated/task_progress/terminal_output.rbs

@@ -0,0 +1,117 @@
+# Generated from lib/task_progress/terminal_output.rb with RBS::Inline
+
+class TaskProgress
+  # Redraws the tree in place on a terminal, from a ticker thread of its own so spinners turn
+  # while nothing reports. A finished subtree folds into its one line, and when the tree is
+  # taller than the screen the finished lines go first, then the ones not started. When the
+  # root finishes the tree is drawn one last time and left on screen - or erased, with `erase: true`.
+  # A line a task `puts` goes above the tree and stays there
+  #
+  # With `interval: nil` there is no thread and every batch redraws, which is what tests want
+  class TerminalOutput
+    SPINNER: Array[String]
+
+    BAR: Integer
+
+    DEFAULT_SIZE: [ Integer, Integer ]
+
+    @dirty: bool
+
+    @ticker: Thread?
+
+    @closed: bool
+
+    @log: Log?
+
+    @frame: Integer
+
+    @drawn: Integer
+
+    @lock: Thread::Mutex
+
+    @clock: ^() -> Float
+
+    @erase: bool
+
+    @interval: (Integer | Float)?
+
+    @io: IO | StringIO
+
+    # Draws on `io` every `interval` seconds - or on every batch, with `interval: nil`. With `erase: true` the tree is cleared once the root finishes
+    # : (?IO | StringIO, ?interval: (Integer | Float)?, ?erase: bool, ?clock: ^() -> Float) -> void
+    def initialize: (?IO | StringIO, ?interval: (Integer | Float)?, ?erase: bool, ?clock: ^() -> Float) -> void
+
+    # Takes one batch, see Log#add_output
+    # : (Batch, Log) -> void
+    def call: (Batch, Log) -> void
+
+    # Draws the tree one last time and stops the ticker
+    # : () -> void
+    def close: () -> void
+
+    # The lines for a snapshot, without the terminal control around them
+    # : (State, ?width: Integer, ?height: Integer) -> Array[String]
+    def lines: (State, ?width: Integer, ?height: Integer) -> Array[String]
+
+    private
+
+    # : () -> void
+    def tick: () -> void
+
+    # : () -> void
+    def finish: () -> void
+
+    # : () -> void
+    def draw: () -> void
+
+    # : (Array[String]) -> void
+    def print_above: (Array[String]) -> void
+
+    # : () -> void
+    def clear: () -> void
+
+    # : () -> String
+    def up: () -> String
+
+    # Under a finished node only what failed shows, so a failure leaves the way down to it
+    # : (State, path) -> bool
+    def hidden?: (State, path) -> bool
+
+    # What fits in `room` lines - the last of them saying how many more there are
+    # : (Array[[path?, Node | Fold | Integer]], Integer) -> Array[[path?, Node | Fold | Integer]]
+    def trim: (Array[[ path?, Node | Fold | Integer ]], Integer) -> Array[[ path?, Node | Fold | Integer ]]
+
+    # : (State, path?, Node | Fold | Integer, Integer) -> String
+    def line: (State, path?, Node | Fold | Integer, Integer) -> String
+
+    # : (Node) -> String
+    def icon: (Node) -> String
+
+    # : (State, path, Node) -> String?
+    def measure: (State, path, Node) -> String?
+
+    # Diagonal stripes that crawl one cell along every frame - for work with no measure
+    # : () -> String
+    def stripes: () -> String
+
+    # : (Integer) -> String
+    def bar: (Integer) -> String
+
+    # The rate over the whole run so far, and the time left at that rate. Steadier than a
+    # rate over the last few ticks, which jumps about with every pause in the work
+    # : (Node) -> String?
+    def pace: (Node) -> String?
+
+    # : (Node) -> String?
+    def elapsed: (Node) -> String?
+
+    # : () -> Integer
+    def columns: () -> Integer
+
+    # : () -> Integer
+    def rows: () -> Integer
+
+    # : () -> [Integer, Integer]
+    def size: () -> [ Integer, Integer ]
+  end
+end

data/sig/generated/task_progress/token.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/task_progress/token.rb with RBS::Inline
+
+class TaskProgress
+  # The right to see a tree and to ask for its tasks to be canceled, signed, and good for a while.
+  # The server issues one when it hands out a page - after it has decided the page may show that
+  # tree - and checks it when the page comes back for the tree or with a cancellation. So neither
+  # can be forged without the secret, or used after the token expires, and the tree's own key never
+  # has to reach a page. Which tasks may be canceled is for `cancelable` to say.
+  #
+  #     tokens = TaskProgress::Token.new(ENV.fetch("TASK_PROGRESS_SECRET"))
+  #     token = tokens.issue(import.key, expires_in: 3600)  # into the page
+  #     tokens.verify(token)                                # => import.key, when the page comes back
+  class Token
+    @secret: String
+
+    @clock: ^() -> Integer
+
+    # Signs with `secret`, which must be at least 32 bytes
+    # : (String, ?clock: ^() -> Integer) -> void
+    def initialize: (String, ?clock: ^() -> Integer) -> void
+
+    # A token for `subject` - a log id, a run, whatever the tokens are checked against - good for `expires_in` seconds
+    # : (String, ?expires_in: Integer) -> String
+    def issue: (String, ?expires_in: Integer) -> String
+
+    # What the token was issued for, or nil if it is forged, mangled or expired
+    # : (String?) -> String?
+    def verify: (String?) -> String?
+
+    private
+
+    # : (String) -> String
+    def sign: (String) -> String
+
+    # : (String) -> String
+    def encode: (String) -> String
+
+    # : (String) -> String
+    def decode: (String) -> String
+  end
+end

data/sig/generated/task_progress/tracked_io.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/task_progress/tracked_io.rb with RBS::Inline
+
+class TaskProgress
+  # A ProgressiveIO that advances a task by how far it has been read. Readers seek (ZipKit reads
+  # the end of an archive first), so only the furthest position counts. The task moves in steps,
+  # a thousandth of the total by default - a loop of small reads over a big file would otherwise
+  # commit a batch per read, and every output and browser would get each of them
+  class TrackedIO < ::ProgressiveIO
+    STEP_WITHOUT_TOTAL: Integer
+
+    @task: TaskProgress
+
+    @total: Integer?
+
+    @step: Integer
+
+    @furthest: Integer
+
+    @reported: Integer
+
+    # Advances `task` as `io` is read, in steps of `step` bytes - see TaskProgress#track_io, which makes one
+    # : (IO, TaskProgress, ?total: Integer?, ?step: Integer?) -> void
+    def initialize: (IO, TaskProgress, ?total: Integer?, ?step: Integer?) -> void
+
+    # ProgressiveIO lets these through unreported, and IO.copy_stream reads anything that is not
+    # an IO with readpartial
+    # Reads the way IO#readpartial does, and reports how far it got
+    # : (*untyped, **untyped) -> untyped
+    def readpartial: (*untyped, **untyped) -> untyped
+
+    # Reads the way IO#read_nonblock does, and reports how far it got
+    # : (*untyped, **untyped) -> untyped
+    def read_nonblock: (*untyped, **untyped) -> untyped
+
+    # Reads the way IO#sysread does, and reports how far it got
+    # : (*untyped, **untyped) -> untyped
+    def sysread: (*untyped, **untyped) -> untyped
+
+    # Reports what was read since the last step
+    # : () -> void
+    def flush_progress: () -> void
+
+    private
+
+    # : (Integer) -> void
+    def moved_to: (Integer) -> void
+  end
+end

data/sig/generated/task_progress/transaction.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/task_progress/transaction.rb with RBS::Inline
+
+class TaskProgress
+  # What a block given to Log#transaction adds its events through. Each one is applied to the
+  # tree as it comes, and journaled, so the whole transaction can be undone if the block raises
+  class Transaction
+    # What it has added so far, in order
+    attr_reader events: Array[Event]
+
+    # What it changed, to undo it by
+    attr_reader journal: Journal
+
+    # The time it opened - every event in it happens then
+    attr_reader at: Float
+
+    # The tree as the transaction has it so far
+    attr_reader state: State
+
+    @random: Random
+
+    # For changing `state` at `at`, drawing task ids from `random` - see Log#transaction, which opens one
+    # : (State, Float, Random) -> void
+    def initialize: (State, Float, Random) -> void
+
+    # Applies the event, and adds it to the batch
+    # : (Event) -> self
+    def <<: (Event) -> self
+
+    # A path for a new child of `path` - see State#new_child
+    # : (path) -> path
+    def new_child: (path) -> path
+  end
+end