@kairos-es/feed 0.0.0-stage → 0.0.0

package/dist/cjs/runFeedSync.js

@@ -0,0 +1,603 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runFeedSync = void 0;
+var _core = require("@kairos-es/core");
+var _effect = require("effect");
+var _deliver = require("./deliver.js");
+var _errors = require("./errors.js");
+var _FeedSink = require("./FeedSink.js");
+var _identifiers = require("./identifiers.js");
+var _reconcile = require("./reconcile.js");
+var _tuning = require("./tuning.js");
+/**
+ * `runFeedSync` — the sync worker: one per feed and sink, holding the lease,
+ * copying the feed's rows to the sink and moving its cursor only once the sink
+ * confirms them (ADR-0019).
+ *
+ * ## The lifecycle
+ *
+ * A worker runs in SESSIONS. A session takes the lease, then loops:
+ *
+ * 1. Read the cursor and the feed's generation. No cursor, or a cursor at another
+ *    generation, means the sink holds a copy of something the feed no longer is,
+ *    so the session RESYNCS (below) and loops.
+ * 2. Otherwise it TAILS: the rows after the cursor, through core's generic
+ *    subscribe machine with `emit: 'page'`, so each page is sent as it is read and
+ *    the worker holds one page in memory, never the backlog. Each page is checked
+ *    against the generation first, and so is every poll interval on its own, since
+ *    a reset that writes nothing yields no page; a generation that moved since the
+ *    cursor was saved ends the tail, and step 1 sees the mismatch.
+ *
+ * Every page goes through one delivery: send, park the keys the sink refuses with
+ * its reasons, send the rest again, confirm. Then ONE compare-and-set moves the
+ * cursor past the whole page and moves the parked list with it — the refused keys
+ * parked, every key that was taken unparked — and fenced on the lease holder, so a
+ * worker that lost its lease moves nothing. Then tombstones every sink has passed
+ * are collected.
+ *
+ * The rules that sequence keeps, each a consequence of a sink not being
+ * transactional:
+ *
+ * - **The cursor moves only after `confirm`.** A crash between `apply` and
+ *   `confirm` resends the batch; a sink is idempotent, so that costs a resend and
+ *   nothing else.
+ * - **A refused key does not hold the feed up.** It is parked and the cursor moves
+ *   past it. It is retried when its row next changes, because a change gives the
+ *   row a `seq` above the cursor, and it leaves the parked list once it is sent
+ *   successfully — a tombstone for a parked key included, which is how a refused
+ *   record that is then deleted stops being parked without anyone acting.
+ * - **A retryable failure keeps the cursor.** The session ends, and supervision
+ *   (below) starts a new one after a back-off no shorter than the sink's
+ *   `retryAfter`; the new session sends the same page again.
+ *
+ * ## Resync
+ *
+ * Every row, page by page from the origin, goes into `resync.begin`'s fresh
+ * target; then the generation is checked once more, the target is published over
+ * the live copy, and the cursor is saved at the new generation with the parked list
+ * REPLACED by the refusals the resync met. Resync progress is held in memory only,
+ * so a crash restarts it from the origin, with a new `begin` that drops the
+ * half-built target the crash left.
+ *
+ * ### Waiting for the materialisation
+ *
+ * The feed's end is not the rebuild's end. After a reset the materialisation
+ * replays the log and writes the feed as it goes, so a resync that reaches the
+ * feed's last row has reached wherever the replay had got to, and publishing there
+ * swaps a complete live copy for a partial one. `readiness.ts` owns that argument.
+ * So `runFeedSync` takes an optional `readiness`: asked once as each attempt
+ * starts, it hands back a probe, and the attempt does not publish until the probe
+ * says the materialisation has caught up. Until then the attempt polls: once per
+ * poll interval it checks the generation, abandoning the attempt as stale if a
+ * reset moved it again, asks the probe, and reads the feed on from where it left
+ * off, loading what the replay wrote meanwhile. The probe is asked BEFORE that
+ * read, so the read that follows a `true` sees every row the materialisation had
+ * committed by the time it answered, since a feed row commits with the checkpoint
+ * that produced it. The lease is still checked immediately before `publish`, and
+ * the generation once more just before that, however long the wait was.
+ *
+ * With no `readiness` the attempt publishes at the feed's end, which is exactly the
+ * behaviour above, and search can serve a PARTIAL copy for as long as the replay
+ * takes. An in-place rebuild has no publish; there the wait holds the closing
+ * reconcile and the cursor save instead, so the reconcile never deletes a record
+ * the replay has not reached yet. Without a `readiness` an in-place rebuild
+ * reconciles at the feed's end too, and so deletes from the live copy every record
+ * the replay had not yet written again; the tail sends each back as the replay
+ * reaches it.
+ *
+ * The wait is UNBOUNDED. A probe that never says yes holds the attempt for good,
+ * with no error and no restart, because publishing early is the very failure the
+ * wait exists to prevent and no timeout could tell a stuck replay from a long one.
+ * It is made visible instead: `inspectFeed` reports the sink `resyncDue` for as long
+ * as it lasts, since the cursor stays at the old generation, and every
+ * `HELD_WAIT_WARN_POLLS` poll intervals (`tuning.ts`) the attempt logs a warning,
+ * "feed sync rebuild held on readiness", with the feed, the sink, the generation,
+ * the polls so far and how long it has been held.
+ *
+ * Each `begin` names a target of its own, never one an earlier attempt used, and
+ * that is what bounds a lease lapse here. A worker that has lost its lease can
+ * still land one call after the new holder's (`FeedSyncStore.ts` says when). Were
+ * the target named after its generation alone, that call could be a `publish` of
+ * the NEW holder's half-built target, which then goes on loading into a fresh one
+ * holding only the later pages, publishes it, and saves its cursor at the head:
+ * whole pages lost, and nothing to bring them back. With a target per attempt, a
+ * stale `publish` moves only the stale worker's own target — or fails, retryably,
+ * when a newer `begin` has dropped it — and a stale `begin` drops the new holder's
+ * target, whose `publish` then fails retryably and whose resync starts again.
+ * What a stale `publish` of its own target still costs is `FeedSyncStore.ts`'s to
+ * say, with the rest of the lease's window.
+ *
+ * `begin`, `load`, `apply` and `publish` each run behind `ensureHeld`; `confirm`
+ * and a reconcile's key listing change nothing, and do not.
+ *
+ * Tombstones are sent as deletes, although the target starts empty. The feed does
+ * not stand still while a resync pages through it: a key loaded on an early page
+ * can be deleted by the read model before the resync is done, and its tombstone
+ * then sits at a `seq` a LATER page reads. Dropping it would load the key, save
+ * the cursor past its delete, and publish a target that holds a record the feed no
+ * longer has, with nothing ever coming to remove it. A tombstone for a key the
+ * target never held costs a send and changes nothing, since a delete of an absent
+ * key is a no-op by the sink laws.
+ *
+ * The same movement decides the parked list. A key can be met more than once in
+ * one resync — refused on an early page, then changed and met again later — so
+ * the list saved is what each key's LAST change in the resync came to: parked if
+ * that change was refused, absent if it was taken. Keeping every refusal the
+ * resync met would leave parked a key the target holds, or one the feed deleted.
+ *
+ * A sink with no `resync` is resynced IN PLACE: every row is sent to the live copy,
+ * live rows as upserts and tombstones as deletes, and then a reconcile deletes what
+ * the feed no longer holds. The live copy serves a mixture of old and new from the
+ * first page on, which is the price of a target with no atomic swap. Its refusals
+ * land in the parked list it saves like any resync's, with two consequences of
+ * writing over the live copy: a refused upsert leaves the PREVIOUS generation's
+ * document of that key live, and an orphan whose delete the closing reconcile was
+ * refused stays live too. Both are parked with the sink's reason, the orphan at the
+ * origin `seq` since it has no row, and the closing reconcile's report goes to
+ * `onReconcile` like a scheduled one's. A sink with neither part could never be
+ * rebuilt, and is refused at construction.
+ *
+ * ## Supervision
+ *
+ * Every failure a session meets ends it, and the worker's own loop decides what
+ * next. It follows `@kairos-es/automation`'s daemon rather than generalising the
+ * read side's supervisor, whose own doc says a progress signal the caller owns does
+ * not qualify — and the signal here, a cursor advance, is the worker's own.
+ *
+ * - `LeaseHeld`: another worker is running. This one waits a poll interval and
+ *   tries again, and the wait is not a failure: a standby worker is a healthy one,
+ *   and it takes over within a poll interval of the first worker's lease going.
+ * - Anything else: a back-off of `restartMinDelay` doubling to `restartMaxDelay`,
+ *   scaled by a jitter drawn from `Random` so a fleet of workers does not retry in
+ *   lockstep, and never shorter than a `SinkRetryable`'s `retryAfter`. A restart
+ *   that follows no cursor advance since the previous restart counts towards
+ *   `maxNoProgressRestarts`; reaching it ends the worker with `FeedSyncStalled`,
+ *   for the caller to report. Any advance resets the count and the curve.
+ *
+ * Defects are not caught: they are bugs, in the driver or in a sink or store that
+ * should have classified its fault, and supervision must not retry a bug.
+ *
+ * ## The scope
+ *
+ * The worker never returns. Run it in a fibre of its own beside the projections,
+ * and close the scope to stop it: each session runs in a child scope of the
+ * caller's, so closing the caller's scope releases the lease.
+ */
+
+/** The tail's signal that the generation moved under it. Never leaves a session. */
+class GenerationMoved extends /*#__PURE__*/_effect.Data.TaggedError('GenerationMoved') {}
+/** The jitter range applied to every restart back-off. */
+const JITTER_LOW = 0.8;
+const JITTER_HIGH = 1.2;
+/**
+ * Run the sync worker for `options.source` and `options.sink`; see the module doc.
+ * Dies at once, before taking the lease, on a sink that has neither `resync` nor
+ * `reconcile`, on a `reconcileEvery` for a sink with no `reconcile`, and on tuning
+ * that is out of range.
+ */
+const runFeedSync = options => _effect.Effect.gen(function* () {
+  const config = yield* _effect.Effect.sync(() => resolveOptions(options));
+  const parent = yield* _effect.Effect.scope;
+  const progress = yield* _effect.Ref.make(0);
+  const id = {
+    feed: options.source.feed,
+    sink: options.sink.name
+  };
+  let seen = 0;
+  let restarts = 0;
+  for (;;) {
+    const child = yield* _effect.Scope.fork(parent);
+    const failure = yield* _effect.Effect.flip(session(options, config, progress).pipe(_effect.Scope.use(child)));
+    if (failure._tag === 'LeaseHeld') {
+      yield* _effect.Effect.sleep(config.pollInterval);
+      continue;
+    }
+    const advanced = yield* _effect.Ref.get(progress);
+    if (advanced !== seen) {
+      seen = advanced;
+      restarts = 0;
+    }
+    restarts += 1;
+    if (restarts >= config.maxNoProgressRestarts) {
+      yield* _effect.Effect.logError('feed sync stalled', {
+        feed: id.feed,
+        sink: id.sink,
+        restarts,
+        reason: String(failure)
+      });
+      return yield* new _errors.FeedSyncStalled({
+        ...id,
+        restarts,
+        reason: failure
+      });
+    }
+    const backoff = yield* restartDelay(config, restarts);
+    const delay = failure._tag === 'SinkRetryable' && failure.retryAfter !== undefined ? _effect.Duration.max(backoff, failure.retryAfter) : backoff;
+    yield* _effect.Effect.logWarning('feed sync restarting', {
+      feed: id.feed,
+      sink: id.sink,
+      restarts,
+      delayMillis: _effect.Duration.toMillis(delay),
+      reason: String(failure)
+    });
+    if (config.onRestart !== undefined) {
+      yield* config.onRestart({
+        ...id,
+        restarts,
+        delay,
+        reason: failure
+      });
+    }
+    yield* _effect.Effect.sleep(delay);
+  }
+});
+exports.runFeedSync = runFeedSync;
+const resolveOptions = options => {
+  const where = `runFeedSync(feed '${options.source.feed}', sink '${options.sink.name}')`;
+  const {
+    resync,
+    reconcile
+  } = options.sink;
+  const rebuild = rebuildOf(where, resync, reconcile);
+  if (options.reconcileEvery !== undefined && reconcile === undefined) {
+    throw new Error(`${where}: reconcileEvery is set, and the sink has no reconcile`);
+  }
+  const tuning = options.tuning ?? {};
+  const pageSize = tuning.pageSize ?? _tuning.DEFAULT_FEED_PAGE_SIZE;
+  const limit = (0, _tuning.readLimit)(pageSize);
+  const maxNoProgressRestarts = tuning.maxNoProgressRestarts ?? _tuning.DEFAULT_FEED_MAX_NO_PROGRESS_RESTARTS;
+  if (!Number.isInteger(maxNoProgressRestarts) || maxNoProgressRestarts <= 0) {
+    throw new Error(`${where}: maxNoProgressRestarts must be a positive integer`);
+  }
+  const pollInterval = (0, _tuning.positiveDuration)('pollInterval', tuning.pollInterval ?? _tuning.DEFAULT_FEED_POLL_INTERVAL);
+  const restartMinDelay = (0, _tuning.positiveDuration)('restartMinDelay', tuning.restartMinDelay ?? _tuning.DEFAULT_FEED_RESTART_MIN_DELAY);
+  const restartMaxDelay = (0, _tuning.positiveDuration)('restartMaxDelay', tuning.restartMaxDelay ?? _tuning.DEFAULT_FEED_RESTART_MAX_DELAY);
+  return {
+    pollInterval,
+    pageSize,
+    limit,
+    restartMinDelay,
+    restartMaxDelay,
+    maxNoProgressRestarts,
+    onRestart: tuning.onRestart,
+    onReconcile: tuning.onReconcile,
+    rebuild,
+    periodic: options.reconcileEvery === undefined || reconcile === undefined ? _effect.Option.none() : _effect.Option.some({
+      every: (0, _tuning.positiveDuration)('reconcileEvery', options.reconcileEvery),
+      reconcile
+    }),
+    readiness: _effect.Option.fromUndefinedOr(options.readiness)
+  };
+};
+/** The sink's {@link Rebuild}, refusing a sink that could never be rebuilt. */
+const rebuildOf = (where, resync, reconcile) => {
+  if (resync !== undefined) {
+    return {
+      _tag: 'Swap',
+      resync
+    };
+  }
+  if (reconcile !== undefined) {
+    return {
+      _tag: 'InPlace',
+      reconcile
+    };
+  }
+  throw new Error(`${where}: the sink has neither resync nor reconcile, so it could never be rebuilt after a reset`);
+};
+/**
+ * The delay before restart `n` (1-based): `min(cap, min × 2^(n-1))`, scaled by a
+ * jitter drawn from `Random`, so a seeded `Random` makes it repeat.
+ */
+const restartDelay = (config, n) => _effect.Effect.map(_effect.Random.nextBetween(JITTER_LOW, JITTER_HIGH), jitter => {
+  const raw = _effect.Duration.toMillis(config.restartMinDelay) * 2 ** (n - 1);
+  const capped = Math.min(raw, _effect.Duration.toMillis(config.restartMaxDelay));
+  return _effect.Duration.millis(Math.round(capped * jitter));
+});
+/**
+ * Read the feed's generation and say whether it is still `held`. The ONE place the
+ * driver asks whether a reset has happened: before choosing to tail or resync, per
+ * tail page, per poll interval of the tail's watch, per poll interval of a resync
+ * waiting on its readiness, and before a resync publishes.
+ * A `held` of `None` — no cursor yet — counts as moved, since the sink then holds
+ * a copy of no generation at all.
+ */
+const checkGeneration = (source, held) => _effect.Effect.map(source.generation, current => ({
+  current,
+  moved: _effect.Option.isNone(held) || held.value !== current
+}));
+const makeSessionContext = (options, config, progress, lease) => {
+  const {
+    source,
+    sink,
+    store
+  } = options;
+  return {
+    source,
+    sink,
+    config,
+    lease,
+    deliverRows: (send, rows) => (0, _deliver.deliver)({
+      send,
+      confirm: sink.confirm,
+      lease,
+      pending: _effect.Array.map(rows, row => ({
+        change: (0, _FeedSink.changeOf)(row),
+        seq: row.seq
+      }))
+    }),
+    advance: args => _effect.Effect.gen(function* () {
+      yield* store.casCursor({
+        feed: source.feed,
+        sink: sink.name,
+        holder: lease.holder,
+        expected: args.expected,
+        next: args.next,
+        parked: args.parked
+      });
+      yield* _effect.Ref.update(progress, n => n + 1);
+      yield* store.collectTombstones(source.feed);
+    }),
+    unparkGone: isGone => (0, _reconcile.unparkGone)(store, {
+      feed: source.feed,
+      sink: sink.name
+    }, isGone),
+    reconcile: reconcile => (0, _reconcile.reconcileWith)({
+      source,
+      sink,
+      reconcile,
+      lease,
+      pageSize: config.pageSize
+    })
+  };
+};
+/** One session: the lease, then resync or tail, forever, until something fails. */
+const session = (options, config, progress) => _effect.Effect.gen(function* () {
+  const id = {
+    feed: options.source.feed,
+    sink: options.sink.name
+  };
+  const lease = yield* options.store.acquireLease(id);
+  const ctx = makeSessionContext(options, config, progress, lease);
+  const step = _effect.Effect.gen(function* () {
+    const cursor = yield* options.store.readCursor(id);
+    const check = yield* checkGeneration(ctx.source, _effect.Option.map(cursor, c => c.generation));
+    if (_effect.Option.isSome(cursor) && !check.moved) {
+      return yield* tail(ctx, cursor.value).pipe(_effect.Effect.catchTag('GenerationMoved', () => _effect.Effect.void));
+    }
+    return yield* resync(ctx, {
+      generation: check.current,
+      previous: cursor
+    });
+  });
+  return yield* _effect.Effect.forever(step);
+});
+/** The tail: pages after the cursor, each delivered then advanced past. */
+const tail = (ctx, start) => _effect.Effect.gen(function* () {
+  const {
+    source,
+    sink,
+    config
+  } = ctx;
+  const current = yield* _effect.Ref.make(start);
+  // Fails `GenerationMoved` once the feed has left the cursor's generation.
+  const ensureGeneration = _effect.Effect.gen(function* () {
+    const cursor = yield* _effect.Ref.get(current);
+    const check = yield* checkGeneration(source, _effect.Option.some(cursor.generation));
+    if (check.moved) {
+      return yield* new GenerationMoved();
+    }
+    return cursor;
+  });
+  const onPage = rows => _effect.Effect.gen(function* () {
+    const cursor = yield* ensureGeneration;
+    const delivered = yield* ctx.deliverRows(sink.apply, rows);
+    const next = {
+      generation: cursor.generation,
+      seq: _effect.Array.lastNonEmpty(rows).seq
+    };
+    yield* ctx.advance({
+      expected: _effect.Option.some(cursor),
+      next,
+      parked: {
+        _tag: 'Amend',
+        park: delivered.parked,
+        unpark: delivered.sent
+      }
+    });
+    yield* _effect.Ref.set(current, next);
+  });
+  // A periodic reconcile parks nothing of its own: an orphan it could not delete
+  // is still in the copy, so the next period finds it and tries again, and the
+  // report says so meanwhile. What it does owe the parked list is every park of a
+  // key now gone from the sink, or `inspectFeed` would go on reporting a refusal
+  // for a record that is no longer there; `unparkGone` says why its failure only
+  // warns.
+  const onReconcile = reconcile => _effect.Effect.gen(function* () {
+    const {
+      report,
+      isGone
+    } = yield* ctx.reconcile(reconcile);
+    if (config.onReconcile !== undefined) {
+      yield* config.onReconcile(report);
+    }
+    yield* ctx.unparkGone(isGone);
+  });
+  const pages = (0, _core.subscribeItems)({
+    fetch: source.changesAfter,
+    cursorOf: row => row.seq,
+    initial: start.seq,
+    ...(source.listen === undefined ? {} : {
+      listen: source.listen
+    }),
+    pollInterval: _effect.Duration.toMillis(config.pollInterval),
+    catchUpPageSize: config.pageSize,
+    emit: 'page'
+  }).pipe(_effect.Stream.chunks, _effect.Stream.map(rows => ({
+    _tag: 'Page',
+    rows
+  })));
+  // A reset that writes no row would otherwise go unseen: the tail checks the
+  // generation per PAGE, and an emptied feed yields no page. So the generation is
+  // also read once per poll interval on its own, and a move ends the tail.
+  const generationWatch = _effect.Stream.tick(config.pollInterval).pipe(_effect.Stream.drop(1), _effect.Stream.as({
+    _tag: 'Watch'
+  }));
+  const reconcileTicks = _effect.Option.match(config.periodic, {
+    onNone: () => _effect.Stream.empty,
+    onSome: ({
+      every,
+      reconcile
+    }) => _effect.Stream.tick(every).pipe(
+    // `tick` fires once at the start; a reconcile is due one period in.
+    _effect.Stream.drop(1), _effect.Stream.as({
+      _tag: 'Reconcile',
+      reconcile
+    }))
+  });
+  // One consumer, so a page, a watch and a reconcile never overlap: nothing else
+  // sends while a reconcile runs, which is what lets it run under this lease.
+  yield* _effect.Stream.runForEach(_effect.Stream.merge(pages, _effect.Stream.merge(generationWatch, reconcileTicks)), event => event._tag === 'Page' ? onPage(event.rows) : event._tag === 'Watch' ? _effect.Effect.asVoid(ensureGeneration) : onReconcile(event.reconcile));
+});
+/** What a swap's `publish` sent: no record at all. */
+const NOTHING_SENT = {
+  sent: [],
+  parked: []
+};
+const startRebuild = (ctx, generation) => {
+  const {
+    rebuild
+  } = ctx.config;
+  if (rebuild._tag === 'InPlace') {
+    return _effect.Effect.succeed({
+      send: ctx.sink.apply,
+      finish: _effect.Effect.gen(function* () {
+        const {
+          report
+        } = yield* ctx.reconcile(rebuild.reconcile);
+        if (ctx.config.onReconcile !== undefined) {
+          yield* ctx.config.onReconcile(report);
+        }
+        // An orphan has no row, so its park carries the origin as its `seq`: there
+        // is no change of it to point at, and `retryParked` on a key with no row
+        // simply unparks it.
+        const parkedAt = yield* _effect.DateTime.now;
+        return {
+          sent: report.deleted,
+          parked: report.refused.map(({
+            key,
+            reason
+          }) => ({
+            key,
+            seq: _identifiers.FEED_ORIGIN,
+            reason,
+            parkedAt
+          }))
+        };
+      })
+    });
+  }
+  const {
+    resync
+  } = rebuild;
+  return _effect.Effect.gen(function* () {
+    // `begin` destroys: it empties a target and drops every other one, which can
+    // be the half-built target of the worker that holds the lease now. So it is a
+    // send like any other, and runs only under a lease just seen held.
+    yield* ctx.lease.ensureHeld;
+    const target = yield* resync.begin(generation);
+    return {
+      send: batch => resync.load(target, batch),
+      finish: _effect.Effect.as(_effect.Effect.andThen(ctx.lease.ensureHeld, resync.publish(target)), NOTHING_SENT)
+    };
+  });
+};
+/** Always ready: the probe of a worker given no `readiness`. */
+const ALWAYS_READY = /*#__PURE__*/_effect.Effect.succeed(true);
+/** A full resync at `generation`; see the module doc. */
+const resync = (ctx, at) => _effect.Effect.gen(function* () {
+  const {
+    source,
+    config
+  } = ctx;
+  // Asked before anything is read, so the point the probe judges by is fixed
+  // before the first page: see the module doc's "Waiting for the materialisation".
+  const ready = yield* _effect.Option.match(config.readiness, {
+    onNone: () => _effect.Effect.succeed(ALWAYS_READY),
+    onSome: readiness => readiness(at.generation)
+  });
+  const rebuilding = yield* startRebuild(ctx, at.generation);
+  const stale = _effect.Effect.map(checkGeneration(source, _effect.Option.some(at.generation)), check => check.moved);
+  // By key, so a later page's outcome for a key replaces an earlier one's: the
+  // list saved is what each key's LAST change in this resync came to.
+  const parked = new Map();
+  const settle = delivered => {
+    for (const sent of delivered.sent) {
+      parked.delete(sent);
+    }
+    for (const record of delivered.parked) {
+      parked.set(record.key, record);
+    }
+  };
+  let last = _identifiers.FEED_ORIGIN;
+  const heldSince = yield* _effect.Clock.currentTimeMillis;
+  let polls = 0;
+  for (;;) {
+    // Before the read, so a `true` covers every row the read then finds.
+    const caughtUp = yield* ready;
+    for (;;) {
+      const rows = yield* source.changesAfter(last, config.limit);
+      if (!_effect.Array.isReadonlyArrayNonEmpty(rows)) {
+        break;
+      }
+      // Tombstones included: see the module doc's Resync section.
+      settle(yield* ctx.deliverRows(rebuilding.send, rows));
+      last = _effect.Array.lastNonEmpty(rows).seq;
+      if (rows.length < config.pageSize) {
+        break;
+      }
+    }
+    if (caughtUp) {
+      break;
+    }
+    yield* _effect.Effect.sleep(config.pollInterval);
+    if (yield* stale) {
+      // Reset again while this waited: abandon the attempt, as below.
+      return;
+    }
+    polls += 1;
+    // The wait has no bound — see the module doc — so a probe that never says
+    // yes must at least be seen not to. Every string or number, never a bigint,
+    // so a logger that JSON-encodes the line keeps it.
+    if (polls % _tuning.HELD_WAIT_WARN_POLLS === 0) {
+      yield* _effect.Effect.logWarning('feed sync rebuild held on readiness', {
+        feed: source.feed,
+        sink: ctx.sink.name,
+        generation: String(at.generation),
+        polls,
+        heldMillis: (yield* _effect.Clock.currentTimeMillis) - heldSince
+      });
+    }
+  }
+  if (yield* stale) {
+    // Reset again while this ran: what was loaded is already stale. Leave the
+    // cursor alone, and the session's next step starts the resync over.
+    return;
+  }
+  settle(yield* rebuilding.finish);
+  yield* ctx.advance({
+    expected: at.previous,
+    next: {
+      generation: at.generation,
+      seq: last
+    },
+    parked: {
+      _tag: 'Replace',
+      park: Array.from(parked.values())
+    }
+  });
+});
+//# sourceMappingURL=runFeedSync.js.map

package/dist/cjs/runFeedSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runFeedSync.js","names":["_core","require","_effect","_deliver","_errors","_FeedSink","_identifiers","_reconcile","_tuning","GenerationMoved","Data","TaggedError","JITTER_LOW","JITTER_HIGH","runFeedSync","options","Effect","gen","config","sync","resolveOptions","parent","scope","progress","Ref","make","id","feed","source","sink","name","seen","restarts","child","Scope","fork","failure","flip","session","pipe","use","_tag","sleep","pollInterval","advanced","get","maxNoProgressRestarts","logError","reason","String","FeedSyncStalled","backoff","restartDelay","delay","retryAfter","undefined","Duration","max","logWarning","delayMillis","toMillis","onRestart","exports","where","resync","reconcile","rebuild","rebuildOf","reconcileEvery","Error","tuning","pageSize","DEFAULT_FEED_PAGE_SIZE","limit","readLimit","DEFAULT_FEED_MAX_NO_PROGRESS_RESTARTS","Number","isInteger","positiveDuration","DEFAULT_FEED_POLL_INTERVAL","restartMinDelay","DEFAULT_FEED_RESTART_MIN_DELAY","restartMaxDelay","DEFAULT_FEED_RESTART_MAX_DELAY","onReconcile","periodic","Option","none","some","every","readiness","fromUndefinedOr","n","map","Random","nextBetween","jitter","raw","capped","Math","min","millis","round","checkGeneration","held","generation","current","moved","isNone","value","makeSessionContext","lease","store","deliverRows","send","rows","deliver","confirm","pending","Arr","row","change","changeOf","seq","advance","args","casCursor","holder","expected","next","parked","update","collectTombstones","unparkGone","isGone","reconcileWith","acquireLease","ctx","step","cursor","readCursor","check","c","isSome","tail","catchTag","void","previous","forever","start","ensureGeneration","onPage","delivered","apply","lastNonEmpty","park","unpark","sent","set","report","pages","subscribeItems","fetch","changesAfter","cursorOf","initial","listen","catchUpPageSize","emit","Stream","chunks","generationWatch","tick","drop","as","reconcileTicks","match","onNone","empty","onSome","runForEach","merge","event","asVoid","NOTHING_SENT","startRebuild","succeed","finish","parkedAt","DateTime","now","deleted","refused","key","FEED_ORIGIN","ensureHeld","target","begin","batch","load","andThen","publish","ALWAYS_READY","at","ready","rebuilding","stale","Map","settle","delete","record","last","heldSince","Clock","currentTimeMillis","polls","caughtUp","isReadonlyArrayNonEmpty","length","HELD_WAIT_WARN_POLLS","heldMillis","Array","from","values"],"sources":["../../src/runFeedSync.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}