@kairos-es/store-postgres 0.0.0 → 1.0.0-alpha.1

package/dist/esm/config.js

@@ -73,7 +73,8 @@ export const PostgresStoreConfig = /*#__PURE__*/Schema.Struct({
   // The two subscribe knobs are core's field definitions, not this engine's: see
   // `subscriptionTuningFields`.
   ...subscriptionTuningFields
-}).pipe(/*#__PURE__*/
+}).pipe(
+/*#__PURE__*/
 // Cross-field guard: the derived table/index/function/channel names must all
 // fit Postgres's 63-byte identifier limit. Returning the message string fails
 // the decode with it; `undefined`/`true` passes.

package/dist/esm/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","names":["subscriptionTuningFields","Schema","oversizedIdentifier","IdentifierAtom","String","pipe","nonEmptyString","pattern","identifier","description","PostgresStoreConfig","Struct","schema","optionalWith","exact","tablePrefix","lockTimeout","Number","nonNegative","finite","filter","config","decodePostgresStoreConfig","decodeUnknownSync"],"sources":["../../src/config.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;AAoBA,SAASA,wBAAwB,QAAQ,iBAAiB;AAC1D,SAASC,MAAM,QAAQ,QAAQ;AAC/B,SAASC,mBAAmB,QAAQ,mBAAgB;AAEpD;;;;;;AAMA,MAAMC,cAAc,gBAAGF,MAAM,CAACG,MAAM,CAACC,IAAI,cACvCJ,MAAM,CAACK,cAAc,EAAE,eACvBL,MAAM,CAACM,OAAO,CAAC,SAAS,EAAE;EACxBC,UAAU,EAAE,wBAAwB;EACpCC,WAAW,EAAE;CACd,CAAC,CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMC,mBAAmB,gBAAGT,MAAM,CAACU,MAAM,CAAC;EAC/C;EACA;EACA;EACAC,MAAM,EAAEX,MAAM,CAACY,YAAY,CAACV,cAAc,EAAE;IAAEW,KAAK,EAAE;EAAI,CAAE,CAAC;EAC5DC,WAAW,EAAEd,MAAM,CAACY,YAAY,CAACV,cAAc,EAAE;IAAEW,KAAK,EAAE;EAAI,CAAE,CAAC;EACjEE,WAAW,EAAEf,MAAM,CAACY,YAAY,CAC9BZ,MAAM,CAACgB,MAAM,CAACZ,IAAI,CAACJ,MAAM,CAACiB,WAAW,EAAE,EAAEjB,MAAM,CAACkB,MAAM,EAAE,CAAC,EACzD;IAAEL,KAAK,EAAE;EAAI,CAAE,CAChB;EACD;EACA;EACA,GAAGd;CACJ,CAAC,CAACK,IAAI;AACL;AACA;AACA;AACAJ,MAAM,CAACmB,MAAM,CAAEC,MAAM,IAAKnB,mBAAmB,CAACmB,MAAM,CAAC,IAAI,IAAI,CAAC,CAC/D;AAGD;;;;;AAKA,OAAO,MAAMC,yBAAyB,gBACpCrB,MAAM,CAACsB,iBAAiB,CAACb,mBAAmB,CAAC","ignoreList":[]}
+{"version":3,"file":"config.js","names":["subscriptionTuningFields","Schema","oversizedIdentifier","IdentifierAtom","String","pipe","nonEmptyString","pattern","identifier","description","PostgresStoreConfig","Struct","schema","optionalWith","exact","tablePrefix","lockTimeout","Number","nonNegative","finite","filter","config","decodePostgresStoreConfig","decodeUnknownSync"],"sources":["../../src/config.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;AAoBA,SAASA,wBAAwB,QAAQ,iBAAiB;AAC1D,SAASC,MAAM,QAAQ,QAAQ;AAC/B,SAASC,mBAAmB,QAAQ,mBAAgB;AAEpD;;;;;;AAMA,MAAMC,cAAc,gBAAGF,MAAM,CAACG,MAAM,CAACC,IAAI,cACvCJ,MAAM,CAACK,cAAc,EAAE,eACvBL,MAAM,CAACM,OAAO,CAAC,SAAS,EAAE;EACxBC,UAAU,EAAE,wBAAwB;EACpCC,WAAW,EAAE;CACd,CAAC,CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMC,mBAAmB,gBAAGT,MAAM,CAACU,MAAM,CAAC;EAC/C;EACA;EACA;EACAC,MAAM,EAAEX,MAAM,CAACY,YAAY,CAACV,cAAc,EAAE;IAAEW,KAAK,EAAE;EAAI,CAAE,CAAC;EAC5DC,WAAW,EAAEd,MAAM,CAACY,YAAY,CAACV,cAAc,EAAE;IAAEW,KAAK,EAAE;EAAI,CAAE,CAAC;EACjEE,WAAW,EAAEf,MAAM,CAACY,YAAY,CAC9BZ,MAAM,CAACgB,MAAM,CAACZ,IAAI,CAACJ,MAAM,CAACiB,WAAW,EAAE,EAAEjB,MAAM,CAACkB,MAAM,EAAE,CAAC,EACzD;IAAEL,KAAK,EAAE;EAAI,CAAE,CAChB;EACD;EACA;EACA,GAAGd;CACJ,CAAC,CAACK,IAAI;AAAA;AACL;AACA;AACA;AACAJ,MAAM,CAACmB,MAAM,CAAEC,MAAM,IAAKnB,mBAAmB,CAACmB,MAAM,CAAC,IAAI,IAAI,CAAC,CAC/D;AAGD;;;;;AAKA,OAAO,MAAMC,yBAAyB,gBACpCrB,MAAM,CAACsB,iBAAiB,CAACb,mBAAmB,CAAC","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kairos-es/store-postgres",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.1",
   "description": "Postgres DcbEventStore backend for kairos-es",
   "license": "BSD-3-Clause",
   "repository": {
@@ -16,7 +16,7 @@
     "@effect/sql": "^0.52.0",
     "@effect/sql-pg": "^0.53.0",
     "effect": "^3.22.0",
-    "@kairos-es/core": "^0.0.0"
+    "@kairos-es/core": "^1.0.0-alpha.1"
   },
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",

package/dist/cjs/internal/subscribe.js

@@ -1,120 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.subscribeStream = exports.DEFAULT_POLL_INTERVAL_MILLIS = exports.DEFAULT_CATCH_UP_PAGE = void 0;
-var _core = require("@kairos-es/core");
-var _effect = require("effect");
-/**
- * A short catch-up page size default for the reconcile loop. Reads page by page
- * until a short page signals the tail is drained, so a large backlog is streamed
- * in bounded chunks rather than one huge SELECT. Overridable via
- * `config.catchUpPageSize`.
- */
-const DEFAULT_CATCH_UP_PAGE = exports.DEFAULT_CATCH_UP_PAGE = 512;
-/**
- * The default upper bound a live subscriber waits for a wake before re-reading
- * from its cursor ANYWAY (milliseconds; overridable via `config.pollInterval`).
- * This periodic position-based poll — not `NOTIFY` — is the correctness
- * guarantee: every committed position is reconciled within this interval
- * regardless of whether its `NOTIFY` was heard, which covers a `NOTIFY` fired
- * before `LISTEN` was fully established, a coalesced/lost `NOTIFY`, and a listen
- * connection that dropped SILENTLY (the `@effect/sql-pg` listen client swallows
- * connection errors and does not auto-reconnect). `NOTIFY` only lowers delivery
- * latency below this interval. Upstream `postgres_tt.py` uses the same 1-second
- * fallback poll (`conn.wait(..., interval=1)`).
- */
-const DEFAULT_POLL_INTERVAL_MILLIS = exports.DEFAULT_POLL_INTERVAL_MILLIS = 1000;
-/**
- * Retry a TRANSIENT poll fault (a `SqlError` from one reconcile read) on a capped
- * exponential backoff rather than letting `Stream.orDie` kill a subscription that
- * may have been alive for days over a single connection blip. A fault that
- * PERSISTS past the cap propagates (the decorator dies it) — infrastructure stays
- * off the contract channel while the stream survives ordinary transients.
- */
-const POLL_RETRY_SCHEDULE = /*#__PURE__*/_effect.Schedule.exponential('100 millis', 2).pipe(/*#__PURE__*/_effect.Schedule.union(/*#__PURE__*/_effect.Schedule.spaced('2 seconds')), /*#__PURE__*/_effect.Schedule.intersect(/*#__PURE__*/_effect.Schedule.recurs(20)));
-/**
- * Build the subscription `Stream`: catch up from `after`, then track the live
- * tail. The cursor threads through the `unfoldChunkEffect` unfold state, starting
- * at `after` and advancing to the last delivered position each batch; the stream
- * never completes on its own (always `Option.some`), so the enclosing scope
- * interrupts it on close. A `SqlError` mid-stream stays on the channel;
- * `makeContractStore` dies it (subscribe is `E = never` on the contract).
- */
-const subscribeStream = (deps, after) => _effect.Stream.unwrapScoped(_effect.Effect.gen(function* () {
-  // The wake primitive: a sliding(1) queue holding at most one pending
-  // signal. The listener `offer`s an opaque wake on every NOTIFY; the poll
-  // loop `take`s (with a timeout). The lost-wakeup guard is STRUCTURAL —
-  // drain the queue BEFORE reading, so a NOTIFY that lands mid-read leaves
-  // a fresh signal that makes the next `take` return at once rather than
-  // sleeping through a real change.
-  const wake = yield* _effect.Queue.sliding(1);
-  // Tap every notification into the wake queue. If the listen stream DOES
-  // surface an error, re-subscribe with capped-exponential backoff. In
-  // practice the @effect/sql-pg listen client usually swallows a dropped
-  // connection SILENTLY rather than erroring, so this retry rarely fires —
-  // the poll fallback below, not this retry, is the real reconnect guarantee:
-  // the reconcile loop re-reads from the cursor on every poll, so a silently-
-  // dropped (and later re-established) listener loses no positions.
-  const listener = deps.listen.pipe(_effect.Stream.tap(() => _effect.Queue.offer(wake, undefined)), _effect.Stream.retry(_effect.Schedule.exponential('50 millis').pipe(_effect.Schedule.union(_effect.Schedule.spaced('1 seconds')))));
-  // Drain the listener into the wake queue on a background fibre; the scope
-  // releases it. We never read its elements directly — every notification is
-  // an opaque wake signal.
-  yield* listener.pipe(_effect.Stream.runDrain, _effect.Effect.forkScoped);
-  // 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
-  // a single connection blip does not kill a days-long subscription; a
-  // persistent fault propagates and dies.
-  const drainFrom = from => _effect.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, _core.ReadLimit.make(deps.catchUpPage));
-      for (const event of events) {
-        collected.push(event);
-      }
-      const lastEvent = events.at(-1);
-      if (lastEvent === undefined || events.length < deps.catchUpPage) {
-        break;
-      }
-      cursor = lastEvent.position;
-    }
-    const last = collected.at(-1)?.position ?? from;
-    return {
-      events: collected,
-      last
-    };
-  }).pipe(_effect.Effect.retry(POLL_RETRY_SCHEDULE));
-  /**
-   * Produce the NEXT non-empty batch from a cursor position, together with
-   * the advanced cursor — a pure `Position → Effect<[Chunk, 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.
-   *
-   * 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 NOTIFY. This effect only
-   * completes by returning a non-empty chunk; the scope interrupts it on close.
-   */
-  const nextBatch = from => _effect.Effect.gen(function* () {
-    while (true) {
-      yield* _effect.Queue.takeAll(wake);
-      const {
-        events,
-        last
-      } = yield* drainFrom(from);
-      if (events.length > 0) {
-        return [_effect.Chunk.fromIterable(events), 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.Effect.ignore(_effect.Effect.timeout(_effect.Queue.take(wake), deps.pollInterval));
-    }
-  });
-  return _effect.Stream.unfoldChunkEffect(after ?? _core.ORIGIN, from => _effect.Effect.map(nextBatch(from), _effect.Option.some));
-}));
-exports.subscribeStream = subscribeStream;
-//# sourceMappingURL=subscribe.js.map

package/dist/cjs/internal/subscribe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"subscribe.js","names":["_core","require","_effect","DEFAULT_CATCH_UP_PAGE","exports","DEFAULT_POLL_INTERVAL_MILLIS","POLL_RETRY_SCHEDULE","Schedule","exponential","pipe","union","spaced","intersect","recurs","subscribeStream","deps","after","Stream","unwrapScoped","Effect","gen","wake","Queue","sliding","listener","listen","tap","offer","undefined","retry","runDrain","forkScoped","drainFrom","from","collected","cursor","events","fetch","ReadLimit","make","catchUpPage","event","push","lastEvent","at","length","position","last","nextBatch","takeAll","Chunk","fromIterable","ignore","timeout","take","pollInterval","unfoldChunkEffect","ORIGIN","map","Option","some"],"sources":["../../../src/internal/subscribe.ts"],"sourcesContent":[null],"mappings":";;;;;;AAgCA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAUA;;;;;;AAMO,MAAME,qBAAqB,GAAAC,OAAA,CAAAD,qBAAA,GAAG,GAAG;AAExC;;;;;;;;;;;;AAYO,MAAME,4BAA4B,GAAAD,OAAA,CAAAC,4BAAA,GAAG,IAAI;AAEhD;;;;;;;AAOA,MAAMC,mBAAmB,gBAAGC,gBAAQ,CAACC,WAAW,CAAC,YAAY,EAAE,CAAC,CAAC,CAACC,IAAI,cACpEF,gBAAQ,CAACG,KAAK,cAACH,gBAAQ,CAACI,MAAM,CAAC,WAAW,CAAC,CAAC,eAC5CJ,gBAAQ,CAACK,SAAS,cAACL,gBAAQ,CAACM,MAAM,CAAC,EAAE,CAAC,CAAC,CACxC;AA6BD;;;;;;;;AAQO,MAAMC,eAAe,GAAGA,CAC7BC,IAAsB,EACtBC,KAA2B,KAE3BC,cAAM,CAACC,YAAY,CACjBC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,IAAI,GAAG,OAAOC,aAAK,CAACC,OAAO,CAAO,CAAC,CAAC;EAE1C;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,QAAQ,GAAGT,IAAI,CAACU,MAAM,CAAChB,IAAI,CAC/BQ,cAAM,CAACS,GAAG,CAAC,MAAMJ,aAAK,CAACK,KAAK,CAACN,IAAI,EAAEO,SAAS,CAAC,CAAC,EAC9CX,cAAM,CAACY,KAAK,CACVtB,gBAAQ,CAACC,WAAW,CAAC,WAAW,CAAC,CAACC,IAAI,CACpCF,gBAAQ,CAACG,KAAK,CAACH,gBAAQ,CAACI,MAAM,CAAC,WAAW,CAAC,CAAC,CAC7C,CACF,CACF;EACD;EACA;EACA;EACA,OAAOa,QAAQ,CAACf,IAAI,CAACQ,cAAM,CAACa,QAAQ,EAAEX,cAAM,CAACY,UAAU,CAAC;EAExD;EACA;EACA;EACA;EACA,MAAMC,SAAS,GACbC,IAAc,IAQdd,cAAM,CAACC,GAAG,CAAC,aAAS;IAClB,MAAMc,SAAS,GAA0B,EAAE;IAC3C,IAAIC,MAAM,GAAGF,IAAI;IACjB;IACA,OAAO,IAAI,EAAE;MACX,MAAMG,MAAM,GAAG,OAAOrB,IAAI,CAACsB,KAAK,CAC9BF,MAAM,EACNG,eAAS,CAACC,IAAI,CAACxB,IAAI,CAACyB,WAAW,CAAC,CACjC;MACD,KAAK,MAAMC,KAAK,IAAIL,MAAM,EAAE;QAC1BF,SAAS,CAACQ,IAAI,CAACD,KAAK,CAAC;MACvB;MACA,MAAME,SAAS,GAAGP,MAAM,CAACQ,EAAE,CAAC,CAAC,CAAC,CAAC;MAC/B,IAAID,SAAS,KAAKf,SAAS,IAAIQ,MAAM,CAACS,MAAM,GAAG9B,IAAI,CAACyB,WAAW,EAAE;QAC/D;MACF;MACAL,MAAM,GAAGQ,SAAS,CAACG,QAAQ;IAC7B;IACA,MAAMC,IAAI,GAAGb,SAAS,CAACU,EAAE,CAAC,CAAC,CAAC,CAAC,EAAEE,QAAQ,IAAIb,IAAI;IAC/C,OAAO;MAAEG,MAAM,EAAEF,SAAS;MAAEa;IAAI,CAAE;EACpC,CAAC,CAAC,CAACtC,IAAI,CAACU,cAAM,CAACU,KAAK,CAACvB,mBAAmB,CAAC,CAAC;EAE5C;;;;;;;;;;;;EAYA,MAAM0C,SAAS,GACbf,IAAc,IAKdd,cAAM,CAACC,GAAG,CAAC,aAAS;IAClB,OAAO,IAAI,EAAE;MACX,OAAOE,aAAK,CAAC2B,OAAO,CAAC5B,IAAI,CAAC;MAC1B,MAAM;QAAEe,MAAM;QAAEW;MAAI,CAAE,GAAG,OAAOf,SAAS,CAACC,IAAI,CAAC;MAC/C,IAAIG,MAAM,CAACS,MAAM,GAAG,CAAC,EAAE;QACrB,OAAO,CAACK,aAAK,CAACC,YAAY,CAACf,MAAM,CAAC,EAAEW,IAAI,CAAU;MACpD;MACA;MACA;MACA,OAAO5B,cAAM,CAACiC,MAAM,CAClBjC,cAAM,CAACkC,OAAO,CAAC/B,aAAK,CAACgC,IAAI,CAACjC,IAAI,CAAC,EAAEN,IAAI,CAACwC,YAAY,CAAC,CACpD;IACH;EACF,CAAC,CAAC;EAEJ,OAAOtC,cAAM,CAACuC,iBAAiB,CAACxC,KAAK,IAAIyC,YAAM,EAAGxB,IAAI,IACpDd,cAAM,CAACuC,GAAG,CAACV,SAAS,CAACf,IAAI,CAAC,EAAE0B,cAAM,CAACC,IAAI,CAAC,CACzC;AACH,CAAC,CAAC,CACH;AAAAxD,OAAA,CAAAU,eAAA,GAAAA,eAAA","ignoreList":[]}

package/dist/dts/internal/subscribe.d.ts

@@ -1,87 +0,0 @@
-/**
- * The subscribe machine for the Postgres engine, extracted from `store.ts`. It owns
- * the wake queue, the listener drain, the paged catch-up reconcile, the `> boundary`
- * de-dup (via the cursor's exclusive lower bound), and the poll loop — all behind
- * two STUBBABLE seams (`fetch`, `listen`), so the wake/poll/dedup logic is
- * UNIT-TESTABLE with no live database (see `test/subscribe.test.ts`). `store.ts`
- * supplies production `fetch`/`listen` built from the pooled/direct clients.
- *
- * Correctness rests on the periodic position-based reconcile — a re-read from the
- * cursor every poll interval — NOT on `NOTIFY`, which is only a latency
- * optimisation. Exclusive-lock commit order equals sequence order, so an
- * ascending re-read never skips a temporary gap; permanent bigserial gaps are
- * simply absent positions and are fine to skip.
- *
- * ## `catchUpPageSize` bounds the STATEMENT, not the emission
- *
- * `drainFrom` below PAGES the catch-up read — `catchUpPageSize` bounds each
- * `SELECT` — 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.
- *
- * That is a memory characteristic and nothing more, which is why ONE chunk is
- * enough here: downstream commit boundaries do not depend on the upstream chunking
- * at all, because the read side's `Stream.groupedWithin` re-chunks the stream into
- * bounded micro-batches whatever arrives (ADR-0007), so a projection's transactions
- * 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.
- */
-import type { SqlError } from '@effect/sql';
-import type { Position, SequencedEvent } from '@kairos-es/core';
-import { ReadLimit } from '@kairos-es/core';
-import { Effect, type Scope, Stream } from 'effect';
-/**
- * A short catch-up page size default for the reconcile loop. Reads page by page
- * until a short page signals the tail is drained, so a large backlog is streamed
- * in bounded chunks rather than one huge SELECT. Overridable via
- * `config.catchUpPageSize`.
- */
-export declare const DEFAULT_CATCH_UP_PAGE = 512;
-/**
- * The default upper bound a live subscriber waits for a wake before re-reading
- * from its cursor ANYWAY (milliseconds; overridable via `config.pollInterval`).
- * This periodic position-based poll — not `NOTIFY` — is the correctness
- * guarantee: every committed position is reconciled within this interval
- * regardless of whether its `NOTIFY` was heard, which covers a `NOTIFY` fired
- * before `LISTEN` was fully established, a coalesced/lost `NOTIFY`, and a listen
- * connection that dropped SILENTLY (the `@effect/sql-pg` listen client swallows
- * connection errors and does not auto-reconnect). `NOTIFY` only lowers delivery
- * latency below this interval. Upstream `postgres_tt.py` uses the same 1-second
- * fallback poll (`conn.wait(..., interval=1)`).
- */
-export declare const DEFAULT_POLL_INTERVAL_MILLIS = 1000;
-/**
- * The two seams the subscribe machine runs over, plus the two tuning knobs. In
- * production `fetch` is a compiled read plan run against the pooled client and
- * mapped to `SequencedEvent`s, and `listen` is `PgClientDirect.listen(channel)`;
- * a unit test stubs both with plain in-memory values.
- */
-export interface SubscriptionDeps {
-    /**
-     * Page-read the events strictly after `from`, up to `limit`, ascending by
-     * position. Returning FEWER than `limit` signals the tail is drained.
-     */
-    readonly fetch: (from: Position, limit: ReadLimit) => Effect.Effect<ReadonlyArray<SequencedEvent>, SqlError.SqlError>;
-    /**
-     * The raw wake source: each element is an opaque wake signal (a `NOTIFY`). The
-     * machine taps it into its own wake queue and drains it on a background fibre;
-     * it never reads the elements. `Stream.never` is a valid poll-only source.
-     */
-    readonly listen: Stream.Stream<unknown, SqlError.SqlError>;
-    /** The poll interval in milliseconds (see `DEFAULT_POLL_INTERVAL_MILLIS`). */
-    readonly pollInterval: number;
-    /** The catch-up page size (see `DEFAULT_CATCH_UP_PAGE`). */
-    readonly catchUpPage: number;
-}
-/**
- * Build the subscription `Stream`: catch up from `after`, then track the live
- * tail. The cursor threads through the `unfoldChunkEffect` unfold state, starting
- * at `after` and advancing to the last delivered position each batch; the stream
- * never completes on its own (always `Option.some`), so the enclosing scope
- * interrupts it on close. A `SqlError` mid-stream stays on the channel;
- * `makeContractStore` dies it (subscribe is `E = never` on the contract).
- */
-export declare const subscribeStream: (deps: SubscriptionDeps, after: Position | undefined) => Stream.Stream<SequencedEvent, SqlError.SqlError, Scope.Scope>;
-//# sourceMappingURL=subscribe.d.ts.map

package/dist/dts/internal/subscribe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["../../../src/internal/subscribe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EAAU,SAAS,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,EAEL,MAAM,EAIN,KAAK,KAAK,EACV,MAAM,EACP,MAAM,QAAQ,CAAA;AAEf;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,4BAA4B,OAAO,CAAA;AAchD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,KACb,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAA;IACpE;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAC1D,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,4DAA4D;IAC5D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAC1B,MAAM,gBAAgB,EACtB,OAAO,QAAQ,GAAG,SAAS,KAC1B,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAuG5D,CAAA"}

package/dist/esm/internal/subscribe.js

@@ -1,113 +0,0 @@
-import { ORIGIN, ReadLimit } from '@kairos-es/core';
-import { Chunk, Effect, Option, Queue, Schedule, Stream } from 'effect';
-/**
- * A short catch-up page size default for the reconcile loop. Reads page by page
- * until a short page signals the tail is drained, so a large backlog is streamed
- * in bounded chunks rather than one huge SELECT. Overridable via
- * `config.catchUpPageSize`.
- */
-export const DEFAULT_CATCH_UP_PAGE = 512;
-/**
- * The default upper bound a live subscriber waits for a wake before re-reading
- * from its cursor ANYWAY (milliseconds; overridable via `config.pollInterval`).
- * This periodic position-based poll — not `NOTIFY` — is the correctness
- * guarantee: every committed position is reconciled within this interval
- * regardless of whether its `NOTIFY` was heard, which covers a `NOTIFY` fired
- * before `LISTEN` was fully established, a coalesced/lost `NOTIFY`, and a listen
- * connection that dropped SILENTLY (the `@effect/sql-pg` listen client swallows
- * connection errors and does not auto-reconnect). `NOTIFY` only lowers delivery
- * latency below this interval. Upstream `postgres_tt.py` uses the same 1-second
- * fallback poll (`conn.wait(..., interval=1)`).
- */
-export const DEFAULT_POLL_INTERVAL_MILLIS = 1000;
-/**
- * Retry a TRANSIENT poll fault (a `SqlError` from one reconcile read) on a capped
- * exponential backoff rather than letting `Stream.orDie` kill a subscription that
- * may have been alive for days over a single connection blip. A fault that
- * PERSISTS past the cap propagates (the decorator dies it) — infrastructure stays
- * off the contract channel while the stream survives ordinary transients.
- */
-const POLL_RETRY_SCHEDULE = /*#__PURE__*/Schedule.exponential('100 millis', 2).pipe(/*#__PURE__*/Schedule.union(/*#__PURE__*/Schedule.spaced('2 seconds')), /*#__PURE__*/Schedule.intersect(/*#__PURE__*/Schedule.recurs(20)));
-/**
- * Build the subscription `Stream`: catch up from `after`, then track the live
- * tail. The cursor threads through the `unfoldChunkEffect` unfold state, starting
- * at `after` and advancing to the last delivered position each batch; the stream
- * never completes on its own (always `Option.some`), so the enclosing scope
- * interrupts it on close. A `SqlError` mid-stream stays on the channel;
- * `makeContractStore` dies it (subscribe is `E = never` on the contract).
- */
-export const subscribeStream = (deps, after) => Stream.unwrapScoped(Effect.gen(function* () {
-  // The wake primitive: a sliding(1) queue holding at most one pending
-  // signal. The listener `offer`s an opaque wake on every NOTIFY; the poll
-  // loop `take`s (with a timeout). The lost-wakeup guard is STRUCTURAL —
-  // drain the queue BEFORE reading, so a NOTIFY that lands mid-read leaves
-  // a fresh signal that makes the next `take` return at once rather than
-  // sleeping through a real change.
-  const wake = yield* Queue.sliding(1);
-  // Tap every notification into the wake queue. If the listen stream DOES
-  // surface an error, re-subscribe with capped-exponential backoff. In
-  // practice the @effect/sql-pg listen client usually swallows a dropped
-  // connection SILENTLY rather than erroring, so this retry rarely fires —
-  // the poll fallback below, not this retry, is the real reconnect guarantee:
-  // the reconcile loop re-reads from the cursor on every poll, so a silently-
-  // dropped (and later re-established) listener loses no positions.
-  const listener = deps.listen.pipe(Stream.tap(() => Queue.offer(wake, undefined)), Stream.retry(Schedule.exponential('50 millis').pipe(Schedule.union(Schedule.spaced('1 seconds')))));
-  // Drain the listener into the wake queue on a background fibre; the scope
-  // releases it. We never read its elements directly — every notification is
-  // an opaque wake signal.
-  yield* listener.pipe(Stream.runDrain, Effect.forkScoped);
-  // 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
-  // a single connection blip does not kill a days-long subscription; a
-  // persistent fault propagates and dies.
-  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.catchUpPage));
-      for (const event of events) {
-        collected.push(event);
-      }
-      const lastEvent = events.at(-1);
-      if (lastEvent === undefined || events.length < deps.catchUpPage) {
-        break;
-      }
-      cursor = lastEvent.position;
-    }
-    const last = collected.at(-1)?.position ?? from;
-    return {
-      events: collected,
-      last
-    };
-  }).pipe(Effect.retry(POLL_RETRY_SCHEDULE));
-  /**
-   * Produce the NEXT non-empty batch from a cursor position, together with
-   * the advanced cursor — a pure `Position → Effect<[Chunk, 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.
-   *
-   * 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 NOTIFY. This effect only
-   * completes by returning a non-empty chunk; the scope interrupts it on close.
-   */
-  const nextBatch = from => Effect.gen(function* () {
-    while (true) {
-      yield* Queue.takeAll(wake);
-      const {
-        events,
-        last
-      } = yield* drainFrom(from);
-      if (events.length > 0) {
-        return [Chunk.fromIterable(events), 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));
-    }
-  });
-  return Stream.unfoldChunkEffect(after ?? ORIGIN, from => Effect.map(nextBatch(from), Option.some));
-}));
-//# sourceMappingURL=subscribe.js.map

package/dist/esm/internal/subscribe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"subscribe.js","names":["ORIGIN","ReadLimit","Chunk","Effect","Option","Queue","Schedule","Stream","DEFAULT_CATCH_UP_PAGE","DEFAULT_POLL_INTERVAL_MILLIS","POLL_RETRY_SCHEDULE","exponential","pipe","union","spaced","intersect","recurs","subscribeStream","deps","after","unwrapScoped","gen","wake","sliding","listener","listen","tap","offer","undefined","retry","runDrain","forkScoped","drainFrom","from","collected","cursor","events","fetch","make","catchUpPage","event","push","lastEvent","at","length","position","last","nextBatch","takeAll","fromIterable","ignore","timeout","take","pollInterval","unfoldChunkEffect","map","some"],"sources":["../../../src/internal/subscribe.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}