@kairos-es/feed 0.0.0-stage → 0.0.0

package/dist/dts-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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"}

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

@@ -0,0 +1,63 @@
+/**
+ * @kairos-es/feed — a state-only change feed: the newest state of each record a
+ * read model touches, written inside that read model's own commit, and copied by
+ * a sync worker to a sink that has no transaction of its own — a search index, a
+ * cache, a mirror (ADR-0019).
+ *
+ * The feed copies STATE. It never tells anyone each thing that happened; that is
+ * `@kairos-es/automation`'s job, and the two are deliberately different shapes: an
+ * automation's only progress record is the log, while a feed keeps a cursor, a
+ * lease and a parked list beside its rows, because what it mirrors is state and
+ * its progress is legitimately a cursor.
+ *
+ * What is here, and where each part's argument lives:
+ *
+ * - The identifiers (`identifiers.ts`) and the error vocabulary (`errors.ts`).
+ * - The feed's write and read sides, `BatchedFeedWriter` / `FeedWriter` and
+ *   `FeedSource` (`Feed.ts`): why the feed is written inside the commit, and what
+ *   "coalesced, latest wins" means for a stored row.
+ * - The sink port, `FeedSink` with its optional `FeedResync` and `FeedReconcile`
+ *   (`FeedSink.ts`): what a sink must keep, and why a sink with neither optional
+ *   part is refused.
+ * - The sync store port, `FeedSyncStore` (`FeedSyncStore.ts`): the cursor, the
+ *   parked list and the worker lease, and the exact contract a backend implements.
+ * - The driver, `runFeedSync` (`runFeedSync.ts`): the lifecycle, the rules it
+ *   keeps, resync, and its own supervision.
+ * - `FeedReadiness` and `materialisationCaughtUp` (`readiness.ts`): why a
+ *   rebuild's publish can wait for the materialisation, and what it waits on.
+ * - `reconcileFeed` (`reconcile.ts`), and `inspectFeed` / `retryParked` /
+ *   `removeSink` (`inspect.ts`).
+ * - The in-memory feed (`inMemoryFeed.ts`) and sink (`inMemorySink.ts`): the parity
+ *   oracles, and what the in-memory feed refuses.
+ *
+ * Wiring, end to end, in memory:
+ *
+ * ```ts
+ * const feed = yield* makeInMemoryFeed({ feed: FeedName.make('course-search'), doc: CourseDoc })
+ * const store = yield* withInMemoryFeed(yield* makeInMemoryProjectionStore, feed, key)
+ *
+ * // In the read model's `apply`, as the LAST step of the batch:
+ * const apply = (batch) =>
+ *   feed.write(Arr.lastNonEmpty(batch).sequenced.position, (writer) =>
+ *     Effect.forEach(touchedCourses(batch), (course) =>
+ *       writer.upsert(FeedKey.make(course.id), toDoc(course)),
+ *     ),
+ *   )
+ *
+ * // Beside the projections, in a fibre of its own:
+ * const { sink } = yield* makeInMemorySink<CourseDoc>({ name: SinkName.make('search'), resync: true })
+ * yield* Effect.forkScoped(runFeedSync({ source: feed.source, sink, store: feed.syncStore }))
+ * ```
+ */
+export { CursorSuperseded, FeedSyncStalled, FeedUnreadable, FeedWriteFailed, LeaseHeld, LeaseLost, SinkHalted, SinkRejected, SinkRetryable, } from './errors.js';
+export type { BatchedFeedWriter, FeedRow, FeedSource, FeedWriter, } from './Feed.js';
+export { changeOf, FeedChange, type FeedChangeDefinition, type FeedReconcile, type FeedResync, type FeedSink, type ResyncTarget, } from './FeedSink.js';
+export { type FeedCursor, type FeedLease, type FeedSyncDescription, type FeedSyncStore, type LeaseDescription, type ParkedChange, type ParkedRecord, type SinkSyncState, sameCursor, } from './FeedSyncStore.js';
+export { FEED_ORIGIN, FeedKey, FeedName, FeedSeq, type FeedSinkId, Generation, LeaseHolder, SinkName, } from './identifiers.js';
+export { type InMemoryFeed, type InMemoryFeedOptions, makeInMemoryFeed, withInMemoryFeed, } from './inMemoryFeed.js';
+export { type InMemoryReceipt, type InMemorySentBatch, type InMemorySink, type InMemorySinkOptions, makeInMemorySink, } from './inMemorySink.js';
+export { type FeedInspection, inspectFeed, removeSink, retryParked, type SinkInspection, } from './inspect.js';
+export { type CaughtUpReadModel, type FeedReadiness, type FeedReadinessProbe, materialisationCaughtUp, } from './readiness.js';
+export { type ReconcileFeedOptions, type ReconcileReport, reconcileFeed, } from './reconcile.js';
+export { type FeedSyncRestart, type FeedSyncTuning, type RunFeedSyncOptions, runFeedSync, } from './runFeedSync.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,eAAe,EACf,SAAS,EACT,SAAS,EACT,UAAU,EACV,YAAY,EACZ,aAAa,GACd,MAAM,UAAU,CAAA;AACjB,YAAY,EACV,iBAAiB,EACjB,OAAO,EACP,UAAU,EACV,UAAU,GACX,MAAM,QAAQ,CAAA;AACf,OAAO,EACL,QAAQ,EACR,UAAU,EACV,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,YAAY,GAClB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,UAAU,GACX,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,WAAW,EACX,OAAO,EACP,QAAQ,EACR,OAAO,EACP,KAAK,UAAU,EACf,UAAU,EACV,WAAW,EACX,QAAQ,GACT,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,KAAK,cAAc,EACnB,WAAW,EACX,UAAU,EACV,WAAW,EACX,KAAK,cAAc,GACpB,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,uBAAuB,GACxB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,aAAa,GACd,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,WAAW,GACZ,MAAM,eAAe,CAAA"}

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

@@ -0,0 +1,71 @@
+/**
+ * `inspectFeed`, `retryParked` and `removeSink`: an operator's view of a feed's
+ * sinks, and the two repairs an operator makes by hand.
+ *
+ * None of them needs the sink's client, because everything they read or change
+ * lives in the source database beside the feed: an operator can see a sink's lag,
+ * its lease, its parked records and when it last advanced, send a parked record
+ * again, and retire a sink, without the credentials of the index concerned. The
+ * same choice `@kairos-es/automation` made for its own `inspect`. There is no CLI
+ * or UI over any of them; they are effects an application wires into whatever it
+ * already has.
+ *
+ * `lastAdvance` and `removeSink` are a pair. Every sink registered on a feed holds
+ * its tombstone collection back, so a sink the application stopped running and
+ * never removed lets tombstones pile up for good; `lastAdvance` is how such a sink
+ * shows — still, while the head moves — and `removeSink` is what lets collection
+ * proceed without it. `FeedSyncStore.ts` owns both rules.
+ */
+import { type DateTime, Effect, Option } from 'effect';
+import type { FeedUnreadable, FeedWriteFailed, LeaseHeld } from './errors.js';
+import type { FeedSource } from './Feed.js';
+import type { FeedCursor, FeedSyncStore, LeaseDescription, ParkedRecord } from './FeedSyncStore.js';
+import type { FeedKey, FeedName, FeedSeq, Generation, SinkName } from './identifiers.js';
+/** One sink of a feed, as `inspectFeed` reports it. */
+export interface SinkInspection {
+    readonly sink: SinkName;
+    /** The generation the sink's cursor was saved at; `None` before its first sync. */
+    readonly generation: Option.Option<Generation>;
+    readonly cursor: Option.Option<FeedCursor>;
+    /** When the cursor last moved; `None` if it never has. See `SinkSyncState.lastAdvance`. */
+    readonly lastAdvance: Option.Option<DateTime.Utc>;
+    /** True when the next pass will resync: no cursor, or one at another generation. */
+    readonly resyncDue: boolean;
+    /** Rows the sink has still to receive; see `SinkSyncState.pending`. */
+    readonly lag: number;
+    readonly lease: Option.Option<LeaseDescription>;
+    readonly parked: ReadonlyArray<ParkedRecord>;
+}
+/** A feed and its sinks. */
+export interface FeedInspection {
+    readonly feed: FeedName;
+    readonly generation: Generation;
+    /** The highest `seq` the feed holds. */
+    readonly head: FeedSeq;
+    readonly sinks: ReadonlyArray<SinkInspection>;
+}
+/** Every sink of `source`'s feed: its cursor, lag, lease and parked records. */
+export declare const inspectFeed: <D>(source: FeedSource<D>, store: FeedSyncStore) => Effect.Effect<FeedInspection, FeedUnreadable>;
+/**
+ * Send one parked record again: delete its park and re-stamp its row's `seq`, so
+ * the next pass of every sink on the feed sends it. Succeeds with whether the key
+ * was parked at all. Every sink on the feed receives the record again, not only
+ * `sink`; an idempotent sink absorbs that.
+ */
+export declare const retryParked: (store: FeedSyncStore, args: {
+    readonly feed: FeedName;
+    readonly sink: SinkName;
+    readonly key: FeedKey;
+}) => Effect.Effect<boolean, FeedWriteFailed>;
+/**
+ * Retire `sink` from `feed`: delete its cursor, its lease record and its parked
+ * records, so it no longer holds the feed's tombstone collection back. Succeeds
+ * with whether the store held anything for it. Fails `LeaseHeld`, removing
+ * nothing, while a worker for the sink is running: stop the worker first. A worker
+ * started for the sink later registers it again from scratch, and resyncs.
+ */
+export declare const removeSink: (store: FeedSyncStore, args: {
+    readonly feed: FeedName;
+    readonly sink: SinkName;
+}) => Effect.Effect<boolean, LeaseHeld | FeedWriteFailed>;
+//# sourceMappingURL=inspect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/inspect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,YAAY,EACb,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EACV,OAAO,EACP,QAAQ,EACR,OAAO,EACP,UAAU,EACV,QAAQ,EACT,MAAM,eAAe,CAAA;AAEtB,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;IAC9C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;IAC1C,2FAA2F;IAC3F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAA;IACjD,oFAAoF;IACpF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAA;IAC/C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;CAC7C;AAED,4BAA4B;AAC5B,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,cAAc,CAAC,CAAA;CAC9C;AAED,gFAAgF;AAChF,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,QAAQ,UAAU,CAAC,CAAC,CAAC,EACrB,OAAO,aAAa,KACnB,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,cAAc,CAsB3C,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,aAAa,EACpB,MAAM;IACJ,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;CACtB,KACA,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,CAA4B,CAAA;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,aAAa,EACpB,MAAM;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,KACzD,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,eAAe,CAA2B,CAAA"}

package/dist/dts-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -0,0 +1,84 @@
+/**
+ * `FeedReadiness` — when a rebuilt copy may go live — and
+ * `materialisationCaughtUp`, the readiness of the common case.
+ *
+ * ## Why a rebuild has anything to wait for
+ *
+ * A reset empties the feed and moves its generation on, and the materialisation
+ * then replays the log, writing the feed afresh as it goes. The sync worker sees
+ * the new generation within a poll interval and starts its resync at once, but the
+ * feed it pages through is only as complete as the replay is far along. Reaching
+ * the feed's last row says nothing about the replay: it is wherever the replay had
+ * got to. So a resync that publishes at the feed's end swaps a complete live copy
+ * for whatever fraction of the rebuild the replay had written, and search serves
+ * that partial copy until the tail fills the rest in.
+ *
+ * Only the materialisation knows how far its replay has got, and the feed's ports
+ * deliberately name no materialisation, so the driver is TOLD, through an optional
+ * readiness signal on `runFeedSync`, and holds the step that makes the rebuild
+ * final until the signal says yes. With no signal the resync publishes at the
+ * feed's end, as it always did, and a rebuild can serve a partial copy for as long
+ * as the replay takes.
+ *
+ * ## Why it is a function returning an effect
+ *
+ * "Caught up" has to be relative to a fixed point: the log as it stood when the
+ * rebuild began. Judged against the log as it stands at each ask, a read model
+ * under steady writes is always a batch or two behind, and the publish would wait
+ * for a quiet moment that may never come. So the signal is asked ONCE per resync
+ * attempt, as the attempt starts, for the generation that attempt rebuilds, and
+ * returns the PROBE the worker then polls — by which time whatever point the probe
+ * judges by is fixed. An attempt starts after the reset that moved the generation,
+ * so a point taken then is at or after the log as it stood at the reset: the error
+ * is towards waiting slightly longer, never towards publishing early.
+ *
+ * Both halves fail `FeedUnreadable`, the feed's own "a read could not be made":
+ * the worker cannot tell a probe that could not read the materialisation's
+ * progress from a feed it could not read, and needs to do the same thing about
+ * either — end the session and try again after a back-off.
+ */
+import { type AnyProjection, DcbEventStore } from '@kairos-es/core';
+import type { KeyedProjectionStore } from '@kairos-es/read';
+import { Effect } from 'effect';
+import { FeedUnreadable } from './errors.js';
+import type { Generation } from './identifiers.js';
+/**
+ * Polled by the worker, between pages, until it answers `true`: the rebuild this
+ * probe was made for may now go live. See the module doc.
+ */
+export type FeedReadinessProbe = Effect.Effect<boolean, FeedUnreadable>;
+/**
+ * Asked once per resync attempt, as it starts, for the generation it rebuilds,
+ * and answering with the {@link FeedReadinessProbe} that attempt polls. See the
+ * module doc for why it is two steps.
+ */
+export type FeedReadiness = (generation: Generation) => Effect.Effect<FeedReadinessProbe, FeedUnreadable>;
+/**
+ * What {@link materialisationCaughtUp} needs of a read model: its bound view store
+ * and its slices. Structural, so any `ReadModel` from `@kairos-es/read` is one.
+ */
+export interface CaughtUpReadModel {
+    readonly store: KeyedProjectionStore;
+    readonly slices: Readonly<Record<string, AnyProjection>>;
+}
+/**
+ * The readiness of the common case: the materialisation's checkpoint has reached
+ * the last event its query selects, as the log stood when the resync attempt
+ * started. Pass the very read model whose `apply` writes the feed, so its query
+ * and its checkpoint are the ones the replay moves.
+ *
+ * The point is the last event the read model's QUERY selects, and not the log's
+ * head, because the runner advances its checkpoint to the positions it is
+ * delivered and is never delivered an event its query does not select: a
+ * checkpoint judged against a head an unrelated event moved would never arrive.
+ * The store hands no cheaper way to that position than reading up to it, so each
+ * attempt starts with one paged read of the query's events past the checkpoint —
+ * the backlog the replay itself is about to read, a page at a time and never held
+ * whole — and each probe after it is one checkpoint read.
+ *
+ * Generation-blind, deliberately: the read model has one checkpoint whatever the
+ * feed's generation, and an attempt whose generation moves on while it waits is
+ * abandoned by the worker's own generation check, so the probe never has to know.
+ */
+export declare const materialisationCaughtUp: (readModel: CaughtUpReadModel) => Effect.Effect<FeedReadiness, never, DcbEventStore>;
+//# sourceMappingURL=readiness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../../src/readiness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EACL,KAAK,aAAa,EAElB,aAAa,EAId,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAC3D,OAAO,EAAgB,MAAM,EAAkB,MAAM,QAAQ,CAAA;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE/C;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,CAAC,CAAA;AAEvE;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAC1B,UAAU,EAAE,UAAU,KACnB,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,cAAc,CAAC,CAAA;AAEtD;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAA;IACpC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAA;CACzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB,GAClC,WAAW,iBAAiB,KAC3B,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,KAAK,EAAE,aAAa,CAuChD,CAAA"}