@kairos-es/feed 0.0.0-stage → 0.0.0

package/dist/dts-cjs/reconcile.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Reconcile: delete what a sink holds that the feed no longer has.
+ *
+ * ## Why a feed needs it at all
+ *
+ * The steady state deletes through tombstones, and a tombstone lives only until
+ * every sink registered on the feed has passed it. A record can still be left
+ * behind in a sink: a sink restored from a backup, a key written into the index by
+ * hand, or a record deleted before a reset, whose tombstone the reset cleared with
+ * every other row, followed by an in-place resync that, having no atomic swap,
+ * sends only the rows the new generation holds and so never deletes it. Reconcile is the one operation that compares the sink with the feed
+ * rather than replaying the feed into the sink, and so the only one that finds
+ * those orphans.
+ *
+ * ## The order of the two reads, and why it is safe
+ *
+ * The sink's keys are listed FIRST and the feed's live keys read SECOND. A key the
+ * sink lists that has a live row by the time the feed is read is kept, so a record
+ * written while reconcile runs is never deleted by it. A key whose row turns into
+ * a tombstone after the feed is read is kept too, and its tombstone deletes it on
+ * the next pass. And a key whose row comes back to life after the feed is read is
+ * deleted here and re-sent by the next pass, because its new `seq` is above the
+ * cursor. Reconcile runs inside the worker that holds the lease, between batches,
+ * so nothing else is sending to the sink while it does (ADR-0019 §8).
+ *
+ * ## What it costs
+ *
+ * It holds every key the sink lists and every live key of the feed in memory at
+ * once, and reads every live document to find the keys. It is a periodic repair,
+ * not a steady-state path: `reconcileEvery` should be measured in hours.
+ */
+import { Effect } from 'effect';
+import type { FeedUnreadable, FeedWriteFailed, LeaseHeld, LeaseLost, SinkHalted, SinkRetryable } from './errors.js';
+import type { FeedSource } from './Feed.js';
+import { type FeedReconcile, type FeedSink } from './FeedSink.js';
+import type { FeedSyncStore } from './FeedSyncStore.js';
+import { type FeedKey } from './identifiers.js';
+/** What one reconcile did. */
+export interface ReconcileReport {
+    /** How many keys the sink listed. */
+    readonly listed: number;
+    /** The orphans deleted: listed by the sink, with no live row in the feed. */
+    readonly deleted: ReadonlyArray<FeedKey>;
+    /** Orphans whose delete the sink refused, with its reason. They stay in the sink. */
+    readonly refused: ReadonlyArray<{
+        readonly key: FeedKey;
+        readonly reason: string;
+    }>;
+}
+/** Every key of `source` whose row is live, read page by page from the origin. */
+export declare const liveKeys: <D>(source: FeedSource<D>, pageSize: number) => Effect.Effect<ReadonlySet<FeedKey>, FeedUnreadable>;
+/** Options for {@link reconcileFeed}. */
+export interface ReconcileFeedOptions<D, Receipt> {
+    readonly source: FeedSource<D>;
+    readonly sink: FeedSink<D, Receipt> & {
+        readonly reconcile: FeedReconcile;
+    };
+    readonly store: FeedSyncStore;
+    /** How many rows to read, and deletes to send, at a time. */
+    readonly pageSize?: number;
+}
+/**
+ * Reconcile `sink` against `source` once, now. It takes the worker lease itself,
+ * so it fails `LeaseHeld` while a sync worker for the same feed and sink runs —
+ * reconcile through that worker's `reconcileEvery` instead, or stop it first.
+ */
+export declare const reconcileFeed: <D, Receipt>(options: ReconcileFeedOptions<D, Receipt>) => Effect.Effect<ReconcileReport, LeaseHeld | LeaseLost | FeedUnreadable | FeedWriteFailed | SinkRetryable | SinkHalted>;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/dts-cjs/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAgB,MAAM,EAAkB,MAAM,QAAQ,CAAA;AAG7D,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,SAAS,EACT,SAAS,EACT,UAAU,EACV,aAAa,EACd,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAc,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1E,OAAO,KAAK,EAAa,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EAAe,KAAK,OAAO,EAAmB,MAAM,eAAe,CAAA;AAG1E,8BAA8B;AAC9B,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IACxC,qFAAqF;IACrF,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;QAC9B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;QACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KACxB,CAAC,CAAA;CACH;AAED,kFAAkF;AAClF,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,QAAQ,UAAU,CAAC,CAAC,CAAC,EACrB,UAAU,MAAM,KACf,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,cAAc,CAoBjD,CAAA;AAmGJ,yCAAyC;AACzC,MAAM,WAAW,oBAAoB,CAAC,CAAC,EAAE,OAAO;IAC9C,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG;QAAE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;KAAE,CAAA;IAC3E,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,OAAO,EACtC,SAAS,oBAAoB,CAAC,CAAC,EAAE,OAAO,CAAC,KACxC,MAAM,CAAC,MAAM,CACd,eAAe,EACb,SAAS,GACT,SAAS,GACT,cAAc,GACd,eAAe,GACf,aAAa,GACb,UAAU,CAgBX,CAAA"}

package/dist/dts-cjs/runFeedSync.d.ts

@@ -0,0 +1,220 @@
+/**
+ * `runFeedSync` — the sync worker: one per feed and sink, holding the lease,
+ * copying the feed's rows to the sink and moving its cursor only once the sink
+ * confirms them (ADR-0019).
+ *
+ * ## The lifecycle
+ *
+ * A worker runs in SESSIONS. A session takes the lease, then loops:
+ *
+ * 1. Read the cursor and the feed's generation. No cursor, or a cursor at another
+ *    generation, means the sink holds a copy of something the feed no longer is,
+ *    so the session RESYNCS (below) and loops.
+ * 2. Otherwise it TAILS: the rows after the cursor, through core's generic
+ *    subscribe machine with `emit: 'page'`, so each page is sent as it is read and
+ *    the worker holds one page in memory, never the backlog. Each page is checked
+ *    against the generation first, and so is every poll interval on its own, since
+ *    a reset that writes nothing yields no page; a generation that moved since the
+ *    cursor was saved ends the tail, and step 1 sees the mismatch.
+ *
+ * Every page goes through one delivery: send, park the keys the sink refuses with
+ * its reasons, send the rest again, confirm. Then ONE compare-and-set moves the
+ * cursor past the whole page and moves the parked list with it — the refused keys
+ * parked, every key that was taken unparked — and fenced on the lease holder, so a
+ * worker that lost its lease moves nothing. Then tombstones every sink has passed
+ * are collected.
+ *
+ * The rules that sequence keeps, each a consequence of a sink not being
+ * transactional:
+ *
+ * - **The cursor moves only after `confirm`.** A crash between `apply` and
+ *   `confirm` resends the batch; a sink is idempotent, so that costs a resend and
+ *   nothing else.
+ * - **A refused key does not hold the feed up.** It is parked and the cursor moves
+ *   past it. It is retried when its row next changes, because a change gives the
+ *   row a `seq` above the cursor, and it leaves the parked list once it is sent
+ *   successfully — a tombstone for a parked key included, which is how a refused
+ *   record that is then deleted stops being parked without anyone acting.
+ * - **A retryable failure keeps the cursor.** The session ends, and supervision
+ *   (below) starts a new one after a back-off no shorter than the sink's
+ *   `retryAfter`; the new session sends the same page again.
+ *
+ * ## Resync
+ *
+ * Every row, page by page from the origin, goes into `resync.begin`'s fresh
+ * target; then the generation is checked once more, the target is published over
+ * the live copy, and the cursor is saved at the new generation with the parked list
+ * REPLACED by the refusals the resync met. Resync progress is held in memory only,
+ * so a crash restarts it from the origin, with a new `begin` that drops the
+ * half-built target the crash left.
+ *
+ * ### Waiting for the materialisation
+ *
+ * The feed's end is not the rebuild's end. After a reset the materialisation
+ * replays the log and writes the feed as it goes, so a resync that reaches the
+ * feed's last row has reached wherever the replay had got to, and publishing there
+ * swaps a complete live copy for a partial one. `readiness.ts` owns that argument.
+ * So `runFeedSync` takes an optional `readiness`: asked once as each attempt
+ * starts, it hands back a probe, and the attempt does not publish until the probe
+ * says the materialisation has caught up. Until then the attempt polls: once per
+ * poll interval it checks the generation, abandoning the attempt as stale if a
+ * reset moved it again, asks the probe, and reads the feed on from where it left
+ * off, loading what the replay wrote meanwhile. The probe is asked BEFORE that
+ * read, so the read that follows a `true` sees every row the materialisation had
+ * committed by the time it answered, since a feed row commits with the checkpoint
+ * that produced it. The lease is still checked immediately before `publish`, and
+ * the generation once more just before that, however long the wait was.
+ *
+ * With no `readiness` the attempt publishes at the feed's end, which is exactly the
+ * behaviour above, and search can serve a PARTIAL copy for as long as the replay
+ * takes. An in-place rebuild has no publish; there the wait holds the closing
+ * reconcile and the cursor save instead, so the reconcile never deletes a record
+ * the replay has not reached yet. Without a `readiness` an in-place rebuild
+ * reconciles at the feed's end too, and so deletes from the live copy every record
+ * the replay had not yet written again; the tail sends each back as the replay
+ * reaches it.
+ *
+ * The wait is UNBOUNDED. A probe that never says yes holds the attempt for good,
+ * with no error and no restart, because publishing early is the very failure the
+ * wait exists to prevent and no timeout could tell a stuck replay from a long one.
+ * It is made visible instead: `inspectFeed` reports the sink `resyncDue` for as long
+ * as it lasts, since the cursor stays at the old generation, and every
+ * `HELD_WAIT_WARN_POLLS` poll intervals (`tuning.ts`) the attempt logs a warning,
+ * "feed sync rebuild held on readiness", with the feed, the sink, the generation,
+ * the polls so far and how long it has been held.
+ *
+ * Each `begin` names a target of its own, never one an earlier attempt used, and
+ * that is what bounds a lease lapse here. A worker that has lost its lease can
+ * still land one call after the new holder's (`FeedSyncStore.ts` says when). Were
+ * the target named after its generation alone, that call could be a `publish` of
+ * the NEW holder's half-built target, which then goes on loading into a fresh one
+ * holding only the later pages, publishes it, and saves its cursor at the head:
+ * whole pages lost, and nothing to bring them back. With a target per attempt, a
+ * stale `publish` moves only the stale worker's own target — or fails, retryably,
+ * when a newer `begin` has dropped it — and a stale `begin` drops the new holder's
+ * target, whose `publish` then fails retryably and whose resync starts again.
+ * What a stale `publish` of its own target still costs is `FeedSyncStore.ts`'s to
+ * say, with the rest of the lease's window.
+ *
+ * `begin`, `load`, `apply` and `publish` each run behind `ensureHeld`; `confirm`
+ * and a reconcile's key listing change nothing, and do not.
+ *
+ * Tombstones are sent as deletes, although the target starts empty. The feed does
+ * not stand still while a resync pages through it: a key loaded on an early page
+ * can be deleted by the read model before the resync is done, and its tombstone
+ * then sits at a `seq` a LATER page reads. Dropping it would load the key, save
+ * the cursor past its delete, and publish a target that holds a record the feed no
+ * longer has, with nothing ever coming to remove it. A tombstone for a key the
+ * target never held costs a send and changes nothing, since a delete of an absent
+ * key is a no-op by the sink laws.
+ *
+ * The same movement decides the parked list. A key can be met more than once in
+ * one resync — refused on an early page, then changed and met again later — so
+ * the list saved is what each key's LAST change in the resync came to: parked if
+ * that change was refused, absent if it was taken. Keeping every refusal the
+ * resync met would leave parked a key the target holds, or one the feed deleted.
+ *
+ * A sink with no `resync` is resynced IN PLACE: every row is sent to the live copy,
+ * live rows as upserts and tombstones as deletes, and then a reconcile deletes what
+ * the feed no longer holds. The live copy serves a mixture of old and new from the
+ * first page on, which is the price of a target with no atomic swap. Its refusals
+ * land in the parked list it saves like any resync's, with two consequences of
+ * writing over the live copy: a refused upsert leaves the PREVIOUS generation's
+ * document of that key live, and an orphan whose delete the closing reconcile was
+ * refused stays live too. Both are parked with the sink's reason, the orphan at the
+ * origin `seq` since it has no row, and the closing reconcile's report goes to
+ * `onReconcile` like a scheduled one's. A sink with neither part could never be
+ * rebuilt, and is refused at construction.
+ *
+ * ## Supervision
+ *
+ * Every failure a session meets ends it, and the worker's own loop decides what
+ * next. It follows `@kairos-es/automation`'s daemon rather than generalising the
+ * read side's supervisor, whose own doc says a progress signal the caller owns does
+ * not qualify — and the signal here, a cursor advance, is the worker's own.
+ *
+ * - `LeaseHeld`: another worker is running. This one waits a poll interval and
+ *   tries again, and the wait is not a failure: a standby worker is a healthy one,
+ *   and it takes over within a poll interval of the first worker's lease going.
+ * - Anything else: a back-off of `restartMinDelay` doubling to `restartMaxDelay`,
+ *   scaled by a jitter drawn from `Random` so a fleet of workers does not retry in
+ *   lockstep, and never shorter than a `SinkRetryable`'s `retryAfter`. A restart
+ *   that follows no cursor advance since the previous restart counts towards
+ *   `maxNoProgressRestarts`; reaching it ends the worker with `FeedSyncStalled`,
+ *   for the caller to report. Any advance resets the count and the curve.
+ *
+ * Defects are not caught: they are bugs, in the driver or in a sink or store that
+ * should have classified its fault, and supervision must not retry a bug.
+ *
+ * ## The scope
+ *
+ * The worker never returns. Run it in a fibre of its own beside the projections,
+ * and close the scope to stop it: each session runs in a child scope of the
+ * caller's, so closing the caller's scope releases the lease.
+ */
+import { Duration, Effect, Scope } from 'effect';
+import { FeedSyncStalled } from './errors.js';
+import type { FeedSource } from './Feed.js';
+import { type FeedSink } from './FeedSink.js';
+import type { FeedSyncStore } from './FeedSyncStore.js';
+import { type FeedName, type SinkName } from './identifiers.js';
+import type { FeedReadiness } from './readiness.js';
+import { type ReconcileReport } from './reconcile.js';
+/** What `onRestart` is told before each restart's back-off. */
+export interface FeedSyncRestart {
+    readonly feed: FeedName;
+    readonly sink: SinkName;
+    /** Consecutive restarts with no cursor advance, this one included. */
+    readonly restarts: number;
+    readonly delay: Duration.Duration;
+    /** The failure that ended the session. */
+    readonly reason: unknown;
+}
+/** The worker's knobs. Every one has a default; see `tuning.ts`'s module doc. */
+export interface FeedSyncTuning {
+    /** The upper bound on an idle sleep. Default 1 second. */
+    readonly pollInterval?: Duration.Input;
+    /** Rows read, and changes sent, per page. Default core's catch-up page, 512. */
+    readonly pageSize?: number;
+    /** The first restart back-off. Default 100 ms. */
+    readonly restartMinDelay?: Duration.Input;
+    /** The restart back-off's cap, before jitter. Default 30 seconds. */
+    readonly restartMaxDelay?: Duration.Input;
+    /** Consecutive restarts with no cursor advance before `FeedSyncStalled`. Default 40. */
+    readonly maxNoProgressRestarts?: number;
+    readonly onRestart?: (info: FeedSyncRestart) => Effect.Effect<void>;
+    /**
+     * Told what each reconcile the worker runs did: each scheduled one, and the one
+     * that closes an in-place rebuild.
+     */
+    readonly onReconcile?: (report: ReconcileReport) => Effect.Effect<void>;
+}
+/** Options for {@link runFeedSync}. */
+export interface RunFeedSyncOptions<D, Receipt> {
+    readonly source: FeedSource<D>;
+    readonly sink: FeedSink<D, Receipt>;
+    readonly store: FeedSyncStore;
+    readonly tuning?: FeedSyncTuning;
+    /**
+     * Reconcile the sink against the feed this often, between batches, under the
+     * worker's own lease. Needs the sink's `reconcile`; absent, the worker
+     * reconciles only as part of an in-place resync.
+     */
+    readonly reconcileEvery?: Duration.Input;
+    /**
+     * Hold each resync's `publish` — or, in place, its closing reconcile — until the
+     * materialisation writing the feed has caught up with the log, for as long as
+     * that takes; see the module doc's Resync section. Absent, a resync publishes at
+     * the feed's end, and search can be PARTIAL while a rebuild's replay runs.
+     * `materialisationCaughtUp` builds the common case from the read model.
+     */
+    readonly readiness?: FeedReadiness;
+}
+/**
+ * Run the sync worker for `options.source` and `options.sink`; see the module doc.
+ * Dies at once, before taking the lease, on a sink that has neither `resync` nor
+ * `reconcile`, on a `reconcileEvery` for a sink with no `reconcile`, and on tuning
+ * that is out of range.
+ */
+export declare const runFeedSync: <D, Receipt>(options: RunFeedSyncOptions<D, Receipt>) => Effect.Effect<never, FeedSyncStalled, Scope.Scope>;
+//# sourceMappingURL=runFeedSync.d.ts.map

package/dist/dts-cjs/runFeedSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runFeedSync.d.ts","sourceRoot":"","sources":["../../src/runFeedSync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyJG;AAGH,OAAO,EAKL,QAAQ,EACR,MAAM,EAIN,KAAK,EAEN,MAAM,QAAQ,CAAA;AAGf,OAAO,EAEL,eAAe,EAQhB,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAW,UAAU,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAGV,aAAa,EAGd,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAGL,KAAK,QAAQ,EAGb,KAAK,QAAQ,EACd,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAAE,aAAa,EAAsB,MAAM,aAAa,CAAA;AACpE,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,aAAa,CAAA;AAYpB,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,QAAQ,CAAA;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;IACtC,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;IACzC,qEAAqE;IACrE,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;IACzC,wFAAwF;IACxF,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAA;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACnE;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CACxE;AAED,uCAAuC;AACvC,MAAM,WAAW,kBAAkB,CAAC,CAAC,EAAE,OAAO;IAC5C,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;IACnC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAA;IAChC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAA;CACnC;AAmBD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,OAAO,EACpC,SAAS,kBAAkB,CAAC,CAAC,EAAE,OAAO,CAAC,KACtC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,CAAC,KAAK,CAiDhD,CAAA"}

package/dist/dts-cjs/tuning.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The driver's tuning: its defaults, and the checks that refuse a nonsensical
+ * value at construction rather than somewhere inside a running worker.
+ *
+ * The page size defaults to core's own catch-up page, and the supervision curve to
+ * the read side's — 100 ms doubling to 30 s — so a feed behaves like its
+ * neighbours unless told otherwise. The no-progress cap is the read side's too,
+ * and for the same reason: forty restarts on that curve is some twenty minutes of
+ * a sink refusing everything, which is long enough to ride out an outage and short
+ * enough that a broken wiring is reported the same day.
+ *
+ * Package-internal; the options a caller sets are `FeedSyncTuning`'s, on
+ * `runFeedSync`.
+ */
+import { ReadLimit } from '@kairos-es/core';
+import { Duration } from 'effect';
+/** Rows read, and changes sent, per page. */
+export declare const DEFAULT_FEED_PAGE_SIZE: number;
+/** The upper bound on an idle worker's sleep: the poll that is the guarantee. */
+export declare const DEFAULT_FEED_POLL_INTERVAL: Duration.Duration;
+/** The first restart back-off. */
+export declare const DEFAULT_FEED_RESTART_MIN_DELAY: Duration.Duration;
+/** The restart back-off's cap, before jitter. */
+export declare const DEFAULT_FEED_RESTART_MAX_DELAY: Duration.Duration;
+/** Consecutive restarts without a cursor advance before the worker gives up. */
+export declare const DEFAULT_FEED_MAX_NO_PROGRESS_RESTARTS = 40;
+/**
+ * How many poll intervals a rebuild held on its readiness waits between two
+ * warnings that it is still held. Not a bound: the wait goes on, since publishing
+ * early is the failure the wait exists to prevent. Counted in polls, not time, so
+ * it scales with `pollInterval`: sixty polls is long past any replay that is
+ * merely busy at any sensible interval, and rare enough not to flood a log while
+ * a long one runs.
+ */
+export declare const HELD_WAIT_WARN_POLLS = 60;
+/** The page size as a `ReadLimit`, refusing one that is not a positive integer. */
+export declare const readLimit: (pageSize: number) => ReadLimit;
+/** A duration input decoded, refusing one that is not positive and finite. */
+export declare const positiveDuration: (label: string, input: Duration.Input) => Duration.Duration;
+//# sourceMappingURL=tuning.d.ts.map

package/dist/dts-cjs/tuning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuning.d.ts","sourceRoot":"","sources":["../../src/tuning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAA8B,SAAS,EAAE,MAAM,iBAAiB,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAEjC,6CAA6C;AAC7C,eAAO,MAAM,sBAAsB,EAAE,MAAmC,CAAA;AAExE,iFAAiF;AACjF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,QAA8B,CAAA;AAEhF,kCAAkC;AAClC,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,QAChC,CAAA;AAEtB,iDAAiD;AACjD,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,QAChC,CAAA;AAEtB,gFAAgF;AAChF,eAAO,MAAM,qCAAqC,KAAK,CAAA;AAEvD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC,mFAAmF;AACnF,eAAO,MAAM,SAAS,GAAI,UAAU,MAAM,KAAG,SAO5C,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,EACb,OAAO,QAAQ,CAAC,KAAK,KACpB,QAAQ,CAAC,QAMX,CAAA"}

package/dist/dts-esm/Feed.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The feed's two faces: the WRITE side a read model's `apply` uses inside its
+ * commit, and the READ side a sync worker tails.
+ *
+ * ## Why the feed is written inside the materialisation's commit
+ *
+ * A feed row exists if and only if the view write and the checkpoint advance that
+ * produced it landed (ADR-0019 §2). That is the read side's existing exactly-once
+ * seam, reused rather than rebuilt: the `ProjectionStore` brackets a read model's
+ * view writes with its guarded checkpoint advance, so a feed written through the
+ * same bracket commits with the view, rolls back with it on a lost guard, and is
+ * never seen half-written. Nothing else about the feed's correctness would survive
+ * a feed written beside the commit instead of inside it.
+ *
+ * ## Why writes are batched before they land
+ *
+ * `BatchedFeedWriter.write` hands its body a `FeedWriter`, collects every upsert
+ * and remove the body makes, and lands them together when the body succeeds:
+ * the last write per key wins within one call. Two reasons, one per kind of store.
+ *
+ * - A transactional store would roll a part-written batch back on its own; there
+ *   coalescing is purely an economy, one row write per key instead of one per
+ *   event.
+ * - A non-transactional store cannot roll anything back, and the `ProjectionStore`
+ *   port's contract therefore asks that such a store's per-batch view write be ONE
+ *   atomic effect. Buffering is what makes the feed's half of the batch one atomic
+ *   effect too, so a body that fails half-way leaves no feed row behind.
+ *
+ * ## What "coalesced, latest wins" means for the stored row
+ *
+ * One row per key. An upsert of a document EQUAL to the stored one writes nothing
+ * and takes no sequence value, so an event that changes nothing a sink indexes
+ * costs the sink nothing (ADR-0019 §4). Equality is of the ENCODED document, as a
+ * JSON value whose object keys are unordered, so what counts as a change is the
+ * same in every backend. A remove leaves a TOMBSTONE — the row, with no document —
+ * so every sink's cursor can pass it and send the delete, and a remove of a key
+ * that is absent or already a tombstone writes nothing.
+ */
+import type { Position, ReadLimit } from '@kairos-es/core';
+import type { Effect, Option, Stream } from 'effect';
+import type { FeedUnreadable, FeedWriteFailed } from './errors.js';
+import type { FeedKey, FeedName, FeedSeq, Generation } from './identifiers.js';
+/**
+ * One row of a feed: the newest state of one record. `doc` is `None` for a
+ * tombstone. `eventPosition` is the position of the event batch that last wrote
+ * the row, kept for "the sink is at least as fresh as P" and never used as a
+ * cursor; `seq` is the cursor.
+ */
+export interface FeedRow<D> {
+    readonly key: FeedKey;
+    readonly doc: Option.Option<D>;
+    readonly seq: FeedSeq;
+    readonly eventPosition: Position;
+}
+/**
+ * What a read model's `apply` writes through, for each search record the batch
+ * touches. Used only inside {@link BatchedFeedWriter.write}'s body.
+ */
+export interface FeedWriter<D> {
+    /** The record's newest state. Writes nothing when the stored document is equal. */
+    readonly upsert: (key: FeedKey, doc: D) => Effect.Effect<void, FeedWriteFailed>;
+    /** A tombstone. Writes nothing when the key is absent or already a tombstone. */
+    readonly remove: (key: FeedKey) => Effect.Effect<void, FeedWriteFailed>;
+}
+/**
+ * A feed's write side: run `body` with a {@link FeedWriter}, and land what it
+ * wrote, coalesced by key, when it succeeds. `at` becomes every written row's
+ * `eventPosition`; pass the position of the last event in the batch being
+ * applied. `RW` is what the backend itself needs from the context — a SQL backend
+ * writes through the read model's own client, so the client is in `RW` and the
+ * write joins whatever transaction the `ProjectionStore` opened around `apply`.
+ *
+ * Call it from inside the materialisation's `commit` and nowhere else: a feed
+ * written outside the commit is a feed that can disagree with its view.
+ */
+export interface BatchedFeedWriter<D, RW = never> {
+    readonly feed: FeedName;
+    readonly write: <A, E, R>(at: Position, body: (writer: FeedWriter<D>) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | FeedWriteFailed, R | RW>;
+}
+/**
+ * A feed's read side, as the sync worker sees it.
+ *
+ * `changesAfter` returns the rows whose `seq` is strictly greater than `after`, in
+ * ascending `seq` order, at most `limit` of them, tombstones included. Its one
+ * obligation is the subscribe machine's: a row committed and visible must never
+ * have a `seq` below one already returned. A feed bound to one materialisation
+ * keeps it, because that materialisation has one writer.
+ *
+ * `listen`, when present, is a WAKE and nothing more: each element says "there
+ * may be new rows", and a missed, duplicated or coalesced one makes a read early
+ * or late but never wrong, because the poll is the guarantee.
+ */
+export interface FeedSource<D> {
+    readonly feed: FeedName;
+    readonly generation: Effect.Effect<Generation, FeedUnreadable>;
+    readonly changesAfter: (after: FeedSeq, limit: ReadLimit) => Effect.Effect<ReadonlyArray<FeedRow<D>>, FeedUnreadable>;
+    readonly listen?: Stream.Stream<unknown, FeedUnreadable>;
+}
+//# sourceMappingURL=Feed.d.ts.map

package/dist/dts-esm/Feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Feed.d.ts","sourceRoot":"","sources":["../../src/Feed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAC9B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAA;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,CACf,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,CAAC,KACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAA;IACzC,iFAAiF;IACjF,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAA;CACxE;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,EAAE,GAAG,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACtB,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KACpD,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACnD;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;IAC9D,QAAQ,CAAC,YAAY,EAAE,CACrB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,SAAS,KACb,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,CAAC,CAAA;CACzD"}

package/dist/dts-esm/FeedSink.d.ts

@@ -0,0 +1,189 @@
+/**
+ * The sink port: what a target a feed is copied to must offer the driver.
+ *
+ * ## Three parts, two of them optional
+ *
+ * - `apply` and `confirm` are the whole of the steady state. `apply` sends a
+ *   batch and returns a `Receipt`; `confirm` resolves once that batch is applied
+ *   AND VISIBLE in the target. The driver moves its cursor only after `confirm`
+ *   (ADR-0019 §6), so a crash between the two resends the batch — which is why
+ *   every sink must be IDEMPOTENT: the same batch applied twice leaves the target
+ *   as once. Full-record replace satisfies that; a partial operation such as an
+ *   increment does not, and a sink must never use one.
+ * - `resync` is how a sink rebuilds after the feed's generation moves: load every
+ *   row into a fresh target that is not yet serving — tombstones too, as deletes,
+ *   since the feed can delete a key the same resync has already loaded — then swap
+ *   it over the live one atomically, so search keeps serving the old copy until the new one is
+ *   complete and records deleted from the feed do not survive the rebuild.
+ * - `reconcile` lists the keys the target holds, so the driver can delete those
+ *   the feed no longer has. Deletes go through the ordinary `apply`.
+ *
+ * A sink with no atomic swap leaves out `resync`, and the driver then resyncs IN
+ * PLACE: it sends every row to the live target and reconciles away what the feed
+ * no longer holds. That needs `reconcile`, so `runFeedSync` refuses at
+ * construction a sink that has neither part: such a sink could never be rebuilt.
+ *
+ * ## Why `FeedChange` is not `FeedRow`
+ *
+ * A sink is handed the change to make, not the row it came from: an `Upsert` with
+ * the document or a `Delete`. The sequence and the event position are the
+ * driver's business, and a sink that could see them could be tempted to keep a
+ * cursor of its own, which would be a second record of progress.
+ */
+import { Data, type Effect, type Stream } from 'effect';
+import type { NonEmptyReadonlyArray } from 'effect/Array';
+import type { SinkHalted, SinkRejected, SinkRetryable } from './errors.js';
+import type { FeedRow } from './Feed.js';
+import type { FeedKey, Generation, SinkName } from './identifiers.js';
+/** One change for a sink to make: the record's newest state, or its removal. */
+export type FeedChange<D> = Data.TaggedEnum<{
+    Upsert: {
+        readonly key: FeedKey;
+        readonly doc: D;
+    };
+    Delete: {
+        readonly key: FeedKey;
+    };
+}>;
+/** The generic definition behind {@link FeedChange}'s constructors. */
+export interface FeedChangeDefinition extends Data.TaggedEnum.WithGenerics<1> {
+    readonly taggedEnum: FeedChange<this['A']>;
+}
+/** `FeedChange.Upsert({ key, doc })`, `FeedChange.Delete({ key })`, and matchers. */
+export declare const FeedChange: {
+    readonly Upsert: <A>(args: {
+        readonly key: FeedKey;
+        readonly doc: A;
+    }) => {
+        readonly _tag: "Upsert";
+        readonly key: FeedKey;
+        readonly doc: A;
+    };
+    readonly Delete: <A>(args: {
+        readonly key: FeedKey;
+    }) => {
+        readonly _tag: "Delete";
+        readonly key: FeedKey;
+    };
+    readonly $is: <Tag extends "Upsert" | "Delete">(tag: Tag) => {
+        <T extends {
+            readonly _tag: "Upsert";
+            readonly key: FeedKey;
+            readonly doc: any;
+        } | {
+            readonly _tag: "Delete";
+            readonly key: FeedKey;
+        }>(u: T): u is T & {
+            readonly _tag: Tag;
+        };
+        (u: unknown): u is Extract<{
+            readonly _tag: "Upsert";
+            readonly key: FeedKey;
+            readonly doc: unknown;
+        }, {
+            readonly _tag: Tag;
+        }> | Extract<{
+            readonly _tag: "Delete";
+            readonly key: FeedKey;
+        }, {
+            readonly _tag: Tag;
+        }>;
+    };
+    readonly $match: {
+        <A, B, C, D, Cases extends {
+            readonly Upsert: (args: {
+                readonly _tag: "Upsert";
+                readonly key: FeedKey;
+                readonly doc: A;
+            }) => any;
+            readonly Delete: (args: {
+                readonly _tag: "Delete";
+                readonly key: FeedKey;
+            }) => any;
+        }>(cases: Cases): (self: {
+            readonly _tag: "Upsert";
+            readonly key: FeedKey;
+            readonly doc: A;
+        } | {
+            readonly _tag: "Delete";
+            readonly key: FeedKey;
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Upsert" | "Delete"]>>;
+        <A, B, C, D, Cases extends {
+            readonly Upsert: (args: {
+                readonly _tag: "Upsert";
+                readonly key: FeedKey;
+                readonly doc: A;
+            }) => any;
+            readonly Delete: (args: {
+                readonly _tag: "Delete";
+                readonly key: FeedKey;
+            }) => any;
+        }>(self: {
+            readonly _tag: "Upsert";
+            readonly key: FeedKey;
+            readonly doc: A;
+        } | {
+            readonly _tag: "Delete";
+            readonly key: FeedKey;
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Upsert" | "Delete"]>>;
+    };
+};
+/** The change a row asks of a sink: its document as an upsert, a tombstone as a delete. */
+export declare const changeOf: <D>(row: FeedRow<D>) => FeedChange<D>;
+/**
+ * Where ONE resync attempt is being built. `name` is the sink's own name for it (an
+ * index name, say), and it is the attempt's alone: no two `begin`s return the same
+ * one, even for one generation. So a worker that has lost its lease without yet
+ * knowing it can only ever publish its OWN target, never the half-built target of
+ * the worker that holds the lease now; `runFeedSync.ts` owns what that buys.
+ */
+export interface ResyncTarget {
+    readonly generation: Generation;
+    readonly name: string;
+}
+/** A sink's rebuild: a fresh target, loaded, then swapped over the live one. */
+export interface FeedResync<D, Receipt> {
+    /**
+     * A fresh, empty target that is not live, under a name no earlier `begin`
+     * returned. Drops every other target an earlier attempt left — crashed,
+     * abandoned, or still being loaded by a worker that lost its lease — whose
+     * `publish` must then fail retryably rather than touch the live copy.
+     */
+    readonly begin: (generation: Generation) => Effect.Effect<ResyncTarget, SinkRetryable | SinkHalted>;
+    /**
+     * `apply`, against the target rather than the live copy. Confirmed by `confirm`.
+     * A target a later `begin` dropped must NEVER BE PUBLISHED, since the worker
+     * loading into it can be one that lost its lease without knowing it, and a target
+     * rebuilt from its later pages alone must never be swapped over the live copy as
+     * a fragment. Failing `SinkRetryable` here is the plain way to keep that. A sink
+     * whose writes recreate a missing target (an index that springs into being on its
+     * first write) may let the load land and recreate it instead, provided `publish`
+     * then tells the recreated target from the one `begin` made and refuses it.
+     */
+    readonly load: (target: ResyncTarget, batch: NonEmptyReadonlyArray<FeedChange<D>>) => Effect.Effect<Receipt, SinkRetryable | SinkRejected | SinkHalted>;
+    /**
+     * Swap the target over the live copy, atomically, and resolve once it serves. A
+     * target a later `begin` dropped — gone, or brought back by a load — fails
+     * `SinkRetryable` and leaves the live copy as it was. Once the swap has landed, a
+     * sink may tidy the live copy of its own bookkeeping (a marker it set to tell its
+     * target apart) on a best-effort basis: the swap is the publish, so a failure of
+     * that tidying must not fail it.
+     */
+    readonly publish: (target: ResyncTarget) => Effect.Effect<void, SinkRetryable | SinkHalted>;
+}
+/** A sink's key listing, for deleting what the feed no longer holds. */
+export interface FeedReconcile {
+    /** Every key the live target holds, in any order, each once. */
+    readonly listKeys: Stream.Stream<FeedKey, SinkRetryable | SinkHalted>;
+}
+/** A target a feed is copied to. See the module doc. */
+export interface FeedSink<D, Receipt> {
+    readonly name: SinkName;
+    readonly apply: (batch: NonEmptyReadonlyArray<FeedChange<D>>) => Effect.Effect<Receipt, SinkRetryable | SinkRejected | SinkHalted>;
+    /** Resolves once the batch the receipt names is applied and visible. */
+    readonly confirm: (receipt: Receipt) => Effect.Effect<void, SinkRetryable | SinkHalted>;
+    /** Absent: the driver resyncs in place, which needs `reconcile`. */
+    readonly resync?: FeedResync<D, Receipt>;
+    readonly reconcile?: FeedReconcile;
+}
+//# sourceMappingURL=FeedSink.d.ts.map

package/dist/dts-esm/FeedSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedSink.d.ts","sourceRoot":"","sources":["../../src/FeedSink.ts"],"names":[],"mappings":"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"}