@kairos-es/core 1.0.0-alpha.5 → 1.0.0-alpha.6

package/dist/dts-esm/SubscribeMachine.d.ts

@@ -5,6 +5,15 @@
  * the cursor's exclusive lower bound) and the poll loop that together turn a paged
  * read into a live subscription.
  *
+ * The algorithm is `subscribeItems`, generic over the item `A` it delivers and the
+ * cursor `C` it resumes from, because nothing in it is about an event: any source
+ * that can page-read strictly after a cursor and name the cursor of what it
+ * returned is subscribable by the same loop. `subscribeStream` is the event-store
+ * shape — `SequencedEvent` ordered by `Position` — over the same loop, and it is
+ * what every engine calls, unchanged by the generalisation. A second kind of
+ * source reuses the loop rather than growing a second one, for the reason the next
+ * paragraph gives.
+ *
  * It lives in core because delivery semantics are contract semantics. An engine
  * supplies TRANSPORT through two STUBBABLE seams — `fetch`, a paged read strictly
  * after a cursor, and `listen`, an optional wake source — and inherits the delivery
@@ -15,48 +24,52 @@
  * Both seams take plain in-memory values in a test, so the wake/poll/de-dup logic
  * is exercisable with no live backend at all.
  *
- * All THREE are the callers, and the count matters to a reader here: it means there
- * is exactly ONE delivery algorithm in this repo, and it is the code below. The
+ * All THREE engines are callers, and the count matters to a reader here: it means
+ * there is exactly ONE delivery algorithm in this repo, and it is the code below. The
  * in-memory store is a caller like the rest — it hands in a `fetch` over its log
  * `Ref` and its append `PubSub` as a wake source and keeps no delivery logic of its
  * own — which is what makes the shared contract suite's subscribe cases a comparison
  * of two BACKENDS rather than of two delivery algorithms.
  *
- * Correctness rests on the periodic position-based reconcile — a re-read from the
+ * Correctness rests on the periodic cursor-based reconcile — a re-read from the
  * cursor every poll interval — and NEVER on the wake source, which only lowers
  * delivery latency below that interval. A subscription with no wake source at all
  * is therefore complete and correct, merely slower, which is why `listen` is
  * optional in the TYPE rather than by the convention of passing `Stream.never`:
  * poll-only delivery is a supported shape, not a degraded one.
  *
- * ## The precondition every engine inherits: ASCENDING COMMIT ORDER
+ * ## The precondition every caller inherits: ASCENDING COMMIT ORDER
  *
- * A position that is committed and VISIBLE must never be below one already
- * delivered. Gaps are fine: the cursor is an ascending exclusive lower bound, so a
- * number that is allocated and never committed, or never allocated at all, is
- * simply a number the machine never sees. Out-of-order commits are not fine. If one
+ * It binds EVERY caller, over whatever cursor it chose — an engine's `Position`, or
+ * any other `C` handed to `subscribeItems` — and the example below is written in
+ * positions only because the engines are the callers it was first written for. A
+ * cursor that is committed and VISIBLE must never be below one already delivered.
+ * Gaps are fine: the cursor is an ascending exclusive lower bound, so a number
+ * that is allocated and never committed, or never allocated at all, is simply a
+ * number the machine never sees. Out-of-order commits are not fine. If one
  * writer allocates position 5 and another allocates 6, and 6 commits first, a poll
  * landing between the two commits delivers 6 and advances the cursor past it — and
  * 5 is then lost forever, because no later read looks below the cursor and nothing
- * anywhere notices the hole. An engine whose concurrent writers can commit out of
+ * anywhere notices the hole. A caller whose concurrent writers can commit out of
  * order MUST serialise them, or this machine will silently skip. An engine that
  * takes an exclusive lock on both of its append paths discharges the obligation
  * that way; an engine whose append is a single statement discharges it
  * structurally.
  *
  * The obligation is written down HERE, in the algorithm that depends on it, rather
- * than in whichever engine happens to satisfy it. It is a property of this delivery
- * loop and of nothing else, so an engine author reading only their own source has
+ * than in whichever caller happens to satisfy it. It is a property of this delivery
+ * loop and of nothing else, so an author reading only their own source has
  * no way to discover that anything downstream needs it — and the failure mode is
  * the worst kind there is: no error, no defect, no failing test, just an event that
  * a subscriber never receives. A single engine owning both its append path and its
  * own wake loop can leave the assumption implicit; a shared machine cannot.
  *
- * ## `catchUpPageSize` bounds the READ, not the emission
+ * ## `catchUpPageSize` bounds the READ, not the emission — unless `emit: 'page'`
  *
- * `drainFrom` below PAGES the catch-up read — `catchUpPageSize` bounds each
- * `fetch` — but it COLLECTS every page into one array, which is emitted as a SINGLE
- * chunk. So peak memory at subscription start is O(backlog) rather than O(page): a
+ * Under the default `emit: 'backlog'`, which is what `subscribeStream` and so every
+ * engine uses, `drainFrom` below PAGES the catch-up read — `catchUpPageSize` bounds
+ * each `fetch` — but it COLLECTS every page into one array, which is emitted as a
+ * SINGLE chunk. So peak memory at subscription start is O(backlog) rather than O(page): a
  * subscriber joining behind a large log materialises the whole backlog before its
  * consumer sees the first element.
  *
@@ -67,6 +80,19 @@
  * stay small even against a one-chunk catch-up. The cost therefore lands on backlog
  * memory alone, and it lands hardest on the durable-log-with-in-memory-view mode,
  * where an ephemeral view re-catches-up the entire log on every boot.
+ *
+ * `emit: 'page'` changes exactly that and nothing else. Each fetched page is
+ * emitted as its own chunk and the cursor advances past it before the next read, so
+ * peak memory is O(page) and the consumer sees the first item after ONE read rather
+ * than after the whole backlog. Delivery is unchanged: the same items in the same
+ * order, the same de-dup, the same wake and poll. What a caller gives up is the
+ * one-chunk catch-up, so it must not read meaning into chunk boundaries under
+ * either mode. It is for a consumer that does NOT re-chunk downstream and whose
+ * catch-up can be the whole of a large source — a full resync of a table, say —
+ * where holding the backlog would be the cost the paging was meant to avoid. The
+ * engines keep `'backlog'` because the read side's re-chunking already bounds what
+ * they commit, and changing their emission would move a behaviour nobody asked to
+ * move.
  */
 import { Effect, Schema, type Scope, Stream } from 'effect';
 import type { Position, SequencedEvent } from './Event.js';
@@ -130,9 +156,74 @@ export declare const subscriptionTuningFields: {
     readonly catchUpPageSize: Schema.optionalKey<Schema.Int>;
 };
 /**
- * The two seams the subscribe machine runs over, plus the two tuning knobs. `E` is
- * the engine's own infrastructure error — whatever its reads fail with — and it
- * stays on the channel through to `makeContractStore`, which dies it.
+ * How a subscription hands its catch-up to the consumer: the whole backlog as ONE
+ * chunk (`'backlog'`), or each fetched page as a chunk of its own (`'page'`). The
+ * module doc's "`catchUpPageSize` bounds the READ" section owns what each costs.
+ *
+ * A closed union of two words rather than a boolean, so a call site says WHICH
+ * behaviour it chose instead of what it turned off, and a third shape, should one
+ * ever be argued for, is added beside these rather than encoded in a second flag.
+ */
+export type SubscriptionEmission = 'backlog' | 'page';
+/**
+ * The machine's inputs over ANY item `A` with an ascending cursor `C`: the two seams,
+ * where the cursor comes from and starts, and the tuning.
+ *
+ * Generic in the item and the cursor because nothing in the algorithm is about an
+ * EVENT. The wake queue, the poll, the paged reconcile and the exclusive-lower-bound
+ * de-dup need only three things of what they deliver: a page-read strictly after a
+ * cursor, a way to read the cursor OFF a delivered item, and a starting cursor. A
+ * log of `SequencedEvent`s ordered by `Position` is one such source; a feed of rows
+ * ordered by a feed-local sequence is another, and a second copy of this loop for it
+ * would be exactly the divergence the module doc argues against.
+ *
+ * The machine never COMPARES two cursors. `fetch` is the only thing that interprets
+ * one — its exclusive lower bound is what does the de-dup — so `C` needs no ordering
+ * instance here, and the ascending-commit-order obligation in the module doc is the
+ * caller's, stated over whatever `C` it chose.
+ *
+ * `initial` is REQUIRED, unlike `subscribeStream`'s `after`. Only a cursor type the
+ * machine knows can have a default — `ORIGIN` for `Position` — and for any other the
+ * caller is the only party that knows what "before everything" is.
+ *
+ * `pollInterval` and `catchUpPageSize` are optional here and fall back to
+ * `DEFAULT_POLL_INTERVAL_MILLIS` and `DEFAULT_CATCH_UP_PAGE_SIZE`: a caller with no
+ * config of its own takes the same figures every engine does, from the same place.
+ * The event-store shape, `SubscriptionDeps`, keeps them required, because every
+ * engine already resolves them from its config and that type is unchanged.
+ */
+export interface ItemSubscriptionDeps<A, C, E> {
+    /**
+     * Page-read the items strictly after `after`, up to `limit`, ascending by cursor.
+     * Returning FEWER than `limit` signals the tail is drained. The exclusive lower
+     * bound IS the de-dup: a re-read from the cursor never returns what was delivered.
+     */
+    readonly fetch: (after: C, limit: ReadLimit) => Effect.Effect<ReadonlyArray<A>, E>;
+    /** The cursor of a delivered item: the next `fetch` starts strictly after it. */
+    readonly cursorOf: (item: A) => C;
+    /** The cursor to start from, exclusive: the first `fetch` reads strictly after it. */
+    readonly initial: C;
+    /** The raw wake source — see `SubscriptionDeps.listen`, whose rules it shares. */
+    readonly listen?: Stream.Stream<unknown, E>;
+    /**
+     * The poll interval in milliseconds (default `DEFAULT_POLL_INTERVAL_MILLIS`):
+     * finite and greater than 0, or `subscribeItems` dies.
+     */
+    readonly pollInterval?: number;
+    /**
+     * The catch-up page size (default `DEFAULT_CATCH_UP_PAGE_SIZE`): an integer
+     * greater than 0, or `subscribeItems` dies.
+     */
+    readonly catchUpPageSize?: number;
+    /** The catch-up's chunking (default `'backlog'`); see `SubscriptionEmission`. */
+    readonly emit?: SubscriptionEmission;
+}
+/**
+ * The two seams the event-store subscribe machine runs over, plus the two tuning
+ * knobs: `ItemSubscriptionDeps` fixed to `SequencedEvent` and `Position`, the shape
+ * every engine's `subscribe` already hands to `subscribeStream`. `E` is the engine's
+ * own infrastructure error — whatever its reads fail with — and it stays on the
+ * channel through to `makeContractStore`, which dies it.
  *
  * ONE type parameter and not two, deliberately: a wake source with an error type of
  * its own is `Stream.orDie`d by the caller, yielding a `Stream<unknown, never>`
@@ -164,12 +255,35 @@ export interface SubscriptionDeps<E> {
     readonly catchUpPageSize: number;
 }
 /**
- * Build the subscription `Stream`: catch up from `after`, then track the live tail.
- * The cursor threads through the `Stream.paginate` state, starting at `after` and
- * advancing to the last delivered position each batch; the stream never completes
- * on its own (the next state is always `Option.some`), so the enclosing scope
- * interrupts it on close. An `E` mid-stream stays on the channel; `makeContractStore` dies it
- * (subscribe is `E = never` on the contract).
+ * Build a subscription `Stream` over any ascending-cursor source: catch up from
+ * `initial`, then track the live tail. The cursor threads through the
+ * `Stream.paginate` state, starting at `initial` and advancing to the cursor of the
+ * last delivered item each batch; the stream never completes on its own (the next
+ * state is always `Option.some`), so the enclosing scope interrupts it on close. An
+ * `E` mid-stream stays on the channel, for the caller to die or to supervise.
+ *
+ * This is THE delivery algorithm, and `subscribeStream` runs the same machine. Under
+ * `emit: 'backlog'` a batch is everything a drain to the tail returned; under
+ * `'page'` it is one fetched page, so the paginate step and the page coincide and a
+ * full page is followed at once by the next read rather than by a wait.
+ *
+ * A `pollInterval` or `catchUpPageSize` the config fields would refuse is a DEFECT
+ * here, raised by the stream before it reads or forks anything, with a message
+ * naming the field. This caller may have no config whose decode would have caught
+ * it, and unchecked the two failures are silent or late: a page size of 0 gives a
+ * stream that never emits and never fails, and 1.5 dies only at the first read,
+ * inside `ReadLimit`, in words that name neither knob.
+ */
+export declare const subscribeItems: <A, C, E>(deps: ItemSubscriptionDeps<A, C, E>) => Stream.Stream<A, E, Scope.Scope>;
+/**
+ * Build the event subscription `Stream`: catch up from `after`, then track the live
+ * tail. A THIN wrapper over the machine `subscribeItems` runs, fixing the item to
+ * `SequencedEvent`, the cursor to its `position`, the start to `ORIGIN` when `after`
+ * is absent, and the emission to the default `'backlog'` — so every engine's call
+ * site, and every figure it delivers, is what it was before the machine became
+ * generic. It skips `subscribeItems`' tuning check, for the reason on `machine`. An `E`
+ * mid-stream stays on the channel; `makeContractStore` dies it (subscribe is
+ * `E = never` on the contract).
  */
 export declare const subscribeStream: <E>(deps: SubscriptionDeps<E>, after: Position | undefined) => Stream.Stream<SequencedEvent, E, Scope.Scope>;
 //# sourceMappingURL=SubscribeMachine.d.ts.map

package/dist/dts-esm/SubscribeMachine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SubscribeMachine.d.ts","sourceRoot":"","sources":["../../src/SubscribeMachine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,OAAO,EACL,MAAM,EAIN,MAAM,EACN,KAAK,KAAK,EACV,MAAM,EACP,MAAM,QAAQ,CAAA;AACf,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACvD,OAAO,EAAU,SAAS,EAAE,MAAM,SAAS,CAAA;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,MAAM,CAAA;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,4BAA4B,OAAO,CAAA;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,wBAAwB;;;CAO3B,CAAA;AAiBV;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,KACb,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAA;IACpD;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IAC3C,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CACjC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAC/B,MAAM,gBAAgB,CAAC,CAAC,CAAC,EACzB,OAAO,QAAQ,GAAG,SAAS,KAC1B,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CA+G5C,CAAA"}
+{"version":3,"file":"SubscribeMachine.d.ts","sourceRoot":"","sources":["../../src/SubscribeMachine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,OAAO,EACL,MAAM,EAIN,MAAM,EACN,KAAK,KAAK,EACV,MAAM,EACP,MAAM,QAAQ,CAAA;AACf,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACvD,OAAO,EAAU,SAAS,EAAE,MAAM,SAAS,CAAA;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,MAAM,CAAA;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,4BAA4B,OAAO,CAAA;AAWhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,wBAAwB;;;CAG3B,CAAA;AA2CV;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,MAAM,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,KAAK,EAAE,CAAC,EACR,KAAK,EAAE,SAAS,KACb,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IACvC,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;IACjC,sFAAsF;IACtF,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;IACnB,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IAC3C;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,iFAAiF;IACjF,QAAQ,CAAC,IAAI,CAAC,EAAE,oBAAoB,CAAA;CACrC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,KACb,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAA;IACpD;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IAC3C,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EACpC,MAAM,oBAAoB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAClC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAGjC,CAAA;AA4HD;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAC/B,MAAM,gBAAgB,CAAC,CAAC,CAAC,EACzB,OAAO,QAAQ,GAAG,SAAS,KAC1B,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAQ3C,CAAA"}

package/dist/esm/SubscribeMachine.js

@@ -5,6 +5,15 @@
  * the cursor's exclusive lower bound) and the poll loop that together turn a paged
  * read into a live subscription.
  *
+ * The algorithm is `subscribeItems`, generic over the item `A` it delivers and the
+ * cursor `C` it resumes from, because nothing in it is about an event: any source
+ * that can page-read strictly after a cursor and name the cursor of what it
+ * returned is subscribable by the same loop. `subscribeStream` is the event-store
+ * shape — `SequencedEvent` ordered by `Position` — over the same loop, and it is
+ * what every engine calls, unchanged by the generalisation. A second kind of
+ * source reuses the loop rather than growing a second one, for the reason the next
+ * paragraph gives.
+ *
  * It lives in core because delivery semantics are contract semantics. An engine
  * supplies TRANSPORT through two STUBBABLE seams — `fetch`, a paged read strictly
  * after a cursor, and `listen`, an optional wake source — and inherits the delivery
@@ -15,48 +24,52 @@
  * Both seams take plain in-memory values in a test, so the wake/poll/de-dup logic
  * is exercisable with no live backend at all.
  *
- * All THREE are the callers, and the count matters to a reader here: it means there
- * is exactly ONE delivery algorithm in this repo, and it is the code below. The
+ * All THREE engines are callers, and the count matters to a reader here: it means
+ * there is exactly ONE delivery algorithm in this repo, and it is the code below. The
  * in-memory store is a caller like the rest — it hands in a `fetch` over its log
  * `Ref` and its append `PubSub` as a wake source and keeps no delivery logic of its
  * own — which is what makes the shared contract suite's subscribe cases a comparison
  * of two BACKENDS rather than of two delivery algorithms.
  *
- * Correctness rests on the periodic position-based reconcile — a re-read from the
+ * Correctness rests on the periodic cursor-based reconcile — a re-read from the
  * cursor every poll interval — and NEVER on the wake source, which only lowers
  * delivery latency below that interval. A subscription with no wake source at all
  * is therefore complete and correct, merely slower, which is why `listen` is
  * optional in the TYPE rather than by the convention of passing `Stream.never`:
  * poll-only delivery is a supported shape, not a degraded one.
  *
- * ## The precondition every engine inherits: ASCENDING COMMIT ORDER
+ * ## The precondition every caller inherits: ASCENDING COMMIT ORDER
  *
- * A position that is committed and VISIBLE must never be below one already
- * delivered. Gaps are fine: the cursor is an ascending exclusive lower bound, so a
- * number that is allocated and never committed, or never allocated at all, is
- * simply a number the machine never sees. Out-of-order commits are not fine. If one
+ * It binds EVERY caller, over whatever cursor it chose — an engine's `Position`, or
+ * any other `C` handed to `subscribeItems` — and the example below is written in
+ * positions only because the engines are the callers it was first written for. A
+ * cursor that is committed and VISIBLE must never be below one already delivered.
+ * Gaps are fine: the cursor is an ascending exclusive lower bound, so a number
+ * that is allocated and never committed, or never allocated at all, is simply a
+ * number the machine never sees. Out-of-order commits are not fine. If one
  * writer allocates position 5 and another allocates 6, and 6 commits first, a poll
  * landing between the two commits delivers 6 and advances the cursor past it — and
  * 5 is then lost forever, because no later read looks below the cursor and nothing
- * anywhere notices the hole. An engine whose concurrent writers can commit out of
+ * anywhere notices the hole. A caller whose concurrent writers can commit out of
  * order MUST serialise them, or this machine will silently skip. An engine that
  * takes an exclusive lock on both of its append paths discharges the obligation
  * that way; an engine whose append is a single statement discharges it
  * structurally.
  *
  * The obligation is written down HERE, in the algorithm that depends on it, rather
- * than in whichever engine happens to satisfy it. It is a property of this delivery
- * loop and of nothing else, so an engine author reading only their own source has
+ * than in whichever caller happens to satisfy it. It is a property of this delivery
+ * loop and of nothing else, so an author reading only their own source has
  * no way to discover that anything downstream needs it — and the failure mode is
  * the worst kind there is: no error, no defect, no failing test, just an event that
  * a subscriber never receives. A single engine owning both its append path and its
  * own wake loop can leave the assumption implicit; a shared machine cannot.
  *
- * ## `catchUpPageSize` bounds the READ, not the emission
+ * ## `catchUpPageSize` bounds the READ, not the emission — unless `emit: 'page'`
  *
- * `drainFrom` below PAGES the catch-up read — `catchUpPageSize` bounds each
- * `fetch` — but it COLLECTS every page into one array, which is emitted as a SINGLE
- * chunk. So peak memory at subscription start is O(backlog) rather than O(page): a
+ * Under the default `emit: 'backlog'`, which is what `subscribeStream` and so every
+ * engine uses, `drainFrom` below PAGES the catch-up read — `catchUpPageSize` bounds
+ * each `fetch` — but it COLLECTS every page into one array, which is emitted as a
+ * SINGLE chunk. So peak memory at subscription start is O(backlog) rather than O(page): a
  * subscriber joining behind a large log materialises the whole backlog before its
  * consumer sees the first element.
  *
@@ -67,6 +80,19 @@
  * stay small even against a one-chunk catch-up. The cost therefore lands on backlog
  * memory alone, and it lands hardest on the durable-log-with-in-memory-view mode,
  * where an ephemeral view re-catches-up the entire log on every boot.
+ *
+ * `emit: 'page'` changes exactly that and nothing else. Each fetched page is
+ * emitted as its own chunk and the cursor advances past it before the next read, so
+ * peak memory is O(page) and the consumer sees the first item after ONE read rather
+ * than after the whole backlog. Delivery is unchanged: the same items in the same
+ * order, the same de-dup, the same wake and poll. What a caller gives up is the
+ * one-chunk catch-up, so it must not read meaning into chunk boundaries under
+ * either mode. It is for a consumer that does NOT re-chunk downstream and whose
+ * catch-up can be the whole of a large source — a full resync of a table, say —
+ * where holding the backlog would be the cost the paging was meant to avoid. The
+ * engines keep `'backlog'` because the read side's re-chunking already bounds what
+ * they commit, and changing their emission would move a behaviour nobody asked to
+ * move.
  */
 import { Effect, Option, Queue, Schedule, Schema, Stream } from 'effect';
 import { ORIGIN, ReadLimit } from "./Event.js";
@@ -95,6 +121,10 @@ export const DEFAULT_CATCH_UP_PAGE_SIZE = 512;
  * one-second fallback poll (`conn.wait(..., interval=1)`).
  */
 export const DEFAULT_POLL_INTERVAL_MILLIS = 1000;
+/** A usable `pollInterval`: see `subscriptionTuningFields` for the bounds' argument. */
+const PollIntervalMillis = /*#__PURE__*/Schema.Number.check(/*#__PURE__*/Schema.isGreaterThan(0), /*#__PURE__*/Schema.isFinite());
+/** A usable `catchUpPageSize`: see `subscriptionTuningFields` for the bounds' argument. */
+const CatchUpPageSize = /*#__PURE__*/Schema.Int.check(/*#__PURE__*/Schema.isGreaterThan(0));
 /**
  * The two subscribe-tuning config FIELDS, for an engine whose config is a `Schema`
  * to spread into its own struct.
@@ -125,8 +155,24 @@ export const DEFAULT_POLL_INTERVAL_MILLIS = 1000;
  * absent key, never an explicit `undefined`.
  */
 export const subscriptionTuningFields = {
-  pollInterval: /*#__PURE__*/Schema.optionalKey(/*#__PURE__*/Schema.Number.check(/*#__PURE__*/Schema.isGreaterThan(0), /*#__PURE__*/Schema.isFinite())),
-  catchUpPageSize: /*#__PURE__*/Schema.optionalKey(/*#__PURE__*/Schema.Int.check(/*#__PURE__*/Schema.isGreaterThan(0)))
+  pollInterval: /*#__PURE__*/Schema.optionalKey(PollIntervalMillis),
+  catchUpPageSize: /*#__PURE__*/Schema.optionalKey(CatchUpPageSize)
+};
+/**
+ * Why a caller-supplied tuning knob is unusable, naming the field and the value, or
+ * `undefined` when both are usable or absent. It judges with the SAME two schemas
+ * the config fields are built from, so `subscribeItems`, whose caller may have no
+ * config to decode, accepts exactly what an engine's config accepts and the bounds
+ * have one home.
+ */
+const tuningFault = deps => {
+  if (deps.pollInterval !== undefined && !Schema.is(PollIntervalMillis)(deps.pollInterval)) {
+    return `subscribeItems: pollInterval must be a finite number of milliseconds greater than 0, got ${deps.pollInterval}`;
+  }
+  if (deps.catchUpPageSize !== undefined && !Schema.is(CatchUpPageSize)(deps.catchUpPageSize)) {
+    return `subscribeItems: catchUpPageSize must be an integer greater than 0, got ${deps.catchUpPageSize}`;
+  }
+  return undefined;
 };
 /**
  * Retry a TRANSIENT poll fault (an `E` from one reconcile read) on a capped
@@ -137,14 +183,39 @@ export const subscriptionTuningFields = {
  */
 const POLL_RETRY_SCHEDULE = /*#__PURE__*/Schedule.max([/*#__PURE__*/Schedule.min([/*#__PURE__*/Schedule.exponential('100 millis', 2), /*#__PURE__*/Schedule.spaced('2 seconds')]), /*#__PURE__*/Schedule.recurs(20)]);
 /**
- * Build the subscription `Stream`: catch up from `after`, then track the live tail.
- * The cursor threads through the `Stream.paginate` state, starting at `after` and
- * advancing to the last delivered position each batch; the stream never completes
- * on its own (the next state is always `Option.some`), so the enclosing scope
- * interrupts it on close. An `E` mid-stream stays on the channel; `makeContractStore` dies it
- * (subscribe is `E = never` on the contract).
+ * Build a subscription `Stream` over any ascending-cursor source: catch up from
+ * `initial`, then track the live tail. The cursor threads through the
+ * `Stream.paginate` state, starting at `initial` and advancing to the cursor of the
+ * last delivered item each batch; the stream never completes on its own (the next
+ * state is always `Option.some`), so the enclosing scope interrupts it on close. An
+ * `E` mid-stream stays on the channel, for the caller to die or to supervise.
+ *
+ * This is THE delivery algorithm, and `subscribeStream` runs the same machine. Under
+ * `emit: 'backlog'` a batch is everything a drain to the tail returned; under
+ * `'page'` it is one fetched page, so the paginate step and the page coincide and a
+ * full page is followed at once by the next read rather than by a wait.
+ *
+ * A `pollInterval` or `catchUpPageSize` the config fields would refuse is a DEFECT
+ * here, raised by the stream before it reads or forks anything, with a message
+ * naming the field. This caller may have no config whose decode would have caught
+ * it, and unchecked the two failures are silent or late: a page size of 0 gives a
+ * stream that never emits and never fails, and 1.5 dies only at the first read,
+ * inside `ReadLimit`, in words that name neither knob.
+ */
+export const subscribeItems = deps => {
+  const fault = tuningFault(deps);
+  return fault === undefined ? machine(deps) : Stream.die(new Error(fault));
+};
+/**
+ * The machine itself, with no check of its tuning. `subscribeStream` runs it
+ * directly, and deliberately: the event path stays exactly as it was, with no
+ * second check of figures each SQL engine has already decoded from its config
+ * through the same bounds, and the in-memory store's are a test's own options.
  */
-export const subscribeStream = (deps, after) => Stream.unwrap(Effect.gen(function* () {
+const machine = deps => Stream.unwrap(Effect.gen(function* () {
+  const pageSize = deps.catchUpPageSize ?? DEFAULT_CATCH_UP_PAGE_SIZE;
+  const pollInterval = deps.pollInterval ?? DEFAULT_POLL_INTERVAL_MILLIS;
+  const limit = ReadLimit.make(pageSize);
   // The wake primitive: a sliding(1) queue holding at most one pending
   // signal. The wake source `offer`s an opaque wake on every notification;
   // the poll loop `take`s (with a timeout). The lost-wakeup guard is
@@ -165,61 +236,82 @@ export const subscribeStream = (deps, after) => Stream.unwrap(Effect.gen(functio
   // scope releases it. We never read its elements directly — every
   // notification is an opaque wake signal.
   yield* listener.pipe(Stream.runDrain, Effect.forkScoped);
+  // One page strictly after `from`: the step `drainFrom` loops, and the whole
+  // of a `'page'` read.
+  const fetchPage = from => deps.fetch(from, limit);
   // Reconcile: page-read from `from` until a short page, advancing to the last
-  // delivered position. Retries a TRANSIENT poll fault on a capped schedule so
+  // delivered cursor. Retries a TRANSIENT poll fault on a capped schedule so
   // a single connection blip does not kill a days-long subscription; a
-  // persistent fault propagates and dies.
+  // persistent fault propagates. The retry wraps the WHOLE drain, so a fault on
+  // page three re-reads pages one and two: nothing has been emitted yet, so
+  // that costs reads and never a duplicate.
   const drainFrom = from => Effect.gen(function* () {
     const collected = [];
     let cursor = from;
     // Loop pages until a short page signals the tail is drained.
     while (true) {
-      const events = yield* deps.fetch(cursor, ReadLimit.make(deps.catchUpPageSize));
-      for (const event of events) {
-        collected.push(event);
+      const items = yield* fetchPage(cursor);
+      for (const item of items) {
+        collected.push(item);
       }
-      const lastEvent = events.at(-1);
-      if (lastEvent === undefined || events.length < deps.catchUpPageSize) {
+      const lastItem = items.at(-1);
+      if (lastItem === undefined || items.length < pageSize) {
         break;
       }
-      cursor = lastEvent.position;
+      cursor = deps.cursorOf(lastItem);
     }
-    const last = collected.at(-1)?.position ?? from;
-    return {
-      events: collected,
-      last
-    };
+    return collected;
   }).pipe(Effect.retry(POLL_RETRY_SCHEDULE));
+  // The read one paginate step performs, by emission mode. Under `'page'` the
+  // retry wraps the single page, which is the whole of what is unemitted.
+  const read = (deps.emit ?? 'backlog') === 'page' ? from => fetchPage(from).pipe(Effect.retry(POLL_RETRY_SCHEDULE)) : drainFrom;
   /**
-   * Produce the NEXT non-empty batch from a cursor position, together with
-   * the advanced cursor — a pure `Position → Effect<[events, next]>`. The
-   * `> boundary` de-dup is enforced by `fetch`'s exclusive lower bound, so a
-   * live re-read after a wake never re-emits an already-delivered position.
+   * Produce the NEXT non-empty batch from a cursor, together with the advanced
+   * cursor — a pure `C → Effect<[items, next]>`. The `> boundary` de-dup is
+   * enforced by `fetch`'s exclusive lower bound, so a live re-read after a wake
+   * never re-emits an already-delivered item.
    *
-   * Drain the wake queue BEFORE reading (lost-wakeup guard), then drain from
-   * the cursor. If a drain yields nothing, wait for a wake but only up to the
-   * poll interval, then loop and re-read ANYWAY — the periodic position-based
-   * poll that makes delivery correct independently of any wake. This effect
-   * only completes by returning a non-empty batch; the scope interrupts it on
-   * close.
+   * Drain the wake queue BEFORE reading (lost-wakeup guard), then read from the
+   * cursor. If a read yields nothing, wait for a wake but only up to the poll
+   * interval, then loop and re-read ANYWAY — the periodic cursor-based poll that
+   * makes delivery correct independently of any wake. This effect only
+   * completes by returning a non-empty batch; the scope interrupts it on close.
    */
   const nextBatch = from => Effect.gen(function* () {
     while (true) {
       // `Queue.clear` and not `Queue.takeAll`: the drain must NOT wait, and
       // `takeAll` suspends until at least one signal is present.
       yield* Queue.clear(wake);
-      const {
-        events,
-        last
-      } = yield* drainFrom(from);
-      if (events.length > 0) {
-        return [events, last];
+      const items = yield* read(from);
+      const last = items.at(-1);
+      if (last !== undefined) {
+        return [items, deps.cursorOf(last)];
       }
       // Nothing new: block on a wake, but only up to the poll interval — on
       // timeout we fall through and the loop re-reads regardless.
-      yield* Effect.ignore(Effect.timeout(Queue.take(wake), deps.pollInterval));
+      yield* Effect.ignore(Effect.timeout(Queue.take(wake), pollInterval));
     }
   });
-  return Stream.paginate(after ?? ORIGIN, from => Effect.map(nextBatch(from), ([events, last]) => [events, Option.some(last)]));
+  return Stream.paginate(deps.initial, from => Effect.map(nextBatch(from), ([items, next]) => [items, Option.some(next)]));
 }));
+/**
+ * Build the event subscription `Stream`: catch up from `after`, then track the live
+ * tail. A THIN wrapper over the machine `subscribeItems` runs, fixing the item to
+ * `SequencedEvent`, the cursor to its `position`, the start to `ORIGIN` when `after`
+ * is absent, and the emission to the default `'backlog'` — so every engine's call
+ * site, and every figure it delivers, is what it was before the machine became
+ * generic. It skips `subscribeItems`' tuning check, for the reason on `machine`. An `E`
+ * mid-stream stays on the channel; `makeContractStore` dies it (subscribe is
+ * `E = never` on the contract).
+ */
+export const subscribeStream = (deps, after) => machine({
+  fetch: deps.fetch,
+  cursorOf: event => event.position,
+  initial: after ?? ORIGIN,
+  ...(deps.listen === undefined ? {} : {
+    listen: deps.listen
+  }),
+  pollInterval: deps.pollInterval,
+  catchUpPageSize: deps.catchUpPageSize
+});
 //# sourceMappingURL=SubscribeMachine.js.map

package/dist/esm/SubscribeMachine.js.map

@@ -1 +1 @@
-{"version":3,"file":"SubscribeMachine.js","names":["Effect","Option","Queue","Schedule","Schema","Stream","ORIGIN","ReadLimit","DEFAULT_CATCH_UP_PAGE_SIZE","DEFAULT_POLL_INTERVAL_MILLIS","subscriptionTuningFields","pollInterval","optionalKey","Number","check","isGreaterThan","isFinite","catchUpPageSize","Int","POLL_RETRY_SCHEDULE","max","min","exponential","spaced","recurs","subscribeStream","deps","after","unwrap","gen","wake","sliding","listener","listen","never","pipe","tap","offer","undefined","retry","runDrain","forkScoped","drainFrom","from","collected","cursor","events","fetch","make","event","push","lastEvent","at","length","position","last","nextBatch","clear","ignore","timeout","take","paginate","map","some"],"sources":["../../src/SubscribeMachine.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"SubscribeMachine.js","names":["Effect","Option","Queue","Schedule","Schema","Stream","ORIGIN","ReadLimit","DEFAULT_CATCH_UP_PAGE_SIZE","DEFAULT_POLL_INTERVAL_MILLIS","PollIntervalMillis","Number","check","isGreaterThan","isFinite","CatchUpPageSize","Int","subscriptionTuningFields","pollInterval","optionalKey","catchUpPageSize","tuningFault","deps","undefined","is","POLL_RETRY_SCHEDULE","max","min","exponential","spaced","recurs","subscribeItems","fault","machine","die","Error","unwrap","gen","pageSize","limit","make","wake","sliding","listener","listen","never","pipe","tap","offer","retry","runDrain","forkScoped","fetchPage","from","fetch","drainFrom","collected","cursor","items","item","push","lastItem","at","length","cursorOf","read","emit","nextBatch","clear","last","ignore","timeout","take","paginate","initial","map","next","some","subscribeStream","after","event","position"],"sources":["../../src/SubscribeMachine.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kairos-es/core",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.6",
   "description": "DCB-first event-sourcing contract and in-memory store for Effect 4",
   "license": "BSD-3-Clause",
   "repository": {