@kairos-es/store-postgres 0.0.0

package/dist/cjs/internal/readPlan.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runFetch = exports.compileFetchPlan = void 0;
+var _core = require("@kairos-es/core");
+var _matchSql = require("./matchSql.js");
+var _transport = require("./transport.js");
+/**
+ * Compile a servable query into a `FetchPlan`. The SQL comes from the shared
+ * `matchSql` builders (the tagged path composes the same emitted match chain as the
+ * conflict check, which binds its own placeholder tokens and wraps it differently),
+ * with the pre-quoted names embedded and the VALUES bound as `$n` parameters
+ * (never interpolated).
+ *
+ * The `switch` is exhaustive over core's `ServableQueryShape` with NO `default`
+ * and no trailing fall-through arm, and what that buys is a COMPILE error where
+ * there would otherwise be a silent mis-serve. Core owns that union and this
+ * module only consumes it, so a fourth member added there is a change this file
+ * cannot see coming: a cascade ending in an unguarded tagged branch would have
+ * SERVED that shape as tagged, and both `read` and the `subscribe` poll sharing
+ * its plan would have returned the wrong rows — no error raised, nothing failing
+ * to typecheck. Every arm returns instead, so the added member leaves this
+ * function with a reachable end and a return type that does not admit
+ * `undefined`, and the module stops compiling.
+ */
+const compileFetchPlan = (tables, query) => {
+  const shape = (0, _core.classifyServableQuery)(query);
+  switch (shape.kind) {
+    case 'wildcard':
+      return {
+        text: (0, _matchSql.wildcardReadSql)(tables.main),
+        bind: (after, limit) => [after, limit]
+      };
+    case 'typeOnly':
+      {
+        // node-postgres binds a JS array param as a Postgres array literal, so
+        // `type = ANY($2)` matches any of the item's types. The item's own list is
+        // bound as it stands: a branded `EventType` IS its string to the driver, so
+        // nothing here has to unwrap or copy it.
+        const types = shape.types;
+        return {
+          text: (0, _matchSql.typeOnlyReadSql)(tables.main),
+          bind: (after, limit) => [after, types, limit]
+        };
+      }
+    case 'tagged':
+      {
+        // `after` ($2) is applied at BOTH CTE stages; `limit` ($3) inside the
+        // ordered filtered_ids so it caps by position, not on the outer join.
+        const itemsJson = (0, _transport.jsonbText)((0, _transport.toQueryItemsJson)(query));
+        return {
+          text: (0, _matchSql.taggedReadSql)(tables.main, tables.tag),
+          bind: (after, limit) => [itemsJson, after, limit]
+        };
+      }
+  }
+};
+/**
+ * Run a compiled plan for a given `after`/`limit`, honouring `after` (exclusive;
+ * absent → `0`) and `limit` (`NULL` = no limit), ordered by `id ASC`.
+ */
+exports.compileFetchPlan = compileFetchPlan;
+const runFetch = (sql, plan, after, limit) => sql.unsafe(plan.text, plan.bind(after ?? _core.ORIGIN, limit ?? null));
+exports.runFetch = runFetch;
+//# sourceMappingURL=readPlan.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"readPlan.js","names":["_core","require","_matchSql","_transport","compileFetchPlan","tables","query","shape","classifyServableQuery","kind","text","wildcardReadSql","main","bind","after","limit","types","typeOnlyReadSql","itemsJson","jsonbText","toQueryItemsJson","taggedReadSql","tag","exports","runFetch","sql","plan","unsafe","ORIGIN"],"sources":["../../../src/internal/readPlan.ts"],"sourcesContent":[null],"mappings":";;;;;;AAyBA,IAAAA,KAAA,GAAAC,OAAA;AAEA,IAAAC,SAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAF,OAAA;AA0BA;;;;;;;;;;;;;;;;;;AAkBO,MAAMG,gBAAgB,GAAGA,CAC9BC,MAAkB,EAClBC,KAAY,KACC;EACb,MAAMC,KAAK,GAAG,IAAAC,2BAAqB,EAACF,KAAK,CAAC;EAC1C,QAAQC,KAAK,CAACE,IAAI;IAChB,KAAK,UAAU;MACb,OAAO;QACLC,IAAI,EAAE,IAAAC,yBAAe,EAACN,MAAM,CAACO,IAAI,CAAC;QAClCC,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACD,KAAK,EAAEC,KAAK;OACtC;IACH,KAAK,UAAU;MAAE;QACf;QACA;QACA;QACA;QACA,MAAMC,KAAK,GAAGT,KAAK,CAACS,KAAK;QACzB,OAAO;UACLN,IAAI,EAAE,IAAAO,yBAAe,EAACZ,MAAM,CAACO,IAAI,CAAC;UAClCC,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACD,KAAK,EAAEE,KAAK,EAAED,KAAK;SAC7C;MACH;IACA,KAAK,QAAQ;MAAE;QACb;QACA;QACA,MAAMG,SAAS,GAAG,IAAAC,oBAAS,EAAC,IAAAC,2BAAgB,EAACd,KAAK,CAAC,CAAC;QACpD,OAAO;UACLI,IAAI,EAAE,IAAAW,uBAAa,EAAChB,MAAM,CAACO,IAAI,EAAEP,MAAM,CAACiB,GAAG,CAAC;UAC5CT,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACG,SAAS,EAAEJ,KAAK,EAAEC,KAAK;SACjD;MACH;EACF;AACF,CAAC;AAED;;;;AAAAQ,OAAA,CAAAnB,gBAAA,GAAAA,gBAAA;AAIO,MAAMoB,QAAQ,GAAGA,CACtBC,GAAwB,EACxBC,IAAe,EACfZ,KAA2B,EAC3BC,KAA4B,KAE5BU,GAAG,CAACE,MAAM,CAAWD,IAAI,CAAChB,IAAI,EAAEgB,IAAI,CAACb,IAAI,CAACC,KAAK,IAAIc,YAAM,EAAEb,KAAK,IAAI,IAAI,CAAC,CAAC;AAAAQ,OAAA,CAAAC,QAAA,GAAAA,QAAA","ignoreList":[]}

package/dist/cjs/internal/subscribe.js

@@ -0,0 +1,120 @@
+"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

@@ -0,0 +1 @@
+{"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":"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","ignoreList":[]}

package/dist/cjs/internal/transport.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toQueryItemsJson = exports.toEventJson = exports.rowToSequenced = exports.jsonbText = void 0;
+var _effect = require("effect");
+/**
+ * Serialise a value to a JSON STRING for transport as a `::jsonb`-cast bound
+ * parameter.
+ *
+ * WHY not `sql.json(value)`: `@effect/sql-pg`'s `json` helper binds the RAW
+ * value, and node-postgres serialises a JS *array* bound param as a Postgres
+ * ARRAY literal (`{…}`), not JSON — so `sql.json([...])::jsonb` fails with a
+ * `22P02` invalid-JSON error (an array literal is not valid JSON). Passing a
+ * pre-stringified JSON string and casting `::jsonb` sends plain text that
+ * Postgres parses as JSON, which round-trips reliably for both objects and
+ * arrays. Kept as a named helper so every JSON-transport call site is consistent
+ * and the reasoning lives in one place.
+ */
+const jsonbText = value => JSON.stringify(value);
+/** Serialise a `Query`'s items into their transport JSON shape. */
+exports.jsonbText = jsonbText;
+const toQueryItemsJson = query => query.items.map(item => ({
+  types: [...item.types],
+  tags: [...item.tags]
+}));
+/** Serialise one core `DcbEvent` into its transport JSON shape. */
+exports.toQueryItemsJson = toQueryItemsJson;
+const toEventJson = event => ({
+  type: event.type,
+  // `Encoding.encodeBase64` (from `effect`) keeps this dependency-free and pure
+  // — no `Buffer`, so no `@types/node` and no browser/runtime coupling.
+  data: _effect.Encoding.encodeBase64(event.data),
+  tags: [...event.tags],
+  uuid: event.uuid,
+  occurred_at: _effect.DateTime.formatIso(event.occurredAt)
+});
+/**
+ * Map a raw main-table row to a core `SequencedEvent`. `data` NULL → empty bytes
+ * (a payload-less event round-trips to a zero-length `Uint8Array`); `occurred_at`
+ * Date → `DateTime.Utc`; `id` string → branded `Position`.
+ *
+ * The branded scalars (`type`, `tags`, `uuid`, `position`) are minted by trusted
+ * `as`-cast, NOT by re-running `EventType.make` / `Tag.make` etc. This is
+ * deliberate: these bytes were validated at write time, and the store schema is
+ * intentionally LAX on read (ADR-0006 store-laxness — hand-assembled or pre-ADR
+ * events must remain readable), so re-validating here could REJECT a legitimately
+ * stored value and break that contract. It mirrors the in-memory oracle, which
+ * likewise mints branded positions by cast at its trusted allocation boundary
+ * (`inMemory.ts`). The read boundary is the analogous trusted deserialisation
+ * point.
+ */
+exports.toEventJson = toEventJson;
+const rowToSequenced = row => ({
+  event: {
+    type: row.type,
+    data: row.data ?? new Uint8Array(0),
+    tags: row.tags,
+    uuid: row.uuid,
+    occurredAt: _effect.DateTime.unsafeFromDate(row.occurred_at)
+  },
+  position: BigInt(row.id)
+});
+exports.rowToSequenced = rowToSequenced;
+//# sourceMappingURL=transport.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","names":["_effect","require","jsonbText","value","JSON","stringify","exports","toQueryItemsJson","query","items","map","item","types","tags","toEventJson","event","type","data","Encoding","encodeBase64","uuid","occurred_at","DateTime","formatIso","occurredAt","rowToSequenced","row","Uint8Array","unsafeFromDate","position","BigInt","id"],"sources":["../../../src/internal/transport.ts"],"sourcesContent":[null],"mappings":";;;;;;AAsBA,IAAAA,OAAA,GAAAC,OAAA;AAGA;;;;;;;;;;;;;AAaO,MAAMC,SAAS,GAAIC,KAAc,IAAaC,IAAI,CAACC,SAAS,CAACF,KAAK,CAAC;AAQ1E;AAAAG,OAAA,CAAAJ,SAAA,GAAAA,SAAA;AACO,MAAMK,gBAAgB,GAAIC,KAAY,IAC3CA,KAAK,CAACC,KAAK,CAACC,GAAG,CAAEC,IAAI,KAAM;EACzBC,KAAK,EAAE,CAAC,GAAGD,IAAI,CAACC,KAAK,CAAC;EACtBC,IAAI,EAAE,CAAC,GAAGF,IAAI,CAACE,IAAI;CACpB,CAAC,CAAC;AA4BL;AAAAP,OAAA,CAAAC,gBAAA,GAAAA,gBAAA;AACO,MAAMO,WAAW,GAAIC,KAAe,KAAiB;EAC1DC,IAAI,EAAED,KAAK,CAACC,IAAI;EAChB;EACA;EACAC,IAAI,EAAEC,gBAAQ,CAACC,YAAY,CAACJ,KAAK,CAACE,IAAI,CAAC;EACvCJ,IAAI,EAAE,CAAC,GAAGE,KAAK,CAACF,IAAI,CAAC;EACrBO,IAAI,EAAEL,KAAK,CAACK,IAAI;EAChBC,WAAW,EAAEC,gBAAQ,CAACC,SAAS,CAACR,KAAK,CAACS,UAAU;CACjD,CAAC;AA4BF;;;;;;;;;;;;;;;AAAAlB,OAAA,CAAAQ,WAAA,GAAAA,WAAA;AAeO,MAAMW,cAAc,GAAIC,GAAa,KAAsB;EAChEX,KAAK,EAAE;IACLC,IAAI,EAAEU,GAAG,CAACV,IAAwB;IAClCC,IAAI,EAAES,GAAG,CAACT,IAAI,IAAI,IAAIU,UAAU,CAAC,CAAC,CAAC;IACnCd,IAAI,EAAEa,GAAG,CAACb,IAAmC;IAC7CO,IAAI,EAAEM,GAAG,CAACN,IAAwB;IAClCI,UAAU,EAAEF,gBAAQ,CAACM,cAAc,CAACF,GAAG,CAACL,WAAW;GACpD;EACDQ,QAAQ,EAAEC,MAAM,CAACJ,GAAG,CAACK,EAAE;CACxB,CAAC;AAAAzB,OAAA,CAAAmB,cAAA,GAAAA,cAAA","ignoreList":[]}

package/dist/cjs/store.js

@@ -0,0 +1,256 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.layer = void 0;
+var _core = require("@kairos-es/core");
+var _effect = require("effect");
+var _clients = require("./clients.js");
+var _config = require("./config.js");
+var _ddl = require("./internal/ddl.js");
+var _readPlan = require("./internal/readPlan.js");
+var _transport = require("./internal/transport.js");
+/**
+ * Set `lock_timeout` for the current transaction via a BOUND parameter.
+ *
+ * `SET LOCAL` cannot take a bound parameter, but `set_config(setting, value,
+ * is_local)` is its exact bound-parameter equivalent (`is_local = true` ≡ `SET
+ * LOCAL`) — so the timeout value is a parameter, never interpolated into SQL
+ * text. The value is `'<seconds>s'` (Postgres parses the `s` unit); `'0s'` = no
+ * timeout. Runs inside the append transaction so it scopes to that call only.
+ */
+const setLocalLockTimeout = (sql, lockTimeout) => sql`SELECT set_config('lock_timeout', ${`${lockTimeout}s`}, true)`;
+/**
+ * Build the engine MECHANICS (a `RawDcbEventStore`) over the two clients and a
+ * resolved name set. Contract policy (`assertServableQuery`, `ReadLimit` decode,
+ * error-vs-defect classification) is NOT here — `makeContractStore` adds it
+ * uniformly, so this engine surfaces raw `SqlError`s and the contract conflict.
+ */
+const make = (config, names) => _effect.Effect.gen(function* () {
+  const pooled = yield* _clients.PgClientPooled;
+  const direct = yield* _clients.PgClientDirect;
+  const lockTimeout = config.lockTimeout ?? 0;
+  const pollInterval = config.pollInterval ?? _core.DEFAULT_POLL_INTERVAL_MILLIS;
+  const catchUpPageSize = config.catchUpPageSize ?? _core.DEFAULT_CATCH_UP_PAGE_SIZE;
+  // The pre-quoted table names every read plan embeds (resolved once).
+  const tables = {
+    main: (0, _ddl.quoteQualified)(names.mainTable),
+    tag: (0, _ddl.quoteQualified)(names.tagTable)
+  };
+  // --- read -------------------------------------------------------------
+  /**
+   * The global last position ignoring any filter — the head of a no-limit
+   * read. Empty store → ORIGIN.
+   *
+   * A VALUE over the resolved `pooled`, and deliberately NOT a function of a
+   * client — do not re-introduce the parameter. There is only one client it
+   * could take: `direct` exists solely for `subscribe`'s `listen` (see
+   * `clients.ts`), so a client parameter would advertise a selection seam the
+   * engine does not have.
+   *
+   * Nor would such a parameter be load-bearing for the REPEATABLE READ
+   * transaction this runs inside, which is the trap worth naming, since a
+   * closed-over client LOOKS like it must escape to its own snapshot.
+   * `@effect/sql` resolves a statement's connection when the statement RUNS,
+   * from the FIBRE CONTEXT rather than from the client value: `withTransaction`
+   * acquires one connection and `Effect.locally`s it into
+   * `FiberRef.currentContext` under its `TransactionConnection` tag, and every
+   * statement a client builds resolves through a `getConnection` that reads
+   * that tag first, falling back to the pool acquirer only when it is absent
+   * (`@effect/sql@0.52` `src/internal/client.ts`). A statement therefore joins
+   * a transaction by being RUN inside it, and passing the client along the call
+   * chain neither adds to that nor is required by it. `read-postgres`'s
+   * `pinnedConnection` test observes the same fact from the SERVER: two
+   * statements issued inside one transaction report one `pg_backend_pid()`.
+   *
+   * Built once at layer construction and re-run per read, which a statement
+   * supports: it carries no mutable state and recompiles on every execution.
+   */
+  const globalHead = pooled`
+      SELECT MAX(id) AS max FROM ${pooled(names.mainTable)}
+    `.pipe(_effect.Effect.map(rows => {
+    const max = rows[0]?.max;
+    return max === null || max === undefined ? _core.ORIGIN : BigInt(max);
+  }));
+  /**
+   * The read MECHANICS: the rows a query selects, plus the head a decision
+   * model may then append under. `read` below only shapes the pair into a
+   * `ReadResponse`, so the two snapshot regimes argued for here stay in one
+   * place.
+   *
+   * Named for what it returns rather than for what it reads through: it closes
+   * over `pooled`, and takes no client, for the reason given on `globalHead`.
+   */
+  const readRowsAndHead = (query, options) => _effect.Effect.gen(function* () {
+    // No validation here — the query and limit were validated once at the
+    // `makeContractStore` boundary, so the per-read re-validation is gone.
+    const plan = (0, _readPlan.compileFetchPlan)(tables, query);
+    // Limited read: `head` is the last RETURNED position, taken from the
+    // SAME single statement, so rows and head are already one consistent
+    // snapshot (or ORIGIN when nothing is returned). No transaction needed —
+    // a single statement sees a single snapshot.
+    if (options?.limit !== undefined) {
+      const rows = yield* (0, _readPlan.runFetch)(pooled, plan, options.after, options.limit);
+      const lastRow = rows.at(-1);
+      const head = lastRow === undefined ? _core.ORIGIN : BigInt(lastRow.id);
+      return {
+        rows,
+        head
+      };
+    }
+    // No-limit read: `head` is the GLOBAL last position (ignoring the query
+    // filter), which needs a SEPARATE `MAX(id)` statement. Rows and head
+    // MUST share one MVCC snapshot: under the default READ COMMITTED each
+    // statement snapshots independently, so a concurrent append committing
+    // between the row fetch and the `MAX(id)` would push `head` PAST an
+    // event absent from `events` — and a decision model appending under
+    // `{ after: head }` would then silently miss that event as a conflict,
+    // breaking optimistic concurrency. A REPEATABLE READ, READ ONLY
+    // transaction gives both statements a single snapshot, matching the
+    // in-memory oracle's atomic (mutex-guarded) read. Readers take only
+    // ACCESS SHARE, so this never contends with the exclusive-lock append.
+    return yield* pooled.withTransaction(_effect.Effect.gen(function* () {
+      yield* pooled.unsafe('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY');
+      const rows = yield* (0, _readPlan.runFetch)(pooled, plan, options?.after, undefined);
+      const head = yield* globalHead;
+      return {
+        rows,
+        head
+      };
+    }));
+  });
+  const read = (query, options) => readRowsAndHead(query, options).pipe(_effect.Effect.map(({
+    rows,
+    head
+  }) => ({
+    events: _effect.Stream.fromIterable(rows.map(_transport.rowToSequenced)),
+    head
+  })));
+  /**
+   * The ONE transaction frame every append rides: open a transaction, apply the
+   * per-call `set_config('lock_timeout', …, true)`, then run the caller's
+   * `SELECT <fn>(…)`. Both the conditional and unconditional paths go through
+   * here, so the lock-timeout frame can never diverge between them — the
+   * function's LOCK/check/insert and the timeout are one atomic unit, and the
+   * conflict (zero rows) vs head (`MAX(id)`) is read from the returned rows by
+   * the caller, never from a caught error.
+   */
+  const callAppendFn = select => pooled.withTransaction(setLocalLockTimeout(pooled, lockTimeout).pipe(_effect.Effect.zipRight(select)));
+  const append = (events, condition) => {
+    const eventsJson = events.map(_transport.toEventJson);
+    // Raw mechanics: a CONFLICT is `AppendConditionFailed`; a `SqlError` (incl.
+    // a `55P03` lock-timeout abort) rides the channel too. `makeContractStore`
+    // classifies — conflict stays, everything else becomes a defect.
+    return _effect.Effect.gen(function* () {
+      if (condition === undefined) {
+        // No guard, but the unconditional twin STILL takes the exclusive lock
+        // (see `unconditionalAppendBody`). That lock on BOTH append paths is how
+        // this engine discharges the subscribe machine's ascending-commit-order
+        // precondition (`SubscribeMachine.ts` argues it): without it two
+        // concurrent unconditional writers can commit bigserial ids out of
+        // order, letting `subscribe` skip the later-committing lower id and
+        // `head` overtake an in-flight position. Sharing `callAppendFn` with the
+        // conditional path guarantees the lock is scoped to the call and the
+        // configured timeout applies identically to both append paths.
+        const rows = yield* callAppendFn(pooled`
+              SELECT ${pooled(names.appendUnconditionalFn)}(
+                ${(0, _transport.jsonbText)(eventsJson)}::jsonb
+              ) AS max
+            `);
+        return headFromRows(rows);
+      }
+      const queryItems = (0, _transport.toQueryItemsJson)(condition.failIfEventsMatch);
+      const afterId = condition.after === undefined ? null : condition.after;
+      // The function returns MAX(id) on success, ZERO rows on conflict — the
+      // conflict is the row count, never a caught error.
+      const rows = yield* callAppendFn(pooled`
+            SELECT ${pooled(names.appendFn)}(
+              ${(0, _transport.jsonbText)(queryItems)}::jsonb,
+              ${afterId},
+              ${(0, _transport.jsonbText)(eventsJson)}::jsonb
+            ) AS max
+          `);
+      // Empty result set = conflict.
+      if (rows.length === 0) {
+        return yield* new _core.AppendConditionFailed({
+          condition
+        });
+      }
+      return headFromRows(rows);
+    });
+  };
+  /**
+   * Extract the new head `Position` from the function's single result row. The
+   * function returns exactly one row (`MAX(id)`) on a successful insert; that
+   * value is the last new position (read-your-writes).
+   */
+  const headFromRows = rows => {
+    const max = rows[0]?.max;
+    if (max === null || max === undefined) {
+      // Defensive: a successful unconditional/`NOT conflict` insert always
+      // yields a non-null MAX. A null here means nothing was inserted, which
+      // for an append (always ≥1 event) is a broken invariant → die.
+      throw new Error('kairos-es/store-postgres: append returned no head position');
+    }
+    return BigInt(max);
+  };
+  // --- subscribe --------------------------------------------------------
+  /**
+   * Wire core's subscribe machine to the live clients: `fetch` is the
+   * per-subscription compiled read plan run against the pooled client and mapped
+   * to `SequencedEvent`s; `listen` is the direct client's ref-counted, non-pooled
+   * LISTEN on this store's channel (the Neon-safe path — `clients.ts` owns why
+   * there are two clients at all). The plan is compiled ONCE here so the poll
+   * loop re-binds only the cursor.
+   *
+   * The wake source is `NOTIFY`, and it is a LATENCY optimisation only: the
+   * machine's periodic position-based poll is what makes delivery correct, which
+   * matters more here than the general argument for it suggests. The
+   * `@effect/sql-pg` listen client SWALLOWS connection errors and does not
+   * auto-reconnect, so a dropped LISTEN typically goes quiet rather than
+   * erroring — the machine's listen-side retry then never fires, and the poll is
+   * the ONLY thing that recovers the subscription. The same silence is what a
+   * Neon pooled endpoint produces if `PgClientDirect` is misconfigured: the
+   * pooler drops `LISTEN`/`NOTIFY` without complaint and delivery degrades to
+   * poll-rate rather than failing, which is why that trap is a deployment-time
+   * wiring choice and not a runtime error.
+   *
+   * `E` is `SqlError.SqlError` — both seams fail with it, so the machine's single
+   * error parameter carries it straight through to `makeContractStore`.
+   */
+  const subscribe = (query, after) => {
+    const plan = (0, _readPlan.compileFetchPlan)(tables, query);
+    return (0, _core.subscribeStream)({
+      fetch: (from, limit) => (0, _readPlan.runFetch)(pooled, plan, from, limit).pipe(_effect.Effect.map(rows => rows.map(_transport.rowToSequenced))),
+      listen: direct.listen(names.channel),
+      pollInterval,
+      catchUpPageSize
+    }, after);
+  };
+  return {
+    read,
+    append,
+    subscribe
+  };
+});
+/**
+ * The Postgres `DcbEventStore` layer factory. Builds the engine over
+ * `PgClientPooled` (reads/append/notify) and `PgClientDirect` (the subscribe
+ * listener). The caller wires those two client layers — pointing `PgClientDirect`
+ * at a direct (non-pooler) endpoint on Neon, or at the same URL as `PgClientPooled`
+ * everywhere else.
+ *
+ * `ensureSchema(config)` must have been run (by the caller's migrator or at
+ * boot) before the layer is used; the layer itself performs no DDL, so it stays
+ * a pure runtime dependency requiring only the two clients.
+ */
+const layer = (config = {}) => {
+  // Decode through the config schema so a malformed config (empty/dotted atom,
+  // negative/non-finite timeout, over-63-byte derived name) fails LOUDLY at
+  // construction rather than late on the first append.
+  const decoded = (0, _config.decodePostgresStoreConfig)(config);
+  return _effect.Layer.effect(_core.DcbEventStore, _effect.Effect.map(make(decoded, (0, _ddl.resolveNames)(decoded)), _core.makeContractStore));
+};
+exports.layer = layer;
+//# sourceMappingURL=store.js.map

package/dist/cjs/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["_core","require","_effect","_clients","_config","_ddl","_readPlan","_transport","setLocalLockTimeout","sql","lockTimeout","make","config","names","Effect","gen","pooled","PgClientPooled","direct","PgClientDirect","pollInterval","DEFAULT_POLL_INTERVAL_MILLIS","catchUpPageSize","DEFAULT_CATCH_UP_PAGE_SIZE","tables","main","quoteQualified","mainTable","tag","tagTable","globalHead","pipe","map","rows","max","undefined","ORIGIN","BigInt","readRowsAndHead","query","options","plan","compileFetchPlan","limit","runFetch","after","lastRow","at","head","id","withTransaction","unsafe","read","events","Stream","fromIterable","rowToSequenced","callAppendFn","select","zipRight","append","condition","eventsJson","toEventJson","appendUnconditionalFn","jsonbText","headFromRows","queryItems","toQueryItemsJson","failIfEventsMatch","afterId","appendFn","length","AppendConditionFailed","Error","subscribe","subscribeStream","fetch","from","listen","channel","layer","decoded","decodePostgresStoreConfig","Layer","effect","DcbEventStore","resolveNames","makeContractStore","exports"],"sources":["../../src/store.ts"],"sourcesContent":[null],"mappings":";;;;;;AAoDA,IAAAA,KAAA,GAAAC,OAAA;AAYA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,OAAA,GAAAH,OAAA;AACA,IAAAI,IAAA,GAAAJ,OAAA;AAKA,IAAAK,SAAA,GAAAL,OAAA;AAKA,IAAAM,UAAA,GAAAN,OAAA;AAQA;;;;;;;;;AASA,MAAMO,mBAAmB,GAAGA,CAC1BC,GAAwB,EACxBC,WAAmB,KAEnBD,GAAG,qCAAqC,GAAGC,WAAW,GAAG,SAAS;AAEpE;;;;;;AAMA,MAAMC,IAAI,GAAGA,CACXC,MAA2B,EAC3BC,KAAoB,KAMpBC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,MAAM,GAAG,OAAOC,uBAAc;EACpC,MAAMC,MAAM,GAAG,OAAOC,uBAAc;EACpC,MAAMT,WAAW,GAAGE,MAAM,CAACF,WAAW,IAAI,CAAC;EAC3C,MAAMU,YAAY,GAAGR,MAAM,CAACQ,YAAY,IAAIC,kCAA4B;EACxE,MAAMC,eAAe,GAAGV,MAAM,CAACU,eAAe,IAAIC,gCAA0B;EAE5E;EACA,MAAMC,MAAM,GAAe;IACzBC,IAAI,EAAE,IAAAC,mBAAc,EAACb,KAAK,CAACc,SAAS,CAAC;IACrCC,GAAG,EAAE,IAAAF,mBAAc,EAACb,KAAK,CAACgB,QAAQ;GACnC;EAED;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BA,MAAMC,UAAU,GAA+Cd,MAE7D;mCAC6BA,MAAM,CAACH,KAAK,CAACc,SAAS,CAAC;KACrD,CAACI,IAAI,CACJjB,cAAM,CAACkB,GAAG,CAAEC,IAAI,IAAI;IAClB,MAAMC,GAAG,GAAGD,IAAI,CAAC,CAAC,CAAC,EAAEC,GAAG;IACxB,OAAOA,GAAG,KAAK,IAAI,IAAIA,GAAG,KAAKC,SAAS,GACpCC,YAAM,GACLC,MAAM,CAACH,GAAG,CAAc;EAC/B,CAAC,CAAC,CACH;EAED;;;;;;;;;EASA,MAAMI,eAAe,GAAGA,CACtBC,KAAY,EACZC,OAAqB,KAKrB1B,cAAM,CAACC,GAAG,CAAC,aAAS;IAClB;IACA;IACA,MAAM0B,IAAI,GAAG,IAAAC,0BAAgB,EAAClB,MAAM,EAAEe,KAAK,CAAC;IAE5C;IACA;IACA;IACA;IACA,IAAIC,OAAO,EAAEG,KAAK,KAAKR,SAAS,EAAE;MAChC,MAAMF,IAAI,GAAG,OAAO,IAAAW,kBAAQ,EAC1B5B,MAAM,EACNyB,IAAI,EACJD,OAAO,CAACK,KAAK,EACbL,OAAO,CAACG,KAAK,CACd;MACD,MAAMG,OAAO,GAAGb,IAAI,CAACc,EAAE,CAAC,CAAC,CAAC,CAAC;MAC3B,MAAMC,IAAI,GACRF,OAAO,KAAKX,SAAS,GAAGC,YAAM,GAAIC,MAAM,CAACS,OAAO,CAACG,EAAE,CAAc;MACnE,OAAO;QAAEhB,IAAI;QAAEe;MAAI,CAAE;IACvB;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,OAAO,OAAOhC,MAAM,CAACkC,eAAe,CAClCpC,cAAM,CAACC,GAAG,CAAC,aAAS;MAClB,OAAOC,MAAM,CAACmC,MAAM,CAClB,4DAA4D,CAC7D;MACD,MAAMlB,IAAI,GAAG,OAAO,IAAAW,kBAAQ,EAC1B5B,MAAM,EACNyB,IAAI,EACJD,OAAO,EAAEK,KAAK,EACdV,SAAS,CACV;MACD,MAAMa,IAAI,GAAG,OAAOlB,UAAU;MAC9B,OAAO;QAAEG,IAAI;QAAEe;MAAI,CAAE;IACvB,CAAC,CAAC,CACH;EACH,CAAC,CAAC;EAEJ,MAAMI,IAAI,GAAGA,CACXb,KAAY,EACZC,OAAqB,KAErBF,eAAe,CAACC,KAAK,EAAEC,OAAO,CAAC,CAACT,IAAI,CAClCjB,cAAM,CAACkB,GAAG,CACR,CAAC;IAAEC,IAAI;IAAEe;EAAI,CAAE,MAAoB;IACjCK,MAAM,EAAEC,cAAM,CAACC,YAAY,CAACtB,IAAI,CAACD,GAAG,CAACwB,yBAAc,CAAC,CAAC;IACrDR;GACD,CAAC,CACH,CACF;EAUH;;;;;;;;;EASA,MAAMS,YAAY,GAChBC,MAAsE,IAEtE1C,MAAM,CAACkC,eAAe,CACpB1C,mBAAmB,CAACQ,MAAM,EAAEN,WAAW,CAAC,CAACqB,IAAI,CAACjB,cAAM,CAAC6C,QAAQ,CAACD,MAAM,CAAC,CAAC,CACvE;EAEH,MAAME,MAAM,GAAGA,CACbP,MAA2C,EAC3CQ,SAA2B,KAC2C;IACtE,MAAMC,UAAU,GAAGT,MAAM,CAACrB,GAAG,CAAC+B,sBAAW,CAAC;IAE1C;IACA;IACA;IACA,OAAOjD,cAAM,CAACC,GAAG,CAAC,aAAS;MACzB,IAAI8C,SAAS,KAAK1B,SAAS,EAAE;QAC3B;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,MAAMF,IAAI,GAAG,OAAOwB,YAAY,CAC9BzC,MAAqB;uBACVA,MAAM,CAACH,KAAK,CAACmD,qBAAqB,CAAC;kBACxC,IAAAC,oBAAS,EAACH,UAAU,CAAC;;aAE1B,CACF;QACD,OAAOI,YAAY,CAACjC,IAAI,CAAC;MAC3B;MAEA,MAAMkC,UAAU,GAAG,IAAAC,2BAAgB,EAACP,SAAS,CAACQ,iBAAiB,CAAC;MAChE,MAAMC,OAAO,GAAGT,SAAS,CAAChB,KAAK,KAAKV,SAAS,GAAG,IAAI,GAAG0B,SAAS,CAAChB,KAAK;MAEtE;MACA;MACA,MAAMZ,IAAI,GAAG,OAAOwB,YAAY,CAC9BzC,MAAqB;qBACVA,MAAM,CAACH,KAAK,CAAC0D,QAAQ,CAAC;gBAC3B,IAAAN,oBAAS,EAACE,UAAU,CAAC;gBACrBG,OAAO;gBACP,IAAAL,oBAAS,EAACH,UAAU,CAAC;;WAE1B,CACF;MACD;MACA,IAAI7B,IAAI,CAACuC,MAAM,KAAK,CAAC,EAAE;QACrB,OAAO,OAAO,IAAIC,2BAAqB,CAAC;UAAEZ;QAAS,CAAE,CAAC;MACxD;MACA,OAAOK,YAAY,CAACjC,IAAI,CAAC;IAC3B,CAAC,CAAC;EACJ,CAAC;EAED;;;;;EAKA,MAAMiC,YAAY,GAAIjC,IAAkC,IAAc;IACpE,MAAMC,GAAG,GAAGD,IAAI,CAAC,CAAC,CAAC,EAAEC,GAAG;IACxB,IAAIA,GAAG,KAAK,IAAI,IAAIA,GAAG,KAAKC,SAAS,EAAE;MACrC;MACA;MACA;MACA,MAAM,IAAIuC,KAAK,CACb,4DAA4D,CAC7D;IACH;IACA,OAAOrC,MAAM,CAACH,GAAG,CAAa;EAChC,CAAC;EAED;EAEA;;;;;;;;;;;;;;;;;;;;;;;EAuBA,MAAMyC,SAAS,GAAGA,CAChBpC,KAAY,EACZM,KAAgB,KACiD;IACjE,MAAMJ,IAAI,GAAG,IAAAC,0BAAgB,EAAClB,MAAM,EAAEe,KAAK,CAAC;IAC5C,OAAO,IAAAqC,qBAAe,EACpB;MACEC,KAAK,EAAEA,CAACC,IAAI,EAAEnC,KAAK,KACjB,IAAAC,kBAAQ,EAAC5B,MAAM,EAAEyB,IAAI,EAAEqC,IAAI,EAAEnC,KAAK,CAAC,CAACZ,IAAI,CACtCjB,cAAM,CAACkB,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACD,GAAG,CAACwB,yBAAc,CAAC,CAAC,CAC/C;MACHuB,MAAM,EAAE7D,MAAM,CAAC6D,MAAM,CAAClE,KAAK,CAACmE,OAAO,CAAC;MACpC5D,YAAY;MACZE;KACD,EACDuB,KAAK,CACN;EACH,CAAC;EAED,OAAO;IAAEO,IAAI;IAAEQ,MAAM;IAAEe;EAAS,CAAW;AAC7C,CAAC,CAAC;AAEJ;;;;;;;;;;;AAWO,MAAMM,KAAK,GAAGA,CACnBrE,MAAA,GAA8B,EAAE,KACsC;EACtE;EACA;EACA;EACA,MAAMsE,OAAO,GAAG,IAAAC,iCAAyB,EAACvE,MAAM,CAAC;EACjD,OAAOwE,aAAK,CAACC,MAAM,CACjBC,mBAAa,EACbxE,cAAM,CAACkB,GAAG,CAACrB,IAAI,CAACuE,OAAO,EAAE,IAAAK,iBAAY,EAACL,OAAO,CAAC,CAAC,EAAEM,uBAAiB,CAAC,CACpE;AACH,CAAC;AAAAC,OAAA,CAAAR,KAAA,GAAAA,KAAA","ignoreList":[]}

package/dist/dts/clients.d.ts

@@ -0,0 +1,34 @@
+import type { SqlError } from '@effect/sql';
+import { PgClient } from '@effect/sql-pg';
+import { Context, Layer } from 'effect';
+declare const PgClientPooled_base: Context.TagClass<PgClientPooled, "@kairos-es/store-postgres/PgClientPooled", PgClient.PgClient>;
+/**
+ * The pooled client tag: reads, the append function, and `notify`. Holds a
+ * `PgClient` value rather than being a `PgClient.layer`, so it never collides
+ * with the direct client on the shared `PgClient`/`SqlClient` tag.
+ */
+export declare class PgClientPooled extends PgClientPooled_base {
+}
+declare const PgClientDirect_base: Context.TagClass<PgClientDirect, "@kairos-es/store-postgres/PgClientDirect", PgClient.PgClient>;
+/**
+ * The direct (non-pooler) client tag: the `subscribe` listener ONLY. Point this
+ * at a direct endpoint on Neon so `LISTEN`/`NOTIFY` is not dropped by the pooler.
+ */
+export declare class PgClientDirect extends PgClientDirect_base {
+}
+/**
+ * Build a `PgClientPooled` layer from a `PgClient` config. We construct the
+ * client via `PgClient.make` (scoped) and place it in our OWN tag, then provide
+ * `Reactivity.layer` (which `PgClient.make` requires) — exactly what the
+ * built-in `PgClient.layer` does internally, minus the collision-prone claim on
+ * the shared `PgClient` tag.
+ */
+export declare const pooledLayer: (config: PgClient.PgClientConfig) => Layer.Layer<PgClientPooled, SqlError.SqlError>;
+/**
+ * Build a `PgClientDirect` layer from a `PgClient` config. Same construction as
+ * `pooledLayer`; the two differ only in which endpoint the caller points them
+ * at (and that only matters on Neon).
+ */
+export declare const directLayer: (config: PgClient.PgClientConfig) => Layer.Layer<PgClientDirect, SqlError.SqlError>;
+export {};
+//# sourceMappingURL=clients.d.ts.map

package/dist/dts/clients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../src/clients.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;;AAEvC;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,mBAEE;CAAG;;AAEzC;;;GAGG;AACH,qBAAa,cAAe,SAAQ,mBAEE;CAAG;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,QAAQ,CAAC,cAAc,KAC9B,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAG7C,CAAA;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,QAAQ,CAAC,cAAc,KAC9B,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAG7C,CAAA"}

package/dist/dts/config.d.ts

@@ -0,0 +1,58 @@
+import { Schema } from 'effect';
+/**
+ * Configuration for a Postgres store instance.
+ *
+ * - `schema` — the Postgres schema that owns the store's objects (default
+ *   `public`). `ensureSchema` creates it defensively.
+ * - `tablePrefix` — the base name for the store's tables/indexes/functions
+ *   (default `dcb_events`). Two stores with different prefixes (or schemas)
+ *   cohabit one database without interference.
+ * - `lockTimeout` — seconds passed to `set_config('lock_timeout', …, true)`
+ *   inside every append, bounding how long a blocked writer waits on the
+ *   exclusive lock. `0` (the default) means wait indefinitely — parity with the
+ *   in-memory semaphore's unbounded wait, so the shared contract suite behaves
+ *   identically across engines. A non-zero timeout that fires (`55P03`) is a
+ *   Postgres-only outcome surfaced OFF the shared `append` contract (a defect),
+ *   never as `AppendConditionFailed` — the in-memory oracle cannot produce it.
+ * - `pollInterval` — MILLISECONDS a live `subscribe` waits for a NOTIFY wake
+ *   before re-reading from its cursor anyway, defaulting to core's
+ *   `DEFAULT_POLL_INTERVAL_MILLIS`. Because this engine HAS a wake source, the
+ *   value bounds worst-case live-tail latency rather than being it — only a
+ *   subscriber no NOTIFY reaches waits the whole interval; lower it (e.g. in tests)
+ *   to poll faster. See `packages/core/src/SubscribeMachine.ts` for what the poll
+ *   guarantees and what a wake source is for.
+ * - `catchUpPageSize` — the `subscribe` reconcile page size, defaulting to core's
+ *   `DEFAULT_CATCH_UP_PAGE_SIZE`: how many events a single catch-up/live read
+ *   fetches before looping.
+ */
+export declare const PostgresStoreConfig: Schema.filter<Schema.Struct<{
+    pollInterval: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.Number>>, {
+        exact: true;
+    }>;
+    catchUpPageSize: Schema.optionalWith<Schema.filter<typeof Schema.Int>, {
+        exact: true;
+    }>;
+    schema: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.String>>, {
+        exact: true;
+    }>;
+    tablePrefix: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.String>>, {
+        exact: true;
+    }>;
+    lockTimeout: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.Number>>, {
+        exact: true;
+    }>;
+}>>;
+export type PostgresStoreConfig = typeof PostgresStoreConfig.Type;
+/**
+ * Decode an unknown value into a validated `PostgresStoreConfig`, throwing a
+ * `ParseError` on any violation. Used by `layer`/`ensureSchema` so a bad config
+ * fails at construction time.
+ */
+export declare const decodePostgresStoreConfig: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions) => {
+    readonly schema?: string;
+    readonly tablePrefix?: string;
+    readonly lockTimeout?: number;
+    readonly pollInterval?: number;
+    readonly catchUpPageSize?: number;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/dts/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAiB/B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;GAkB/B,CAAA;AACD,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;CACS,CAAA"}