@demlik/tea 0.13.0 → 0.15.0

package/dist/monitored-run/index.js

@@ -1,10 +0,0 @@
-export { createMonitoredRun, liftRun } from '../chunk-DMYGQB4O.js';
-import '../chunk-O4MVQTEJ.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-DGE4PV4A.js';
-import '../chunk-MU6MCIAC.js';
-import '../chunk-FV3Z5MBE.js';
-import '../chunk-2YFLOCWX.js';
-import '../chunk-ZSUUOEPL.js';
-import '../chunk-OOYD44JI.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/monitored-run/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/paginated-walk/index.d.ts

@@ -1,235 +0,0 @@
-import { C as Cmd } from '../core-Co0LWkIA.js';
-import { PaginatorState } from '../paginator/index.js';
-import { RunCmd, FailMsg, SucceedMsg, CircuitConfig, RateLimitConfig, DeadlineConfig, ResilientPorts, ResilientState, ResilientTimerMsg } from '../resilient-call/index.js';
-import { RetryPolicy } from '../retry-backoff/index.js';
-import { DeadlineSub } from '../deadline/index.js';
-export { deadlineSub, subscribeDeadline } from '../deadline/index.js';
-import 'zod';
-import '../cache/index.js';
-import '../types-XS_miRnB.js';
-import '../circuit-breaker/index.js';
-import '../protocol-B5YmJr0d.js';
-import '../rate-limit/index.js';
-
-/**
- * @demlik/tea/paginated-walk — traverse a paginated API / sitemap end to end
- * WITHOUT a fake clock, without 429s, and resumable across a Durable-Object
- * eviction. The L2 composition that bolts `../resilient-call`'s resilience onto
- * `../paginator`'s cursor walk: each page is fetched as ONE keyed resilient
- * call (retry + backoff + rate-limit gate), and the cursor advances only once a
- * page settles `ok`.
- *
- * ## The recipe (the two siblings it composes)
- *
- *   - **`../paginator`** owns the walk loop: the opaque `Cursor`, the `seen` /
- *     `pages` counters, and the `idle → fetching → … → done` phase machine.
- *     `paginated-walk` never re-implements cursor advancement — it folds each
- *     settled page through `recordPage`, letting the paginator decide
- *     `done` / `fetching(next)` / `paused`. Backpressure is a TWO-way valve:
- *     `recordPage` parks the walk in `paused` once `seen >= highWaterMark`, and
- *     the `drain` / `resume` verbs (delegating to the paginator's own
- *     `drain` / `resume`) lower the gauge and re-open the parked fetch — without
- *     them `highWaterMark` would be a one-way valve that strands a paused walk.
- *   - **`../resilient-call`** owns the page fetch: the single `resilient_run`
- *     effect per page is gated through that knob's cache → circuit → rate-limit
- *     → retry pipeline. A transient page failure backs off and re-issues the
- *     SAME cursor (idempotent retry); the walk does not advance until the page
- *     genuinely settles.
- *
- * Those are the only two siblings this module calls into. The resilience knobs
- * (`retry` / `circuit` / `rateLimit` / `deadline`) are NOT separate bricks
- * `paginated-walk` composes — they belong to `resilient-call`, which owns the
- * rate-limit gate internally. This module merely passes them through to
- * `createResilientCall` and re-uses two config TYPES at the boundary:
- * `RateLimitConfig` (re-exported by `resilient-call`) and `RetryPolicy` (from
- * `../retry-backoff`). Pass a `rateLimit` and `resilient-call`'s token bucket
- * throttles page fetches ("don't 429 the upstream"); omit it and the walk runs
- * as fast as the upstream answers.
- *
- * Because the page-fetch resilience IS a `resilient-call` slice, this knob
- * **inherits that knob's contract verbatim**: the slice is a flat record, every
- * verb returns `readonly [State, Cmd[]]`, time is always an `at` parameter, and
- * the jitter RNG is injected once at `createPaginatedWalk(config, rng)` — never
- * read inside a verb (per the spec, `paginated-walk` *extends* `resilient-call`).
- *
- * ## The two non-negotiables (canon)
- *
- *   - **Durable** — the slice is plain data: the paginator phase + counters, and
- *     the resilient-call brick states (all JSON-serializable). The cursor lives
- *     in the Model, not a closure, so a walk survives eviction mid-traversal and
- *     resumes from the exact page it was fetching.
- *   - **Replayable** — every transition is a verb returning new state + Cmds.
- *     `nextCursor` / `onPage` are pure config functions applied at the verb
- *     boundary; the Cmds they yield are plain data. `replay` reconstructs the
- *     whole walk exactly.
- *
- * ## Where the clock / RNG live
- *
- * Inside the verbs: nowhere. `at` arrives on `start` / `pageOk` / `pageErr` /
- * `onTimer` and is threaded straight into the underlying resilient-call gate (so
- * a rate-limited or retried page measures backoff from that `at`). The jitter
- * RNG is injected at construction. The only clock read is `Date.now()` inside
- * the resilient-call `handlers` port (the effect boundary), inherited unchanged.
- *
- * ## The fixed fetch key
- *
- * A walk fetches one page at a time, so the resilient-call layer tracks exactly
- * one logical call under the constant key `PAGE_KEY`. The cursor being fetched
- * is the resilient call's `input`, so a post-eviction resume re-issues the same
- * page request. (`resilient-call` is keyed to support N concurrent calls; a walk
- * deliberately uses a single key — the paginator is the sequencer.)
- *
- * ## Typical wiring
- *
- *   const walk = createPaginatedWalk<PageToken, ApiPage>({
- *     firstPage: null,                          // the API's "page one" sentinel
- *     nextCursor: (page) => page.nextToken ?? null,
- *     onPage: (page) => [{ type: "index_rows", rows: page.items }],
- *     rateLimit: { capacity: 10, refillPerSec: 5 },
- *     retry: defaultRetryPolicy,
- *   });
- *
- *   // in the machine:
- *   init: () => [{ walk: walk.init() }, []],
- *   update: {
- *     start:    (s, m)  => lift(s, walk.start(s.walk, m.at)),
- *     page_ok:  (s, m)  => lift(s, walk.pageOk(s.walk, m.result, m.at)),
- *     page_err: (s, m)  => lift(s, walk.pageErr(s.walk, m.error, m.at)),
- *     retry_due:(s, m)  => lift(s, walk.onTimer(s.walk, m)),
- *     drained:  (s, m)  => lift(s, walk.drain(s.walk, m.n)),
- *     resume:   (s, m)  => lift(s, walk.resume(s.walk, m.at)),
- *   },
- *   subscriptions: (s) => walk.subs(s.walk),
- *   subscribe: { deadline: subscribeDeadline },
- *   interpret: walk.handlers({ run: (cursor) => api.fetchPage(cursor) }),
- */
-
-/**
- * The paginated-walk knob. Generic in `Cursor` (the opaque page handle the
- * upstream API hands back — offset, page token, "next" URL, …) and `Page` (the
- * shape your fetch port resolves with).
- *
- * `nextCursor` and `onPage` are PURE config functions applied at the verb
- * boundary, never stored in the slice or in a Cmd (invariant 3 — Cmds are
- * plain data, not closures). `nextCursor(page)` extracts the API's next-page
- * handle (or `null` at the end); `onPage(page)` yields the Cmds the consumer
- * wants emitted for each successfully fetched page (index rows, write to R2,
- * dispatch a downstream Msg — whatever; an empty array is fine).
- *
- * The resilience bricks (`retry` / `circuit` / `rateLimit` / `deadline`) are
- * the SAME optional knobs `resilient-call` exposes — paginated-walk extends it.
- * `rateLimit` is the brick that keeps the walk from 429-ing the upstream.
- */
-interface PaginatedWalkConfig<Cursor, Page, EmittedCmd extends Cmd> {
-    /**
-     * The cursor the walk fetches first. For an offset API this is typically `0`;
-     * for a token API, whatever sentinel the API treats as "page one" (often
-     * `null` or `""`). Threaded into `paginator`'s `firstCursor`.
-     */
-    readonly firstPage: Cursor;
-    /**
-     * Extract the next cursor from a just-fetched page. Return a `Cursor` to keep
-     * walking, or `null` when the API signalled the end (the walk finishes). PURE
-     * + consumer-specific (only the consumer knows the API's pagination shape).
-     */
-    readonly nextCursor: (page: Page) => Cursor | null;
-    /**
-     * The Cmds to emit for each successfully fetched page — the consumer's work
-     * per page (index, persist, fan out, …). Returns plain-data Cmds; `[]` is a
-     * valid "I process the page synchronously elsewhere" answer. PURE.
-     */
-    readonly onPage: (page: Page) => readonly EmittedCmd[];
-    /**
-     * How many items a page contributes to the paginator's backpressure gauge
-     * (`seen`). Defaults to `1` per page (count pages, not items) when omitted; a
-     * consumer that wants per-item backpressure returns `page.items.length`. PURE.
-     */
-    readonly pageSize?: (page: Page) => number;
-    /**
-     * Backpressure threshold handed to the paginator. `seen >= highWaterMark`
-     * parks the walk in `paused` instead of fetching the next page. Non-positive
-     * (the default `0`) disables backpressure — the walk runs flat out until the
-     * API exhausts. See `../paginator`'s `highWaterMark` docs.
-     */
-    readonly highWaterMark?: number;
-    /** Exponential-backoff retry policy for a transient page-fetch failure. */
-    readonly retry?: RetryPolicy;
-    /** Circuit breaker around the page fetch (one upstream → one breaker). */
-    readonly circuit?: CircuitConfig;
-    /** Token-bucket rate limit — the "don't 429 the upstream" knob. */
-    readonly rateLimit?: RateLimitConfig;
-    /** Overall wall-clock deadline per individual page fetch. */
-    readonly deadline?: DeadlineConfig;
-}
-/**
- * The slice. `walk` is the cursor/phase/counters from `../paginator`;
- * `resilience` is the `../resilient-call` slice that gates the page fetch.
- * Every field is JSON-serializable, so the whole walk survives a reload.
- *
- * The two move in lockstep: `walk` decides WHICH cursor to fetch next, while
- * `resilience` decides HOW that fetch is attempted (gated, retried, backed
- * off). `pageOk` advances `walk`; `pageErr` defers to `resilience` and leaves
- * `walk` parked on the same cursor until the page truly settles.
- */
-interface PaginatedWalkState<Cursor, Page> {
-    readonly walk: PaginatorState<Cursor>;
-    readonly resilience: ResilientState<Cursor, Page>;
-}
-/**
- * The page-fetch effect this knob emits: the inherited `resilient_run` Cmd from
- * resilient-call, whose `input` is the `Cursor` to fetch and whose `key` is the
- * fixed `PAGE_KEY`. The consumer's `handlers(ports)` interprets it.
- */
-type FetchPageCmd<Cursor> = RunCmd<Cursor>;
-/** Page-settled Msgs the `handlers` port dispatches back (inherited verbatim). */
-type PageOkMsg<Page> = SucceedMsg<Page>;
-type PageErrMsg = FailMsg;
-/** The retry / deadline timer Msg — inherited from resilient-call. */
-type PaginatedWalkTimerMsg = ResilientTimerMsg;
-/**
- * Ports the consumer supplies to `handlers`. `run(cursor)` fetches ONE page for
- * the given cursor; throwing routes to `pageErr` (and thus the resilience
- * backoff). Same shape as resilient-call's port, specialized to the page fetch.
- */
-interface PaginatedWalkPorts<Cursor, Page> extends ResilientPorts<Cursor, Page> {
-}
-/** The single resilient-call key every page fetch runs under. */
-declare const PAGE_KEY = "page";
-/**
- * Build a paginated-walk knob from `config`. `rng` is injected for the
- * underlying retry jitter — pass a fixed `() => 0` in tests to pin backoff;
- * defaults to `Math.random` (read at the verb boundary inside resilient-call,
- * never in a `paginated-walk` verb). Inherited straight from resilient-call.
- *
- * Returns the uniform L2 knob contract: `init()`, the verbs `start` / `pageOk`
- * / `pageErr` / `onTimer`, `subs(state)`, and `handlers(ports)`. `Cursor` is
- * the page handle, `Page` the fetch result, `EmittedCmd` the consumer's
- * per-page Cmds plus the inherited `FetchPageCmd`.
- */
-declare function createPaginatedWalk<Cursor, Page, EmittedCmd extends Cmd = Cmd>(config: PaginatedWalkConfig<Cursor, Page, EmittedCmd>, rng?: () => number): {
-    init: () => PaginatedWalkState<Cursor, Page>;
-    start: (s: PaginatedWalkState<Cursor, Page>, at: number) => readonly [PaginatedWalkState<Cursor, Page>, readonly (EmittedCmd | FetchPageCmd<Cursor>)[]];
-    pageOk: (s: PaginatedWalkState<Cursor, Page>, page: Page, at: number) => readonly [PaginatedWalkState<Cursor, Page>, readonly (EmittedCmd | FetchPageCmd<Cursor>)[]];
-    pageErr: (s: PaginatedWalkState<Cursor, Page>, error: unknown, at: number) => readonly [PaginatedWalkState<Cursor, Page>, readonly (EmittedCmd | FetchPageCmd<Cursor>)[]];
-    onTimer: (s: PaginatedWalkState<Cursor, Page>, msg: PaginatedWalkTimerMsg) => readonly [PaginatedWalkState<Cursor, Page>, readonly (EmittedCmd | FetchPageCmd<Cursor>)[]];
-    drain: (s: PaginatedWalkState<Cursor, Page>, n: number) => readonly [PaginatedWalkState<Cursor, Page>, readonly (EmittedCmd | FetchPageCmd<Cursor>)[]];
-    resume: (s: PaginatedWalkState<Cursor, Page>, at: number) => readonly [PaginatedWalkState<Cursor, Page>, readonly (EmittedCmd | FetchPageCmd<Cursor>)[]];
-    isComplete: (s: PaginatedWalkState<Cursor, Page>) => boolean;
-    failure: (s: PaginatedWalkState<Cursor, Page>) => unknown;
-    isStuck: (s: PaginatedWalkState<Cursor, Page>) => boolean;
-    subs: (s: PaginatedWalkState<Cursor, Page>) => readonly DeadlineSub[];
-    handlers: (ports: PaginatedWalkPorts<Cursor, Page>) => {
-        resilient_run: (cmd: RunCmd<Cursor>, ctx: Readonly<Record<never, never>>) => Promise<FailMsg | SucceedMsg<Page>>;
-    };
-};
-/**
- * Lift a knob result `[slice, cmds]` into a host `[State, cmds]` where the slice
- * lives at `state.walk`. A convenience for the common single-slice host;
- * consumers with a differently-named field spread by hand. Pure — a thin record
- * rebuild, no clock / RNG.
- */
-declare function liftWalk<S extends {
-    walk: PaginatedWalkState<Cursor, Page>;
-}, Cursor, Page, C extends Cmd>(state: S, [slice, cmds]: readonly [PaginatedWalkState<Cursor, Page>, readonly C[]]): readonly [S, readonly C[]];
-
-export { DeadlineSub, type FetchPageCmd, PAGE_KEY, type PageErrMsg, type PageOkMsg, type PaginatedWalkConfig, type PaginatedWalkPorts, type PaginatedWalkState, type PaginatedWalkTimerMsg, createPaginatedWalk, liftWalk };

package/dist/paginated-walk/index.js

@@ -1,16 +0,0 @@
-export { PAGE_KEY, createPaginatedWalk, liftWalk } from '../chunk-YUXP55T2.js';
-import '../chunk-SINXE47Y.js';
-import '../chunk-4KLG43GY.js';
-import '../chunk-JELSZN25.js';
-import '../chunk-RH5EFRVJ.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-DGE4PV4A.js';
-import '../chunk-Q2UM7BXU.js';
-import '../chunk-S2EGRPCM.js';
-import '../chunk-UF4MZSLT.js';
-import '../chunk-VYFAZN3F.js';
-import '../chunk-2YFLOCWX.js';
-import '../chunk-ZJ5AOYBH.js';
-import '../chunk-ZSUUOEPL.js';
-import '../chunk-OOYD44JI.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/paginated-walk/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/paginator/index.js

@@ -1,3 +0,0 @@
-export { defaultPaginatorPolicy, drain, initPaginator, isDone, recordPage, resume, start } from '../chunk-SINXE47Y.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/paginator/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/pbt/arbitraries/index.d.ts

@@ -1,136 +0,0 @@
-import * as fc from 'fast-check';
-import { C as Cmd, S as Sub, M as Machine } from '../../core-Co0LWkIA.js';
-import 'zod';
-
-/**
- * Build a Ctx value whose every property access throws. Use as the `ctx`
- * argument to PBT runners when the reducer under test is pure (does not
- * read from ctx). Accidental ctx access during property generation
- * surfaces as a labelled error instead of a silent `undefined` or
- * downstream type-error.
- *
- * Returns a typed `Ctx` (via `as unknown as Ctx`) — the proxy satisfies the
- * type-shape requirement at the call site; the runtime contract is
- * "throw on first read." The `as unknown` cast is the one boundary cast
- * this helper requires; the proxy is structurally a `Ctx` for every
- * property accessor.
- *
- * @example
- *   import { stubCtxThrowingProxy } from "../index";
- *   const ctx = stubCtxThrowingProxy<MyCtx>();
- *   propertyTerminates(machine, ctx, ...);
- *   // If anything reads ctx.someField during the run, an Error throws:
- *   //   "@demlik/tea/pbt: ctx access denied (PBT operates on the pure
- *   //    reducer; ctx field 'someField' was read)"
- */
-declare function stubCtxThrowingProxy<Ctx>(): Ctx;
-
-/**
- * Strict per-variant Msg arbitrary table. Mapped type: every key in
- * `M["type"]` MUST have an arbitrary entry whose `T` is the narrowed
- * variant. Adding a new Msg variant without an entry is a compile error
- * (same load-bearing discipline as `Reducer<S, M, C>` in the substrate).
- *
- * @example
- *   type Msg = { type: "start" } | { type: "tick"; now: number };
- *   const table: MsgArbitraryTable<Msg> = {
- *     start: arbConstantMsg("start"),
- *     tick: arbRecordMsg("tick", { now: fc.integer({ min: 0 }) }),
- *   };
- */
-type MsgArbitraryTable<M extends {
-    type: string;
-}> = {
-    [K in M["type"]]: fc.Arbitrary<Extract<M, {
-        type: K;
-    }>>;
-};
-/**
- * Build a single `fc.Arbitrary<M>` from a `MsgArbitraryTable<M>`. Picks one
- * variant per generation via `fc.oneof`; optional per-variant `weights`
- * bias the distribution (default uniform).
- *
- * @param table   Per-variant arbitrary table (strict — every variant required).
- * @param opts    Optional bias: `weights` is a `Partial<Record<M["type"], number>>`.
- *                Variants without an explicit weight default to 1.
- *
- * @example
- *   const msgArb = arbMsg<Msg>({
- *     start: arbConstantMsg("start"),
- *     tick:  arbRecordMsg("tick", { now: fc.integer() }),
- *     stop:  arbConstantMsg("stop"),
- *   }, { weights: { tick: 5, start: 1, stop: 1 } });
- */
-declare function arbMsg<M extends {
-    type: string;
-}>(table: MsgArbitraryTable<M>, opts?: {
-    weights?: Partial<Record<M["type"], number>>;
-}): fc.Arbitrary<M>;
-/**
- * Build a payload-free Msg variant arbitrary. Sugar for
- * `fc.constant({ type })` that narrows the result to `{ type: T }` literal.
- *
- * @example
- *   arbConstantMsg("stop") // fc.Arbitrary<{ type: "stop" }>
- */
-declare function arbConstantMsg<T extends string>(type: T): fc.Arbitrary<{
-    type: T;
-}>;
-/**
- * Build a record-shaped Msg variant arbitrary. Sugar for
- * `fc.record({ type: fc.constant(type), ...fields })` that stamps the
- * discriminator literal and combines with the per-field arbitraries.
- *
- * @example
- *   arbRecordMsg("tick", { now: fc.integer({ min: 0 }) })
- *   // fc.Arbitrary<{ type: "tick"; now: number }>
- */
-declare function arbRecordMsg<T extends string, R>(type: T, fields: {
-    [K in keyof R]: fc.Arbitrary<R[K]>;
-}): fc.Arbitrary<{
-    type: T;
-} & R>;
-
-/**
- * Build an arbitrary of Msg sequences over a per-Msg arbitrary. Optionally
- * bounded in length and / or prefixed with a fixed sequence.
- *
- * - `minLength` (default 0) and `maxLength` (default 30) bound the random
- *   array length. `prefix` is prepended AFTER the random tail is built; the
- *   final length is `prefix.length + tail.length`.
- * - `prefix` is the load-bearing escape hatch for "the first msg is the
- *   one that exercises the cell I care about" (e.g. Test A's
- *   `[{ type: "ws:client:hello" }]` prefix to land in the
- *   `auditing.ws:client:hello` cell on the first transition).
- *
- * @example
- *   arbMsgSequence(msgArb, { minLength: 1, maxLength: 30 });
- *   arbMsgSequence(msgArb, { prefix: [{ type: "ws:client:hello" }], maxLength: 20 });
- */
-declare function arbMsgSequence<M extends {
-    type: string;
-}>(msgArb: fc.Arbitrary<M>, opts?: {
-    readonly minLength?: number;
-    readonly maxLength?: number;
-    readonly prefix?: readonly NoInfer<M>[];
-}): fc.Arbitrary<readonly M[]>;
-/**
- * State-aware Msg sequence arbitrary — generates only msgs whose
- * precondition holds in the current state. Backed by `fc.commands`
- * internally. Planned for a later phase.
- *
- * **NOT IMPLEMENTED IN v1.** The export exists today so the surface is
- * forward-compatible; this ships in a later phase alongside
- * shrinkers. Calling it throws.
- */
-declare function arbGuidedSequence<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(_machine: Machine<S, M, C, U, Ctx>, _ctx: Ctx, _cells: {
-    [K in M["type"]]?: (state: S) => fc.Arbitrary<Extract<M, {
-        type: K;
-    }>> | null;
-}, _opts?: {
-    maxLength?: number;
-}): fc.Arbitrary<readonly M[]>;
-
-export { type MsgArbitraryTable, arbConstantMsg, arbGuidedSequence, arbMsg, arbMsgSequence, arbRecordMsg, stubCtxThrowingProxy };

package/dist/pbt/arbitraries/index.js

@@ -1,3 +0,0 @@
-export { arbConstantMsg, arbGuidedSequence, arbMsg, arbMsgSequence, arbRecordMsg, stubCtxThrowingProxy } from '../../chunk-AZZLE7XR.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/pbt/arbitraries/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/pbt/runners/index.d.ts

@@ -1,118 +0,0 @@
-import * as fc from 'fast-check';
-import { C as Cmd, S as Sub, M as Machine } from '../../core-Co0LWkIA.js';
-import 'zod';
-
-/**
- * One unit in a fold trace — the four pieces of data a property
- * invariant typically asserts on. `prev` is the state before the msg
- * applied; `next` is the state after; `cmds` is the cmds emitted by this
- * single step (NOT the running total).
- */
-interface Step<S, M, C> {
-    readonly prev: S;
-    readonly msg: M;
-    readonly next: S;
-    readonly cmds: readonly C[];
-}
-/**
- * Fold a Msg sequence through a machine's pure reducer, returning the
- * per-step trace, every state in order, and the final state. Initial
- * state comes from `replay(machine, { msgs: [], ctx, loaded })` — i.e.
- * `machine.init(loaded ?? null, ctx)` faithfully. Init's emitted cmds
- * are NOT included in any `Step` (they're the boot moment, not a Msg).
- *
- * @param machine  The machine under test.
- * @param ctx      The Ctx — typically `stubCtxThrowingProxy<Ctx>()` when
- *                 init is pure. Pass a real ctx if init reads from it.
- * @param loaded   Optional pre-init snapshot (the `loaded` arg to
- *                 `machine.init`). Defaults to `null` (fresh boot).
- * @param msgs     The Msg sequence to fold.
- *
- * @example
- *   const { states, steps, finalState } = foldEvents(machine, ctx, null, [
- *     { type: "start" }, { type: "tick" }, { type: "stop" },
- *   ]);
- *   // steps[1] = { prev: { type: "counting", n: 0 }, msg: { type: "tick" }, ... }
- */
-declare function foldEvents<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, ctx: NoInfer<Ctx>, loaded: NoInfer<S> | null, msgs: readonly NoInfer<M>[]): {
-    readonly states: readonly S[];
-    readonly steps: readonly Step<S, M, C>[];
-    readonly finalState: S;
-};
-
-/** Common options shared by every property runner. */
-interface PropertyOpts<S> {
-    /** Pre-init snapshot — passed to `machine.init(loaded, ctx)`. Default `null`. */
-    readonly loaded?: S | null;
-    /** Number of generated sequences to test. Forwarded to `fc.assert`. */
-    readonly numRuns?: number;
-    /** Optional fast-check seed for reproducibility. */
-    readonly seed?: number;
-}
-/**
- * Assert every generated Msg sequence ends in a terminal state. `terminal`
- * is the predicate that names the acceptable final states (often
- * `(s) => s.type === "done" || s.type === "idle"`).
- *
- * The "every sequence" property catches stuck states (machine gets to a
- * non-terminal state and no further msg can escape) AND silent loops
- * (every msg variant is a noop from a given state).
- *
- * @example
- *   propertyTerminates(
- *     auditBackgroundMachine,
- *     stubCtxThrowingProxy<BackgroundCtx>(),
- *     arbMsgSequence(msgArb, { minLength: 1, maxLength: 30 }),
- *     (s) => s.type === "done" || s.type === "idle",
- *     { loaded: auditingState, numRuns: 500 },
- *   );
- */
-declare function propertyTerminates<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, ctx: NoInfer<Ctx>, seqArb: fc.Arbitrary<readonly NoInfer<M>[]>, terminal: (state: NoInfer<S>) => boolean, opts?: NoInfer<PropertyOpts<S>>): void;
-/**
- * Assert a predicate holds on EVERY transition step in a generated
- * sequence. The predicate sees `{ prev, msg, next, cmds }` per step;
- * return true to accept, false (or throw) to fail.
- *
- * Use to pin a "when X happens in state Y, cmd Z must be emitted" rule.
- * The shrinker minimizes the offending sequence to the smallest Msg list
- * that still violates the predicate.
- *
- * @example
- *   // Pin the resume-handshake fix: `ws:client:hello` in auditing must
- *   // emit `send_ws { client:ready }`.
- *   propertyInvariant(
- *     auditBackgroundMachine, ctx,
- *     arbMsgSequence(msgArb, { prefix: [{ type: "ws:client:hello" }] }),
- *     ({ prev, msg, cmds }) =>
- *       !(prev.type === "auditing" && msg.type === "ws:client:hello") ||
- *       cmds.some((c) => c.type === "send_ws" && c.msg.type === "client:ready"),
- *     { loaded: auditingState, numRuns: 200 },
- *   );
- */
-declare function propertyInvariant<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, ctx: NoInfer<Ctx>, seqArb: fc.Arbitrary<readonly NoInfer<M>[]>, invariant: (step: Step<NoInfer<S>, NoInfer<M>, NoInfer<C>>) => boolean, opts?: NoInfer<PropertyOpts<S>>): void;
-/**
- * Assert a predicate over the full trace plus the final state. Use when
- * the property is "some Msg appeared in the trace before reaching the
- * final state" or "no two consecutive steps had the same state.type" —
- * predicates that need the full sequence, not a single step.
- *
- * @example
- *   propertyTrace(
- *     machine, ctx, seqArb,
- *     (steps, final) =>
- *       final.type !== "done" ||
- *       steps.some((step) => step.msg.type === "ws:audit:done"),
- *     { loaded: auditingState, numRuns: 500 },
- *   );
- */
-declare function propertyTrace<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, ctx: NoInfer<Ctx>, seqArb: fc.Arbitrary<readonly NoInfer<M>[]>, predicate: (steps: readonly Step<NoInfer<S>, NoInfer<M>, NoInfer<C>>[], finalState: NoInfer<S>) => boolean, opts?: NoInfer<PropertyOpts<S>>): void;
-
-export { type Step, foldEvents, propertyInvariant, propertyTerminates, propertyTrace };

package/dist/pbt/runners/index.js

@@ -1,5 +0,0 @@
-export { foldEvents, propertyInvariant, propertyTerminates, propertyTrace } from '../../chunk-CRPZJVD2.js';
-import '../../chunk-ZSUUOEPL.js';
-import '../../chunk-OOYD44JI.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/pbt/runners/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}