async-lube 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 2.1.0
+
+### Added
+
+- `offload(url, { data, delay, onBatch })` loads a module file, a `URL` or a URL string, in one stateful worker and
+  returns `{ ready, call(request), close() }`. The module default-exports a setup function that gets `data` and
+  returns `{ call, batch?, close? }` (type it with `OffloadSetup`). Replies are matched by id, calls made in one tick
+  travel in one message, and the worker runs the requests that arrived together, gathered for `delay` milliseconds
+  (0: the next macrotask), as one batch, never two at once. `batch(run)` wraps a batch, e.g. in a transaction; if it
+  throws every call of the batch rejects, and a value it returns reaches `onBatch` in the calling thread, after which
+  the calls of the batch settle (they reject if `onBatch` rejects). A failing setup rejects `ready` and every call,
+  and a crashed worker rejects its calls and every later one. `close()` lets the sent calls finish, runs the module's
+  `close`, ends the thread and resolves after it exited; later calls reject with `CancelError`.
+  `offload("not a url")` throws a `TypeError`.
+- `redial(connect, { signal, base, most })` keeps one connection up: it calls `connect({ attempt, signal, open, close })`
+  at once and again after each `close()`, waiting `base` milliseconds (default 1000) after a connection that
+  called `open()` and doubling the wait up to `most` (default 30000) after each one that closed without
+  opening. A `connect` that throws or rejects counts as a close. When `signal` aborts it stops the wait, aborts the
+  signal of the connection in hand and resolves once that connection has closed.
+- `limiter(...).take(key?)` answers at once, without waiting, whether a start is free in the rate window:
+  it returns `0` and counts the start, or the milliseconds until the next start is accepted and counts
+  nothing. It ignores `concurrency` and the queue but shares the window with calls and `acquire()`, uses
+  the state of `key`, and throws a `TypeError` without a `rate`.
+- `limiter({ rate: { window: "fixed" } })` opens a window at the first start after the last one ended and
+  allows `count` starts in it, for calls, `acquire()` and `take()`. The default `"sliding"` is unchanged.
+
+### Fixed
+
+- `share` of a value that is not a stream rejects the first read and ends the loop, so reading again
+  without `return()` no longer waits forever.
+- `merge` releases the streams it already opened when a later source is not a stream.
+- A flow node that restarts with its next queued value while its `fallback` target is still running
+  no longer runs the target one more time.
+
 ## 2.0.0
 
 ### Breaking

package/README.md

@@ -249,7 +249,7 @@ const thumbnail = await resize(bytes, 200, signal) // the signal terminates the
 ```
 - `attempt` takes the same `retry` options as a request and a flow node.
 - `limiter` starts the calls in order, and `key(id)` gives each user or tenant the same limits.
-- `offload` sends the function as its source, so it uses only its arguments and globals.
+- `offload` sends the function as its source, so it uses only its arguments and globals. `offload(url, { data, delay, onBatch })` loads a module file in one stateful worker instead, and `call(request)` sends requests that run in batches.
 
 [docs/tasks.md](https://github.com/artxe/lube-series/blob/master/packages/async-lube/docs/tasks.md): leases, keys and workers.
 

package/docs/http.md

@@ -233,7 +233,7 @@ const logged = http({
 ```
 
 ## Caches and stores
-`http` does not cache responses or hold UI state. It fits under a query cache, under a few lines of your own, or under a store of 27 lines.
+`http` does not cache responses or hold UI state. It fits under a query cache, under a few lines of your own, or under a small store.
 
 ```ts
 // TanStack Query, SWR or any cache: pass its signal, and let the cache own the key

package/docs/reference.md

@@ -71,7 +71,7 @@ A request is a promise of the data with `cancel(reason?)`, `safe()` and `raw()`,
 | `overlap` | `"restart"` (default), `"ignore"`, `"rerun"` or `"queue"`: what the node does when it is started again while it runs |
 | `concurrency` | The items that run at the same time, for a `flow.each()` node |
 | `limit` | The updates that `overlap: "queue"` or a `flow.queue()` dependency keeps waiting, dropping the oldest above it. The value in use is never dropped |
-| `overflow` | `"drop"` (default), or `"wait"` to stop reading the stream dependencies while the queue is full, which needs one |
+| `overflow` | `"drop"` (default), or `"wait"` to stop reading the stream dependencies while the queue is full, which needs one. Either needs a `limit` |
 | `release` | `(result, error)` when the result is no longer used: commits, rolls back or closes it. The node starts only when a dependent can run |
 | `name` | The name in `nodes`, `results`, `errors` and snapshots |
 
@@ -97,7 +97,9 @@ The stream functions are listed in [Operators](https://github.com/artxe/lube-ser
 | API | |
 | --- | --- |
 | `attempt(fn, { retry, signal, timeout })` | Runs `fn({ attempt, signal })` again after it fails, with a timeout for each attempt |
-| `limiter({ concurrency, rate: { count, per } })` | A function `(fn, signal?)` that runs the calls within the limits, in order, with `acquire(signal?)`, `key(id)`, `pending` and `running` |
+| `redial(connect, { signal, base, most })` | Calls `connect({ attempt, signal, open, close })` at once and again after each `close()`, waiting `base` ms (default 1000) after a connection that opened and doubling up to `most` ms (default 30000) after each that closed without opening, until `signal` aborts; resolves once the connection in hand has closed |
+| `limiter({ concurrency, rate: { count, per, window } })` | A function `(fn, signal?)` that runs the calls within the limits, in order, with `acquire(signal?)`, `key(id)`, `take(id?)` (`0` or the milliseconds until a start is free, at once), `pending` and `running`; `window` is `"sliding"` (default) or `"fixed"` |
 | `durable(store, fn, { idle, lease, migrate, owner, poll, revision })` | From `async-lube/durable`: `run(key, input)`, `join(key)`, `start(key, input)`, `send(key, name, value)`, `cancel(key, reason?)`, `get(key)`, `serve({ batch, interval, onError, signal }?)`, `stop()` and `running`, with `step`, `sleep` and `wait(name, { timeout, until })` in `fn(input, context)` |
 | `memory()`, `sqlite(db, table?)`, `dueAt(run)` | From `async-lube/durable`: the stores, and when a run is due, for a store of your own |
 | `offload(fn, { concurrency })` | A function that runs `fn` in a worker, with `close()`. Its calls have `cancel()`, and an `AbortSignal` as the last argument cancels them |
+| `offload(url, { data, delay, onBatch })` | A stateful worker that loads the module at `url`: `{ ready, call(request), close() }`. The requests of one tick travel in one message and run in one batch of the module's `batch(run)`, and a value it returns reaches `onBatch` before the calls settle |

package/docs/tasks.md

@@ -2,7 +2,7 @@
 `attempt`, `limiter` and `offload` give any async work, on a page or a server, a retry and a timeout, a limit shared by everything that uses a database or an API quota, and a worker for heavy functions.
 
 ```ts
-import { attempt, limiter, offload } from "async-lube"
+import { attempt, limiter, offload, redial } from "async-lube"
 
 // a database query with a timeout for each attempt, retried twice
 const rows = await attempt(({ signal }) => db.query(sql, { signal }), { retry: 2, timeout: 5000 })
@@ -18,6 +18,21 @@ await jobs.key(user.id)(() => export_data(user))
 const lease = await pool.acquire(signal)
 try { await copy_tables() } finally { lease.release() }
 
+// a packet limit per socket, answered at once and never waiting
+const packets = limiter({ rate: { count: 20, per: 1000, window: "fixed" } })
+const retry_after = packets.take(socket.id) // 0, or the milliseconds until a start is free
+
+// one WebSocket kept up, reconnecting after each close with a capped backoff
+const stop = new AbortController()
+const stopped = redial(({ attempt, signal, open, close }) => {
+    const socket = new WebSocket(urls[(attempt - 1) % urls.length])
+    socket.onopen = open
+    socket.onclose = close
+    signal.addEventListener("abort", () => socket.close(), { once: true })
+}, { signal: stop.signal, base: 1000, most: 30000 })
+stop.abort()
+await stopped
+
 // heavy work in a worker, so that the page or the server keeps answering
 const resize = offload(async (bytes: ArrayBuffer, width: number) => {
     // only its arguments and globals: this runs in the worker
@@ -25,8 +40,10 @@ const resize = offload(async (bytes: ArrayBuffer, width: number) => {
 const thumbnail = await resize(bytes, 200, signal) // the signal terminates the worker
 ```
 - `attempt` gives the function `{ attempt, signal }`, and the signal aborts on a timeout or the `signal` option, so pass it on. `retry` takes a count or `{ count, delay, when }`, as a flow node does, where a `delay` function that returns undefined stops retrying, and a `signal` that aborts rejects with `CancelError`, also while it waits for the next attempt.
-- `limiter` starts the calls in order when they are within its limits. A signal as the second argument takes a call out of the line while it waits, and `pending` and `running` count the calls. `acquire()` holds a slot until `release()`, and `key(id)` is a limiter with the same limits for each key, dropped when it has nothing to do. Like `durable`, it throws a TypeError for an option it does not know, e.g. `concurency`, and `attempt` rejects with one.
+- `limiter` starts the calls in order when they are within its limits. A signal as the second argument takes a call out of the line while it waits, and `pending` and `running` count the calls. `acquire()` holds a slot until `release()`, and `key(id)` is a limiter with the same limits for each key, dropped when it has nothing to do. `take(id?)` answers at once, without waiting: `0` when a start is free in the rate window, which it counts, otherwise the milliseconds until the next start is accepted, which it counts nothing for. It ignores `concurrency` and the queue but shares the window with the calls and `acquire()`, so a queued call waits for it, and it throws a TypeError without a `rate`. The window is `"sliding"` by default, where each start frees its slot `per` milliseconds later, or `"fixed"`, where a window opens at the first start after the last one ended and frees all `count` starts at once when it ends. Like `durable`, it throws a TypeError for an option it does not know, e.g. `concurency`, and `attempt` rejects with one.
 - `offload` sends the function as its source, so it may use only its arguments and globals: an arrow function or a function expression, not a method or a closure. The arguments and the result are copied as `postMessage` copies them, `concurrency` workers run at once, 1 by default, and `close()` terminates them. An `AbortSignal` as the last argument or `cancel()` of the call terminates its worker. In Node.js it needs 20.16 or later, and idle workers do not keep the process running.
+- `offload(url, { data, delay, onBatch })` loads a module file, a `URL` or a URL string, in one stateful worker, for work that keeps a state, e.g. a database. The module default-exports a setup function that gets `data` and returns `{ call, batch, close }`, possibly after an async setup, and `ready` resolves when it has finished or rejects with its error, which every call rejects with too. `call(request)` returns the result of the module's `call`, matched by id, and the calls made in the same tick travel in one message. The worker gathers the requests that arrive within `delay` milliseconds (0, the next macrotask, by default) into one batch and never runs two at once: `batch(run)` wraps a batch, where `run()` calls `call` for every request in order and its promise settles when every result has settled, so `db.exec("BEGIN"); run(); db.exec("COMMIT")` works for sync calls and `await run()` for async ones. If `batch` throws or rejects, every call of the batch rejects with that error. A value it returns reaches `onBatch` in the calling thread, and the calls of the batch settle only after `onBatch` resolves (in order, and they reject with its error if it rejects), e.g. to ship a changeset before the replies. `close()` lets the calls already sent finish, runs the module's `close`, ends the thread and resolves after it exited; calls made after it reject with `CancelError`. A worker that crashed rejects its calls and every later one, and is not started again. Type the default export with `OffloadSetup<Data, Request, Result>`.
+- `redial(connect, { signal, base, most })` keeps one connection up, e.g. a WebSocket: it calls `connect({ attempt, signal, open, close })` at once and again after each `close()`, until `signal` aborts. The connector calls `open()` when the connection is up, which resets the wait, and `close()` when it ended. The wait before the next `connect` is `base` milliseconds (1000 by default) after a connection that opened, and doubles up to `most` (30000 by default) after each one that closed without opening. `attempt` counts every call from 1, so it can rotate addresses, and a `connect` that throws or rejects counts as a close. When `signal` aborts, the signal of the connection in hand aborts with the same reason, so close the connection on it, and the result resolves once that connection has closed.
 - Files, database cursors and `readline` are async iterables, so they are streams: `for await (const line of readline.createInterface({ input: createReadStream(path) }))`, or a flow dependency that `overflow: "wait"` slows down.
 
 The signatures are in the [API tables](https://github.com/artxe/lube-series/blob/master/packages/async-lube/docs/reference.md#tasks).

package/package.json

@@ -4,9 +4,6 @@
     "url": "https://github.com/artxe/lube-series/issues"
   },
   "description": "Syntax sugar for fetch requests, streams, async flows and durable runs",
-  "devDependencies": {
-    "@typescript/native": "npm:typescript@^7.0.2"
-  },
   "engines": {
     "node": ">=18"
   },
@@ -35,6 +32,7 @@
     "types/index.*",
     "types/limiter.*",
     "types/offload.*",
+    "types/redial.*",
     "types/stream.*"
   ],
   "homepage": "https://github.com/artxe/lube-series/tree/master/packages/async-lube#readme",
@@ -50,6 +48,7 @@
     "http",
     "lube",
     "rate limit",
+    "reconnect",
     "retry",
     "server-sent events",
     "stream",
@@ -78,10 +77,10 @@
       ]
     }
   },
-  "version": "2.0.0",
+  "version": "2.1.0",
   "scripts": {
     "dts": "node ../../scripts/tsc_with_clean.js async-lube",
     "lint": "pnpm -w lint",
-    "test": "pnpm -w exec vitest run --coverage test/async-lube && pnpm -w exec vitest run --config vitest.browser.config.js"
+    "test": "pnpm -w exec vitest run test/async-lube test/browser"
   }
 }

package/public.d.ts

@@ -39,6 +39,25 @@ export type AttemptOptions = {
 	/** Milliseconds for each attempt, which aborts its `signal` and fails with TimeoutError. */
 	timeout?: number | undefined
 }
+export interface RedialOptions {
+	/** Milliseconds to wait before connecting again after a connection that opened, and after the first one that failed. Default: 1000. */
+	base?: number | undefined
+	/** Most milliseconds to wait: the wait doubles after each connection that closed without opening, up to this. Not less than `base`. Default: 30000. */
+	most?: number | undefined
+	/** Cancels the waiting and the connection in hand, and stops reconnecting. Required. */
+	signal: AbortSignal
+}
+/** What `redial` gives `connect` for one connection. */
+export interface RedialContext {
+	/** Counts every call of `connect` from 1, e.g. to rotate addresses. */
+	attempt: number
+	/** Ends this connection, so `redial` connects again after the wait. Only the first call counts. */
+	close(): void
+	/** Marks this connection as up and resets the wait. Calling it again, or after the connection closed, does nothing. */
+	open(): void
+	/** Aborts, with the reason of the signal of `redial`, when that signal aborts while this connection is in hand. */
+	signal: AbortSignal
+}
 /** A slot of a limiter, held until `release()`, e.g. by a transaction across several flow nodes. */
 export type Lease = {
 	/** Gives the slot back. Calling it again does nothing. */
@@ -59,6 +78,19 @@ export interface Limiter {
 	readonly pending: number
 	/** The calls that run. */
 	readonly running: number
+	/**
+	 * Answers at once, without waiting, whether a start is free in the rate window: `0` and the start is counted,
+	 * or the milliseconds until the next start is accepted, and nothing is counted.
+	 * It ignores `concurrency` and the queue, and counts against the same window as the calls and `acquire()`, so a queued call waits for it.
+	 * With a key it uses the state of that key, as `key(key)` would, without making a limiter. Throws a TypeError without a `rate`.
+	 * @example
+	 * const packets = limiter({ rate: { count: 20, per: 1000, window: "fixed" } })
+	 * socket.on("message", () => {
+	 *   const retry_after = packets.take(socket.id)
+	 *   if (retry_after > 0) return socket.send(`slow down, retry in ${retry_after} ms`)
+	 * })
+	 */
+	take(key?: unknown): number
 }
 /** A call of an `offload()` function: its result, with `cancel()` to stop it. */
 export type OffloadCall<T> = Promise<T> & { cancel(reason?: unknown): void }
@@ -69,6 +101,86 @@ export interface Offloaded<A extends unknown[], R> {
 	/** Terminates the workers and cancels the calls. A later call starts a worker again. */
 	close(): void
 }
+/** What a worker module returns from its setup function, see `offload(url)`. */
+export interface OffloadHandlers<Q, R, B = unknown> {
+	/**
+	 * Wraps one batch of requests, e.g. in a transaction. `run()` calls `call` for every request of the batch, in order, before it returns,
+	 * and its promise settles when every result has settled. If `batch` throws or rejects, every call of the batch rejects with that error.
+	 * A value other than `undefined` that it returns travels with the replies to the `onBatch` option of the caller.
+	 */
+	batch?(run: () => Promise<void>): B | undefined | Promise<B | undefined>
+	/** Runs one request and returns its result or a promise of it. A throw or a rejection rejects that call only. */
+	call(request: Q): R | Promise<R>
+	/** Runs when the module is closed, after the last batch. */
+	close?(): void | Promise<void>
+}
+/**
+ * The default export of a worker module for `offload(url)`: it gets the `data` option and returns the handlers, possibly after an async setup.
+ * @example
+ * const setup: OffloadSetup<string, number, Row> = path => {
+ *   const db = open(path)
+ *   return { call: id => db.get(id), batch: async run => { db.exec("BEGIN"); await run(); db.exec("COMMIT") } }
+ * }
+ * export default setup
+ */
+export type OffloadSetup<D, Q, R, B = unknown> = (data: D) => OffloadHandlers<Q, R, B> | Promise<OffloadHandlers<Q, R, B>>
+export interface OffloadModuleOptions<D = unknown, B = unknown> {
+	/** Copied as `postMessage` copies it, and passed to the setup function of the module. */
+	data?: D | undefined
+	/** Milliseconds the worker gathers requests before it runs a batch, 0 by default: until the next macrotask. */
+	delay?: number | undefined
+	/** Gets the value that `batch` returned, in the thread that called `offload`. The calls of the batch settle after it resolves, and reject with its error if it rejects. */
+	onBatch?: ((value: B) => unknown) | undefined
+}
+/** A worker that loaded a module, see `offload(url)`. */
+export interface OffloadModule<Q, R> {
+	/** Sends the request to the worker. Requests made in the same tick travel in one message. Rejects with the error of the module or of a crashed worker. */
+	call(request: Q): Promise<R>
+	/**
+	 * Lets the calls already sent finish, runs the `close` of the module, then ends the thread. Calls made afterwards reject with a `CancelError`.
+	 * Rejects with the error of the `close` of the module, but the thread ends anyway. Returns the same promise every time.
+	 */
+	close(): Promise<void>
+	/** Resolves when the setup of the module has finished, and rejects with its error, which every call rejects with too. */
+	readonly ready: Promise<void>
+}
+export interface OffloadFunction {
+	/**
+	 * Runs a function in a Worker, or a worker thread in Node.js 20.16 or later, so that heavy work does not block the page or the server.
+	 * The function travels as its source, so it may use only its arguments and globals: an arrow function or a function expression,
+	 * not a method or a closure. Arguments and results are copied as `postMessage` copies them. `concurrency` workers run at once, 1 by default.
+	 * @example
+	 * const resize = offload(async (bytes: ArrayBuffer, width: number) => shrink(bytes, width))
+	 * const thumbnail = await resize(bytes, 200, signal) // the signal terminates the worker
+	 */
+	<A extends unknown[], R>(fn: (...args: A) => R, options?: { concurrency?: number | undefined }): Offloaded<A, R>
+	/**
+	 * Loads a module file in one stateful worker, for work that keeps a state, e.g. a database. The module default-exports a setup function
+	 * that gets `data` and returns `{ call, batch?, close? }`, see `OffloadSetup`. Replies are matched by id, calls made in the same tick
+	 * travel in one message, and the worker runs the requests that arrived together as one batch, never two at once: `batch(run)` can
+	 * wrap them in a transaction, and a value it returns reaches `onBatch` before the calls of the batch settle. A crashed worker rejects
+	 * its calls and every later one, and is not started again. Idle, it does not keep a Node.js process running.
+	 * @example
+	 * // main thread
+	 * const store = offload<Request, Result>(new URL("./store.js", import.meta.url), {
+	 *   data: { path: "game.db" },
+	 *   onBatch: changes => socket.send(changes) // the calls settle after this resolves
+	 * })
+	 * await store.ready
+	 * const [ a, b ] = await Promise.all([ store.call({ get: 1 }), store.call({ put: 2 }) ]) // one batch
+	 * await store.close()
+	 * // store.js
+	 * export default function({ path }) {
+	 *   const db = open(path)
+	 *   return {
+	 *     call: request => run(db, request),
+	 *     batch: async run => { db.exec("BEGIN"); await run(); db.exec("COMMIT"); return db.changes() },
+	 *     close: () => db.close()
+	 *   }
+	 * }
+	 */
+	<Q, R, D = unknown, B = unknown>(url: string | URL, options?: OffloadModuleOptions<D, B>): OffloadModule<Q, R>
+}
 export interface ChannelFunction {
 	/**
 	 * A stream that values are pushed into, e.g. from a callback API or a form.

package/src/attempt.js

@@ -29,9 +29,11 @@ export async function attempt(fn, options = {}) {
 		signal,
 		timeout
 	} = options
-	if (timeout != null && !(typeof timeout == "number" && timeout > 0)) throw TypeError(
-		"The timeout of attempt() must be a positive number of milliseconds"
-	)
+	if (timeout != null && !(typeof timeout == "number" && timeout > 0)) {
+		throw TypeError(
+			"The timeout of attempt() must be a positive number of milliseconds"
+		)
+	}
 	const retry = typeof retry_option == "number" ? { count: retry_option } : retry_option
 	for (let count = 1; ; count++) {
 		const controller = new AbortController()
@@ -43,7 +45,9 @@ export async function attempt(fn, options = {}) {
 			)
 			: void 0
 		try {
-			if (controller.signal.aborted) throw controller.signal.reason
+			if (controller.signal.aborted) {
+				throw controller.signal.reason
+			}
 			return /** @type {Awaited<T>} */(await race_signal(
 				Promise.resolve()
 					.then(
@@ -57,12 +61,18 @@ export async function attempt(fn, options = {}) {
 				controller.signal
 			))/**/
 		} catch (error) {
-			if (signal?.aborted) throw to_cancel_error(signal.reason)
-			if (!retry || count > retry.count || retry.when && !await retry.when(error, count)) throw error
+			if (signal?.aborted) {
+				throw to_cancel_error(signal.reason)
+			}
+			if (!retry || count > retry.count || retry.when && !await retry.when(error, count)) {
+				throw error
+			}
 			const delay = typeof retry.delay == "function"
 				? retry.delay(count, error, 0)
 				: retry.delay ?? 0
-			if (delay == null) throw error
+			if (delay == null) {
+				throw error
+			}
 			clearTimeout(timer)
 			if (delay > 0) {
 				await sleep(delay, signal)

package/src/durable/context.js

@@ -20,12 +20,16 @@ import { take_event, unclaim, wake_if_sent } from "./state.js"
  * @returns {void}
  */
 function check_idle(d, execution) {
-	if (!execution.blocked.length || execution.flights || execution.suspending) return
+	if (!execution.blocked.length || execution.flights || execution.suspending) {
+		return
+	}
 	execution.suspending = true
 	setTimeout(
 		() => {
 			execution.suspending = false
-			if (!execution.blocked.length || execution.flights || execution.lost || execution.finished) return
+			if (!execution.blocked.length || execution.flights || execution.lost || execution.finished) {
+				return
+			}
 			const wakes = execution.blocked.flatMap(
 				item => item.wake == null ? [] : [ item.wake ]
 			)
@@ -36,7 +40,9 @@ function check_idle(d, execution) {
 				? "waiting"
 				: "sleeping"
 			unclaim(saved)
-			if (wakes.length) saved.wake = Math.min(...wakes)
+			if (wakes.length) {
+				saved.wake = Math.min(...wakes)
+			}
 			wake_if_sent(saved)
 			execution.finished = true
 			void persist(d, execution).then(
@@ -49,7 +55,9 @@ function check_idle(d, execution) {
 						return
 					}
 					execution.interrupt(SUSPENDED)
-					if (saved.status == "running") void execution.gone.then(() => resume(d, execution.key)).catch(noop)
+					if (saved.status == "running") {
+						void execution.gone.then(() => resume(d, execution.key)).catch(noop)
+					}
 				}
 			)
 		},
@@ -68,22 +76,30 @@ export function context_of(d, execution) {
 		key,
 		signal,
 		sleep(name, ms) {
-			if (!(Number.isFinite(ms) && ms >= 0)) return Promise.reject(
-				TypeError(
-					"The ms of sleep() must be a non-negative number of milliseconds"
+			if (!(Number.isFinite(ms) && ms >= 0)) {
+				return Promise.reject(
+					TypeError(
+						"The ms of sleep() must be a non-negative number of milliseconds"
+					)
 				)
-			)
+			}
 			const refused = refuse(execution)
-			if (refused) return refused
+			if (refused) {
+				return refused
+			}
 			const entry = entry_of(execution, name, "sleep")
-			if (entry.done) return Promise.resolve()
+			if (entry.done) {
+				return Promise.resolve()
+			}
 			if (entry.until == null) {
 				entry.until = Date.now() + ms
 				void persist(d, execution)
 			}
 			const until = entry.until
 			const left = until - Date.now()
-			if (left > d.idle_ms) return suspend(d, execution, until, "sleeping")
+			if (left > d.idle_ms) {
+				return suspend(d, execution, until, "sleeping")
+			}
 			execution.flights++
 			return sleep_until(until, signal)
 				.then(
@@ -101,7 +117,9 @@ export function context_of(d, execution) {
 		},
 		step(name, work) {
 			const refused = refuse(execution)
-			if (refused) return refused
+			if (refused) {
+				return refused
+			}
 			const index = execution.cursor
 			const entry = entry_of(execution, name, "step")
 			if (entry.done) {
@@ -116,17 +134,6 @@ export function context_of(d, execution) {
 					)
 			}
 			execution.flights++
-			/**
-			 * @param {unknown} error
-			 * @returns {Promise<never>}
-			 */
-			function failed(error) {
-				if (signal.aborted || execution.lost || execution.finished) throw error
-				entry.done = true
-				entry.error = saved_error(error)
-				void persist(d, execution)
-				return fail(execution, entry, error)
-			}
 			return Promise.resolve()
 				.then(
 					() => refuse(execution) ?? work(
@@ -139,11 +146,13 @@ export function context_of(d, execution) {
 				.then(
 					value => {
 						const problem = json_problem(value)
-						if (problem) return failed(
-							TypeError(
-								`The result of step "${name}" of run "${key}" is not a JSON value: ${problem}`
+						if (problem) {
+							return failed(
+								TypeError(
+									`The result of step "${name}" of run "${key}" is not a JSON value: ${problem}`
+								)
 							)
-						)
+						}
 						entry.done = true
 						entry.value = copy(value)
 						void persist(d, execution)
@@ -157,6 +166,19 @@ export function context_of(d, execution) {
 						check_idle(d, execution)
 					}
 				)
+			/**
+			 * @param {unknown} error
+			 * @returns {Promise<never>}
+			 */
+			function failed(error) {
+				if (signal.aborted || execution.lost || execution.finished) {
+					throw error
+				}
+				entry.done = true
+				entry.error = saved_error(error)
+				void persist(d, execution)
+				return fail(execution, entry, error)
+			}
 		},
 		wait(name, wait_options = {}) {
 			try {
@@ -166,17 +188,23 @@ export function context_of(d, execution) {
 					"wait"
 				)
 				const { timeout, until } = wait_options
-				if (!(timeout == null || Number.isFinite(timeout) && timeout >= 0)) throw TypeError(
-					"The timeout of wait() must be a non-negative number of milliseconds"
-				)
-				if (!(until == null || Math.abs(until) <= 8640000000000000)) throw TypeError(
-					"The until of wait() must be a time in milliseconds since the epoch"
-				)
+				if (!(timeout == null || Number.isFinite(timeout) && timeout >= 0)) {
+					throw TypeError(
+						"The timeout of wait() must be a non-negative number of milliseconds"
+					)
+				}
+				if (!(until == null || Math.abs(until) <= 8640000000000000)) {
+					throw TypeError(
+						"The until of wait() must be a time in milliseconds since the epoch"
+					)
+				}
 			} catch (error) {
 				return Promise.reject(error)
 			}
 			const refused = refuse(execution)
-			if (refused) return refused
+			if (refused) {
+				return refused
+			}
 			const entry = entry_of(execution, name, "wait")
 			const { timeout } = wait_options
 			if (entry.done) {
@@ -192,11 +220,15 @@ export function context_of(d, execution) {
 			}
 			const fresh = entry.until == null
 			if (fresh) {
-				if (timeout != null) entry.until = Date.now() + timeout
-				if (wait_options.until != null) entry.until = Math.min(
-					entry.until ?? Infinity,
-					wait_options.until
-				)
+				if (timeout != null) {
+					entry.until = Date.now() + timeout
+				}
+				if (wait_options.until != null) {
+					entry.until = Math.min(
+						entry.until ?? Infinity,
+						wait_options.until
+					)
+				}
 			}
 			const event = execution.saved.events?.[name]?.[0]
 			if (event && !execution.unsaved.has(event) && (entry.until == null || event.at <= entry.until)) {
@@ -208,7 +240,9 @@ export function context_of(d, execution) {
 					/** @type {never} */(copy(event.value))/**/
 				)
 			}
-			if (fresh && entry.until != null) void persist(d, execution)
+			if (fresh && entry.until != null) {
+				void persist(d, execution)
+			}
 			const until = entry.until
 			return new Promise(
 				(resolve, reject) => {
@@ -221,22 +255,42 @@ export function context_of(d, execution) {
 						resolve: /** @type {(value: unknown) => void} */(resolve)/**/
 					}
 					const list = execution.waiters.get(name) ?? []
-					if (!list.length) execution.waiters.set(name, list)
+					if (!list.length) {
+						execution.waiters.set(name, list)
+					}
 					list.push(waiter)
 					watch_inbox(d, execution)
 					/** @type {ReturnType<typeof setTimeout>} */
 					let timer
-					/**
-					 * @returns {void}
-					 */
+					if (until != null && until <= Date.now()) {
+						expire()
+					} else {
+						timer = setTimeout(
+							expire,
+							clamp_delay(
+								Math.min(
+									d.idle_ms,
+									until == null ? Infinity : until - Date.now()
+								)
+							)
+						)
+					}
+					waiter.clear = () => clearTimeout(timer)
+					/** @returns {void} */
 					function expire() {
-						if (execution.finished || execution.lost || !list.includes(waiter)) return
+						if (execution.finished || execution.lost || !list.includes(waiter)) {
+							return
+						}
 						if (until != null && until <= Date.now()) {
 							void inbox_read(d, execution).then(
 								read => {
-									if (execution.finished || execution.lost) return
+									if (execution.finished || execution.lost) {
+										return
+									}
 									const index = list.indexOf(waiter)
-									if (index < 0) return
+									if (index < 0) {
+										return
+									}
 									if (!read) {
 										timer = setTimeout(expire, d.poll_ms)
 										return
@@ -251,10 +305,12 @@ export function context_of(d, execution) {
 							execution.blocked.push(waiter.block)
 							check_idle(d, execution)
 						}
-						if (until != null) timer = setTimeout(
-							expire,
-							clamp_delay(until - Date.now())
-						)
+						if (until != null) {
+							timer = setTimeout(
+								expire,
+								clamp_delay(until - Date.now())
+							)
+						}
 					}
 					/**
 					 * @param {number} index
@@ -273,19 +329,6 @@ export function context_of(d, execution) {
 						)
 						reject(error)
 					}
-					if (until != null && until <= Date.now()) expire()
-					else {
-						timer = setTimeout(
-							expire,
-							clamp_delay(
-								Math.min(
-									d.idle_ms,
-									until == null ? Infinity : until - Date.now()
-								)
-							)
-						)
-					}
-					waiter.clear = () => clearTimeout(timer)
 				}
 			)
 		}