bend-kit-runner Releases (18): 0.13.0.1 0x0b6e7368cef7f567455568708dcf376e indexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.13.0.1 0.13.0.0 0xfeb617c861f7160ec440aa2d93102ad4 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.13.0.0 0.12.0.1 0x92a0303baba9178f097241191a0ae2fb unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.12.0.1 0.12.0.0 0xef1fd5e854c3200ca063c9b6f8691de7 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.12.0.0 0.11.0.1 0x4607e4e3426b9d873fd4253dc81dd8b5 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.11.0.1 0.11.0.0 0xd1d0999105337762717bc3ec41e1f726 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.11.0.0 0.10.0.1 0xac1177ca1ce38562c1eb95bc47fc6d53 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.10.0.1 0.10.0.0 0xf734a80d59c8f9bddb283a2b64ca29d3 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.10.0.0 0.9.0.0 0x85f96738e2e5df65cc133af1d12bd747 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.9.0.0 0.8.1.0 0x835485f417d4c052139893274f69e1d9 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.8.1.0 0.8.0.0 0x8943d7476d84e1c52210bca903bb75d2 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.8.0.0 0.7.0.0 0x73559c52763964eec984bb79177885e9 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.7.0.0 0.6.0.0 0x579cfefafb80e6d25852d085feffef66 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.6.0.0 0.5.0.0 0xbcaf901cd6a16d4a47c2644b7b602ec6 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.5.0.0 0.4.0.0 0x945c847bfe348ac3f0c9137731f9f60c unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.4.0.0 0.3.0.0 0x80a6f1a0beef7d6b1dbe0e5a1d196f0b unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.3.0.0 0.2.0.0 0xb1936b54bbc8b33fb34c6f2a1c988bb8 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.2.0.0 0.1.0.0 0xec9c4ae2f46b17b8f237bec9c30d85a4 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-runner@0.1.0.0 Definitions (251, 1 to 100 shown): Runner.Why (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Why) # Why retry gave up on a ticket: its budget was spent, its deadline passed, its failure must not repeat, # or another try would repeat its failure. type Why is Data: WhySpent{} WhyLate{} WhyUnsafe{} WhyFailed{} Runner.Dead (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Dead) # A ticket that retry gave up on, with its payload, and when it gave up (wall-clock ms). # It stays until Revive, Cancel, or Purge takes it. type Dead<-A: Data> is Data: Dead{ticket: Q.Ticket, why: Why, at: Nat} Runner.Op (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Op) # One durable transition. Each one is one journal record, appended before the state changes. # Select: the queue's select at now. Replay runs it at the same now, so it takes the same ticket. # Requeue: the attempt failed; it counts one failure. Defer: the breaker held the ticket back; no attempt ran. # Abandon: retry gave up at at; the running ticket becomes dead. Revive: a dead ticket is pending again at deadline, with a new budget. # Purge: the dead tickets abandoned before before are dropped. PurgeAll: every dead ticket is dropped. # Break: the breaker of target changed to state. type Op<-A: Data> is Data: Enqueue{deadline: Nat, payload: A} Select{now: Nat} Complete{id: Nat} Cancel{id: Nat} … Runner.Try (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Try) # The failed attempts of a ticket, and its first deadline, from which the policy deadline counts. type Try is Data: Try{fails: Nat, start: Nat} Runner.Tries (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Tries) # A Try for each ticket that is not yet complete, cancelled, or dead, by ticket id. def Tries() -> Data: Runner.Breakers (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Breakers) # The breaker state of each target that has one, by target. An absent target is closed with no failures. def Breakers() -> Data: Runner.dead.hash (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.hash) def dead.hash(i: Nat) -> U32: Runner.Graves (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Graves) # The dead tickets, by ticket id. def Graves(-A: Data) -> Data: Runner.State (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=State) # The durable state: the queue, the tries, the dead tickets, and the breakers. type State<-A: Data> is Data: State{queue: Q.State, tries: Tries(), dead: Graves(A), breakers: Breakers()} Runner.new (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=new) def new(-A: Data) -> State: Runner.queue (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=queue) def queue(-A: Data, s: State) -> Q.State: Runner.tries (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=tries) def tries(-A: Data, s: State) -> Tries(): Runner.dead (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead) # The dead tickets, by id. A Revive of one makes it pending again; a Cancel or a Purge drops it. def dead(-A: Data, s: State) -> Graves(A): Runner.breakers (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=breakers) def breakers(-A: Data, s: State) -> Breakers(): Runner.dead.get (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.get) def dead.get(~A: Data, ds: Graves(A), +i: Nat) -> Maybe<&2, Dead>: Runner.dead.drop (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.drop) def dead.drop(~A: Data, ds: Graves(A), +i: Nat) -> Graves(A): Runner.dead.bury (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.bury) def dead.bury(~A: Data, m: Maybe<&2, Q.Ticket>, ds: Graves(A), w: Why, +at: Nat) -> Graves(A): Runner.dead.list.entries (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.list.entries) def dead.list.entries(-A: Data, es: List<&2, M.Entry>>, acc: List<&2, Dead>) -> List<&2, Dead>: Runner.dead.list.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.list.go) def dead.list.go(-A: Data, ds: Graves(A), acc: List<&2, Dead>) -> List<&2, Dead>: Runner.dead.list (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.list) # The dead tickets, in no set order. def dead.list(-A: Data, ds: Graves(A)) -> List<&2, Dead>: Runner.dead.old.keep (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.old.keep) def dead.old.keep(-A: Data, old: Bool, +i: Nat, rest: List<&2, Nat>) -> List<&2, Nat>: Runner.dead.old (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.old) # The ids of the dead tickets abandoned before t. def dead.old(-A: Data, ds: List<&2, Dead>, +t: Nat) -> List<&2, Nat>: Runner.dead.drops (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.drops) def dead.drops(~A: Data, ks: List<&2, Nat>, ds: Graves(A)) -> Graves(A): Runner.dead.purge (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=dead.purge) # The dead tickets without those abandoned before t. It walks every dead ticket once. def dead.purge(~A: Data, +ds: Graves(A), +t: Nat) -> Graves(A): Runner.tries.drop (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=tries.drop) def tries.drop(ts: Tries(), +i: Nat) -> Tries(): Runner.tries.get (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=tries.get) def tries.get(ts: Tries(), +i: Nat) -> Maybe<&2, Try>: Runner.tries.bump.got (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=tries.bump.got) def tries.bump.got(m: Maybe<&2, Try>, ts: Tries(), +i: Nat) -> Tries(): Runner.tries.bump (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=tries.bump) def tries.bump(+ts: Tries(), +i: Nat) -> Tries(): Runner.brk.got (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=brk.got) def brk.got(r: Breakers() & Retry.State) -> Retry.State: Runner.brk.get (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=brk.get) # The breaker state of target key. def brk.get(-A: Data, s: State, key: String) -> Retry.State: Runner.brk.state (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=brk.state) def brk.state(br: Retry.Breaker, old: Retry.State) -> Retry.State: Runner.brk.nats (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=brk.nats) def brk.nats(a: List<&2, Nat>, b: List<&2, Nat>) -> Bool: Runner.brk.same (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=brk.same) def brk.same(a: Retry.State, b: Retry.State) -> Bool: Runner.calm.state (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=calm.state) def calm.state(b: Retry.State) -> Retry.State: Runner.calm.map (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=calm.map) def calm.map(m: Breakers()) -> Breakers(): Runner.calm (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=calm) # The probes of a half-open breaker died with the process that ran them, so open counts none in flight. def calm(-A: Data, s: State) -> State: Runner.step.enqueued (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=step.enqueued) def step.enqueued(-A: Data, r: Q.State & Nat, ts: Tries(), ds: Graves(A), bs: Breakers(), d: Nat) -> State: Runner.step.selected (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=step.selected) def step.selected(-A: Data, r: Q.State & Maybe<&2, Q.Ticket>, ts: Tries(), ds: Graves(A), bs: Breakers()) -> State: Runner.step.requeued (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=step.requeued) def step.requeued(-A: Data, r: Q.State & Bool, ts: Tries(), ds: Graves(A), bs: Breakers()) -> State: Runner.step.completed (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=step.completed) # Complete takes the ticket from the running list only: O(running), not O(pending). def step.completed(-A: Data, r: Q.State & Maybe<&2, Q.Ticket>, ts: Tries(), ds: Graves(A), bs: Breakers()) -> State: Runner.step.abandoned (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=step.abandoned) # Abandon takes the ticket from the running list, as Complete does, and keeps it with its payload. def step.abandoned(~A: Data, r: Q.State & Maybe<&2, Q.Ticket>, ts: Tries(), ds: Graves(A), bs: Breakers(), w: Why, +at: Nat) -> State: Runner.step.revived (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=step.revived) # The revived ticket keeps its payload and takes id i, the key it was dead under. def step.revived(~A: Data, m: Maybe<&2, Dead>, +i: Nat, n: Nat, h: H.Heap>, r: List<&2, Q.Ticket>, ts: Tries(), ds: Graves(A), bs: Breakers(), +d: Nat) -> State: Runner.step.broke (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=step.broke) # A closed breaker with no failures reads the same as an absent one, so it leaves the map. def step.broke(bs: Breakers(), k: String, b: Retry.State) -> Breakers(): Runner.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=step) # The state after op. Live and replay both run it, so they agree. def step(~A: Data, s: State, op: Op) -> State: Runner.apply.op (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=apply.op) def apply.op(~A: Data, m: Maybe<&2, Op>, s: State) -> Maybe<&2, State>: Runner.apply (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=apply) # Folds one record into the replayed state. A record that does not decode ends the replay with None. def apply(~A: Data, ~R: Type, ~dec: R -> Maybe<&2, Op>, acc: Maybe<&2, State>, r: R) -> Maybe<&2, State>: Runner.Rec (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Rec) # A journal record. Compaction writes one Snap of the whole state; every other record is one op. type Rec<-A: Data> is Data: Snap{state: State} Do{op: Op} Runner.load.rec (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=load.rec) def load.rec(~A: Data, m: Maybe<&2, Rec>, s: State) -> Maybe<&2, State>: Runner.load (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=load) # Folds one record into the replayed state: a Snap replaces it, and an op steps it, as apply does. # A record that does not decode ends the replay with None. def load(~A: Data, ~R: Type, ~dec: R -> Maybe<&2, Rec>, acc: Maybe<&2, State>, r: R) -> Maybe<&2, State>: Runner.Pick (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Pick) # Picked: a due ticket and one unit of the pool for it. Idle: no due ticket, or no free unit; the pool is unchanged. type Pick<-A: Data> is Type: Picked{pool: Res.Pool, ticket: Q.Ticket, grant: Res.Grant} Idle{pool: Res.Pool} Runner.pick.took (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=pick.took) def pick.took(-A: Data, r: Res.Reserve, t: Q.Ticket) -> Pick: Runner.pick.due (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=pick.due) def pick.due(-A: Data, m: Maybe<&2, Q.Ticket>, p: Res.Pool) -> Pick: Runner.pick.sel (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=pick.sel) def pick.sel(-A: Data, r: Q.State & Maybe<&2, Q.Ticket>, p: Res.Pool) -> Pick: Runner.pick (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=pick) # The ticket that Select{now} takes, with one unit of p, when there is a ticket due and a unit free. def pick(~A: Data, p: Res.Pool, s: State, now: Nat) -> Pick: Runner.budget.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=budget.of) # The budget left for ticket i: the policy's attempts less its failures, until its start plus the policy deadline. def budget.of(+attempts: Nat, t: Maybe<&2, Try>, d: Maybe<&2, Nat>) -> Retry.Budget: Runner.budget (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=budget) def budget(p: Retry.Policy, t: Maybe<&2, Try>) -> Retry.Budget: Runner.fails (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=fails) # The failures so far: the index of the next retry. def fails(t: Maybe<&2, Try>) -> Nat: Runner.gave (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=gave) # Why retry stopped a transient failure: no attempt is left, or the next wait would reach the deadline. def gave(b: Retry.Budget) -> Why: Runner.stopped (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=stopped) # A settled attempt completes its ticket; retry gave up at now on any other. def stopped(-A: Data, o: Retry.Outcome, b: Retry.Budget, +id: Nat, +now: Nat) -> Op: Runner.after.plan (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=after.plan) def after.plan(-A: Data, pl: Retry.Plan, o: Retry.Outcome, b: Retry.Budget, +id: Nat, +now: Nat) -> Op: Runner.after (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=after) # The record after an attempt of ticket id ends at now with o: requeue at now plus retry's wait, # complete when o is settled, or abandon when retry gave up. def after(-A: Data, +o: Retry.Outcome, p: Retry.Policy, +b: Retry.Budget, +id: Nat, +n: Nat, +now: Nat, +r: Nat) -> Op: Runner.brk.after (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=brk.after) # A target's breaker after an attempt ends at now with o. def brk.after(+circ: Retry.Circuit, old: Retry.State, +now: Nat, o: Retry.Outcome) -> Retry.Breaker: Runner.until (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=until) # When an open breaker lets attempts start again. def until(br: Retry.Breaker, +now: Nat) -> Nat: Runner.held (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=held) # The record for a ticket that admit refused: Defer to when the breaker may admit, or Abandon when its budget is spent or late. def held(-A: Data, why: Retry.Deny, br: Retry.Breaker, +id: Nat, +now: Nat) -> Op: Runner.why.code (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=why.code) def why.code(w: Why) -> Nat: Runner.W (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=W) def W() -> Nat: Runner.put.u64 (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=put.u64) # Nat fields hold values under 2^64. def put.u64(b: Bytes.Bytes, +at: U32, +n: Nat) -> Bytes.Bytes: Runner.head (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=head) def head(+tag: U32, +a: Nat, +c: Nat) -> Bytes.Bytes: Runner.snap.u32 (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.u32) def snap.u32(out: Bytes.Bytes, +v: U32) -> Bytes.Bytes: Runner.snap.u64 (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.u64) def snap.u64(out: Bytes.Bytes, +n: Nat) -> Bytes.Bytes: Runner.snap.chars (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.chars) def snap.chars(s: String, out: Bytes.Bytes) -> Bytes.Bytes: Runner.snap.key (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.key) # A target is a u32 count of chars, then each char as a u32. def snap.key(out: Bytes.Bytes, +k: String) -> Bytes.Bytes: Runner.snap.nats (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.nats) def snap.nats(xs: List<&2, Nat>, out: Bytes.Bytes) -> Bytes.Bytes: Runner.snap.brk (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.brk) # A breaker state is a u32 kind. 0 is closed: a u32 count, then each failure as a u64. 1 is open: until. 2 is half-open: busy. def snap.brk(out: Bytes.Bytes, b: Retry.State) -> Bytes.Bytes: Runner.encode (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=encode) def encode(~A: Data, ~penc: A -> Bytes.Bytes, op: Op) -> Bytes.Bytes: Runner.get.field (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=get.field) def get.field(m: Maybe<&2, U32>) -> U32: Runner.get.u32 (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=get.u32) def get.u32(r: Bytes.Bytes & Maybe<&2, U32>) -> Bytes.Bytes & U32: Runner.get.hi (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=get.hi) def get.hi(+lo: U32, r: Bytes.Bytes & Maybe<&2, U32>) -> Bytes.Bytes & Nat: Runner.get.lo (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=get.lo) def get.lo(+at: U32, r: Bytes.Bytes & Maybe<&2, U32>) -> Bytes.Bytes & Nat: Runner.get.u64 (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=get.u64) def get.u64(b: Bytes.Bytes, +at: U32) -> Bytes.Bytes & Nat: Runner.snap.payload (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.payload) def snap.payload(out: Bytes.Bytes, p: Bytes.Bytes) -> Bytes.Bytes: Runner.snap.ticket (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.ticket) def snap.ticket(~A: Data, ~penc: A -> Bytes.Bytes, out: Bytes.Bytes, t: Q.Ticket) -> Bytes.Bytes: Runner.snap.heap (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.heap) def snap.heap(~A: Data, ~penc: A -> Bytes.Bytes, h: H.Heap>, out: Bytes.Bytes) -> Bytes.Bytes: Runner.snap.run (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.run) def snap.run(~A: Data, ~penc: A -> Bytes.Bytes, xs: List<&2, Q.Ticket>, out: Bytes.Bytes) -> Bytes.Bytes: Runner.snap.tries (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.tries) def snap.tries(ts: Tries(), out: Bytes.Bytes) -> Bytes.Bytes: Runner.snap.entries (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.entries) def snap.entries(~A: Data, ~penc: A -> Bytes.Bytes, es: List<&2, M.Entry>>, out: Bytes.Bytes) -> Bytes.Bytes: Runner.snap.graves (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.graves) def snap.graves(~A: Data, ~penc: A -> Bytes.Bytes, ds: Graves(A), out: Bytes.Bytes) -> Bytes.Bytes: Runner.snap.brks (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=snap.brks) def snap.brks(xs: List<&2, Sigma<&2, &2, String, _ => Retry.State>>, out: Bytes.Bytes) -> Bytes.Bytes: Runner.encode.snap (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=encode.snap) # The Snap record of s. def encode.snap(~A: Data, ~penc: A -> Bytes.Bytes, s: State) -> Bytes.Bytes: Runner.encode.rec (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=encode.rec) def encode.rec(~A: Data, ~penc: A -> Bytes.Bytes, r: Rec) -> Bytes.Bytes: Runner.Rd (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Rd) # A snapshot reader: the record, and the offset of the next field. type Rd is Type: Rd{b: Bytes.Bytes, at: U32} Runner.Dec (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Dec) # One step of the snapshot decoder. None: a field runs past the record or does not decode. def Dec(-T: Type) -> Type: Runner.Dec.next (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Dec.next) def Dec.next(-A: Type, -B: Type, m: Maybe<&1, Rd & A>, f: A -> Dec(B)) -> Maybe<&1, Rd & B>: Runner.Dec.bind (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Dec.bind) def Dec.bind(-A: Type, -B: Type, m: Dec(A), f: A -> Dec(B)) -> Dec(B): Runner.Dec.pure (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Dec.pure) def Dec.pure(-A: Type, x: A) -> Dec(A): Runner.Dec.fail (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=Dec.fail) def Dec.fail(-A: Type) -> Dec(A): Runner.rd.u32.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=rd.u32.of) def rd.u32.of(m: Maybe<&2, U32>, b: Bytes.Bytes, +at: U32) -> Maybe<&1, Rd & U32>: Runner.rd.u32.got (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=rd.u32.got) def rd.u32.got(+at: U32, r: Bytes.Bytes & Maybe<&2, U32>) -> Maybe<&1, Rd & U32>: Runner.rd.u32.at (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=rd.u32.at) def rd.u32.at(r: Rd) -> Maybe<&1, Rd & U32>: Runner.rd.u32 (https://jend.leeeet.dev/definition.txt?path=bend-kit-runner@0.13.0.1/runner.bend&name=rd.u32) def rd.u32() -> Dec(U32): More: https://jend.leeeet.dev/packages/bend-kit-runner.txt?definitions_offset=100