@evolu/common 8.5.0 → 8.6.0

package/dist/src/Schedule.d.ts

@@ -32,6 +32,7 @@ import type { Predicate } from "./Types.ts";
  *
  * ```ts
  * import {
+ *   assertOk,
  *   err,
  *   exponential,
  *   jitter,
@@ -59,18 +60,24 @@ import type { Predicate } from "./Types.ts";
  * await using run = testCreateRun({
  *   random: { next: () => 0 as RandomNumber },
  * });
- * expectOk(await run(fetchWithRetry), "data");
+ * assertOk(await run(fetchWithRetry), "data");
  * ```
  *
  * Or use a preset:
  *
  * ```ts
- * import { ok, retry, retryStrategyAws, type Task } from "@evolu/common";
+ * import {
+ *   assertTrue,
+ *   ok,
+ *   retry,
+ *   retryStrategyAws,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * const fetchData: Task<string> = () => ok("data");
  * const fetchWithRetry = retry(fetchData, retryStrategyAws);
  *
- * expect(fetchWithRetry).toBeTypeOf("function");
+ * assertTrue(typeof fetchWithRetry === "function");
  * ```
  */
 export type Schedule<out Output, in Input = unknown> = (deps: ScheduleDeps) => (input: Input) => NextResult<readonly [Output, Millis]>;
@@ -105,12 +112,12 @@ export interface ScheduleStep<Output> {
  * ### Recurring immediately
  *
  * ```ts
- * import { forever, take, testCreateDeps } from "@evolu/common";
+ * import { assertOk, forever, take, testCreateDeps } from "@evolu/common";
  *
  * // Retry immediately, up to 5 times.
  * const immediate = take(5)(forever);
  * const step = immediate(testCreateDeps());
- * expectOk(step(undefined), [0, 0]);
+ * assertOk(step(undefined), [0, 0]);
  * ```
  *
  * @group Constructors
@@ -124,13 +131,19 @@ export declare const forever: Schedule<number>;
  * ### Scheduling one recurrence
  *
  * ```ts
- * import { done, once, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   done,
+ *   once,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // Produce one scheduled recurrence, then stop.
  * const oneShot = once;
  * const step = oneShot(testCreateDeps());
- * expectOk(step(undefined), [0, 0]);
- * expectErr(step(undefined), done());
+ * assertOk(step(undefined), [0, 0]);
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Constructors
@@ -148,15 +161,21 @@ export declare const once: Schedule<number>;
  * ### Limiting recurrence count
  *
  * ```ts
- * import { done, recurs, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   done,
+ *   recurs,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // Retry up to 3 times (4 total attempts including the initial operation).
  * const retry = recurs(3);
  * const step = retry(testCreateDeps());
- * expectOk(step(undefined), [0, 0]);
+ * assertOk(step(undefined), [0, 0]);
  * step(undefined);
  * step(undefined);
- * expectErr(step(undefined), done());
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Constructors
@@ -171,7 +190,7 @@ export declare const recurs: (n: Int0To100OrNonNegativeInt) => Schedule<number>;
  * ### Constant spacing
  *
  * ```ts
- * import { spaced, take, testCreateDeps } from "@evolu/common";
+ * import { assertOk, spaced, take, testCreateDeps } from "@evolu/common";
  *
  * // Poll every second, retry three times, or run a long-lived heartbeat.
  * const poll = spaced("1s");
@@ -179,9 +198,9 @@ export declare const recurs: (n: Int0To100OrNonNegativeInt) => Schedule<number>;
  * const heartbeat = spaced("30s");
  * const deps = testCreateDeps();
  *
- * expectOk(poll(deps)(undefined), [1000, 1000]);
- * expectOk(retry(deps)(undefined), [500, 500]);
- * expectOk(heartbeat(deps)(undefined), [30000, 30000]);
+ * assertOk(poll(deps)(undefined), [1000, 1000]);
+ * assertOk(retry(deps)(undefined), [500, 500]);
+ * assertOk(heartbeat(deps)(undefined), [30000, 30000]);
  * ```
  *
  * @group Constructors
@@ -202,17 +221,17 @@ export declare const spaced: (duration: Duration) => Schedule<Millis>;
  * ### Exponential growth factors
  *
  * ```ts
- * import { exponential, testCreateDeps } from "@evolu/common";
+ * import { assertOk, exponential, testCreateDeps } from "@evolu/common";
  *
  * // Standard doubling and gentler 1.5× growth.
  * const standard = exponential("100ms");
  * const gentle = exponential("100ms", 1.5);
  * const standardStep = standard(testCreateDeps());
  * const gentleStep = gentle(testCreateDeps());
- * expectOk(standardStep(undefined), [100, 100]);
- * expectOk(standardStep(undefined), [200, 200]);
- * expectOk(gentleStep(undefined), [100, 100]);
- * expectOk(gentleStep(undefined), [150, 150]);
+ * assertOk(standardStep(undefined), [100, 100]);
+ * assertOk(standardStep(undefined), [200, 200]);
+ * assertOk(gentleStep(undefined), [100, 100]);
+ * assertOk(gentleStep(undefined), [150, 150]);
  * ```
  *
  * @group Constructors
@@ -233,12 +252,12 @@ export declare const exponential: (base: Duration, factor?: number) => Schedule<
  * ### Linear growth
  *
  * ```ts
- * import { linear, testCreateDeps } from "@evolu/common";
+ * import { assertOk, linear, testCreateDeps } from "@evolu/common";
  *
  * // 100ms, 200ms, 300ms, 400ms, ...
  * const step = linear("100ms")(testCreateDeps());
- * expectOk(step(undefined), [100, 100]);
- * expectOk(step(undefined), [200, 200]);
+ * assertOk(step(undefined), [100, 100]);
+ * assertOk(step(undefined), [200, 200]);
  * ```
  *
  * @group Constructors
@@ -261,13 +280,13 @@ export declare const linear: (base: Duration) => Schedule<Millis>;
  * ### Fibonacci growth
  *
  * ```ts
- * import { fibonacci, testCreateDeps } from "@evolu/common";
+ * import { assertOk, fibonacci, testCreateDeps } from "@evolu/common";
  *
  * // 100ms, 100ms, 200ms, 300ms, 500ms, ...
  * const step = fibonacci("100ms")(testCreateDeps());
- * expectOk(step(undefined), [100, 100]);
- * expectOk(step(undefined), [100, 100]);
- * expectOk(step(undefined), [200, 200]);
+ * assertOk(step(undefined), [100, 100]);
+ * assertOk(step(undefined), [100, 100]);
+ * assertOk(step(undefined), [200, 200]);
  * ```
  *
  * @group Constructors
@@ -287,7 +306,7 @@ export declare const fibonacci: (initial: Duration) => Schedule<Millis>;
  * ### Maintaining a fixed cadence
  *
  * ```ts
- * import { fixed, take, testCreateDeps } from "@evolu/common";
+ * import { assertOk, fixed, take, testCreateDeps } from "@evolu/common";
  *
  * // A bounded health check and an unbounded cron-like cadence.
  * const healthCheck = take(10)(fixed("5s"));
@@ -295,10 +314,10 @@ export declare const fibonacci: (initial: Duration) => Schedule<Millis>;
  *
  * const healthDeps = testCreateDeps();
  * const healthStep = healthCheck(healthDeps);
- * expectOk(healthStep(undefined), [0, 5000]);
+ * assertOk(healthStep(undefined), [0, 5000]);
  * healthDeps.time.advance("3s");
- * expectOk(healthStep(undefined), [1, 2000]);
- * expectOk(cronLike(testCreateDeps())(undefined), [0, 60000]);
+ * assertOk(healthStep(undefined), [1, 2000]);
+ * assertOk(cronLike(testCreateDeps())(undefined), [0, 60000]);
  * ```
  *
  * @group Constructors
@@ -315,7 +334,7 @@ export declare const fixed: (interval: Duration) => Schedule<number>;
  * ### Aligning to time windows
  *
  * ```ts
- * import { testCreateDeps, windowed } from "@evolu/common";
+ * import { assertOk, testCreateDeps, windowed } from "@evolu/common";
  *
  * const stepAfter = (elapsed: "3s" | "7s") => {
  *   const deps = testCreateDeps();
@@ -326,8 +345,8 @@ export declare const fixed: (interval: Duration) => Schedule<number>;
  * };
  *
  * // At 3s the next boundary is 2s away; at 7s it is 3s away.
- * expectOk(stepAfter("3s"), [1, 2000]);
- * expectOk(stepAfter("7s"), [1, 3000]);
+ * assertOk(stepAfter("3s"), [1, 2000]);
+ * assertOk(stepAfter("7s"), [1, 3000]);
  * ```
  *
  * @group Constructors
@@ -341,12 +360,18 @@ export declare const windowed: (interval: Duration) => Schedule<number>;
  * ### Scheduling one delayed recurrence
  *
  * ```ts
- * import { done, fromDelay, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   done,
+ *   fromDelay,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // Wait one second, then stop.
  * const step = fromDelay("1s")(testCreateDeps());
- * expectOk(step(undefined), [1000, 1000]);
- * expectErr(step(undefined), done());
+ * assertOk(step(undefined), [1000, 1000]);
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Constructors
@@ -361,15 +386,21 @@ export declare const fromDelay: (delay: Duration) => Schedule<Millis>;
  * ### Sequencing custom delays
  *
  * ```ts
- * import { done, fromDelays, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   done,
+ *   fromDelays,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // A custom retry sequence: 100ms, 500ms, then 2s.
  * const custom = fromDelays("100ms", "500ms", "2s");
  * const step = custom(testCreateDeps());
- * expectOk(step(undefined), [100, 100]);
- * expectOk(step(undefined), [500, 500]);
- * expectOk(step(undefined), [2000, 2000]);
- * expectErr(step(undefined), done());
+ * assertOk(step(undefined), [100, 100]);
+ * assertOk(step(undefined), [500, 500]);
+ * assertOk(step(undefined), [2000, 2000]);
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Constructors
@@ -385,6 +416,8 @@ export declare const fromDelays: (...delays: ReadonlyArray<Duration>) => Schedul
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   done,
  *   elapsed,
  *   exponential,
@@ -396,7 +429,7 @@ export declare const fromDelays: (...delays: ReadonlyArray<Duration>) => Schedul
  *
  * // Track elapsed time alongside each backoff step.
  * const withTiming = intersectSchedules(exponential("100ms"), elapsed);
- * expectOk(withTiming(testCreateDeps())(undefined), [[100, 0], 100]);
+ * assertOk(withTiming(testCreateDeps())(undefined), [[100, 0], 100]);
  *
  * // Or stop a schedule after 30 seconds of elapsed time.
  * const timeLimited = whileScheduleOutput((ms: Millis) => ms < 30000)(
@@ -406,7 +439,7 @@ export declare const fromDelays: (...delays: ReadonlyArray<Duration>) => Schedul
  * const step = timeLimited(deps);
  * step(undefined);
  * deps.time.advance("30s");
- * expectErr(step(undefined), done());
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Constructors
@@ -422,6 +455,8 @@ export declare const elapsed: Schedule<Millis>;
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   done,
  *   during,
  *   exponential,
@@ -433,16 +468,16 @@ export declare const elapsed: Schedule<Millis>;
  * const timeLimited = during("30s");
  * const deps = testCreateDeps();
  * const step = timeLimited(deps);
- * expectOk(step(undefined), [0, 0]);
+ * assertOk(step(undefined), [0, 0]);
  * deps.time.advance("30.1s");
- * expectErr(step(undefined), done());
+ * assertErr(step(undefined), done());
  *
  * // Combine elapsed time with backoff for a time-boxed retry.
  * const timedRetry = intersectSchedules(
  *   exponential("100ms"),
  *   during("10s"),
  * );
- * expectOk(timedRetry(testCreateDeps())(undefined), [[100, 0], 100]);
+ * assertOk(timedRetry(testCreateDeps())(undefined), [[100, 0], 100]);
  * ```
  *
  * @group Constructors
@@ -457,6 +492,7 @@ export declare const during: (duration: Duration) => Schedule<Millis>;
  *
  * ```ts
  * import {
+ *   assertOk,
  *   always,
  *   exponential,
  *   intersectSchedules,
@@ -465,14 +501,14 @@ export declare const during: (duration: Duration) => Schedule<Millis>;
  *
  * // Always emit the same label.
  * const labeled = always("retry");
- * expectOk(labeled(testCreateDeps())(undefined), ["retry", 0]);
+ * assertOk(labeled(testCreateDeps())(undefined), ["retry", 0]);
  *
  * // Add a label while preserving exponential timing.
  * const withLabel = intersectSchedules(
  *   exponential("100ms"),
  *   always("backoff"),
  * );
- * expectOk(withLabel(testCreateDeps())(undefined), [
+ * assertOk(withLabel(testCreateDeps())(undefined), [
  *   [100, "backoff"],
  *   100,
  * ]);
@@ -491,7 +527,7 @@ export declare const always: <A>(value: A) => Schedule<A>;
  * ### Unfolding state
  *
  * ```ts
- * import { testCreateDeps, unfoldSchedule } from "@evolu/common";
+ * import { assertOk, testCreateDeps, unfoldSchedule } from "@evolu/common";
  *
  * // Unfold counters, custom backoff values, or state machines.
  * const counter = unfoldSchedule(0, (n) => n + 1);
@@ -514,12 +550,12 @@ export declare const always: <A>(value: A) => Schedule<A>;
  * const counterStep = counter(testCreateDeps());
  * const backoffStep = customBackoff(testCreateDeps());
  * const phaseStep = phases(testCreateDeps());
- * expectOk(counterStep(undefined), [0, 0]);
- * expectOk(counterStep(undefined), [1, 0]);
+ * assertOk(counterStep(undefined), [0, 0]);
+ * assertOk(counterStep(undefined), [1, 0]);
  * backoffStep(undefined);
  * phaseStep(undefined);
- * expectOk(backoffStep(undefined), [150, 0]);
- * expectOk(phaseStep(undefined), ["warmup", 0]);
+ * assertOk(backoffStep(undefined), [150, 0]);
+ * assertOk(phaseStep(undefined), ["warmup", 0]);
  * ```
  *
  * @group Constructors
@@ -536,14 +572,20 @@ export declare const unfoldSchedule: <State>(initial: State, next: (state: State
  * ### Limiting a schedule
  *
  * ```ts
- * import { done, exponential, take, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertErr,
+ *   done,
+ *   exponential,
+ *   take,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // Three exponential retries, then Done.
  * const step = take(3)(exponential("100ms"))(testCreateDeps());
  * step(undefined);
  * step(undefined);
  * step(undefined);
- * expectErr(step(undefined), done());
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Limiting
@@ -558,6 +600,8 @@ export declare const take: (n: Int0To100OrNonNegativeInt) => <Output, Input>(sch
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   done,
  *   exponential,
  *   maxElapsed,
@@ -567,9 +611,9 @@ export declare const take: (n: Int0To100OrNonNegativeInt) => <Output, Input>(sch
  * // Retry for at most 30 seconds.
  * const deps = testCreateDeps();
  * const step = maxElapsed("30s")(exponential("1s"))(deps);
- * expectOk(step(undefined), [1000, 1000]);
+ * assertOk(step(undefined), [1000, 1000]);
  * deps.time.advance("30s");
- * expectErr(step(undefined), done());
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Limiting
@@ -583,7 +627,12 @@ export declare const maxElapsed: (duration: Duration) => <Output, Input>(schedul
  * ### Capping delays
  *
  * ```ts
- * import { exponential, maxDelay, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   exponential,
+ *   maxDelay,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // Exponential delays grow 1s, 2s, 4s, 8s, then stay capped at 10s.
  * const step = maxDelay("10s")(exponential("1s"))(testCreateDeps());
@@ -591,7 +640,7 @@ export declare const maxElapsed: (duration: Duration) => <Output, Input>(schedul
  * step(undefined);
  * step(undefined);
  * step(undefined);
- * expectOk(step(undefined), [16000, 10000]);
+ * assertOk(step(undefined), [16000, 10000]);
  * ```
  *
  * @group Limiting
@@ -617,6 +666,7 @@ export declare const maxDelay: (max: Duration) => <Output, Input>(schedule: Sche
  *
  * ```ts
  * import {
+ *   assertOk,
  *   exponential,
  *   jitter,
  *   spaced,
@@ -634,8 +684,8 @@ export declare const maxDelay: (max: Duration) => <Output, Input>(schedule: Sche
  * // Poll around a 30s target cadence, from 27s to 33s.
  * const polling = jitter("10%", "around")(spaced("30s"));
  *
- * expectOk(conservative(deps)(undefined), [1000, 875]);
- * expectOk(polling(deps)(undefined), [30000, 30000]);
+ * assertOk(conservative(deps)(undefined), [1000, 875]);
+ * assertOk(polling(deps)(undefined), [30000, 30000]);
  * ```
  *
  * @group Delay
@@ -650,12 +700,17 @@ export declare const jitter: (percentage?: Percentage, mode?: "below" | "around"
  * ### Replacing the first delay
  *
  * ```ts
- * import { delayed, exponential, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   delayed,
+ *   exponential,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * const step = delayed("1s")(exponential("100ms"))(testCreateDeps());
  * // Only the first delay is replaced; later exponential delays are unchanged.
- * expectOk(step(undefined), [100, 1000]);
- * expectOk(step(undefined), [200, 200]);
+ * assertOk(step(undefined), [100, 1000]);
+ * assertOk(step(undefined), [200, 200]);
  * ```
  *
  * @group Delay
@@ -667,11 +722,16 @@ export declare const delayed: (initialDelay: Duration) => <Output, Input>(schedu
  * ### Adding to every delay
  *
  * ```ts
- * import { addDelay, exponential, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   addDelay,
+ *   exponential,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // Add 500ms to every exponential delay.
  * const step = addDelay("500ms")(exponential("100ms"))(testCreateDeps());
- * expectOk(step(undefined), [100, 600]);
+ * assertOk(step(undefined), [100, 600]);
  * ```
  *
  * @group Delay
@@ -685,7 +745,12 @@ export declare const addDelay: (extra: Duration) => (<Output, Input>(schedule: S
  * ### Transforming delays
  *
  * ```ts
- * import { exponential, modifyDelay, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   exponential,
+ *   modifyDelay,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // Arbitrary transformations can double or cap delays.
  * const slower = modifyDelay((delay) => delay * 2)(exponential("100ms"));
@@ -695,8 +760,8 @@ export declare const addDelay: (extra: Duration) => (<Output, Input>(schedule: S
  * );
  * const deps = testCreateDeps();
  *
- * expectOk(slower(deps)(undefined), [100, 200]);
- * expectOk(capped(deps)(undefined), [20000, 10000]);
+ * assertOk(slower(deps)(undefined), [100, 200]);
+ * assertOk(capped(deps)(undefined), [20000, 10000]);
  * ```
  *
  * @group Delay
@@ -719,21 +784,26 @@ export declare const modifyDelay: (f: (delay: Millis) => number) => <Output, Inp
  * ### Compensating for execution time
  *
  * ```ts
- * import { compensate, spaced, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   compensate,
+ *   spaced,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * const fastDeps = testCreateDeps();
  * const fastStep = compensate(spaced("5s"))(fastDeps);
- * expectOk(fastStep(undefined), [5000, 5000]);
+ * assertOk(fastStep(undefined), [5000, 5000]);
  * // Five seconds waiting plus one second working leaves four seconds.
  * fastDeps.time.advance("6s");
- * expectOk(fastStep(undefined), [5000, 4000]);
+ * assertOk(fastStep(undefined), [5000, 4000]);
  *
  * const slowDeps = testCreateDeps();
  * const slowStep = compensate(spaced("5s"))(slowDeps);
- * expectOk(slowStep(undefined), [5000, 5000]);
+ * assertOk(slowStep(undefined), [5000, 5000]);
  * // Five seconds waiting plus six seconds working leaves no delay.
  * slowDeps.time.advance("11s");
- * expectOk(slowStep(undefined), [5000, 0]);
+ * assertOk(slowStep(undefined), [5000, 0]);
  * ```
  *
  * @group Delay
@@ -750,6 +820,8 @@ export declare const compensate: <Output, Input>(schedule: Schedule<Output, Inpu
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   done,
  *   exponential,
  *   testCreateDeps,
@@ -764,8 +836,8 @@ export declare const compensate: <Output, Input>(schedule: Schedule<Output, Inpu
  *   (error: MyError) => error.type === "Transient",
  * )(exponential("100ms"));
  * const step = retryTransient(testCreateDeps());
- * expectOk(step({ type: "Transient" }), [100, 100]);
- * expectErr(step({ type: "Fatal" }), done());
+ * assertOk(step({ type: "Transient" }), [100, 100]);
+ * assertErr(step({ type: "Fatal" }), done());
  * ```
  *
  * @group Filtering
@@ -781,6 +853,8 @@ export declare const whileScheduleInput: <Input>(predicate: Predicate<Input>) =>
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   done,
  *   exponential,
  *   testCreateDeps,
@@ -795,8 +869,8 @@ export declare const whileScheduleInput: <Input>(predicate: Predicate<Input>) =>
  *   (error: MyError) => error.type === "Fatal",
  * )(exponential("100ms"));
  * const step = stopOnFatal(testCreateDeps());
- * expectOk(step({ type: "Transient" }), [100, 100]);
- * expectErr(step({ type: "Fatal" }), done());
+ * assertOk(step({ type: "Transient" }), [100, 100]);
+ * assertErr(step({ type: "Fatal" }), done());
  * ```
  *
  * @group Filtering
@@ -811,6 +885,7 @@ export declare const untilScheduleInput: <Input>(predicate: Predicate<Input>) =>
  *
  * ```ts
  * import {
+ *   assertErr,
  *   done,
  *   exponential,
  *   testCreateDeps,
@@ -826,7 +901,7 @@ export declare const untilScheduleInput: <Input>(predicate: Predicate<Input>) =>
  * step(undefined);
  * step(undefined);
  * step(undefined);
- * expectErr(step(undefined), done());
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Filtering
@@ -841,6 +916,7 @@ export declare const whileScheduleOutput: <Output>(predicate: Predicate<Output>)
  *
  * ```ts
  * import {
+ *   assertErr,
  *   done,
  *   exponential,
  *   testCreateDeps,
@@ -857,7 +933,7 @@ export declare const whileScheduleOutput: <Output>(predicate: Predicate<Output>)
  * step(undefined);
  * step(undefined);
  * step(undefined);
- * expectErr(step(undefined), done());
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Filtering
@@ -874,6 +950,7 @@ export declare const untilScheduleOutput: <Output>(predicate: Predicate<Output>)
  *
  * ```ts
  * import {
+ *   assertOk,
  *   exponential,
  *   resetScheduleAfter,
  *   testCreateDeps,
@@ -882,9 +959,9 @@ export declare const untilScheduleOutput: <Output>(predicate: Predicate<Output>)
  * const backoff = resetScheduleAfter("1m")(exponential("1s"));
  * const deps = testCreateDeps();
  * const step = backoff(deps);
- * expectOk(step(undefined), [1000, 1000]);
+ * assertOk(step(undefined), [1000, 1000]);
  * deps.time.advance("1m");
- * expectOk(step(undefined), [1000, 1000]);
+ * assertOk(step(undefined), [1000, 1000]);
  * ```
  *
  * @group State
@@ -899,6 +976,7 @@ export declare const resetScheduleAfter: (duration: DurationLiteral | PositiveMi
  *
  * ```ts
  * import {
+ *   assertOk,
  *   exponential,
  *   mapSchedule,
  *   testCreateDeps,
@@ -910,7 +988,7 @@ export declare const resetScheduleAfter: (duration: DurationLiteral | PositiveMi
  *   doubled: delay * 2,
  * }))(exponential("100ms"));
  * const step = schedule(testCreateDeps());
- * expectOk(step(undefined), [{ delay: 100, doubled: 200 }, 100]);
+ * assertOk(step(undefined), [{ delay: 100, doubled: 200 }, 100]);
  * ```
  *
  * @group Transform
@@ -927,7 +1005,15 @@ export declare const mapSchedule: <A, B>(f: (a: A) => B) => <Input>(schedule: Sc
  * ### Passing through input
  *
  * ```ts
- * import { exponential, passthrough, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   exponential,
+ *   passthrough,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * interface MyError {
  *   readonly message: string;
@@ -939,8 +1025,16 @@ export declare const mapSchedule: <A, B>(f: (a: A) => B) => <Input>(schedule: Sc
  * const error = { message: "Unavailable" };
  * const deps = testCreateDeps();
  *
- * expectOk(identity(deps)(error), [error, 0]);
- * expectOk(withInput(deps)(error), [error, 100]);
+ * const identityResult = identity(deps)(error);
+ * assertOk(identityResult);
+ * assertType(Data, identityResult.value);
+ * assertEqual(identityResult.value, [error, 0]);
+ *
+ * const inputResult = withInput(deps)(error);
+ * assertOk(inputResult);
+ * assertType(Data, inputResult.value);
+ * const inputValue: Data = inputResult.value;
+ * assertEqual(inputValue, [error, 100]);
  * ```
  *
  * @group Constructors
@@ -958,6 +1052,7 @@ export declare function passthrough<Output, Input>(schedule: Schedule<Output, In
  *
  * ```ts
  * import {
+ *   assertOk,
  *   exponential,
  *   foldSchedule,
  *   minMillis,
@@ -987,9 +1082,9 @@ export declare function passthrough<Output, Input>(schedule: Schedule<Output, In
  * const deps = testCreateDeps();
  * const totalStep = withTotal(deps);
  * totalStep(undefined);
- * expectOk(totalStep(undefined), [300, 200]);
- * expectOk(collected(deps)(undefined), [[1000], 1000]);
- * expectOk(counted(deps)(undefined), [
+ * assertOk(totalStep(undefined), [300, 200]);
+ * assertOk(collected(deps)(undefined), [[1000], 1000]);
+ * assertOk(counted(deps)(undefined), [
  *   { attempts: 1, lastDelay: 100 },
  *   100,
  * ]);
@@ -1008,12 +1103,17 @@ export declare const foldSchedule: <Z, Output>(initial: Z, f: (acc: Z, output: O
  * ### Counting repetitions
  *
  * ```ts
- * import { exponential, repetitions, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   exponential,
+ *   repetitions,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * // Count retries while preserving exponential timing.
  * const step = repetitions(exponential("100ms"))(testCreateDeps());
- * expectOk(step(undefined), [0, 100]);
- * expectOk(step(undefined), [1, 200]);
+ * assertOk(step(undefined), [0, 100]);
+ * assertOk(step(undefined), [1, 200]);
  * ```
  *
  * @group Transform
@@ -1029,6 +1129,8 @@ export declare const repetitions: <Output, Input>(schedule: Schedule<Output, Inp
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
  *   delays,
  *   exponential,
  *   tapScheduleOutput,
@@ -1044,9 +1146,9 @@ export declare const repetitions: <Output, Input>(schedule: Schedule<Output, Inp
  * })(delays(exponential("100ms")));
  * const deps = testCreateDeps();
  *
- * expectOk(monitorDelays(deps)(undefined), [100, 100]);
- * expectOk(logged(deps)(undefined), [100, 100]);
- * expect(observed).toEqual([100]);
+ * assertOk(monitorDelays(deps)(undefined), [100, 100]);
+ * assertOk(logged(deps)(undefined), [100, 100]);
+ * assertEqual(observed, [100]);
  * ```
  *
  * @group Transform
@@ -1063,6 +1165,7 @@ export declare const delays: <Output, Input>(schedule: Schedule<Output, Input>)
  *
  * ```ts
  * import {
+ *   assertOk,
  *   collectAllScheduleOutputs,
  *   spaced,
  *   take,
@@ -1073,7 +1176,7 @@ export declare const delays: <Output, Input>(schedule: Schedule<Output, Input>)
  * const collected = collectAllScheduleOutputs(take(3)(spaced("100ms")));
  * const step = collected(testCreateDeps());
  * step(undefined);
- * expectOk(step(undefined), [[100, 100], 100]);
+ * assertOk(step(undefined), [[100, 100], 100]);
  * ```
  *
  * @group Collection
@@ -1089,6 +1192,7 @@ export declare const collectAllScheduleOutputs: <Output, Input>(schedule: Schedu
  *
  * ```ts
  * import {
+ *   assertOk,
  *   collectScheduleInputs,
  *   exponential,
  *   take,
@@ -1102,7 +1206,7 @@ export declare const collectAllScheduleOutputs: <Output, Input>(schedule: Schedu
  * const errorHistory = collectScheduleInputs(retries);
  * const step = errorHistory(testCreateDeps());
  * step("network");
- * expectOk(step("timeout"), [["network", "timeout"], 200]);
+ * assertOk(step("timeout"), [["network", "timeout"], 200]);
  * ```
  *
  * @group Collection
@@ -1118,6 +1222,8 @@ export declare const collectScheduleInputs: <Output, Input>(schedule: Schedule<O
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   collectWhileScheduleOutput,
  *   done,
  *   exponential,
@@ -1133,8 +1239,8 @@ export declare const collectScheduleInputs: <Output, Input>(schedule: Schedule<O
  * step(undefined);
  * step(undefined);
  * step(undefined);
- * expectOk(step(undefined), [[100, 200, 400, 800], 800]);
- * expectErr(step(undefined), done());
+ * assertOk(step(undefined), [[100, 200, 400, 800], 800]);
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Collection
@@ -1150,6 +1256,8 @@ export declare const collectWhileScheduleOutput: <Output>(predicate: Predicate<O
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   collectUntilScheduleOutput,
  *   done,
  *   exponential,
@@ -1165,8 +1273,8 @@ export declare const collectWhileScheduleOutput: <Output>(predicate: Predicate<O
  * step(undefined);
  * step(undefined);
  * step(undefined);
- * expectOk(step(undefined), [[100, 200, 400, 800], 800]);
- * expectErr(step(undefined), done());
+ * assertOk(step(undefined), [[100, 200, 400, 800], 800]);
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Collection
@@ -1182,6 +1290,7 @@ export declare const collectUntilScheduleOutput: <Output>(predicate: Predicate<O
  *
  * ```ts
  * import {
+ *   assertOk,
  *   exponential,
  *   fixed,
  *   sequenceSchedules,
@@ -1198,7 +1307,7 @@ export declare const collectUntilScheduleOutput: <Output>(predicate: Predicate<O
  * step(undefined);
  * step(undefined);
  * step(undefined);
- * expectOk(step(undefined), [0, 500]);
+ * assertOk(step(undefined), [0, 500]);
  * ```
  *
  * @group Composition
@@ -1213,6 +1322,8 @@ export declare const sequenceSchedules: <Output, Input>(...schedules: ReadonlyAr
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   done,
  *   exponential,
  *   forever,
@@ -1228,9 +1339,9 @@ export declare const sequenceSchedules: <Output, Input>(...schedules: ReadonlyAr
  *   take(5)(exponential("1s")),
  *   maxElapsed("30s")(forever),
  * )(deps);
- * expectOk(step(undefined), [[1000, 0], 1000]);
+ * assertOk(step(undefined), [[1000, 0], 1000]);
  * deps.time.advance("30s");
- * expectErr(step(undefined), done());
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Composition
@@ -1245,6 +1356,8 @@ export declare const intersectSchedules: <OutputA, OutputB, Input>(a: Schedule<O
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   done,
  *   spaced,
  *   take,
@@ -1258,9 +1371,9 @@ export declare const intersectSchedules: <OutputA, OutputB, Input>(a: Schedule<O
  *   take(2)(spaced("200ms")),
  * );
  * const step = either(testCreateDeps());
- * expectOk(step(undefined), [100, 100]);
- * expectOk(step(undefined), [200, 200]);
- * expectErr(step(undefined), done());
+ * assertOk(step(undefined), [100, 100]);
+ * assertOk(step(undefined), [200, 200]);
+ * assertErr(step(undefined), done());
  * ```
  *
  * @group Composition
@@ -1280,6 +1393,8 @@ export declare const unionSchedules: <OutputA, OutputB, Input>(a: Schedule<Outpu
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
  *   done,
  *   exponential,
  *   take,
@@ -1299,10 +1414,10 @@ export declare const unionSchedules: <OutputA, OutputB, Input>(a: Schedule<Outpu
  *   )(exponential("100ms")),
  * );
  * const step = awsWithThrottling(testCreateDeps());
- * expectOk(step({ type: "Throttled" }), [1000, 1000]);
- * expectOk(step({ type: "NetworkError" }), [100, 100]);
- * expectOk(step({ type: "Throttled" }), [2000, 2000]);
- * expectErr(step({ type: "NetworkError" }), done());
+ * assertOk(step({ type: "Throttled" }), [1000, 1000]);
+ * assertOk(step({ type: "NetworkError" }), [100, 100]);
+ * assertOk(step({ type: "Throttled" }), [2000, 2000]);
+ * assertErr(step({ type: "NetworkError" }), done());
  * ```
  *
  * @group Composition
@@ -1318,6 +1433,7 @@ export declare const whenInput: <Input, Output>(predicate: Predicate<Input>, alt
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   exponential,
  *   retryStrategyAws,
  *   tapScheduleOutput,
@@ -1340,8 +1456,8 @@ export declare const whenInput: <Input, Output>(predicate: Predicate<Input>, alt
  * logged(deps)(undefined);
  * tracked(deps)(undefined);
  *
- * expect(messages).toEqual(["Next delay: 100ms"]);
- * expect(recordedCandidates).toEqual([50]);
+ * assertEqual(messages, ["Next delay: 100ms"]);
+ * assertEqual(recordedCandidates, [50]);
  * ```
  *
  * @group Side effects
@@ -1357,6 +1473,7 @@ export declare const tapScheduleOutput: <Output>(f: (output: Output) => void) =>
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   exponential,
  *   tapScheduleInput,
  *   testCreateDeps,
@@ -1383,8 +1500,8 @@ export declare const tapScheduleOutput: <Output>(f: (output: Output) => void) =>
  * logged(deps)(error);
  * tracked(deps)(error);
  *
- * expect(messages).toEqual(["Retrying after error: NetworkError"]);
- * expect(reasons).toEqual(["NetworkError"]);
+ * assertEqual(messages, ["Retrying after error: NetworkError"]);
+ * assertEqual(reasons, ["NetworkError"]);
  * ```
  *
  * @group Side effects