@kairos-es/feed 0.0.0-stage → 0.0.0

package/dist/cjs/index.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CursorSuperseded", {
+  enumerable: true,
+  get: function () {
+    return _errors.CursorSuperseded;
+  }
+});
+Object.defineProperty(exports, "FEED_ORIGIN", {
+  enumerable: true,
+  get: function () {
+    return _identifiers.FEED_ORIGIN;
+  }
+});
+Object.defineProperty(exports, "FeedChange", {
+  enumerable: true,
+  get: function () {
+    return _FeedSink.FeedChange;
+  }
+});
+Object.defineProperty(exports, "FeedKey", {
+  enumerable: true,
+  get: function () {
+    return _identifiers.FeedKey;
+  }
+});
+Object.defineProperty(exports, "FeedName", {
+  enumerable: true,
+  get: function () {
+    return _identifiers.FeedName;
+  }
+});
+Object.defineProperty(exports, "FeedSeq", {
+  enumerable: true,
+  get: function () {
+    return _identifiers.FeedSeq;
+  }
+});
+Object.defineProperty(exports, "FeedSyncStalled", {
+  enumerable: true,
+  get: function () {
+    return _errors.FeedSyncStalled;
+  }
+});
+Object.defineProperty(exports, "FeedUnreadable", {
+  enumerable: true,
+  get: function () {
+    return _errors.FeedUnreadable;
+  }
+});
+Object.defineProperty(exports, "FeedWriteFailed", {
+  enumerable: true,
+  get: function () {
+    return _errors.FeedWriteFailed;
+  }
+});
+Object.defineProperty(exports, "Generation", {
+  enumerable: true,
+  get: function () {
+    return _identifiers.Generation;
+  }
+});
+Object.defineProperty(exports, "LeaseHeld", {
+  enumerable: true,
+  get: function () {
+    return _errors.LeaseHeld;
+  }
+});
+Object.defineProperty(exports, "LeaseHolder", {
+  enumerable: true,
+  get: function () {
+    return _identifiers.LeaseHolder;
+  }
+});
+Object.defineProperty(exports, "LeaseLost", {
+  enumerable: true,
+  get: function () {
+    return _errors.LeaseLost;
+  }
+});
+Object.defineProperty(exports, "SinkHalted", {
+  enumerable: true,
+  get: function () {
+    return _errors.SinkHalted;
+  }
+});
+Object.defineProperty(exports, "SinkName", {
+  enumerable: true,
+  get: function () {
+    return _identifiers.SinkName;
+  }
+});
+Object.defineProperty(exports, "SinkRejected", {
+  enumerable: true,
+  get: function () {
+    return _errors.SinkRejected;
+  }
+});
+Object.defineProperty(exports, "SinkRetryable", {
+  enumerable: true,
+  get: function () {
+    return _errors.SinkRetryable;
+  }
+});
+Object.defineProperty(exports, "changeOf", {
+  enumerable: true,
+  get: function () {
+    return _FeedSink.changeOf;
+  }
+});
+Object.defineProperty(exports, "inspectFeed", {
+  enumerable: true,
+  get: function () {
+    return _inspect.inspectFeed;
+  }
+});
+Object.defineProperty(exports, "makeInMemoryFeed", {
+  enumerable: true,
+  get: function () {
+    return _inMemoryFeed.makeInMemoryFeed;
+  }
+});
+Object.defineProperty(exports, "makeInMemorySink", {
+  enumerable: true,
+  get: function () {
+    return _inMemorySink.makeInMemorySink;
+  }
+});
+Object.defineProperty(exports, "materialisationCaughtUp", {
+  enumerable: true,
+  get: function () {
+    return _readiness.materialisationCaughtUp;
+  }
+});
+Object.defineProperty(exports, "reconcileFeed", {
+  enumerable: true,
+  get: function () {
+    return _reconcile.reconcileFeed;
+  }
+});
+Object.defineProperty(exports, "removeSink", {
+  enumerable: true,
+  get: function () {
+    return _inspect.removeSink;
+  }
+});
+Object.defineProperty(exports, "retryParked", {
+  enumerable: true,
+  get: function () {
+    return _inspect.retryParked;
+  }
+});
+Object.defineProperty(exports, "runFeedSync", {
+  enumerable: true,
+  get: function () {
+    return _runFeedSync.runFeedSync;
+  }
+});
+Object.defineProperty(exports, "sameCursor", {
+  enumerable: true,
+  get: function () {
+    return _FeedSyncStore.sameCursor;
+  }
+});
+Object.defineProperty(exports, "withInMemoryFeed", {
+  enumerable: true,
+  get: function () {
+    return _inMemoryFeed.withInMemoryFeed;
+  }
+});
+var _errors = require("./errors.js");
+var _FeedSink = require("./FeedSink.js");
+var _FeedSyncStore = require("./FeedSyncStore.js");
+var _identifiers = require("./identifiers.js");
+var _inMemoryFeed = require("./inMemoryFeed.js");
+var _inMemorySink = require("./inMemorySink.js");
+var _inspect = require("./inspect.js");
+var _readiness = require("./readiness.js");
+var _reconcile = require("./reconcile.js");
+var _runFeedSync = require("./runFeedSync.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_errors","require","_FeedSink","_FeedSyncStore","_identifiers","_inMemoryFeed","_inMemorySink","_inspect","_readiness","_reconcile","_runFeedSync"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,IAAAA,OAAA,GAAAC,OAAA;AAiBA,IAAAC,SAAA,GAAAD,OAAA;AASA,IAAAE,cAAA,GAAAF,OAAA;AAWA,IAAAG,YAAA,GAAAH,OAAA;AAUA,IAAAI,aAAA,GAAAJ,OAAA;AAMA,IAAAK,aAAA,GAAAL,OAAA;AAOA,IAAAM,QAAA,GAAAN,OAAA;AAOA,IAAAO,UAAA,GAAAP,OAAA;AAMA,IAAAQ,UAAA,GAAAR,OAAA;AAKA,IAAAS,YAAA,GAAAT,OAAA","ignoreList":[]}

package/dist/cjs/inspect.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.retryParked = exports.removeSink = exports.inspectFeed = void 0;
+var _effect = require("effect");
+/**
+ * `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.
+ */
+
+/** Every sink of `source`'s feed: its cursor, lag, lease and parked records. */
+const inspectFeed = (source, store) => _effect.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: _effect.Option.map(state.cursor, c => c.generation),
+      cursor: state.cursor,
+      lastAdvance: state.lastAdvance,
+      resyncDue: _effect.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.
+ */
+exports.inspectFeed = inspectFeed;
+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.
+ */
+exports.retryParked = retryParked;
+const removeSink = (store, args) => store.removeSink(args);
+exports.removeSink = removeSink;
+//# sourceMappingURL=inspect.js.map

package/dist/cjs/inspect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.js","names":["_effect","require","inspectFeed","source","store","Effect","gen","generation","description","describe","feed","head","sinks","map","state","sink","Option","cursor","c","lastAdvance","resyncDue","match","onNone","onSome","lag","pending","lease","parked","exports","retryParked","args","removeSink"],"sources":["../../src/inspect.ts"],"sourcesContent":[null],"mappings":";;;;;;AAkBA,IAAAA,OAAA,GAAAC,OAAA;AAlBA;;;;;;;;;;;;;;;;;;;AA4DA;AACO,MAAMC,WAAW,GAAGA,CACzBC,MAAqB,EACrBC,KAAoB,KAEpBC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,UAAU,GAAG,OAAOJ,MAAM,CAACI,UAAU;EAC3C,MAAMC,WAAW,GAAG,OAAOJ,KAAK,CAACK,QAAQ,CAACN,MAAM,CAACO,IAAI,CAAC;EACtD,OAAO;IACLA,IAAI,EAAEP,MAAM,CAACO,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,EAAES,cAAM,CAACH,GAAG,CAACC,KAAK,CAACG,MAAM,EAAGC,CAAC,IAAKA,CAAC,CAACX,UAAU,CAAC;MACzDU,MAAM,EAAEH,KAAK,CAACG,MAAM;MACpBE,WAAW,EAAEL,KAAK,CAACK,WAAW;MAC9BC,SAAS,EAAEJ,cAAM,CAACK,KAAK,CAACP,KAAK,CAACG,MAAM,EAAE;QACpCK,MAAM,EAAEA,CAAA,KAAM,IAAI;QAClBC,MAAM,EAAGL,CAAC,IAAKA,CAAC,CAACX,UAAU,KAAKA;OACjC,CAAC;MACFiB,GAAG,EAAEV,KAAK,CAACW,OAAO;MAClBC,KAAK,EAAEZ,KAAK,CAACY,KAAK;MAClBC,MAAM,EAAEb,KAAK,CAACa;KACf,CAAC;GACH;AACH,CAAC,CAAC;AAEJ;;;;;;AAAAC,OAAA,CAAA1B,WAAA,GAAAA,WAAA;AAMO,MAAM2B,WAAW,GAAGA,CACzBzB,KAAoB,EACpB0B,IAIC,KAC2C1B,KAAK,CAACyB,WAAW,CAACC,IAAI,CAAC;AAErE;;;;;;;AAAAF,OAAA,CAAAC,WAAA,GAAAA,WAAA;AAOO,MAAME,UAAU,GAAGA,CACxB3B,KAAoB,EACpB0B,IAA0D,KACF1B,KAAK,CAAC2B,UAAU,CAACD,IAAI,CAAC;AAAAF,OAAA,CAAAG,UAAA,GAAAA,UAAA","ignoreList":[]}

package/dist/cjs/readiness.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.materialisationCaughtUp = void 0;
+var _core = require("@kairos-es/core");
+var _effect = require("effect");
+var _errors = require("./errors.js");
+/**
+ * `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.
+ */
+
+/**
+ * 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.
+ */
+const materialisationCaughtUp = readModel => _effect.Effect.gen(function* () {
+  const log = yield* _core.DcbEventStore;
+  const query = (0, _core.composeProjections)(readModel.slices).query;
+  const limit = _core.ReadLimit.make(_core.DEFAULT_CATCH_UP_PAGE_SIZE);
+  const checkpoint = _effect.Effect.mapError(readModel.store.readCheckpoint, cause => new _errors.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.Effect.gen(function* () {
+    let last = from;
+    for (;;) {
+      const response = yield* log.read(query, {
+        after: last,
+        limit
+      });
+      const page = yield* _effect.Stream.runCollect(response.events);
+      const final = _effect.Array.last(page);
+      if (_effect.Option.isSome(final)) {
+        last = final.value.position;
+      }
+      if (page.length < limit) {
+        return last;
+      }
+    }
+  });
+  const readiness = () => _effect.Effect.map(_effect.Effect.flatMap(checkpoint, lastSelectedAfter), target => _effect.Effect.map(checkpoint, reached => reached >= target));
+  return readiness;
+});
+exports.materialisationCaughtUp = materialisationCaughtUp;
+//# sourceMappingURL=readiness.js.map

package/dist/cjs/readiness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.js","names":["_core","require","_effect","_errors","materialisationCaughtUp","readModel","Effect","gen","log","DcbEventStore","query","composeProjections","slices","limit","ReadLimit","make","DEFAULT_CATCH_UP_PAGE_SIZE","checkpoint","mapError","store","readCheckpoint","cause","FeedUnreadable","reason","key","projection","lastSelectedAfter","from","last","response","read","after","page","Stream","runCollect","events","final","Arr","Option","isSome","value","position","length","readiness","map","flatMap","target","reached","exports"],"sources":["../../src/readiness.ts"],"sourcesContent":[null],"mappings":";;;;;;AAuCA,IAAAA,KAAA,GAAAC,OAAA;AASA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAjDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA;;;;;;;;;;;;;;;;;;;AAmBO,MAAMG,uBAAuB,GAClCC,SAA4B,IAE5BC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,GAAG,GAAG,OAAOC,mBAAa;EAChC,MAAMC,KAAK,GAAG,IAAAC,wBAAkB,EAACN,SAAS,CAACO,MAAM,CAAC,CAACF,KAAK;EACxD,MAAMG,KAAK,GAAGC,eAAS,CAACC,IAAI,CAACC,gCAA0B,CAAC;EACxD,MAAMC,UAAU,GAAGX,cAAM,CAACY,QAAQ,CAChCb,SAAS,CAACc,KAAK,CAACC,cAAc,EAC7BC,KAAK,IACJ,IAAIC,sBAAc,CAAC;IACjBC,MAAM,EAAE,iCAAiClB,SAAS,CAACc,KAAK,CAACK,GAAG,CAACC,UAAU,qBAAqB;IAC5FJ;GACD,CAAC,CACL;EAED;EACA;EACA,MAAMK,iBAAiB,GAAIC,IAAc,IACvCrB,cAAM,CAACC,GAAG,CAAC,aAAS;IAClB,IAAIqB,IAAI,GAAGD,IAAI;IACf,SAAS;MACP,MAAME,QAAQ,GAAG,OAAOrB,GAAG,CAACsB,IAAI,CAACpB,KAAK,EAAE;QAAEqB,KAAK,EAAEH,IAAI;QAAEf;MAAK,CAAE,CAAC;MAC/D,MAAMmB,IAAI,GAAG,OAAOC,cAAM,CAACC,UAAU,CAACL,QAAQ,CAACM,MAAM,CAAC;MACtD,MAAMC,KAAK,GAAGC,aAAG,CAACT,IAAI,CAACI,IAAI,CAAC;MAC5B,IAAIM,cAAM,CAACC,MAAM,CAACH,KAAK,CAAC,EAAE;QACxBR,IAAI,GAAGQ,KAAK,CAACI,KAAK,CAACC,QAAQ;MAC7B;MACA,IAAIT,IAAI,CAACU,MAAM,GAAG7B,KAAK,EAAE;QACvB,OAAOe,IAAI;MACb;IACF;EACF,CAAC,CAAC;EAEJ,MAAMe,SAAS,GAAkBA,CAAA,KAC/BrC,cAAM,CAACsC,GAAG,CACRtC,cAAM,CAACuC,OAAO,CAAC5B,UAAU,EAAES,iBAAiB,CAAC,EAC5CoB,MAAM,IACLxC,cAAM,CAACsC,GAAG,CAAC3B,UAAU,EAAG8B,OAAO,IAAKA,OAAO,IAAID,MAAM,CAAC,CACzD;EACH,OAAOH,SAAS;AAClB,CAAC,CAAC;AAAAK,OAAA,CAAA5C,uBAAA,GAAAA,uBAAA","ignoreList":[]}

package/dist/cjs/reconcile.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unparkGone = exports.reconcileWith = exports.reconcileFeed = exports.liveKeys = void 0;
+var _effect = require("effect");
+var _deliver = require("./deliver.js");
+var _FeedSink = require("./FeedSink.js");
+var _identifiers = require("./identifiers.js");
+var _tuning = require("./tuning.js");
+/**
+ * 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.
+ */
+
+/** Every key of `source` whose row is live, read page by page from the origin. */
+const liveKeys = (source, pageSize) => _effect.Effect.gen(function* () {
+  const live = new Set();
+  const limit = (0, _tuning.readLimit)(pageSize);
+  let after = _identifiers.FEED_ORIGIN;
+  for (;;) {
+    const rows = yield* source.changesAfter(after, limit);
+    for (const row of rows) {
+      if (_effect.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
+ */
+exports.liveKeys = liveKeys;
+const reconcileWith = args => _effect.Effect.gen(function* () {
+  const listed = yield* _effect.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 _effect.Array.chunksOf(orphans, args.pageSize)) {
+    const pending = _effect.Array.map(chunk, key => ({
+      change: _FeedSink.FeedChange.Delete({
+        key
+      }),
+      seq: _identifiers.FEED_ORIGIN
+    }));
+    const delivered = yield* (0, _deliver.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
+ */
+exports.reconcileWith = reconcileWith;
+const unparkGone = (store, id, isGone) => _effect.Effect.gen(function* () {
+  const parked = yield* store.readParked(id);
+  yield* _effect.Effect.forEach(parked.filter(p => isGone(p.key)), p => store.retryParked({
+    ...id,
+    key: p.key
+  }), {
+    discard: true
+  });
+}).pipe(_effect.Effect.catch(cause => _effect.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.
+ */
+exports.unparkGone = unparkGone;
+const reconcileFeed = options => _effect.Effect.scoped(_effect.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 ?? _tuning.DEFAULT_FEED_PAGE_SIZE
+  });
+  yield* unparkGone(options.store, id, isGone);
+  return report;
+}));
+exports.reconcileFeed = reconcileFeed;
+//# sourceMappingURL=reconcile.js.map

package/dist/cjs/reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.js","names":["_effect","require","_deliver","_FeedSink","_identifiers","_tuning","liveKeys","source","pageSize","Effect","gen","live","Set","limit","readLimit","after","FEED_ORIGIN","rows","changesAfter","row","Option","isSome","doc","add","key","delete","last","at","undefined","length","seq","exports","reconcileWith","args","listed","Stream","runCollect","reconcile","listKeys","orphans","Array","from","filter","has","deleted","refused","chunk","Arr","chunksOf","pending","map","change","FeedChange","Delete","delivered","deliver","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","DEFAULT_FEED_PAGE_SIZE"],"sources":["../../src/reconcile.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}