@kairos-es/feed 0.0.0-stage → 0.0.0

package/dist/cjs/tuning.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readLimit = exports.positiveDuration = exports.HELD_WAIT_WARN_POLLS = exports.DEFAULT_FEED_RESTART_MIN_DELAY = exports.DEFAULT_FEED_RESTART_MAX_DELAY = exports.DEFAULT_FEED_POLL_INTERVAL = exports.DEFAULT_FEED_PAGE_SIZE = exports.DEFAULT_FEED_MAX_NO_PROGRESS_RESTARTS = void 0;
+var _core = require("@kairos-es/core");
+var _effect = require("effect");
+/**
+ * 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`.
+ */
+
+/** Rows read, and changes sent, per page. */
+const DEFAULT_FEED_PAGE_SIZE = exports.DEFAULT_FEED_PAGE_SIZE = _core.DEFAULT_CATCH_UP_PAGE_SIZE;
+/** The upper bound on an idle worker's sleep: the poll that is the guarantee. */
+const DEFAULT_FEED_POLL_INTERVAL = exports.DEFAULT_FEED_POLL_INTERVAL = /*#__PURE__*/_effect.Duration.seconds(1);
+/** The first restart back-off. */
+const DEFAULT_FEED_RESTART_MIN_DELAY = exports.DEFAULT_FEED_RESTART_MIN_DELAY = /*#__PURE__*/_effect.Duration.millis(100);
+/** The restart back-off's cap, before jitter. */
+const DEFAULT_FEED_RESTART_MAX_DELAY = exports.DEFAULT_FEED_RESTART_MAX_DELAY = /*#__PURE__*/_effect.Duration.seconds(30);
+/** Consecutive restarts without a cursor advance before the worker gives up. */
+const DEFAULT_FEED_MAX_NO_PROGRESS_RESTARTS = exports.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.
+ */
+const HELD_WAIT_WARN_POLLS = exports.HELD_WAIT_WARN_POLLS = 60;
+/** The page size as a `ReadLimit`, refusing one that is not a positive integer. */
+const readLimit = pageSize => {
+  if (!Number.isInteger(pageSize) || pageSize <= 0) {
+    throw new Error(`feed: pageSize must be a positive integer (got ${pageSize})`);
+  }
+  return _core.ReadLimit.make(pageSize);
+};
+/** A duration input decoded, refusing one that is not positive and finite. */
+exports.readLimit = readLimit;
+const positiveDuration = (label, input) => {
+  const decoded = _effect.Duration.fromInputUnsafe(input);
+  if (!_effect.Duration.isFinite(decoded) || _effect.Duration.toMillis(decoded) <= 0) {
+    throw new Error(`feed: ${label} must be a positive, finite duration`);
+  }
+  return decoded;
+};
+exports.positiveDuration = positiveDuration;
+//# sourceMappingURL=tuning.js.map

package/dist/cjs/tuning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuning.js","names":["_core","require","_effect","DEFAULT_FEED_PAGE_SIZE","exports","DEFAULT_CATCH_UP_PAGE_SIZE","DEFAULT_FEED_POLL_INTERVAL","Duration","seconds","DEFAULT_FEED_RESTART_MIN_DELAY","millis","DEFAULT_FEED_RESTART_MAX_DELAY","DEFAULT_FEED_MAX_NO_PROGRESS_RESTARTS","HELD_WAIT_WARN_POLLS","readLimit","pageSize","Number","isInteger","Error","ReadLimit","make","positiveDuration","label","input","decoded","fromInputUnsafe","isFinite","toMillis"],"sources":["../../src/tuning.ts"],"sourcesContent":[null],"mappings":";;;;;;AAcA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAfA;;;;;;;;;;;;;;;AAiBA;AACO,MAAME,sBAAsB,GAAAC,OAAA,CAAAD,sBAAA,GAAWE,gCAA0B;AAExE;AACO,MAAMC,0BAA0B,GAAAF,OAAA,CAAAE,0BAAA,gBAAsBC,gBAAQ,CAACC,OAAO,CAAC,CAAC,CAAC;AAEhF;AACO,MAAMC,8BAA8B,GAAAL,OAAA,CAAAK,8BAAA,gBACzCF,gBAAQ,CAACG,MAAM,CAAC,GAAG,CAAC;AAEtB;AACO,MAAMC,8BAA8B,GAAAP,OAAA,CAAAO,8BAAA,gBACzCJ,gBAAQ,CAACC,OAAO,CAAC,EAAE,CAAC;AAEtB;AACO,MAAMI,qCAAqC,GAAAR,OAAA,CAAAQ,qCAAA,GAAG,EAAE;AAEvD;;;;;;;;AAQO,MAAMC,oBAAoB,GAAAT,OAAA,CAAAS,oBAAA,GAAG,EAAE;AAEtC;AACO,MAAMC,SAAS,GAAIC,QAAgB,IAAe;EACvD,IAAI,CAACC,MAAM,CAACC,SAAS,CAACF,QAAQ,CAAC,IAAIA,QAAQ,IAAI,CAAC,EAAE;IAChD,MAAM,IAAIG,KAAK,CACb,kDAAkDH,QAAQ,GAAG,CAC9D;EACH;EACA,OAAOI,eAAS,CAACC,IAAI,CAACL,QAAQ,CAAC;AACjC,CAAC;AAED;AAAAX,OAAA,CAAAU,SAAA,GAAAA,SAAA;AACO,MAAMO,gBAAgB,GAAGA,CAC9BC,KAAa,EACbC,KAAqB,KACA;EACrB,MAAMC,OAAO,GAAGjB,gBAAQ,CAACkB,eAAe,CAACF,KAAK,CAAC;EAC/C,IAAI,CAAChB,gBAAQ,CAACmB,QAAQ,CAACF,OAAO,CAAC,IAAIjB,gBAAQ,CAACoB,QAAQ,CAACH,OAAO,CAAC,IAAI,CAAC,EAAE;IAClE,MAAM,IAAIN,KAAK,CAAC,SAASI,KAAK,sCAAsC,CAAC;EACvE;EACA,OAAOE,OAAO;AAChB,CAAC;AAAApB,OAAA,CAAAiB,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/dist/dts-cjs/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-cjs/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-cjs/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-cjs/FeedSink.d.ts.map

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

package/dist/dts-cjs/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-cjs/FeedSyncStore.d.ts.map

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