@kairos-es/feed 0.0.0-stage → 0.0.0

package/dist/esm/inMemorySink.js

@@ -0,0 +1,134 @@
+/**
+ * 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, Ref, Stream } from 'effect';
+import { SinkRetryable } from "./errors.js";
+const LIVE = 'live';
+const applyTo = (documents, changes) => {
+  const next = new Map(documents);
+  for (const change of changes) {
+    if (change._tag === 'Upsert') {
+      next.set(change.key, change.doc);
+    } else {
+      next.delete(change.key);
+    }
+  }
+  return next;
+};
+/** What a load into, or a publish of, a target a later `begin` dropped fails with. */
+const droppedTarget = name => new SinkRetryable({
+  reason: `the resync target '${name}' was dropped by a later begin`
+});
+/** The resync target's name for one attempt at `generation`; see the module doc. */
+const targetName = (generation, attempt) => `${LIVE}__g${generation}_${attempt}`;
+/** Build an in-memory sink; see the module doc. */
+export const makeInMemorySink = options => Effect.gen(function* () {
+  const state = yield* Ref.make({
+    live: new Map(),
+    targets: new Map(),
+    batches: [],
+    published: [],
+    attempts: 0
+  });
+  const record = (target, changes) => Effect.flatten(Ref.modify(state, s => {
+    const batches = [...s.batches, {
+      target,
+      changes
+    }];
+    const receipt = {
+      target,
+      batch: batches.length
+    };
+    if (target === LIVE) {
+      return [Effect.succeed(receipt), {
+        ...s,
+        batches,
+        live: applyTo(s.live, changes)
+      }];
+    }
+    const built = s.targets.get(target);
+    // Dropped by a later begin: recreating it here is what would let a
+    // stale worker's publish swap a fragment in. `FeedResync.load` says so.
+    if (built === undefined) {
+      return [Effect.fail(droppedTarget(target)), s];
+    }
+    return [Effect.succeed(receipt), {
+      ...s,
+      batches,
+      targets: new Map(s.targets).set(target, applyTo(built, changes))
+    }];
+  }));
+  const resync = {
+    // Every other target is dropped: whatever attempt left it, it will never be
+    // published now, and its own publish must fail rather than swap it in.
+    begin: generation => Ref.modify(state, s => {
+      const attempts = s.attempts + 1;
+      const name = targetName(generation, attempts);
+      return [{
+        generation,
+        name
+      }, {
+        ...s,
+        attempts,
+        targets: new Map([[name, new Map()]])
+      }];
+    }),
+    load: (target, batch) => record(target.name, batch),
+    publish: target => Effect.flatten(Ref.modify(state, s => {
+      const built = s.targets.get(target.name);
+      if (built === undefined) {
+        return [Effect.fail(droppedTarget(target.name)), s];
+      }
+      const targets = new Map(s.targets);
+      targets.delete(target.name);
+      return [Effect.void, {
+        ...s,
+        live: built,
+        targets,
+        published: [...s.published, target.generation]
+      }];
+    }))
+  };
+  const sink = {
+    name: options.name,
+    apply: batch => record(LIVE, batch),
+    confirm: () => Effect.void,
+    ...(options.resync === true ? {
+      resync
+    } : {}),
+    ...(options.reconcile === true ? {
+      reconcile: {
+        listKeys: Stream.unwrap(Effect.map(Ref.get(state), s => Stream.fromIterable(Array.from(s.live.keys()))))
+      }
+    } : {})
+  };
+  return {
+    sink,
+    documents: Effect.map(Ref.get(state), s => s.live),
+    batches: Effect.map(Ref.get(state), s => s.batches),
+    published: Effect.map(Ref.get(state), s => s.published)
+  };
+});
+//# sourceMappingURL=inMemorySink.js.map

package/dist/esm/inMemorySink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemorySink.js","names":["Effect","Ref","Stream","SinkRetryable","LIVE","applyTo","documents","changes","next","Map","change","_tag","set","key","doc","delete","droppedTarget","name","reason","targetName","generation","attempt","makeInMemorySink","options","gen","state","make","live","targets","batches","published","attempts","record","target","flatten","modify","s","receipt","batch","length","succeed","built","get","undefined","fail","resync","begin","load","publish","void","sink","apply","confirm","reconcile","listKeys","unwrap","map","fromIterable","Array","from","keys"],"sources":["../../src/inMemorySink.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/index.js

@@ -0,0 +1,62 @@
+/**
+ * @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 { changeOf, FeedChange } from "./FeedSink.js";
+export { sameCursor } from "./FeedSyncStore.js";
+export { FEED_ORIGIN, FeedKey, FeedName, FeedSeq, Generation, LeaseHolder, SinkName } from "./identifiers.js";
+export { makeInMemoryFeed, withInMemoryFeed } from "./inMemoryFeed.js";
+export { makeInMemorySink } from "./inMemorySink.js";
+export { inspectFeed, removeSink, retryParked } from "./inspect.js";
+export { materialisationCaughtUp } from "./readiness.js";
+export { reconcileFeed } from "./reconcile.js";
+export { runFeedSync } from "./runFeedSync.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["CursorSuperseded","FeedSyncStalled","FeedUnreadable","FeedWriteFailed","LeaseHeld","LeaseLost","SinkHalted","SinkRejected","SinkRetryable","changeOf","FeedChange","sameCursor","FEED_ORIGIN","FeedKey","FeedName","FeedSeq","Generation","LeaseHolder","SinkName","makeInMemoryFeed","withInMemoryFeed","makeInMemorySink","inspectFeed","removeSink","retryParked","materialisationCaughtUp","reconcileFeed","runFeedSync"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,SACEA,gBAAgB,EAChBC,eAAe,EACfC,cAAc,EACdC,eAAe,EACfC,SAAS,EACTC,SAAS,EACTC,UAAU,EACVC,YAAY,EACZC,aAAa,QACR,aAAU;AAOjB,SACEC,QAAQ,EACRC,UAAU,QAML,eAAY;AACnB,SASEC,UAAU,QACL,oBAAiB;AACxB,SACEC,WAAW,EACXC,OAAO,EACPC,QAAQ,EACRC,OAAO,EAEPC,UAAU,EACVC,WAAW,EACXC,QAAQ,QACH,kBAAe;AACtB,SAGEC,gBAAgB,EAChBC,gBAAgB,QACX,mBAAgB;AACvB,SAKEC,gBAAgB,QACX,mBAAgB;AACvB,SAEEC,WAAW,EACXC,UAAU,EACVC,WAAW,QAEN,cAAW;AAClB,SAIEC,uBAAuB,QAClB,gBAAa;AACpB,SAGEC,aAAa,QACR,gBAAa;AACpB,SAIEC,WAAW,QACN,kBAAe","ignoreList":[]}

package/dist/esm/inspect.js

@@ -0,0 +1,58 @@
+/**
+ * `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 { Effect, Option } from 'effect';
+/** Every sink of `source`'s feed: its cursor, lag, lease and parked records. */
+export const inspectFeed = (source, store) => Effect.gen(function* () {
+  const generation = yield* source.generation;
+  const description = yield* store.describe(source.feed);
+  return {
+    feed: source.feed,
+    generation,
+    head: description.head,
+    sinks: description.sinks.map(state => ({
+      sink: state.sink,
+      generation: Option.map(state.cursor, c => c.generation),
+      cursor: state.cursor,
+      lastAdvance: state.lastAdvance,
+      resyncDue: Option.match(state.cursor, {
+        onNone: () => true,
+        onSome: c => c.generation !== generation
+      }),
+      lag: state.pending,
+      lease: state.lease,
+      parked: state.parked
+    }))
+  };
+});
+/**
+ * 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 const retryParked = (store, args) => store.retryParked(args);
+/**
+ * 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 const removeSink = (store, args) => store.removeSink(args);
+//# sourceMappingURL=inspect.js.map

package/dist/esm/inspect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.js","names":["Effect","Option","inspectFeed","source","store","gen","generation","description","describe","feed","head","sinks","map","state","sink","cursor","c","lastAdvance","resyncDue","match","onNone","onSome","lag","pending","lease","parked","retryParked","args","removeSink"],"sources":["../../src/inspect.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;AAkBA,SAAwBA,MAAM,EAAEC,MAAM,QAAQ,QAAQ;AA0CtD;AACA,OAAO,MAAMC,WAAW,GAAGA,CACzBC,MAAqB,EACrBC,KAAoB,KAEpBJ,MAAM,CAACK,GAAG,CAAC,aAAS;EAClB,MAAMC,UAAU,GAAG,OAAOH,MAAM,CAACG,UAAU;EAC3C,MAAMC,WAAW,GAAG,OAAOH,KAAK,CAACI,QAAQ,CAACL,MAAM,CAACM,IAAI,CAAC;EACtD,OAAO;IACLA,IAAI,EAAEN,MAAM,CAACM,IAAI;IACjBH,UAAU;IACVI,IAAI,EAAEH,WAAW,CAACG,IAAI;IACtBC,KAAK,EAAEJ,WAAW,CAACI,KAAK,CAACC,GAAG,CAAEC,KAAK,KAAM;MACvCC,IAAI,EAAED,KAAK,CAACC,IAAI;MAChBR,UAAU,EAAEL,MAAM,CAACW,GAAG,CAACC,KAAK,CAACE,MAAM,EAAGC,CAAC,IAAKA,CAAC,CAACV,UAAU,CAAC;MACzDS,MAAM,EAAEF,KAAK,CAACE,MAAM;MACpBE,WAAW,EAAEJ,KAAK,CAACI,WAAW;MAC9BC,SAAS,EAAEjB,MAAM,CAACkB,KAAK,CAACN,KAAK,CAACE,MAAM,EAAE;QACpCK,MAAM,EAAEA,CAAA,KAAM,IAAI;QAClBC,MAAM,EAAGL,CAAC,IAAKA,CAAC,CAACV,UAAU,KAAKA;OACjC,CAAC;MACFgB,GAAG,EAAET,KAAK,CAACU,OAAO;MAClBC,KAAK,EAAEX,KAAK,CAACW,KAAK;MAClBC,MAAM,EAAEZ,KAAK,CAACY;KACf,CAAC;GACH;AACH,CAAC,CAAC;AAEJ;;;;;;AAMA,OAAO,MAAMC,WAAW,GAAGA,CACzBtB,KAAoB,EACpBuB,IAIC,KAC2CvB,KAAK,CAACsB,WAAW,CAACC,IAAI,CAAC;AAErE;;;;;;;AAOA,OAAO,MAAMC,UAAU,GAAGA,CACxBxB,KAAoB,EACpBuB,IAA0D,KACFvB,KAAK,CAACwB,UAAU,CAACD,IAAI,CAAC","ignoreList":[]}

package/dist/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": []
+}

package/dist/esm/readiness.js

@@ -0,0 +1,92 @@
+/**
+ * `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 { composeProjections, DcbEventStore, DEFAULT_CATCH_UP_PAGE_SIZE, ReadLimit } from '@kairos-es/core';
+import { Array as Arr, Effect, Option, Stream } from 'effect';
+import { FeedUnreadable } from "./errors.js";
+/**
+ * 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 const materialisationCaughtUp = readModel => Effect.gen(function* () {
+  const log = yield* DcbEventStore;
+  const query = composeProjections(readModel.slices).query;
+  const limit = ReadLimit.make(DEFAULT_CATCH_UP_PAGE_SIZE);
+  const checkpoint = Effect.mapError(readModel.store.readCheckpoint, cause => new FeedUnreadable({
+    reason: `the checkpoint of projection '${readModel.store.key.projection}' could not be read`,
+    cause
+  }));
+  // The last position the query selects after `from`, or `from` itself when it
+  // selects none: page by page, so the backlog is never held in memory at once.
+  const lastSelectedAfter = from => Effect.gen(function* () {
+    let last = from;
+    for (;;) {
+      const response = yield* log.read(query, {
+        after: last,
+        limit
+      });
+      const page = yield* Stream.runCollect(response.events);
+      const final = Arr.last(page);
+      if (Option.isSome(final)) {
+        last = final.value.position;
+      }
+      if (page.length < limit) {
+        return last;
+      }
+    }
+  });
+  const readiness = () => Effect.map(Effect.flatMap(checkpoint, lastSelectedAfter), target => Effect.map(checkpoint, reached => reached >= target));
+  return readiness;
+});
+//# sourceMappingURL=readiness.js.map

package/dist/esm/readiness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.js","names":["composeProjections","DcbEventStore","DEFAULT_CATCH_UP_PAGE_SIZE","ReadLimit","Array","Arr","Effect","Option","Stream","FeedUnreadable","materialisationCaughtUp","readModel","gen","log","query","slices","limit","make","checkpoint","mapError","store","readCheckpoint","cause","reason","key","projection","lastSelectedAfter","from","last","response","read","after","page","runCollect","events","final","isSome","value","position","length","readiness","map","flatMap","target","reached"],"sources":["../../src/readiness.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAEEA,kBAAkB,EAClBC,aAAa,EACbC,0BAA0B,EAE1BC,SAAS,QACJ,iBAAiB;AAExB,SAASC,KAAK,IAAIC,GAAG,EAAEC,MAAM,EAAEC,MAAM,EAAEC,MAAM,QAAQ,QAAQ;AAC7D,SAASC,cAAc,QAAQ,aAAU;AA2BzC;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,MAAMC,uBAAuB,GAClCC,SAA4B,IAE5BL,MAAM,CAACM,GAAG,CAAC,aAAS;EAClB,MAAMC,GAAG,GAAG,OAAOZ,aAAa;EAChC,MAAMa,KAAK,GAAGd,kBAAkB,CAACW,SAAS,CAACI,MAAM,CAAC,CAACD,KAAK;EACxD,MAAME,KAAK,GAAGb,SAAS,CAACc,IAAI,CAACf,0BAA0B,CAAC;EACxD,MAAMgB,UAAU,GAAGZ,MAAM,CAACa,QAAQ,CAChCR,SAAS,CAACS,KAAK,CAACC,cAAc,EAC7BC,KAAK,IACJ,IAAIb,cAAc,CAAC;IACjBc,MAAM,EAAE,iCAAiCZ,SAAS,CAACS,KAAK,CAACI,GAAG,CAACC,UAAU,qBAAqB;IAC5FH;GACD,CAAC,CACL;EAED;EACA;EACA,MAAMI,iBAAiB,GAAIC,IAAc,IACvCrB,MAAM,CAACM,GAAG,CAAC,aAAS;IAClB,IAAIgB,IAAI,GAAGD,IAAI;IACf,SAAS;MACP,MAAME,QAAQ,GAAG,OAAOhB,GAAG,CAACiB,IAAI,CAAChB,KAAK,EAAE;QAAEiB,KAAK,EAAEH,IAAI;QAAEZ;MAAK,CAAE,CAAC;MAC/D,MAAMgB,IAAI,GAAG,OAAOxB,MAAM,CAACyB,UAAU,CAACJ,QAAQ,CAACK,MAAM,CAAC;MACtD,MAAMC,KAAK,GAAG9B,GAAG,CAACuB,IAAI,CAACI,IAAI,CAAC;MAC5B,IAAIzB,MAAM,CAAC6B,MAAM,CAACD,KAAK,CAAC,EAAE;QACxBP,IAAI,GAAGO,KAAK,CAACE,KAAK,CAACC,QAAQ;MAC7B;MACA,IAAIN,IAAI,CAACO,MAAM,GAAGvB,KAAK,EAAE;QACvB,OAAOY,IAAI;MACb;IACF;EACF,CAAC,CAAC;EAEJ,MAAMY,SAAS,GAAkBA,CAAA,KAC/BlC,MAAM,CAACmC,GAAG,CACRnC,MAAM,CAACoC,OAAO,CAACxB,UAAU,EAAEQ,iBAAiB,CAAC,EAC5CiB,MAAM,IACLrC,MAAM,CAACmC,GAAG,CAACvB,UAAU,EAAG0B,OAAO,IAAKA,OAAO,IAAID,MAAM,CAAC,CACzD;EACH,OAAOH,SAAS;AAClB,CAAC,CAAC","ignoreList":[]}

package/dist/esm/reconcile.js

@@ -0,0 +1,153 @@
+/**
+ * Reconcile: delete what a sink holds that the feed no longer has.
+ *
+ * ## Why a feed needs it at all
+ *
+ * The steady state deletes through tombstones, and a tombstone lives only until
+ * every sink registered on the feed has passed it. A record can still be left
+ * behind in a sink: a sink restored from a backup, a key written into the index by
+ * hand, or a record deleted before a reset, whose tombstone the reset cleared with
+ * every other row, followed by an in-place resync that, having no atomic swap,
+ * sends only the rows the new generation holds and so never deletes it. Reconcile is the one operation that compares the sink with the feed
+ * rather than replaying the feed into the sink, and so the only one that finds
+ * those orphans.
+ *
+ * ## The order of the two reads, and why it is safe
+ *
+ * The sink's keys are listed FIRST and the feed's live keys read SECOND. A key the
+ * sink lists that has a live row by the time the feed is read is kept, so a record
+ * written while reconcile runs is never deleted by it. A key whose row turns into
+ * a tombstone after the feed is read is kept too, and its tombstone deletes it on
+ * the next pass. And a key whose row comes back to life after the feed is read is
+ * deleted here and re-sent by the next pass, because its new `seq` is above the
+ * cursor. Reconcile runs inside the worker that holds the lease, between batches,
+ * so nothing else is sending to the sink while it does (ADR-0019 §8).
+ *
+ * ## What it costs
+ *
+ * It holds every key the sink lists and every live key of the feed in memory at
+ * once, and reads every live document to find the keys. It is a periodic repair,
+ * not a steady-state path: `reconcileEvery` should be measured in hours.
+ */
+import { Array as Arr, Effect, Option, Stream } from 'effect';
+import { deliver } from "./deliver.js";
+import { FeedChange } from "./FeedSink.js";
+import { FEED_ORIGIN } from "./identifiers.js";
+import { DEFAULT_FEED_PAGE_SIZE, readLimit } from "./tuning.js";
+/** Every key of `source` whose row is live, read page by page from the origin. */
+export const liveKeys = (source, pageSize) => Effect.gen(function* () {
+  const live = new Set();
+  const limit = readLimit(pageSize);
+  let after = FEED_ORIGIN;
+  for (;;) {
+    const rows = yield* source.changesAfter(after, limit);
+    for (const row of rows) {
+      if (Option.isSome(row.doc)) {
+        live.add(row.key);
+      } else {
+        live.delete(row.key);
+      }
+    }
+    const last = rows.at(-1);
+    if (last === undefined || rows.length < pageSize) {
+      return live;
+    }
+    after = last.seq;
+  }
+});
+/**
+ * Reconcile under a lease the caller already holds. Package-internal: the driver
+ * calls it between batches and in an in-place resync, and `reconcileFeed` calls it
+ * after taking the lease itself.
+ *
+ * @internal
+ */
+export const reconcileWith = args => Effect.gen(function* () {
+  const listed = yield* Stream.runCollect(args.reconcile.listKeys);
+  const live = yield* liveKeys(args.source, args.pageSize);
+  const orphans = Array.from(new Set(listed)).filter(key => !live.has(key));
+  const deleted = [];
+  const refused = [];
+  for (const chunk of Arr.chunksOf(orphans, args.pageSize)) {
+    const pending = Arr.map(chunk, key => ({
+      change: FeedChange.Delete({
+        key
+      }),
+      seq: FEED_ORIGIN
+    }));
+    const delivered = yield* deliver({
+      send: args.sink.apply,
+      confirm: args.sink.confirm,
+      lease: args.lease,
+      pending
+    });
+    deleted.push(...delivered.sent);
+    refused.push(...delivered.parked.map(p => ({
+      key: p.key,
+      reason: p.reason
+    })));
+  }
+  const listedKeys = new Set(listed);
+  const deletedKeys = new Set(deleted);
+  return {
+    report: {
+      listed: listedKeys.size,
+      deleted,
+      refused
+    },
+    isGone: key => !live.has(key) && (deletedKeys.has(key) || !listedKeys.has(key))
+  };
+});
+/**
+ * Unpark every parked key a reconcile found gone from the sink for good (see
+ * {@link Reconciled}): a park reporting a refusal for such a key — an in-place
+ * rebuild's orphan, or a tombstone whose delete the tail was refused — reports a
+ * record that is not there. `retryParked` unparks a key with no row and re-stamps
+ * one that has a row, which for a tombstone sends every sink one idempotent delete.
+ *
+ * It judges by what the sink holds, not by what this reconcile deleted, so a park
+ * an earlier unpark failed to clear goes on the next reconcile. That is why a
+ * failure here is a warning and not an error: it costs a stale entry in
+ * `inspectFeed` until then, and failing would end a worker's session, or discard
+ * an operator's report, over a record that is already gone.
+ *
+ * @internal
+ */
+export const unparkGone = (store, id, isGone) => Effect.gen(function* () {
+  const parked = yield* store.readParked(id);
+  yield* Effect.forEach(parked.filter(p => isGone(p.key)), p => store.retryParked({
+    ...id,
+    key: p.key
+  }), {
+    discard: true
+  });
+}).pipe(Effect.catch(cause => Effect.logWarning('feed reconcile could not unpark a record it found gone; the next reconcile will', {
+  feed: id.feed,
+  sink: id.sink,
+  reason: cause.message
+})));
+/**
+ * Reconcile `sink` against `source` once, now. It takes the worker lease itself,
+ * so it fails `LeaseHeld` while a sync worker for the same feed and sink runs —
+ * reconcile through that worker's `reconcileEvery` instead, or stop it first.
+ */
+export const reconcileFeed = options => Effect.scoped(Effect.gen(function* () {
+  const id = {
+    feed: options.source.feed,
+    sink: options.sink.name
+  };
+  const lease = yield* options.store.acquireLease(id);
+  const {
+    report,
+    isGone
+  } = yield* reconcileWith({
+    source: options.source,
+    sink: options.sink,
+    reconcile: options.sink.reconcile,
+    lease,
+    pageSize: options.pageSize ?? DEFAULT_FEED_PAGE_SIZE
+  });
+  yield* unparkGone(options.store, id, isGone);
+  return report;
+}));
+//# sourceMappingURL=reconcile.js.map

package/dist/esm/reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.js","names":["Array","Arr","Effect","Option","Stream","deliver","FeedChange","FEED_ORIGIN","DEFAULT_FEED_PAGE_SIZE","readLimit","liveKeys","source","pageSize","gen","live","Set","limit","after","rows","changesAfter","row","isSome","doc","add","key","delete","last","at","undefined","length","seq","reconcileWith","args","listed","runCollect","reconcile","listKeys","orphans","from","filter","has","deleted","refused","chunk","chunksOf","pending","map","change","Delete","delivered","send","sink","apply","confirm","lease","push","sent","parked","p","reason","listedKeys","deletedKeys","report","size","isGone","unparkGone","store","id","readParked","forEach","retryParked","discard","pipe","catch","cause","logWarning","feed","message","reconcileFeed","options","scoped","name","acquireLease"],"sources":["../../src/reconcile.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}