@kairos-es/feed 0.0.0-stage → 0.0.0

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

@@ -0,0 +1,281 @@
+/**
+ * `FeedSyncStore` — the port for a sync worker's durable state, kept in the SOURCE
+ * database beside the feed rows: one cursor per feed and sink, the parked list,
+ * and the worker lease (ADR-0019 §10).
+ *
+ * The in-memory feed implements it as the parity oracle, and `@kairos-es/feed-postgres`
+ * implements it over its cursor and parked tables. Everything below is the
+ * contract both must keep; the driver relies on no more than this.
+ *
+ * ## The lease, and why a feed takes one where a projection does not
+ *
+ * A projection needs no lease (ADR-0007): its view is transactional, so a rival
+ * runner's write is rolled back by the guarded checkpoint advance before anyone
+ * sees it. A sink is not transactional. Two workers on one sink can both send
+ * before either moves the cursor, and an older read sent late overwrites a newer
+ * record, which no compare-and-set run AFTER the send can undo. So one worker per
+ * feed and sink holds a lease, and sends nothing without it (ADR-0019 §5).
+ *
+ * `acquireLease` is SCOPED. It either takes the lease or fails `LeaseHeld` at
+ * once — it never waits — and the lease is released when the scope closes. What
+ * it returns is a {@link FeedLease}: the holder id the store issued, and
+ * `ensureHeld`, which the driver runs before EVERY call that changes the sink —
+ * `apply`, and a resync's `begin`, `load` and `publish` — and which fails
+ * `LeaseLost` the moment the store can tell the lease is no longer this worker's.
+ * How the store keeps the lease alive, and how it tells, is its own business, and
+ * there are two shapes it may take:
+ *
+ * - **A lease row with an expiry**, renewed by a heartbeat the store forks into the
+ *   lease's scope. `ensureHeld` fails once a renewal has found the row taken, and
+ *   once the lease is within a SAFETY MARGIN of the expiry it last stored — never
+ *   only at the expiry itself. This works through a transaction pooler and needs no
+ *   reserved connection. Its cost is a window, and the margin is what bounds it:
+ *   `ensureHeld` judges the lease when a call STARTS, and nothing stops a call
+ *   already in flight when the lease lapses. A call that ends within the margin of
+ *   the check that let it through lands while the lease is still this worker's,
+ *   and cannot be overtaken by a new holder's, renewals failing meanwhile or not.
+ *   A call that takes longer than the margin — a slow sink call, one retrying its
+ *   hosts, or a process pause between the check and the call — can land after the
+ *   lease has lapsed and after the new holder's own calls. That is ONE stale call,
+ *   since the worker's next `ensureHeld` fails, and it can land as late as the
+ *   call's duration less the margin past the lapse; no pause longer than the lease
+ *   is needed, only a call longer than the margin while renewals are failing. In
+ *   the tail that is one stale batch. In a resync it
+ *   can be a `publish`, which swaps in the worker's whole target, complete as of
+ *   its own read of the feed: if the new holder has already published and moved its
+ *   cursor on, every record that changed in between is served at its older state —
+ *   a key deleted since comes back, one created since is missing — until it changes
+ *   again or the next resync. A reconcile removes the keys that came back, and
+ *   repairs nothing else. It can be a `begin`, which drops the new holder's target
+ *   and costs that holder a restarted resync. It is never a `publish` of another
+ *   worker's target, because each `begin` names a target of its own
+ *   (`runFeedSync.ts` owns why).
+ * - **A session lock on a dedicated connection.** `ensureHeld` checks the
+ *   connection is still alive. A process pause opens no window of its own, because
+ *   the lock survives it and goes only when the session goes. The window is the
+ *   session dying while a call is in flight, or between the check and the call:
+ *   that call is let through, and the new holder can take the lock the moment the
+ *   session is gone. It is the same ONE stale call, at the same costs as above,
+ *   since the next `ensureHeld` asks a session that is gone, and it can land as
+ *   late as that call's whole duration after the session died — which, for a sink
+ *   call that retries its hosts, can be long. The price of this shape is the
+ *   connection.
+ *
+ * Both shapes record the holder where the cursor compare-and-set can see it, and
+ * `casCursor` FENCES on it: a call whose `holder` is not the current holder fails
+ * `CursorSuperseded` and lands nothing. That is what stops a worker that lost its
+ * lease from moving the cursor, whichever shape the lease takes. The in-memory
+ * feed takes a third, trivial shape: the holder recorded in its one state, taken
+ * only when no holder is recorded, in the same atomic step as that check, and
+ * cleared by the finaliser of the lease's scope.
+ *
+ * ## The cursor
+ *
+ * A cursor is a `(generation, seq)` pair; a sink with no cursor yet has none, and
+ * resyncs. `casCursor` is guarded like a checkpoint: it lands only when the stored
+ * cursor EQUALS `expected` (both absent, or both present with an equal generation
+ * and an equal seq) AND the lease is held by `holder`. It moves the parked list in
+ * the SAME atomic step, so a park recorded for a batch can never outlive a cursor
+ * advance that was refused, nor be lost from one that landed.
+ *
+ * An advance that lands also records WHEN it landed, as the sink's `lastAdvance`,
+ * in that same step; a refused one records nothing. The time is read from the
+ * Effect `Clock` of the process making the call (`DateTime.now`), never from the
+ * database's own clock, so `TestClock` governs it exactly as it governs the
+ * lease's expiry, and every backend reports one clock. Taking a lease is not an
+ * advance: a sink whose cursor has never moved has no `lastAdvance`.
+ *
+ * ## The parked list
+ *
+ * Parks are written only through `casCursor`, as a {@link ParkedChange}:
+ *
+ * - `Amend` upserts each entry in `park` (a key already parked takes the new seq,
+ *   reason and time) and deletes each key in `unpark` that is parked. A key never
+ *   appears in both. The driver unparks every key it sent successfully, which is
+ *   how a parked record leaves the list once a later change of it syncs.
+ * - `Replace` discards the whole list for this feed and sink, then parks `park`.
+ *   A resync uses it, because a resync re-sends every record and the parks it
+ *   meets are the only ones still true; `park` holds a key only when the last
+ *   change of it the resync sent was refused.
+ *
+ * `retryParked` deletes one park AND re-stamps the row's `seq` with a fresh value,
+ * in one atomic step, so the next pass of every sink on the feed sends it again;
+ * the other sinks receive a record they already hold, which an idempotent sink
+ * absorbs. A key with no row left is simply unparked.
+ *
+ * ## Tombstone collection
+ *
+ * `collectTombstones(feed)` deletes the tombstone rows whose `seq` is at or below
+ * the LOWEST cursor `seq` over EVERY sink registered on the feed — every sink the
+ * store holds a cursor or a lease for — and reports how many it deleted. The
+ * minimum is taken over every registered sink's cursor WHATEVER generation it was
+ * saved at. A registered sink whose cursor is ABSENT blocks collection entirely: it
+ * counts as below every tombstone, and nothing is deleted until it has saved one.
+ * No sink registered, nothing deleted.
+ *
+ * A cursor at an older generation needs no rule of its own, because the minimum
+ * already holds it below every tombstone. A reset empties the feed in the same
+ * atomic step as it moves the generation, and `seq` never goes back, so every row
+ * the feed holds after a reset carries a `seq` above every value the feed reached
+ * before it. And a cursor is saved at a generation only with a `seq` read while the
+ * feed was at that generation: the driver reads the generation AFTER reading the
+ * rows and before saving, so rows read after a reset are never saved under the
+ * generation the reset left. So a cursor at an older generation is below every row
+ * the feed now holds, tombstones included, and holds collection back until its
+ * sink saves a cursor at the current generation. An arm of its own could only
+ * restate that, and could never be seen to differ from it.
+ *
+ * Such a sink is resyncing, as is one with no cursor, and the obvious reading —
+ * that a resync starts from the origin and so needs no tombstone — is wrong. A
+ * resync reads the feed page by page while the feed keeps moving, and it saves its
+ * cursor at the last `seq` it READ, not at the head. A key it loaded on an early
+ * page can be deleted after its last page was read; another sink passes that
+ * tombstone; and were it collected then, the resync would publish the key and
+ * start its tail at a cursor below a delete that no longer exists, holding the
+ * record for good. So the rule counts every registered sink, and a resync holds
+ * collection back until its cursor is saved. The cost is that tombstones
+ * accumulate while any sink resyncs — or is registered and never run again, which
+ * holds collection back until the sink is removed (below). `lastAdvance` in a
+ * {@link FeedSyncDescription} is how such a sink shows.
+ *
+ * The store computes the lowest cursor itself, in the same step as the delete, so
+ * a cursor moving between the two cannot let a tombstone go that some sink still
+ * needs.
+ *
+ * ## Removing a sink
+ *
+ * `removeSink(id)` deregisters a sink the application has retired. In ONE atomic
+ * step it deletes everything the store holds for that feed and sink — its cursor,
+ * its `lastAdvance`, its lease record and every parked record — and succeeds with
+ * whether there was anything to delete. A registered sink holds tombstone
+ * collection back for as long as it is registered, so a retired one left
+ * registered holds it back for good; this is the way out, and the next
+ * `collectTombstones` takes its minimum over the sinks that remain.
+ *
+ * It is REFUSED with `LeaseHeld`, deleting nothing, while a LIVE worker holds the
+ * sink's lease. Deleting the cursor under a running worker would only make it
+ * resync from the origin and register the sink again: stop the worker, then
+ * remove the sink. Whether the lease is live is the lease's own test, made in the
+ * same atomic step as the delete, so no worker can take the lease between the
+ * test and the delete:
+ *
+ * - **A lease row with an expiry** is live while its expiry is later than the
+ *   caller's `Clock` now. A lapsed row is not live, and is deleted with the rest.
+ * - **A session lock** is live while any session holds the lock, which the row
+ *   cannot say. So the store tries the lock ITSELF, on the same key, for the length
+ *   of the removing transaction (a transaction-scoped try-lock), and refuses when
+ *   it cannot have it. A holder recorded on the row while the store CAN have the
+ *   lock belongs to a session that has gone, and is deleted with the rest.
+ * - **The in-memory feed** refuses while a holder is recorded.
+ *
+ * Each test belongs to the kind of lease the HOLDER took, not to the kind the
+ * store was built to take: where one sink can be leased either way, by workers
+ * built differently, the store makes every test that applies, since a row alone
+ * cannot say which kind is holding it.
+ *
+ * Nothing about the fence changes. A worker that lost its lease without knowing it
+ * finds no holder recorded after a removal, so its `casCursor` fails
+ * `CursorSuperseded`, as it would against any other holder. And a worker started
+ * for the sink again simply registers it anew, with no cursor, and resyncs: a
+ * removal leaves no mark that would refuse it.
+ *
+ * ## Description
+ *
+ * `describe(feed)` is everything `inspectFeed` reports that lives in the store, in
+ * one read: the feed's head (its highest stored `seq`, `FEED_ORIGIN` when it holds
+ * no row) and, per sink with a cursor or a lease, the cursor, when it last moved
+ * (`lastAdvance`), the lease, the parked list and the number of rows still pending
+ * for it.
+ *
+ * ## Errors
+ *
+ * An infrastructure fault is `FeedUnreadable` on a read and `FeedWriteFailed` on a
+ * write, never a defect, so the driver's supervision can back off and try again.
+ * A `FeedSinkId` naming a feed the store does not serve is a wiring defect, and a
+ * store may die on it.
+ */
+import type { DateTime, Effect, Option, Scope } from 'effect';
+import type { CursorSuperseded, FeedUnreadable, FeedWriteFailed, LeaseHeld, LeaseLost } from './errors.js';
+import type { FeedKey, FeedName, FeedSeq, FeedSinkId, Generation, LeaseHolder, SinkName } from './identifiers.js';
+/** How far one sink has been synced: the generation, and the last confirmed seq. */
+export interface FeedCursor {
+    readonly generation: Generation;
+    readonly seq: FeedSeq;
+}
+/** Whether two optional cursors are the same cursor, as `casCursor` compares them. */
+export declare const sameCursor: (left: Option.Option<FeedCursor>, right: Option.Option<FeedCursor>) => boolean;
+/** A held lease, as the worker that holds it sees it. */
+export interface FeedLease {
+    readonly holder: LeaseHolder;
+    /** Fails `LeaseLost` once the lease is no longer this holder's. Run before every send. */
+    readonly ensureHeld: Effect.Effect<void, LeaseLost | FeedUnreadable>;
+}
+/** One parked record: the key, the `seq` of the row the sink refused, and why. */
+export interface ParkedRecord {
+    readonly key: FeedKey;
+    readonly seq: FeedSeq;
+    readonly reason: string;
+    readonly parkedAt: DateTime.Utc;
+}
+/** How a cursor advance moves the parked list; see the module doc. */
+export type ParkedChange = {
+    readonly _tag: 'Amend';
+    readonly park: ReadonlyArray<ParkedRecord>;
+    readonly unpark: ReadonlyArray<FeedKey>;
+} | {
+    readonly _tag: 'Replace';
+    readonly park: ReadonlyArray<ParkedRecord>;
+};
+/** The lease as a description reports it. `expiresAt` is `None` for a lease with no expiry. */
+export interface LeaseDescription {
+    readonly holder: LeaseHolder;
+    readonly expiresAt: Option.Option<DateTime.Utc>;
+}
+/** One sink's state, as the store holds it. */
+export interface SinkSyncState {
+    readonly sink: SinkName;
+    readonly cursor: Option.Option<FeedCursor>;
+    /**
+     * When the cursor last moved, by the `Clock` of the worker that moved it; `None`
+     * if it never has. A sink whose cursor stays still while the feed's head moves is
+     * a sink nothing runs, and it holds tombstone collection back until removed.
+     */
+    readonly lastAdvance: Option.Option<DateTime.Utc>;
+    readonly lease: Option.Option<LeaseDescription>;
+    readonly parked: ReadonlyArray<ParkedRecord>;
+    /**
+     * The rows this sink has still to receive: those above its cursor's `seq`, or
+     * every live row when it has no cursor. Counted against the stored rows, so a
+     * cursor at an older generation counts as if it were current; `inspectFeed` is
+     * what says a resync is due.
+     */
+    readonly pending: number;
+}
+/** Everything `describe` reports; see the module doc. */
+export interface FeedSyncDescription {
+    readonly head: FeedSeq;
+    readonly sinks: ReadonlyArray<SinkSyncState>;
+}
+/** The port for a sync worker's durable state. See the module doc for every rule. */
+export interface FeedSyncStore {
+    readonly acquireLease: (id: FeedSinkId) => Effect.Effect<FeedLease, LeaseHeld | FeedUnreadable | FeedWriteFailed, Scope.Scope>;
+    readonly readCursor: (id: FeedSinkId) => Effect.Effect<Option.Option<FeedCursor>, FeedUnreadable>;
+    readonly casCursor: (args: {
+        readonly feed: FeedName;
+        readonly sink: SinkName;
+        readonly holder: LeaseHolder;
+        readonly expected: Option.Option<FeedCursor>;
+        readonly next: FeedCursor;
+        readonly parked: ParkedChange;
+    }) => Effect.Effect<void, CursorSuperseded | FeedWriteFailed>;
+    readonly readParked: (id: FeedSinkId) => Effect.Effect<ReadonlyArray<ParkedRecord>, FeedUnreadable>;
+    readonly retryParked: (args: {
+        readonly feed: FeedName;
+        readonly sink: SinkName;
+        readonly key: FeedKey;
+    }) => Effect.Effect<boolean, FeedWriteFailed>;
+    readonly collectTombstones: (feed: FeedName) => Effect.Effect<number, FeedWriteFailed>;
+    readonly removeSink: (id: FeedSinkId) => Effect.Effect<boolean, LeaseHeld | FeedWriteFailed>;
+    readonly describe: (feed: FeedName) => Effect.Effect<FeedSyncDescription, FeedUnreadable>;
+}
+//# sourceMappingURL=FeedSyncStore.d.ts.map

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

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

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

@@ -0,0 +1,16 @@
+import type { FeedChange } from './FeedSink.js';
+import type { ParkedRecord } from './FeedSyncStore.js';
+import type { FeedKey, FeedSeq } from './identifiers.js';
+/** One change to send, and the `seq` of the row it came from (for its park). */
+export interface Pending<D> {
+    readonly change: FeedChange<D>;
+    readonly seq: FeedSeq;
+}
+/** What a delivered batch came to: the keys the sink took, and the parks. */
+export interface Delivered {
+    readonly sent: ReadonlyArray<FeedKey>;
+    readonly parked: ReadonlyArray<ParkedRecord>;
+}
+/** The reason recorded for a refused key the sink gave no reason for. */
+export declare const UNEXPLAINED_REFUSAL = "refused by the sink, with no reason given";
+//# sourceMappingURL=deliver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deliver.d.ts","sourceRoot":"","sources":["../../src/deliver.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,KAAK,EAAa,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAErD,gFAAgF;AAChF,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;IAC9B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;CACtB;AAED,6EAA6E;AAC7E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IACrC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;CAC7C;AAED,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,8CAA8C,CAAA"}

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

@@ -0,0 +1,131 @@
+/**
+ * The change feed's error vocabulary.
+ *
+ * ## The sink's three answers
+ *
+ * A sink classifies every failure into one of three, and the driver's whole
+ * behaviour on failure follows from which. The names borrow the meaning of
+ * `@kairos-es/automation`'s classification without depending on that package: a
+ * feed is not an automation (ADR-0019), and a dependency for three class names
+ * would make it look like one.
+ *
+ * - `SinkRetryable` — the sink could not take the batch NOW (a rate limit, a 5xx, a
+ *   timeout). The cursor stays where it is and the batch is sent again after a
+ *   back-off, never sooner than `retryAfter` when the sink names one.
+ * - `SinkRejected` — the sink will never take THESE records as they stand (too
+ *   large, invalid). The named keys are parked with the sink's reasons, the rest of
+ *   the batch is sent again without them, and the cursor moves past the whole page.
+ *   A parked record is retried when its row next changes.
+ * - `SinkHalted` — something is wrong that retrying will not mend (bad
+ *   credentials, a missing index). The worker stops, and supervision decides.
+ *
+ * ## The feed's own tables
+ *
+ * `FeedWriteFailed` and `FeedUnreadable` are infrastructure faults on the feed's
+ * own durable state, split by direction: a write that did not land, a read that
+ * could not be made. They are tagged errors rather than defects for the reason the
+ * `ProjectionStore` port gives for its own: the driver's supervision has to tell
+ * "back off and try again" from "give up", and only a value can carry that.
+ *
+ * ## The worker's lease and cursor
+ *
+ * `LeaseHeld`, `LeaseLost` and `CursorSuperseded` are the three ways the
+ * single-worker guarantee shows itself: another worker holds the lease, this
+ * worker's lease went while it ran, or the cursor it expected to advance is not
+ * the one stored (a rival moved it, or the lease changed hands).
+ */
+import { Duration } from 'effect';
+import type { NonEmptyReadonlyArray } from 'effect/Array';
+import type { FeedKey, FeedName, FeedSinkId, SinkName } from './identifiers.js';
+declare const SinkRetryable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SinkRetryable";
+} & Readonly<A>;
+/** The sink cannot take the batch now: keep the cursor and back off. */
+export declare class SinkRetryable extends SinkRetryable_base<{
+    readonly reason: string;
+    /** The least the driver waits before sending again, when the sink knows it. */
+    readonly retryAfter?: Duration.Duration;
+}> {
+    get message(): string;
+}
+declare const SinkRejected_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SinkRejected";
+} & Readonly<A>;
+/** The sink refuses these records as they stand: park them, send the rest. */
+export declare class SinkRejected extends SinkRejected_base<{
+    readonly keys: NonEmptyReadonlyArray<FeedKey>;
+    /** The sink's reason per refused key; a key absent here is parked unexplained. */
+    readonly reasons: ReadonlyMap<FeedKey, string>;
+}> {
+    get message(): string;
+}
+declare const SinkHalted_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SinkHalted";
+} & Readonly<A>;
+/** Something retrying will not mend: stop the worker. */
+export declare class SinkHalted extends SinkHalted_base<{
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+declare const FeedWriteFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FeedWriteFailed";
+} & Readonly<A>;
+/** A write to the feed's own tables did not land. */
+export declare class FeedWriteFailed extends FeedWriteFailed_base<{
+    readonly reason: string;
+    readonly cause?: unknown;
+}> {
+    get message(): string;
+}
+declare const FeedUnreadable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FeedUnreadable";
+} & Readonly<A>;
+/** A read of the feed's own tables could not be made. */
+export declare class FeedUnreadable extends FeedUnreadable_base<{
+    readonly reason: string;
+    readonly cause?: unknown;
+}> {
+    get message(): string;
+}
+declare const LeaseHeld_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LeaseHeld";
+} & Readonly<A>;
+/** Another worker holds the lease for this feed and sink. */
+export declare class LeaseHeld extends LeaseHeld_base<FeedSinkId> {
+    get message(): string;
+}
+declare const LeaseLost_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LeaseLost";
+} & Readonly<A>;
+/** This worker's lease is no longer its own; it must stop sending at once. */
+export declare class LeaseLost extends LeaseLost_base<FeedSinkId> {
+    get message(): string;
+}
+declare const CursorSuperseded_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CursorSuperseded";
+} & Readonly<A>;
+/**
+ * The cursor compare-and-set lost: the stored cursor is not the one expected, or
+ * the lease is not held by the worker that asked. Nothing the call carried landed.
+ */
+export declare class CursorSuperseded extends CursorSuperseded_base<FeedSinkId> {
+    get message(): string;
+}
+declare const FeedSyncStalled_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FeedSyncStalled";
+} & Readonly<A>;
+/**
+ * The sync worker gave up: it restarted `restarts` times in a row without moving
+ * its cursor once. `reason` is the failure that ended the last attempt.
+ */
+export declare class FeedSyncStalled extends FeedSyncStalled_base<{
+    readonly feed: FeedName;
+    readonly sink: SinkName;
+    readonly restarts: number;
+    readonly reason: unknown;
+}> {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAQ,QAAQ,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;;;;AAE5E,wEAAwE;AACxE,qBAAa,aAAc,SAAQ,mBAAkC;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAA;CACxC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAI7B;CACF;;;;AAED,8EAA8E;AAC9E,qBAAa,YAAa,SAAQ,kBAAiC;IACjE,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC,OAAO,CAAC,CAAA;IAC7C,kFAAkF;IAClF,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;CAC/C,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,yDAAyD;AACzD,qBAAa,UAAW,SAAQ,gBAA+B;IAC7D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,qDAAqD;AACrD,qBAAa,eAAgB,SAAQ,qBAAoC;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,yDAAyD;AACzD,qBAAa,cAAe,SAAQ,oBAAmC;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,6DAA6D;AAC7D,qBAAa,SAAU,SAAQ,eAA8B,UAAU,CAAC;IACtE,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,8EAA8E;AAC9E,qBAAa,SAAU,SAAQ,eAA8B,UAAU,CAAC;IACtE,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,sBAEpC,UAAU,CAAC;IACX,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,qBAAoC;IACvE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

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

@@ -0,0 +1,67 @@
+/**
+ * The change feed's branded identifiers.
+ *
+ * Every one of them is a branded `Schema`, as every domain identifier in this
+ * repository is, so a raw string or `bigint` cannot stand in for one by accident.
+ * Two of them are worth a word, because they look like things the read side
+ * already has and are deliberately not those things.
+ *
+ * - `FeedSeq` is NOT a `Position`. A `Position` is a place in the global event log,
+ *   and one event may fan out into many feed rows (a teacher renamed, fifty courses
+ *   touched). Give those fifty rows the event's position as their cursor and they
+ *   all share one value, so a page boundary that falls among them loses the rest of
+ *   them: the next page asks for rows strictly after a value the lost ones also
+ *   carry. A feed-local sequence gives every row a cursor value of its own. The
+ *   event position is still kept on each row, as `eventPosition`, for the one
+ *   question it answers — "is the sink at least as fresh as P?" — and is never a
+ *   cursor.
+ * - `Generation` is NOT a counter a caller reads meaning into. It is compared for
+ *   EQUALITY only: a sink whose cursor was saved at a generation other than the
+ *   feed's current one resyncs. That is what lets the in-memory feed draw a fresh
+ *   generation from `Random` on every boot while a durable feed counts upwards, and
+ *   both satisfy the one rule the driver needs.
+ */
+import { Schema } from 'effect';
+/**
+ * The name of one change feed. A feed is bound to ONE materialisation, because a
+ * feed sequence taken inside a commit is ascending in commit order only while one
+ * transaction at a time writes that feed — which the read side gives per
+ * materialisation and no wider.
+ */
+export declare const FeedName: Schema.brand<Schema.String, "FeedName">;
+export type FeedName = typeof FeedName.Type;
+/** A record's key within a feed, and the sink's object id for that record. */
+export declare const FeedKey: Schema.brand<Schema.String, "FeedKey">;
+export type FeedKey = typeof FeedKey.Type;
+/**
+ * The feed-local cursor: unique, and ascending in commit order. Compared, never
+ * arithmetic'd, and never assumed contiguous — a sequence shared by several feeds
+ * leaves gaps in each, and a coalesced row gives up its old value when it moves.
+ */
+export declare const FeedSeq: Schema.brand<Schema.BigInt, "FeedSeq">;
+export type FeedSeq = typeof FeedSeq.Type;
+/** The sentinel feed sequence meaning "before the first row". */
+export declare const FEED_ORIGIN: FeedSeq;
+/**
+ * The feed's generation: it moves on every reset of the materialisation the feed
+ * is bound to, and on every boot of an ephemeral feed. Compared for equality only;
+ * see the module doc.
+ */
+export declare const Generation: Schema.brand<Schema.BigInt, "Generation">;
+export type Generation = typeof Generation.Type;
+/** The name of one sink. A feed keeps one cursor per sink. */
+export declare const SinkName: Schema.brand<Schema.String, "SinkName">;
+export type SinkName = typeof SinkName.Type;
+/**
+ * Who holds a sync worker's lease. Issued by the `FeedSyncStore` when the lease is
+ * taken, and checked again by every cursor compare-and-set, so a worker that has
+ * lost its lease cannot move the cursor even if it is still running.
+ */
+export declare const LeaseHolder: Schema.brand<Schema.String, "LeaseHolder">;
+export type LeaseHolder = typeof LeaseHolder.Type;
+/** One sync worker's identity: the feed it reads and the sink it writes. */
+export interface FeedSinkId {
+    readonly feed: FeedName;
+    readonly sink: SinkName;
+}
+//# sourceMappingURL=identifiers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../../src/identifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,yCAGpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,8EAA8E;AAC9E,eAAO,MAAM,OAAO,wCAGnB,CAAA;AACD,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC;;;;GAIG;AACH,eAAO,MAAM,OAAO,wCAGnB,CAAA;AACD,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC,iEAAiE;AACjE,eAAO,MAAM,WAAW,EAAE,OAA0B,CAAA;AAEpD;;;;GAIG;AACH,eAAO,MAAM,UAAU,2CAGtB,CAAA;AACD,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAE/C,8DAA8D;AAC9D,eAAO,MAAM,QAAQ,yCAGpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,WAAW,4CAGvB,CAAA;AACD,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD,4EAA4E;AAC5E,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CACxB"}

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

@@ -0,0 +1,32 @@
+import type { CheckpointKey, ProjectionStore } from '@kairos-es/read';
+import { Effect, Schema } from 'effect';
+import type { BatchedFeedWriter, FeedSource } from './Feed.js';
+import { type FeedSyncStore } from './FeedSyncStore.js';
+import { type FeedName } from './identifiers.js';
+/** The in-memory feed; see the module doc. */
+export interface InMemoryFeed<D> extends BatchedFeedWriter<D> {
+    readonly source: FeedSource<D>;
+    readonly syncStore: FeedSyncStore;
+}
+/** Options for {@link makeInMemoryFeed}. */
+export interface InMemoryFeedOptions<D, I> {
+    readonly feed: FeedName;
+    /** The document's schema: what an upsert encodes, and compares, through. */
+    readonly doc: Schema.Codec<D, I>;
+}
+/** Build an in-memory feed at a fresh generation; see the module doc. */
+export declare const makeInMemoryFeed: <D, I>(options: InMemoryFeedOptions<D, I>) => Effect.Effect<InMemoryFeed<D>>;
+/**
+ * `store`, with `resetCheckpoint` for `key` replaced by one that also empties
+ * `feed` and moves its generation on, so every sink resyncs once the read model is
+ * replayed. Every other key passes through untouched, and `readCheckpoint` and
+ * `commit` are the store's own, so the result works through `forKey` exactly as
+ * the store does.
+ *
+ * Binding is checked here, at construction: a feed serves ONE materialisation,
+ * because one writer is what keeps its sequence ascending in commit order, so a
+ * feed already bound to another checkpoint key is refused, as is a durable `store`
+ * (see the module doc). Both refusals are defects.
+ */
+export declare const withInMemoryFeed: <D>(store: ProjectionStore, feed: InMemoryFeed<D>, key: CheckpointKey) => Effect.Effect<ProjectionStore>;
+//# sourceMappingURL=inMemoryFeed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inMemoryFeed.d.ts","sourceRoot":"","sources":["../../src/inMemoryFeed.ts"],"names":[],"mappings":"AA8CA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACrE,OAAO,EAEL,MAAM,EAKN,MAAM,EAEP,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,EAAE,iBAAiB,EAAW,UAAU,EAAc,MAAM,QAAQ,CAAA;AAChF,OAAO,EAIL,KAAK,aAAa,EAKnB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAGL,KAAK,QAAQ,EAMd,MAAM,eAAe,CAAA;AAEtB,8CAA8C;AAC9C,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,iBAAiB,CAAC,CAAC,CAAC;IAC3D,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;CAClC;AAsDD,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB,CAAC,CAAC,EAAE,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CACjC;AAED,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,EACnC,SAAS,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,KACjC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CA0W5B,CAAA;AAwBJ;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAChC,OAAO,eAAe,EACtB,MAAM,YAAY,CAAC,CAAC,CAAC,EACrB,KAAK,aAAa,KACjB,MAAM,CAAC,MAAM,CAAC,eAAe,CA+B5B,CAAA"}

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

@@ -0,0 +1,61 @@
+/**
+ * The in-memory sink: a `FeedSink` over a `Ref` of documents, with an optional
+ * `FeedResync` and `FeedReconcile`, and the ORACLE the sink law suite holds every
+ * other sink against.
+ *
+ * It keeps the laws by construction: an upsert replaces the whole document, a
+ * delete of an absent key is a no-op, so the same batch applied twice leaves it as
+ * once; a batch is visible the moment `apply` returns, so `confirm` has nothing to
+ * wait for; a resync target is a separate map that `publish` swaps in whole, so a
+ * published resync holds exactly what was loaded into it, and a load into a target
+ * a later `begin` dropped fails rather than recreating it. Each `begin` names its
+ * target by a counter the sink's own state holds, so two workers sharing one sink
+ * value — the way two processes share one real index — never share a target, and
+ * the name is the same on every run of a test.
+ *
+ * Its two optional parts are switched on by option rather than always present,
+ * because which parts a sink has CHANGES what the driver does — a sink with no
+ * `resync` is resynced in place — and a test of either path needs a sink that
+ * lacks the other. It also records every batch it is handed, live or into a
+ * target, so a case can say how many sends a change cost.
+ *
+ * It lives for as long as the value is held, independently of any feed, which is
+ * what lets a test keep one sink across two in-memory feeds and watch the second
+ * feed's fresh generation force a resync.
+ */
+import { Effect } from 'effect';
+import type { NonEmptyReadonlyArray } from 'effect/Array';
+import type { FeedChange, FeedSink } from './FeedSink.js';
+import type { FeedKey, Generation, SinkName } from './identifiers.js';
+/** What the in-memory sink's `apply` and `load` return: where, and which batch. */
+export interface InMemoryReceipt {
+    /** `'live'`, or the name of the resync target the batch was loaded into. */
+    readonly target: string;
+    readonly batch: number;
+}
+/** One batch the sink was handed, and where it went. */
+export interface InMemorySentBatch<D> {
+    readonly target: string;
+    readonly changes: NonEmptyReadonlyArray<FeedChange<D>>;
+}
+/** Options for {@link makeInMemorySink}. */
+export interface InMemorySinkOptions {
+    readonly name: SinkName;
+    /** Give the sink a `FeedResync` (an atomic swap). */
+    readonly resync?: boolean;
+    /** Give the sink a `FeedReconcile` (a key listing). */
+    readonly reconcile?: boolean;
+}
+/** The in-memory sink and what a test reads back from it. */
+export interface InMemorySink<D> {
+    readonly sink: FeedSink<D, InMemoryReceipt>;
+    /** The live documents, by key. */
+    readonly documents: Effect.Effect<ReadonlyMap<FeedKey, D>>;
+    /** Every batch handed to `apply` or `load`, in order. */
+    readonly batches: Effect.Effect<ReadonlyArray<InMemorySentBatch<D>>>;
+    /** The generation of every resync published, in order. */
+    readonly published: Effect.Effect<ReadonlyArray<Generation>>;
+}
+/** Build an in-memory sink; see the module doc. */
+export declare const makeInMemorySink: <D>(options: InMemorySinkOptions) => Effect.Effect<InMemorySink<D>>;
+//# sourceMappingURL=inMemorySink.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inMemorySink.d.ts","sourceRoot":"","sources":["../../src/inMemorySink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,MAAM,EAAe,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAc,QAAQ,EAAgB,MAAM,YAAY,CAAA;AAChF,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAElE,mFAAmF;AACnF,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED,wDAAwD;AACxD,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;CACvD;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,qDAAqD;IACrD,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,uDAAuD;IACvD,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAC7B;AAED,6DAA6D;AAC7D,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,eAAe,CAAC,CAAA;IAC3C,kCAAkC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAA;IAC1D,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACpE,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAA;CAC7D;AAsCD,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAChC,SAAS,mBAAmB,KAC3B,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CA+G5B,CAAA"}