@demlik/tea 0.12.0 → 0.14.0

package/dist/prediction/index.d.ts

@@ -1,130 +0,0 @@
-import { C as Cmd, S as Sub, M as Machine } from '../core-Bjc0bS8j.js';
-
-/**
- * @demlik/tea/prediction — the client-prediction ack primitive (epic #186, facet 2).
- *
- * The contract the Gambetta/Valve authoritative-server netcode loop needs:
- * **command-seq-in → last-applied-seq-out.** A client tags each predicted
- * command/`Msg` with a monotonic `seq`; the authoritative side replies with the
- * `lastAppliedSeq` it has processed. `partitionByAck` then splits the client's
- * pending buffer into the inputs the server has ACKED (`seq <= lastAppliedSeq`)
- * and those still PENDING (`seq > lastAppliedSeq`) — the un-acked tail the
- * reconciliation pass (#214) replays over the authoritative snapshot via
- * `foldMsgs` (#211, `@demlik/tea/pure`).
- *
- * Deliberately **Model-shape-agnostic** (ADR 0006): the ack is a standalone
- * value, NOT a field this module requires on the consumer's `State`. It
- * generalizes the `lastAckedSeq`-on-the-Model + `seq`-threaded-through-the-Msg
- * pattern vortex hand-rolled (epic #186). It is a LEAF module — pure and
- * runtime-free, importing nothing from the tea core or host, so it can never
- * drag `run`/the host into a client bundle.
- *
- * This is the read/ack side of the primitive; `tagSeq`/`nextSeq` are the write
- * side, letting a client mint monotonic seqs from its pending buffer alone —
- * again with no counter field on the Model.
- *
- * `reconcile` (the read side's payoff, #214) composes this ack partition with
- * the pure fold seam `foldMsgs` (#211) to perform the whole Gambetta/Valve
- * reconciliation step in one call. The `foldMsgs` import is the ONLY dependency
- * this leaf takes, and it reaches into the pure-core leaf (`../pure/core`) — NOT
- * the runtime root — so the module stays runtime-free and the `@demlik/tea/pure`
- * import-graph guard (ADR 0006, #213) still holds.
- */
-
-/**
- * A monotonic, non-negative sequence number tagging one client-predicted
- * command. Monotonicity is the client's contract (mint successive seqs with
- * `nextSeq`); this module only ever *compares* seqs.
- */
-type Seq = number;
-/** A command (or `Msg`) tagged with the `seq` the client assigned it. */
-interface SeqTagged<T> {
-    readonly seq: Seq;
-    readonly value: T;
-}
-/** Tag a command/`Msg` with its sequence number. */
-declare const tagSeq: <T>(seq: Seq, value: T) => SeqTagged<T>;
-/**
- * The authoritative side's acknowledgement: the highest `seq` it has applied.
- * Everything with `seq <= lastAppliedSeq` is settled; everything above is still
- * in flight. This *is* the whole "ack from the authoritative side" — a value
- * the consumer carries however it likes (a wire field, a message payload),
- * never a shape this module imposes on the Model.
- */
-interface Ack {
-    readonly lastAppliedSeq: Seq;
-}
-/** Construct an `Ack` for a last-applied sequence number. */
-declare const ack: (lastAppliedSeq: Seq) => Ack;
-/**
- * The "nothing applied yet" cursor — the ack value for a server that has applied
- * no client input at all. Because `nextSeq` mints **0-based** seqs and
- * `partitionByAck` acks **inclusively** (`seq <= lastAppliedSeq`), the pre-first
- * cursor must sit strictly *below* seq 0: `lastAppliedSeq = 0` would falsely ack
- * the seq-0 input before the server ever saw it. `-1` is "before any seq", and
- * `partitionByAck(buffer, NO_ACK)` therefore leaves the whole buffer PENDING.
- *
- * This names the boundary value on the seam so no consumer has to re-discover it
- * as a magic number: it is the primitive's own design (0-based mint + inclusive
- * partition) that creates the trap, so it is the primitive's job to name the
- * escape. Pair with {@link initAck} when an {@link Ack} is wanted instead of the
- * bare `Seq`.
- */
-declare const NO_ACK: Seq;
-/**
- * The `Ack` for a server that has applied nothing yet — `ack(NO_ACK)`. The `Ack`
- * counterpart to the {@link NO_ACK} `Seq` sentinel, for a consumer that carries
- * an `Ack` rather than a bare `lastAppliedSeq`.
- */
-declare const initAck: () => Ack;
-/** The result of splitting a seq-tagged buffer against an ack. */
-interface AckPartition<T> {
-    /** Inputs the authoritative side has applied (`seq <= lastAppliedSeq`). */
-    readonly acked: readonly SeqTagged<T>[];
-    /** Inputs still in flight / un-acked (`seq > lastAppliedSeq`) — the replay tail. */
-    readonly pending: readonly SeqTagged<T>[];
-}
-/**
- * Partition a buffer of seq-tagged commands into ACKED and PENDING against the
- * authoritative `lastAppliedSeq`. Pure and total: every item lands in exactly
- * one bucket, input order is preserved within each bucket, and the boundary
- * `seq == lastAppliedSeq` is ACKED (inclusive `<=`). Routing is by `seq` value,
- * not buffer position, so an out-of-order or duplicate-seq buffer partitions
- * correctly. Accepts either an {@link Ack} or a bare `lastAppliedSeq` number, so
- * a caller passes whichever it holds.
- */
-declare const partitionByAck: <T>(buffer: readonly SeqTagged<T>[], ackOrSeq: Ack | Seq) => AckPartition<T>;
-/**
- * The next sequence number to assign: one past the highest `seq` in the buffer,
- * or `0` for an empty buffer. Lets a client mint monotonic seqs from its pending
- * buffer alone — no counter field on the Model — and is tolerant of an unordered
- * buffer (it takes the max, not the last element).
- */
-declare const nextSeq: <T>(buffer: readonly SeqTagged<T>[]) => Seq;
-/**
- * The client prediction/reconciliation helper — the Gambetta/Valve
- * authoritative-server loop's reconcile step, generalized (#214, epic #186).
- *
- * Given the latest `authoritativeState` from the server, the server's
- * `lastAppliedSeq` ack, and the client's `pending` buffer of seq-tagged inputs,
- * it returns the corrected predicted state: drop the inputs the server has
- * already applied (`seq <= lastAppliedSeq`) and replay ONLY the un-acked tail
- * (`seq > lastAppliedSeq`) over the authoritative snapshot.
- *
- * It is **composed, not re-derived** (ADR 0006): the drop is {@link partitionByAck}
- * (the ack primitive, #212) and the replay is `foldMsgs` (the pure fold seam,
- * #211) — there is no second copy of the partition logic and no second copy of
- * the fold. `lastAppliedSeq` accepts either an {@link Ack} or a bare `Seq`, so a
- * caller passes whichever it holds, matching `partitionByAck`.
- *
- * Pure and host-agnostic: it takes the `machine` (which `foldMsgs` needs to
- * dispatch `update`) but touches no `Store`, `interpret`, or subscription, and
- * imports nothing from the runtime — so it ships on `@demlik/tea/prediction`
- * and the client-safe `@demlik/tea/pure` umbrella without dragging `run` into a
- * client bundle.
- */
-declare function reconcile<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, authoritativeState: S, lastAppliedSeq: Ack | Seq, pending: readonly SeqTagged<M>[]): S;
-
-export { type Ack, type AckPartition, NO_ACK, type Seq, type SeqTagged, ack, initAck, nextSeq, partitionByAck, reconcile, tagSeq };

package/dist/prediction/index.js

@@ -1,4 +0,0 @@
-export { NO_ACK, ack, initAck, nextSeq, partitionByAck, reconcile, tagSeq } from '../chunk-4KTWLPL5.js';
-import '../chunk-B5VXOFMZ.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/prediction/index.js.map

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

package/dist/protocol-B5YmJr0d.d.ts

@@ -1,45 +0,0 @@
-/**
- * The closed set of cross-module Msg/Cmd discriminant strings. Declared `as
- * const` so each entry is usable as both a value (construction / reducer keys /
- * switch labels) and, via `typeof MsgType.X`, a literal type (`readonly type:`
- * fields). The single source of truth for issue #60.
- */
-declare const MsgType: {
-    /** The "run the port for `key`" effect Cmd resilient-call emits. */
-    readonly ResilientRun: "resilient_run";
-    /** PRIVATE success settle Msg (read only by `agentEvents`, #47). */
-    readonly ResilientOk: "resilient_ok";
-    /** Failure settle Msg — routed to the `fail` verb (back off via retry). */
-    readonly ResilientErr: "resilient_err";
-    /** Begin a run. */
-    readonly AgentStart: "agent_start";
-    /** PRIVATE tool-fan-out success settle Msg (read only by `agentEvents`, #47). */
-    readonly AgentToolOk: "agent_tool_ok";
-    /** Tool-fan-out failure settle Msg. */
-    readonly AgentToolErr: "agent_tool_err";
-    /**
-     * Re-fire the one outstanding effect on rehydrate (the do↔agent seam). Fired
-     * by `do/host`'s `autoBoot` via the typed `agentBootMsg` constructor, matched
-     * by the agent reducer — see `AgentBootPort` in `../agent`.
-     */
-    readonly AgentBoot: "agent_boot";
-    /**
-     * The "summarize the oldest N turns" effect Cmd the agent emits when its
-     * `CompactionPolicy` asks to compact before a brain call. A DEDICATED
-     * round-trip (design B1), distinct from the brain call's `resilient_run`, so
-     * compaction is its own honest `Awaiting` state — see `../agent`.
-     */
-    readonly CompactRun: "compact_run";
-    /** Compaction round-trip resolved — carries the summary text the fold-back folds. */
-    readonly CompactOk: "compact_ok";
-    /** Compaction round-trip failed (exhausted retry) — surfaced as data, not a stall. */
-    readonly CompactErr: "compact_err";
-    /** Refresh port resolved — carries the fresh `Token`. */
-    readonly TokenRefreshed: "token_refreshed";
-    /** Refresh port rejected — carries the rejection (errors are data). */
-    readonly TokenRefreshFailed: "token_refresh_failed";
-    /** The 401 the consumer dispatches when a guarded call comes back unauthorized. */
-    readonly Unauthorized: "unauthorized";
-};
-
-export { MsgType as M };

package/dist/pure/index.d.ts

@@ -1,2 +0,0 @@
-export { Ack, AckPartition, NO_ACK, Seq, SeqTagged, ack, initAck, nextSeq, partitionByAck, reconcile, tagSeq } from '../prediction/index.js';
-export { C as Cmd, d as ContextFree, D as DepKeyedSub, e as Dispose, f as Identity, I as Interpret, c as InterpretDetached, M as Machine, g as MachineShape, N as NoCellError, h as NoCtx, a as Port, P as PortEmitter, R as Reducer, S as Sub, b as SubId, i as Subscribe, j as SyncReturn, T as Transitions, U as UpdateForm, k as acceptsOf, n as describeMachine, o as detectUpdateForm, p as foldMsgs, r as formOf, t as structuralHash, u as subId } from '../core-Bjc0bS8j.js';

package/dist/pure/index.js

@@ -1,4 +0,0 @@
-export { NO_ACK, ack, initAck, nextSeq, partitionByAck, reconcile, tagSeq } from '../chunk-4KTWLPL5.js';
-export { Cmd, NoCellError, acceptsOf, describeMachine, detectUpdateForm, foldMsgs, formOf, structuralHash, subId } from '../chunk-B5VXOFMZ.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/pure/index.js.map

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

package/dist/rate-limit/index.d.ts

@@ -1,115 +0,0 @@
-/**
- * @demlik/tea/rate-limit — two rate limiters as pure state + ops.
- *
- * Same shape as `@demlik/tea/work-queue`'s `ops.ts`: a state type plus pure
- * transition functions. Host-agnostic by construction — no `Date.now()`, no
- * timers, no I/O. The caller injects the clock (`nowMs`) and wires the result
- * into its own reducer / interpret. This keeps the limiters inside TEA's
- * invariant 2 (transitions are pure: same inputs → same outputs, no `Date.now`)
- * so a consumer can fold them through `update` and exercise them with `replay`
- * / the pbt fold without a fake clock.
- *
- * Every op returns a NEW state value and never mutates its input (invariant 1 —
- * state is a value, not a place). The `tryConsume` / `record` ops return a
- * `[next, ok]` tuple so the caller branches on the decision while threading the
- * advanced state forward; `refill` / `remaining` are read-shaped helpers.
- *
- * Two complementary algorithms, picked by the cost the caller wants to pay:
- *
- *   - **Token bucket** — O(1) state (four numbers), smooths bursts against a
- *     steady refill rate. Allows a burst up to `capacity`, then throttles to
- *     `refillPerSec`. Cheapest; the default choice.
- *   - **Sliding window log** — O(limit) state (one timestamp per in-window
- *     hit), exact "no more than `limit` events per `windowMs`". Pay the memory
- *     for precise window edges when a token bucket's continuous refill would
- *     let through too many at a boundary.
- *
- * NOT exported from the package root — reached via the `@demlik/tea/rate-limit`
- * subpath, same one-shape-per-package rule as `work-queue` and `do`.
- */
-/**
- * A token bucket: `tokens` of `capacity` available now, replenished at
- * `refillPerSec` tokens per second. `lastRefillMs` is the clock reading at
- * which `tokens` was last computed — `refill` advances it. All four fields are
- * plain numbers so the whole bucket is trivially JSON-serializable into a
- * consumer's `Store<S>`.
- */
-interface TokenBucket {
-    readonly tokens: number;
-    readonly capacity: number;
-    readonly refillPerSec: number;
-    readonly lastRefillMs: number;
-}
-/**
- * Create a full bucket. Starts at `capacity` tokens (the conventional "a fresh
- * limiter lets the first burst through" behavior) and stamps `lastRefillMs`
- * with the caller's clock so the first `refill` measures elapsed time from
- * boot, not from epoch 0.
- */
-declare function initBucket(capacity: number, refillPerSec: number, nowMs: number): TokenBucket;
-/**
- * Add the tokens accrued since `lastRefillMs`, clamped to `capacity`, and
- * advance `lastRefillMs` to `nowMs`. PURE — returns a new bucket; the input is
- * untouched.
- *
- * A `nowMs` at or before `lastRefillMs` (clock not advanced, or skewed
- * backwards) adds a non-positive amount; `Math.max(0, …)` floors the elapsed
- * term so a backwards clock can never *remove* tokens. `lastRefillMs` still
- * advances to `nowMs` so the bucket tracks the latest reading the caller
- * presented — the next forward step measures from there, not from a stale
- * future timestamp.
- */
-declare function refill(bucket: TokenBucket, nowMs: number): TokenBucket;
-/**
- * Refill against `nowMs`, then attempt to take `n` tokens (default 1).
- *
- * On success returns `[next, true]` with `n` subtracted; on failure returns
- * `[refilled, false]` — the refilled bucket (so the caller keeps the advanced
- * clock + accrued tokens) with no tokens spent. Branch on the boolean, thread
- * the bucket forward regardless:
- *
- *   const [b1, ok] = tryConsume(bucket, nowMs);
- *   return ok ? [{ ...state, bucket: b1 }, [doWork]] : [{ ...state, bucket: b1 }, []];
- *
- * PURE — input bucket is never mutated.
- */
-declare function tryConsume(bucket: TokenBucket, nowMs: number, n?: number): readonly [TokenBucket, boolean];
-/**
- * A sliding-window log: the timestamps of every hit still inside the trailing
- * `windowMs`, capped at `limit` events per window. `hits` is `readonly` and
- * kept oldest-first (pruning slices the stale prefix off the front, recording
- * appends to the back), so the array is its own sorted index. Exact at the
- * window edge — unlike a token bucket's continuous refill, a hit leaves the
- * count the instant it ages past `windowMs`.
- */
-interface SlidingWindow {
-    readonly hits: readonly number[];
-    readonly windowMs: number;
-    readonly limit: number;
-}
-/** Create an empty window. No hits recorded yet. */
-declare function initWindow(windowMs: number, limit: number): SlidingWindow;
-/**
- * Prune hits older than `nowMs - windowMs`, then record `nowMs` if there is
- * room. Returns `[next, true]` with the hit appended when `hits.length < limit`
- * after pruning, else `[pruned, false]` — the pruned window (capacity recovers
- * as old hits age out) with nothing appended.
- *
- * The cutoff is half-open (see {@link prune}): a hit exactly `windowMs` old is
- * pruned, so a hit recorded at `t` no longer counts at `t + windowMs`. That
- * makes the window's capacity fully recover `windowMs` after the last hit, the
- * behavior tests pin.
- *
- * PURE — input window is never mutated; `hits` is rebuilt by `filter` +
- * spread.
- */
-declare function record(window: SlidingWindow, nowMs: number): readonly [SlidingWindow, boolean];
-/**
- * How many more hits `record` would accept at `nowMs` without blocking —
- * `limit` minus the live (post-prune) hit count, floored at 0. Read-only: it
- * prunes a local copy to answer but returns no new window. Use it to render a
- * "N requests remaining" affordance without committing a hit.
- */
-declare function remaining(window: SlidingWindow, nowMs: number): number;
-
-export { type SlidingWindow, type TokenBucket, initBucket, initWindow, record, refill, remaining, tryConsume };

package/dist/rate-limit/index.js

@@ -1,3 +0,0 @@
-export { initBucket, initWindow, record, refill, remaining, tryConsume } from '../chunk-S2EGRPCM.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/rate-limit/index.js.map

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

package/dist/reconciler/index.d.ts

@@ -1,192 +0,0 @@
-import { CircuitConfig, RateLimitConfig, DeadlineConfig, ResilientPorts, RunCmd, FailMsg, SucceedMsg } from '../resilient-call/index.js';
-import { TtlCache } from '../cache/index.js';
-import { C as Cmd } from '../core-Bjc0bS8j.js';
-import { PaginatedWalkState, PaginatedWalkTimerMsg, FetchPageCmd, PageErrMsg, PageOkMsg } from '../paginated-walk/index.js';
-import { RetryPolicy } from '../retry-backoff/index.js';
-import { DeadlineSub } from '../deadline/index.js';
-export { deadlineSub, subscribeDeadline } from '../deadline/index.js';
-import '../circuit-breaker/index.js';
-import '../protocol-B5YmJr0d.js';
-import '../rate-limit/index.js';
-import '../types-D7u9DkH7.js';
-import '../paginator/index.js';
-
-/**
- * The reconciler knob. Generic in:
- *   - `Actual`  — one item of the ACTUAL world (a fleet node, an audited page, a
- *                 table row). The scan accumulates these.
- *   - `Desired` — the DESIRED spec value the diff converges toward. Opaque to
- *                 this module; only `diff` reads it.
- *   - `Page`    — the shape one actual-list page fetch resolves with.
- *   - `Change`  — one unit of remediation the diff produces and `apply` realizes.
- *   - `ApplyCmd`— the Cmd `apply(change)` yields (the effect that mutates the
- *                 actual world toward desired).
- *
- * `diff` / `apply` / `idOf` / `nextCursor` / `itemsOf` are PURE config functions
- * applied at the verb boundary, never stored in the slice or in a Cmd (Cmds are
- * plain data, not closures). The resilience bricks (`retry` / `circuit` /
- * `rateLimit` / `deadline`) are the SAME optional knobs `paginated-walk` /
- * `resilient-call` expose — reconciler extends them; `rateLimit` keeps the scan
- * from 429-ing the upstream listing API.
- */
-interface ReconcilerConfig<Actual, Desired, Page, Change, ApplyCmd extends Cmd, Cursor = number> {
-    /**
-     * The DESIRED spec to converge on. Held verbatim and handed to `diff` once the
-     * scan completes. Any JSON-serializable value — a list of specs, a target map,
-     * a single target object — `diff` alone interprets it.
-     */
-    readonly desired: Desired;
-    /**
-     * Compute the remediation plan: the ordered `Change[]` that moves `actual` to
-     * `desired`. Called once when the scan finishes (the full actual snapshot is in
-     * hand). An empty plan means "already in sync — nothing to apply". PURE +
-     * consumer-specific (only the consumer knows the domain's reconcile rules).
-     */
-    readonly diff: (desired: Desired, actual: readonly Actual[]) => readonly Change[];
-    /**
-     * Realize one `Change` as the Cmd that mutates the actual world. Returns plain
-     * data (a `{ type, ... }` Cmd the consumer's interpret handler performs).
-     * PURE — the side effect happens when the runtime performs the emitted Cmd,
-     * never here.
-     */
-    readonly apply: (change: Change) => ApplyCmd;
-    /**
-     * Stable identity for a `Change` — the applied-ledger cache key. A re-`applyNext`
-     * after eviction (or after a re-plan) skips a change whose id is already in the
-     * ledger (idempotent re-apply). MUST be a property of the change itself, NOT its
-     * position in the plan: the ledger has to survive re-planning. When omitted the
-     * default keys by the change's serialized CONTENT (`JSON.stringify(change)`) —
-     * a stable per-change identity that is unchanged by where the change sits in the
-     * plan. Supply a domain id (the target node id, the resource key) when one
-     * exists; it is cheaper than serializing and dedupes two changes that differ
-     * only in fields irrelevant to identity. PURE.
-     *
-     * Why NOT positional: keying by index silently drops changes on the documented
-     * re-plan path. After applying the index-0 change, its `"0"` ledger entry would
-     * match WHATEVER different, never-applied change lands at index 0 in the next
-     * plan — the apply loop skips it as "already done". Identity must be intrinsic
-     * to the change so the ledger means "this change settled", not "slot N settled".
-     */
-    readonly idOf?: (change: Change) => string;
-    /**
-     * The cursor the actual-list scan fetches first. For an offset API typically
-     * `0`; for a token API whatever sentinel the API treats as page one.
-     */
-    readonly firstPage: Cursor;
-    /**
-     * Extract the next scan cursor from a fetched page — a `Cursor` to keep
-     * scanning, or `null` when the actual listing is exhausted (scan finishes,
-     * plan computed). PURE + consumer-specific.
-     */
-    readonly nextCursor: (page: Page) => Cursor | null;
-    /**
-     * Extract the actual items from one fetched page. Each page's items are
-     * appended to the running `actual` accumulator. PURE.
-     */
-    readonly itemsOf: (page: Page) => readonly Actual[];
-    /** Exponential-backoff retry policy for a transient scan-page failure. */
-    readonly retry?: RetryPolicy;
-    /** Circuit breaker around the scan fetch (one upstream → one breaker). */
-    readonly circuit?: CircuitConfig;
-    /** Token-bucket rate limit on the scan — the "don't 429 the listing API" knob. */
-    readonly rateLimit?: RateLimitConfig;
-    /** Overall wall-clock deadline per individual scan-page fetch. */
-    readonly deadline?: DeadlineConfig;
-}
-/**
- * Reconcile lifecycle phase. Discriminated on `phase`:
- *
- *   - `idle`     — created, never scanned. `scan` starts the actual-world walk.
- *   - `scanning` — the paginated-walk is traversing the actual listing; pages
- *                  fold into `actual` as they arrive. The scan owns the `walk`
- *                  sub-slice; this phase ends when the walk finishes.
- *   - `applying` — the scan finished, `diff` produced the `plan`, and changes are
- *                  being applied one at a time. `appliedCursor` is the index of
- *                  the next change to apply.
- *   - `done`     — every planned change applied (or an empty plan: already in
- *                  sync). Terminal.
- *   - `failed`   — the scan failed terminally (the page-fetch retries were
- *                  exhausted / a deadline fired). `error` carries why. Terminal.
- */
-type ReconcilePhase = "idle" | "scanning" | "applying" | "done" | "failed";
-/**
- * The slice. Plain data end to end:
- *   - `phase`         — the lifecycle discriminant.
- *   - `walk`          — the `../paginated-walk` scan slice (cursor + resilience).
- *                       Drives the actual-world traversal; POSITION survives
- *                       eviction.
- *   - `actual`        — the accumulated actual items, appended page by page during
- *                       the scan. The full snapshot `diff` is computed against.
- *   - `plan`          — the `Change[]` `diff` produced. Empty until the scan
- *                       finishes; the apply loop walks it by `appliedCursor`.
- *   - `appliedCursor` — index of the NEXT change to apply (0 ≤ cursor ≤ plan.length).
- *                       `cursor === plan.length` means every change applied.
- *   - `applied`       — the applied-ledger cache: `idOf(change) → change`, written
- *                       as each change settles. The idempotency memory the apply
- *                       loop reads to skip already-applied changes after eviction.
- */
-interface ReconcilerState<Actual, Change, Page, Cursor = number> {
-    readonly phase: ReconcilePhase;
-    readonly walk: PaginatedWalkState<Cursor, Page>;
-    readonly actual: readonly Actual[];
-    readonly plan: readonly Change[];
-    readonly appliedCursor: number;
-    readonly applied: TtlCache<Change>;
-}
-/**
- * The actual-list page-fetch effect: the inherited `resilient_run` Cmd from
- * paginated-walk, whose `input` is the `Cursor` to fetch and whose `key` is the
- * fixed `PAGE_KEY`. The consumer's `handlers(ports)` interprets it.
- */
-type ScanPageCmd<Cursor> = FetchPageCmd<Cursor>;
-/** Page-settled Msgs the scan `handlers` port dispatches back (inherited verbatim). */
-type ScanPageOkMsg<Page> = PageOkMsg<Page>;
-type ScanPageErrMsg = PageErrMsg;
-/** The scan retry / deadline timer Msg — inherited from paginated-walk. */
-type ReconcilerTimerMsg = PaginatedWalkTimerMsg;
-/**
- * Ports the consumer supplies to `handlers`. `run(cursor)` fetches ONE page of
- * the ACTUAL listing for the given cursor; throwing routes to `pageErr` (and
- * thus the scan backoff). Same shape as paginated-walk's port.
- */
-interface ReconcilerPorts<Cursor, Page> extends ResilientPorts<Cursor, Page> {
-}
-/**
- * Build a reconciler knob from `config`. `rng` is injected for the underlying
- * scan-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
- * reconciler verb). Inherited straight from paginated-walk.
- *
- * Returns the uniform L2 knob contract: `init()`, the verbs `scan` / `pageOk` /
- * `pageErr` / `planned` / `applyNext` / `applied` / `onTimer`, the derived
- * `isComplete`, `subs(state)`, and `handlers(ports)`.
- */
-declare function createReconciler<Actual, Desired, Page, Change, ApplyCmd extends Cmd = Cmd, Cursor = number>(config: ReconcilerConfig<Actual, Desired, Page, Change, ApplyCmd, Cursor>, rng?: () => number): {
-    init: () => ReconcilerState<Actual, Change, Page, Cursor>;
-    scan: (s: ReconcilerState<Actual, Change, Page, Cursor>, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    pageOk: (s: ReconcilerState<Actual, Change, Page, Cursor>, page: Page, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    pageErr: (s: ReconcilerState<Actual, Change, Page, Cursor>, error: unknown, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    planned: (s: ReconcilerState<Actual, Change, Page, Cursor>, at: number, changes?: readonly Change[]) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    applyNext: (s: ReconcilerState<Actual, Change, Page, Cursor>, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    applied: (s: ReconcilerState<Actual, Change, Page, Cursor>, change: Change, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    onTimer: (s: ReconcilerState<Actual, Change, Page, Cursor>, msg: ReconcilerTimerMsg) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    isComplete: (s: ReconcilerState<Actual, Change, Page, Cursor>) => boolean;
-    subs: (s: ReconcilerState<Actual, Change, Page, Cursor>) => readonly DeadlineSub[];
-    handlers: (ports: ReconcilerPorts<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.rec`. Convenience for the common single-slice host; hosts with
- * a differently-named field spread by hand. PURE — a thin record rebuild, no
- * clock / RNG.
- */
-declare function liftReconciler<S extends {
-    rec: ReconcilerState<Actual, Change, Page, Cursor>;
-}, Actual, Change, Page, Cursor, C extends Cmd>(state: S, [slice, cmds]: readonly [
-    ReconcilerState<Actual, Change, Page, Cursor>,
-    readonly C[]
-]): readonly [S, readonly C[]];
-
-export { DeadlineSub, type ReconcilePhase, type ReconcilerConfig, type ReconcilerPorts, type ReconcilerState, type ReconcilerTimerMsg, type ScanPageCmd, type ScanPageErrMsg, type ScanPageOkMsg, createReconciler, liftReconciler };