@kairos-es/core 0.0.0

package/dist/cjs/SubscribeMachine.js

@@ -0,0 +1,235 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscriptionTuningFields = exports.subscribeStream = exports.DEFAULT_POLL_INTERVAL_MILLIS = exports.DEFAULT_CATCH_UP_PAGE_SIZE = void 0;
+var _effect = require("effect");
+var _Event = require("./Event.js");
+/**
+ * The subscribe machine every engine's `subscribe` is built from — the in-memory
+ * store, `@kairos-es/store-postgres` and `@kairos-es/store-sqlite`: the wake queue,
+ * the wake-source drain, the paged catch-up reconcile, the `> boundary` de-dup (via
+ * the cursor's exclusive lower bound) and the poll loop that together turn a paged
+ * read into a live subscription.
+ *
+ * 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
+ * behaviour whole, exactly as it supplies mechanics to `makeContractStore` and
+ * inherits the contract policy whole. Two engines that each grew their own wake
+ * loop would be identical only by inspection, and `subscribe` is the verb where
+ * that is least affordable: a divergence there loses events rather than failing.
+ * 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
+ * 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
+ * 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
+ *
+ * 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
+ * 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
+ * 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
+ * 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
+ *
+ * `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.
+ *
+ * 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.
+ */
+
+/**
+ * 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 unbounded read. Every engine takes its
+ * `catchUpPageSize` from here — each SQL engine as its config's default, the
+ * in-memory store as its options' — so backends cannot drift on tuning.
+ */
+const DEFAULT_CATCH_UP_PAGE_SIZE = exports.DEFAULT_CATCH_UP_PAGE_SIZE = 512;
+/**
+ * The default upper bound a subscriber waits for a wake before re-reading from its
+ * cursor ANYWAY (milliseconds). Every engine takes its `pollInterval` from here —
+ * each SQL engine as its config's default, the in-memory store as its options' — so
+ * backends cannot drift on tuning.
+ *
+ * This periodic position-based poll — not the wake source — IS the correctness
+ * guarantee: every committed position is reconciled within this interval whether or
+ * not a wake for it was ever heard. That covers a wake fired before the source was
+ * fully established, a coalesced or dropped wake, and a wake source that died
+ * silently and never said so. A wake source only lowers delivery latency BELOW this
+ * interval; it never carries delivery, so no engine's wake mechanism can make the
+ * right figure here engine-specific. It trades worst-case delivery latency against
+ * idle read volume and nothing else. Upstream `postgres_tt.py` picks the same
+ * one-second fallback poll (`conn.wait(..., interval=1)`).
+ */
+const DEFAULT_POLL_INTERVAL_MILLIS = exports.DEFAULT_POLL_INTERVAL_MILLIS = 1000;
+/**
+ * The two subscribe-tuning config FIELDS, for an engine whose config is a `Schema`
+ * to spread into its own struct.
+ *
+ * These knobs are the machine's, not any engine's: they name what the loop above
+ * does, the figures they fall back to are the two constants declared beside them,
+ * and neither is derivable from a backend's own properties — which is why the
+ * defaults already live here. Shipping the FIELD rather than only the default is
+ * what closes the last gap in that arrangement. An engine that spreads these gets
+ * the key NAME, the VALIDATION and the DEFAULT from one place, so a caller who has
+ * tuned one engine's subscribe reads another's without translating, and the two
+ * cannot drift in what they ACCEPT any more than in what they assume. Two engines
+ * hand-authoring the identical `Schema.optionalWith(…)` twice were identical only
+ * by inspection.
+ *
+ * The bounds differ between the two because the quantities do. `pollInterval` is a
+ * duration, so a fraction of a millisecond is meaningful and only `positive` and
+ * `finite` matter: at zero or below the loop would spin without ever waiting for a
+ * wake, and at `Infinity` the periodic re-read — the half that carries delivery —
+ * would never come, which silently converts the wake source from an optimisation
+ * into the guarantee. `catchUpPageSize` is a COUNT, so it must be an integer
+ * (`Schema.Int` excludes `Infinity` with it): the reconcile loop compares a page's
+ * length against it to decide the tail is drained, and a page of zero would report
+ * "drained" forever without reading anything.
+ *
+ * `exact: true` on both keeps the decoded type at `key?: T` rather than
+ * `T | undefined`, matching the repo's `exactOptionalPropertyTypes` discipline — an
+ * absent key, never an explicit `undefined`.
+ */
+const subscriptionTuningFields = exports.subscriptionTuningFields = {
+  pollInterval: /*#__PURE__*/_effect.Schema.optionalWith(/*#__PURE__*/_effect.Schema.Number.pipe(/*#__PURE__*/_effect.Schema.positive(), /*#__PURE__*/_effect.Schema.finite()), {
+    exact: true
+  }),
+  catchUpPageSize: /*#__PURE__*/_effect.Schema.optionalWith(/*#__PURE__*/_effect.Schema.Int.pipe(/*#__PURE__*/_effect.Schema.positive()), {
+    exact: true
+  })
+};
+/**
+ * Retry a TRANSIENT poll fault (an `E` 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. An `E` 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 wake source `offer`s an opaque wake on every notification;
+  // the poll loop `take`s (with a timeout). The lost-wakeup guard is
+  // STRUCTURAL — drain the queue BEFORE reading, so a wake 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 wake source DOES
+  // surface an error, re-subscribe with capped-exponential backoff. Many wake
+  // sources do not error on a dropped connection at all — they simply go
+  // quiet — so this retry is NOT the reconnect guarantee: the poll fallback
+  // below is. The reconcile loop re-reads from the cursor on every poll, so a
+  // silently-dropped (and later re-established) wake source loses no
+  // positions. Absent a wake source entirely, `Stream.never` makes this a
+  // fibre that parks forever and delivery falls to the poll alone.
+  const listener = (deps.listen ?? _effect.Stream.never).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 wake source 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, _Event.ReadLimit.make(deps.catchUpPageSize));
+      for (const event of events) {
+        collected.push(event);
+      }
+      const lastEvent = events.at(-1);
+      if (lastEvent === undefined || events.length < deps.catchUpPageSize) {
+        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 any wake. 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 ?? _Event.ORIGIN, from => _effect.Effect.map(nextBatch(from), _effect.Option.some));
+}));
+exports.subscribeStream = subscribeStream;
+//# sourceMappingURL=SubscribeMachine.js.map

package/dist/cjs/SubscribeMachine.js.map

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

package/dist/cjs/errors.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AppendConditionFailed = void 0;
+var _effect = require("effect");
+/**
+ * Tagged errors for the store contract. Conflicts are values on the error
+ * channel, never defects.
+ */
+
+/**
+ * Raised by `append` when the append condition's `failIfEventsMatch` query
+ * matches at least one event after `condition.after`. Carries only the
+ * offending condition: a correct retry re-reads the store to its new head and
+ * rebuilds its condition from there, so no conflicting position is carried (it
+ * would already be stale by the time it was acted on).
+ */
+class AppendConditionFailed extends /*#__PURE__*/_effect.Data.TaggedError('AppendConditionFailed') {}
+exports.AppendConditionFailed = AppendConditionFailed;
+//# sourceMappingURL=errors.js.map

package/dist/cjs/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":["_effect","require","AppendConditionFailed","Data","TaggedError","exports"],"sources":["../../src/errors.ts"],"sourcesContent":[null],"mappings":";;;;;;AAIA,IAAAA,OAAA,GAAAC,OAAA;AAJA;;;;;AAOA;;;;;;;AAOM,MAAOC,qBAAsB,sBAAQC,YAAI,CAACC,WAAW,CACzD,uBAAuB,CAGvB;AAAAC,OAAA,CAAAH,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/dist/cjs/inMemory.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeInMemoryTestLayer = exports.DcbEventStoreInMemory = void 0;
+var _effect = require("effect");
+var _ContractStore = require("./ContractStore.js");
+var _DcbEventStore = require("./DcbEventStore.js");
+var _Event = require("./Event.js");
+var _errors = require("./errors.js");
+var _Query = require("./Query.js");
+var _SubscribeMachine = require("./SubscribeMachine.js");
+/** Filter a snapshot by `query` and `after` (strict `position > after`). */
+const filterLog = (log, query, after) => log.filter(sequenced => (after === undefined || sequenced.position > after) && (0, _Query.matchesSequenced)(sequenced, query));
+/** The position of the last event in a slice, or `undefined` when empty. */
+const lastPosition = events => events.at(-1)?.position;
+/**
+ * Compute the read result over a snapshot: filter, apply the limit, and derive
+ * `head` per the contract (no limit => global last position or ORIGIN; limit =>
+ * last returned position or ORIGIN).
+ */
+const readSnapshot = (log, query, options) => {
+  const matched = filterLog(log, query, options?.after);
+  const limited = options?.limit === undefined ? matched : matched.slice(0, options.limit);
+  // No limit => head is the global last position (ignoring the filter). With a
+  // limit => head is the last returned event's position. Either way, ORIGIN
+  // when there is nothing to report.
+  const head = (options?.limit === undefined ? lastPosition(log) : lastPosition(limited)) ?? _Event.ORIGIN;
+  return {
+    events: _effect.Stream.fromIterable(limited),
+    head
+  };
+};
+/**
+ * The index of the first event strictly after `after`, by BINARY SEARCH.
+ *
+ * The log is append-only and ascending by position, so the cursor cut is a boundary
+ * in a sorted array and costs O(log n). That is what makes a live subscription's
+ * idle poll affordable at any log size: the poll re-reads from its cursor every
+ * interval whether or not anything arrived, so a linear cut would charge every open
+ * subscription O(n) per interval for as long as it stayed open.
+ */
+const firstIndexAfter = (log, after) => {
+  let low = 0;
+  let high = log.length;
+  while (low < high) {
+    // `>>> 1` rather than a divide: an integer midpoint with no rounding step.
+    const mid = low + high >>> 1;
+    if (log[mid].position > after) {
+      high = mid;
+    } else {
+      low = mid + 1;
+    }
+  }
+  return low;
+};
+/**
+ * `subscribeStream`'s `fetch` seam: up to `limit` events matching `query` strictly
+ * after `from`, ascending.
+ *
+ * The cursor cut comes FIRST and the query match second, so the predicate only ever
+ * sees candidates the cursor admits, and the scan stops the moment `limit` of them
+ * have matched rather than filtering a tail it would discard.
+ *
+ * Deliberately not expressed through `filterLog`, and the reason is COST rather than
+ * the answer: that form returns the same events and scans the whole log per page.
+ *
+ * What is not interchangeable is what the cap COUNTS. The machine's paging contract
+ * reads a SHORT page as "the tail is drained", so the cap has to count MATCHES and a
+ * short page has to mean the scan ran off the end of the log. A cap counting
+ * CANDIDATES — `limit` events taken by POSITION, with the predicate applied within
+ * them — reports a short page for a window that merely held few matches; and a window
+ * holding NONE reports a drained tail while advancing the cursor nowhere, so the
+ * subscription is WEDGED rather than delayed, with no later poll able to move it.
+ * `InMemoryStoreOptions.catchUpPageSize` is what puts a test at that boundary.
+ */
+const fetchPage = (log, query, from, limit) => {
+  const page = [];
+  for (let index = firstIndexAfter(log, from); index < log.length && page.length < limit; index += 1) {
+    const sequenced = log[index];
+    if ((0, _Query.matchesSequenced)(sequenced, query)) {
+      page.push(sequenced);
+    }
+  }
+  return page;
+};
+/**
+ * Build the in-memory store MECHANICS (a `RawDcbEventStore`), wiring the Ref,
+ * semaphore and hub. The contract-enforcement policy (`assertServableQuery`,
+ * `ReadLimit` decode, error-vs-defect classification) is NOT here — it is added
+ * uniformly by `makeContractStore`, so this engine is pure mechanics.
+ */
+const make = options => _effect.Effect.gen(function* () {
+  const beforeCommit = options?.beforeCommit ?? _effect.Effect.void;
+  const suppressWake = options?.suppressWake ?? false;
+  const catchUpPageSize = options?.catchUpPageSize ?? _SubscribeMachine.DEFAULT_CATCH_UP_PAGE_SIZE;
+  const pollInterval = options?.pollInterval ?? _SubscribeMachine.DEFAULT_POLL_INTERVAL_MILLIS;
+  const log = yield* _effect.Ref.make([]);
+  const mutex = yield* _effect.Effect.makeSemaphore(1);
+  const hub = yield* _effect.PubSub.unbounded();
+  const nextPosition = yield* _effect.Ref.make(1n);
+  const read = (query, options) =>
+  // The lock keeps read consistent with concurrent appends; popo.py's RLock
+  // is reentrant, so append's inner read re-enters. Here append inlines the
+  // read logic instead, so a plain lock suffices.
+  mutex.withPermits(1)(_effect.Effect.map(_effect.Ref.get(log), snapshot => readSnapshot(snapshot, query, options)));
+  const append = (events, condition) =>
+  // Critical section: check + commit are atomic (the exactly-one-wins guarantee).
+  mutex.withPermits(1)(_effect.Effect.gen(function* () {
+    const snapshot = yield* _effect.Ref.get(log);
+    if (condition !== undefined) {
+      const conflicts = filterLog(snapshot, condition.failIfEventsMatch, condition.after);
+      // Detect by presence: any matching event after `condition.after`
+      // fails the append. The error carries only the condition (see
+      // `AppendConditionFailed`); a correct retry re-reads to the new head.
+      if (conflicts.length > 0) {
+        return yield* new _errors.AppendConditionFailed({
+          condition
+        });
+      }
+    }
+    // Optional test seam between the conflict-check and the commit (see
+    // `InMemoryStoreOptions.beforeCommit`). Defaults to `Effect.void`, a
+    // synchronous no-op, so the shipped critical section stays atomic by
+    // construction; the concurrency contract test injects `Effect.yieldNow()`
+    // here to make the exactly-one-wins guard genuinely depend on the mutex.
+    yield* beforeCommit;
+    const start = yield* _effect.Ref.get(nextPosition);
+    const appended = events.map((event, index) => ({
+      event,
+      position: start + BigInt(index)
+    }));
+    const end = start + BigInt(events.length);
+    yield* _effect.Ref.set(log, [...snapshot, ...appended]);
+    yield* _effect.Ref.set(nextPosition, end);
+    // The hub is a WAKE SOURCE and nothing else: the subscribe machine never
+    // reads what it carries, and its poll delivers with or without one. That
+    // is why suppressing the publish is a legitimate test seam rather than a
+    // broken store (see `InMemoryStoreOptions.suppressWake`).
+    if (!suppressWake) {
+      yield* _effect.PubSub.publishAll(hub, appended);
+    }
+    // `events` is non-empty, so the last new position is `end - 1`.
+    return end - 1n;
+  }));
+  const subscribe = (query, after) =>
+  // Take the hub seat HERE, before handing the machine its wake source, so the
+  // subscription is established no later than the machine's first `fetch`. That
+  // ordering is what keeps delivery independent of the poll's timer: an append
+  // either lands before that first read, and the read sees it, or after the seat
+  // exists, and its wake is queued. The machine drains a wake source on a forked
+  // fibre, so a seat taken inside that fibre would leave a window in which an
+  // append publishes to nobody — recoverable by the next poll, but only on a
+  // real clock, and much of this store's use is under `TestClock`.
+  //
+  // No mutex: `Ref.get` already reads one committed snapshot, and the machine's
+  // exclusive cursor is what makes the catch-up/live seam exactly-once, so there
+  // is nothing left here for a critical section to protect. `append` keeps its
+  // permit, which is the whole exactly-one-wins guarantee.
+  _effect.Stream.unwrapScoped(_effect.Effect.gen(function* () {
+    const wakes = yield* _effect.PubSub.subscribe(hub);
+    return (0, _SubscribeMachine.subscribeStream)({
+      fetch: (from, limit) => _effect.Effect.map(_effect.Ref.get(log), snapshot => fetchPage(snapshot, query, from, limit)),
+      listen: _effect.Stream.fromQueue(wakes),
+      pollInterval,
+      catchUpPageSize
+    }, after);
+  }));
+  return {
+    read,
+    append,
+    subscribe
+  };
+});
+/** The in-memory `DcbEventStore` layer (production; no test seam). */
+const DcbEventStoreInMemory = exports.DcbEventStoreInMemory = /*#__PURE__*/_effect.Layer.effect(_DcbEventStore.DcbEventStore, /*#__PURE__*/_effect.Effect.map(/*#__PURE__*/make(), _ContractStore.makeContractStore));
+/**
+ * Test-only in-memory layer factory: the same store as `DcbEventStoreInMemory`, but
+ * with `InMemoryStoreOptions`' seams open. Kept off the package's public surface
+ * (deliberately not re-exported from `index.ts`); production code always uses
+ * `DcbEventStoreInMemory`. Every seam exists to make a claim about this store
+ * FALSIFIABLE rather than merely commented — the store contract suite forces the
+ * check/commit interleaving the exactly-one-wins case needs, one core test takes the
+ * wake away and shortens the poll so that what delivers can only be the poll, and
+ * another lowers the catch-up page to reach the second-page boundary the shipped page
+ * size puts out of reach.
+ */
+const makeInMemoryTestLayer = options => _effect.Layer.effect(_DcbEventStore.DcbEventStore, _effect.Effect.map(make(options), _ContractStore.makeContractStore));
+exports.makeInMemoryTestLayer = makeInMemoryTestLayer;
+//# sourceMappingURL=inMemory.js.map

package/dist/cjs/inMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemory.js","names":["_effect","require","_ContractStore","_DcbEventStore","_Event","_errors","_Query","_SubscribeMachine","filterLog","log","query","after","filter","sequenced","undefined","position","matchesSequenced","lastPosition","events","at","readSnapshot","options","matched","limited","limit","slice","head","ORIGIN","Stream","fromIterable","firstIndexAfter","low","high","length","mid","fetchPage","from","page","index","push","make","Effect","gen","beforeCommit","void","suppressWake","catchUpPageSize","DEFAULT_CATCH_UP_PAGE_SIZE","pollInterval","DEFAULT_POLL_INTERVAL_MILLIS","Ref","mutex","makeSemaphore","hub","PubSub","unbounded","nextPosition","read","withPermits","map","get","snapshot","append","condition","conflicts","failIfEventsMatch","AppendConditionFailed","start","appended","event","BigInt","end","set","publishAll","subscribe","unwrapScoped","wakes","subscribeStream","fetch","listen","fromQueue","DcbEventStoreInMemory","exports","Layer","effect","DcbEventStore","makeContractStore","makeInMemoryTestLayer"],"sources":["../../src/inMemory.ts"],"sourcesContent":[null],"mappings":";;;;;;AA2BA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,cAAA,GAAAD,OAAA;AAEA,IAAAE,cAAA,GAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AAEA,IAAAK,MAAA,GAAAL,OAAA;AACA,IAAAM,iBAAA,GAAAN,OAAA;AAMA;AACA,MAAMO,SAAS,GAAGA,CAChBC,GAAkC,EAClCC,KAAY,EACZC,KAA2B,KAE3BF,GAAG,CAACG,MAAM,CACPC,SAAS,IACR,CAACF,KAAK,KAAKG,SAAS,IAAID,SAAS,CAACE,QAAQ,GAAGJ,KAAK,KAClD,IAAAK,uBAAgB,EAACH,SAAS,EAAEH,KAAK,CAAC,CACrC;AAEH;AACA,MAAMO,YAAY,GAChBC,MAAqC,IACZA,MAAM,CAACC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAEJ,QAAQ;AAElD;;;;;AAKA,MAAMK,YAAY,GAAGA,CACnBX,GAAkC,EAClCC,KAAY,EACZW,OAAgC,KAChB;EAChB,MAAMC,OAAO,GAAGd,SAAS,CAACC,GAAG,EAAEC,KAAK,EAAEW,OAAO,EAAEV,KAAK,CAAC;EACrD,MAAMY,OAAO,GACXF,OAAO,EAAEG,KAAK,KAAKV,SAAS,GAAGQ,OAAO,GAAGA,OAAO,CAACG,KAAK,CAAC,CAAC,EAAEJ,OAAO,CAACG,KAAK,CAAC;EAE1E;EACA;EACA;EACA,MAAME,IAAI,GACR,CAACL,OAAO,EAAEG,KAAK,KAAKV,SAAS,GACzBG,YAAY,CAACR,GAAG,CAAC,GACjBQ,YAAY,CAACM,OAAO,CAAC,KAAKI,aAAM;EAEtC,OAAO;IAAET,MAAM,EAAEU,cAAM,CAACC,YAAY,CAACN,OAAO,CAAC;IAAEG;EAAI,CAAE;AACvD,CAAC;AAED;;;;;;;;;AASA,MAAMI,eAAe,GAAGA,CACtBrB,GAAkC,EAClCE,KAAe,KACL;EACV,IAAIoB,GAAG,GAAG,CAAC;EACX,IAAIC,IAAI,GAAGvB,GAAG,CAACwB,MAAM;EACrB,OAAOF,GAAG,GAAGC,IAAI,EAAE;IACjB;IACA,MAAME,GAAG,GAAIH,GAAG,GAAGC,IAAI,KAAM,CAAC;IAC9B,IAAIvB,GAAG,CAACyB,GAAG,CAAC,CAACnB,QAAQ,GAAGJ,KAAK,EAAE;MAC7BqB,IAAI,GAAGE,GAAG;IACZ,CAAC,MAAM;MACLH,GAAG,GAAGG,GAAG,GAAG,CAAC;IACf;EACF;EACA,OAAOH,GAAG;AACZ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;AAoBA,MAAMI,SAAS,GAAGA,CAChB1B,GAAkC,EAClCC,KAAY,EACZ0B,IAAc,EACdZ,KAAgB,KACiB;EACjC,MAAMa,IAAI,GAA0B,EAAE;EACtC,KACE,IAAIC,KAAK,GAAGR,eAAe,CAACrB,GAAG,EAAE2B,IAAI,CAAC,EACtCE,KAAK,GAAG7B,GAAG,CAACwB,MAAM,IAAII,IAAI,CAACJ,MAAM,GAAGT,KAAK,EACzCc,KAAK,IAAI,CAAC,EACV;IACA,MAAMzB,SAAS,GAAGJ,GAAG,CAAC6B,KAAK,CAAC;IAC5B,IAAI,IAAAtB,uBAAgB,EAACH,SAAS,EAAEH,KAAK,CAAC,EAAE;MACtC2B,IAAI,CAACE,IAAI,CAAC1B,SAAS,CAAC;IACtB;EACF;EACA,OAAOwB,IAAI;AACb,CAAC;AA8DD;;;;;;AAMA,MAAMG,IAAI,GACRnB,OAA8B,IAE9BoB,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,YAAY,GAAGtB,OAAO,EAAEsB,YAAY,IAAIF,cAAM,CAACG,IAAI;EACzD,MAAMC,YAAY,GAAGxB,OAAO,EAAEwB,YAAY,IAAI,KAAK;EACnD,MAAMC,eAAe,GACnBzB,OAAO,EAAEyB,eAAe,IAAIC,4CAA0B;EACxD,MAAMC,YAAY,GAAG3B,OAAO,EAAE2B,YAAY,IAAIC,8CAA4B;EAC1E,MAAMxC,GAAG,GAAG,OAAOyC,WAAG,CAACV,IAAI,CAAgC,EAAE,CAAC;EAC9D,MAAMW,KAAK,GAAG,OAAOV,cAAM,CAACW,aAAa,CAAC,CAAC,CAAC;EAC5C,MAAMC,GAAG,GAAG,OAAOC,cAAM,CAACC,SAAS,EAAkB;EACrD,MAAMC,YAAY,GAAG,OAAON,WAAG,CAACV,IAAI,CAAS,EAAE,CAAC;EAEhD,MAAMiB,IAAI,GAAGA,CACX/C,KAAY,EACZW,OAAqB;EAErB;EACA;EACA;EACA8B,KAAK,CAACO,WAAW,CAAC,CAAC,CAAC,CAClBjB,cAAM,CAACkB,GAAG,CAACT,WAAG,CAACU,GAAG,CAACnD,GAAG,CAAC,EAAGoD,QAAQ,IAChCzC,YAAY,CAACyC,QAAQ,EAAEnD,KAAK,EAAEW,OAAO,CAAC,CACvC,CACF;EAEH,MAAMyC,MAAM,GAAGA,CACb5C,MAA2C,EAC3C6C,SAA2B;EAE3B;EACAZ,KAAK,CAACO,WAAW,CAAC,CAAC,CAAC,CAClBjB,cAAM,CAACC,GAAG,CAAC,aAAS;IAClB,MAAMmB,QAAQ,GAAG,OAAOX,WAAG,CAACU,GAAG,CAACnD,GAAG,CAAC;IAEpC,IAAIsD,SAAS,KAAKjD,SAAS,EAAE;MAC3B,MAAMkD,SAAS,GAAGxD,SAAS,CACzBqD,QAAQ,EACRE,SAAS,CAACE,iBAAiB,EAC3BF,SAAS,CAACpD,KAAK,CAChB;MACD;MACA;MACA;MACA,IAAIqD,SAAS,CAAC/B,MAAM,GAAG,CAAC,EAAE;QACxB,OAAO,OAAO,IAAIiC,6BAAqB,CAAC;UAAEH;QAAS,CAAE,CAAC;MACxD;IACF;IAEA;IACA;IACA;IACA;IACA;IACA,OAAOpB,YAAY;IAEnB,MAAMwB,KAAK,GAAG,OAAOjB,WAAG,CAACU,GAAG,CAACJ,YAAY,CAAC;IAC1C,MAAMY,QAAQ,GAA0BlD,MAAM,CAACyC,GAAG,CAChD,CAACU,KAAK,EAAE/B,KAAK,MAAM;MACjB+B,KAAK;MACLtD,QAAQ,EAAGoD,KAAK,GAAGG,MAAM,CAAChC,KAAK;KAChC,CAAC,CACH;IACD,MAAMiC,GAAG,GAAGJ,KAAK,GAAGG,MAAM,CAACpD,MAAM,CAACe,MAAM,CAAC;IACzC,OAAOiB,WAAG,CAACsB,GAAG,CAAC/D,GAAG,EAAE,CAAC,GAAGoD,QAAQ,EAAE,GAAGO,QAAQ,CAAC,CAAC;IAC/C,OAAOlB,WAAG,CAACsB,GAAG,CAAChB,YAAY,EAAEe,GAAG,CAAC;IACjC;IACA;IACA;IACA;IACA,IAAI,CAAC1B,YAAY,EAAE;MACjB,OAAOS,cAAM,CAACmB,UAAU,CAACpB,GAAG,EAAEe,QAAQ,CAAC;IACzC;IACA;IACA,OAAQG,GAAG,GAAG,EAAE;EAClB,CAAC,CAAC,CACH;EAEH,MAAMG,SAAS,GAAGA,CAChBhE,KAAY,EACZC,KAAgB;EAEhB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACAiB,cAAM,CAAC+C,YAAY,CACjBlC,cAAM,CAACC,GAAG,CAAC,aAAS;IAClB,MAAMkC,KAAK,GAAG,OAAOtB,cAAM,CAACoB,SAAS,CAACrB,GAAG,CAAC;IAC1C,OAAO,IAAAwB,iCAAe,EACpB;MACEC,KAAK,EAAEA,CAAC1C,IAAI,EAAEZ,KAAK,KACjBiB,cAAM,CAACkB,GAAG,CAACT,WAAG,CAACU,GAAG,CAACnD,GAAG,CAAC,EAAGoD,QAAQ,IAChC1B,SAAS,CAAC0B,QAAQ,EAAEnD,KAAK,EAAE0B,IAAI,EAAEZ,KAAK,CAAC,CACxC;MACHuD,MAAM,EAAEnD,cAAM,CAACoD,SAAS,CAACJ,KAAK,CAAC;MAC/B5B,YAAY;MACZF;KACD,EACDnC,KAAK,CACN;EACH,CAAC,CAAC,CACH;EAEH,OAAO;IAAE8C,IAAI;IAAEK,MAAM;IAAEY;EAAS,CAAW;AAC7C,CAAC,CAAC;AAEJ;AACO,MAAMO,qBAAqB,GAAAC,OAAA,CAAAD,qBAAA,gBAA+BE,aAAK,CAACC,MAAM,CAC3EC,4BAAa,eACb5C,cAAM,CAACkB,GAAG,cAACnB,IAAI,EAAE,EAAE8C,gCAAiB,CAAC,CACtC;AAED;;;;;;;;;;;AAWO,MAAMC,qBAAqB,GAChClE,OAA6B,IAE7B8D,aAAK,CAACC,MAAM,CAACC,4BAAa,EAAE5C,cAAM,CAACkB,GAAG,CAACnB,IAAI,CAACnB,OAAO,CAAC,EAAEiE,gCAAiB,CAAC,CAAC;AAAAJ,OAAA,CAAAK,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/dist/cjs/index.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  DcbEventStoreInMemory: true
+};
+Object.defineProperty(exports, "DcbEventStoreInMemory", {
+  enumerable: true,
+  get: function () {
+    return _inMemory.DcbEventStoreInMemory;
+  }
+});
+var _AppendCondition = require("./AppendCondition.js");
+Object.keys(_AppendCondition).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _AppendCondition[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _AppendCondition[key];
+    }
+  });
+});
+var _ContractStore = require("./ContractStore.js");
+Object.keys(_ContractStore).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ContractStore[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ContractStore[key];
+    }
+  });
+});
+var _DcbEventStore = require("./DcbEventStore.js");
+Object.keys(_DcbEventStore).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _DcbEventStore[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DcbEventStore[key];
+    }
+  });
+});
+var _Event = require("./Event.js");
+Object.keys(_Event).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Event[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Event[key];
+    }
+  });
+});
+var _errors = require("./errors.js");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _errors[key];
+    }
+  });
+});
+var _inMemory = require("./inMemory.js");
+var _Projection = require("./Projection.js");
+Object.keys(_Projection).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Projection[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Projection[key];
+    }
+  });
+});
+var _Query = require("./Query.js");
+Object.keys(_Query).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Query[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Query[key];
+    }
+  });
+});
+var _retryOnConflict = require("./retryOnConflict.js");
+Object.keys(_retryOnConflict).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _retryOnConflict[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _retryOnConflict[key];
+    }
+  });
+});
+var _SubscribeMachine = require("./SubscribeMachine.js");
+Object.keys(_SubscribeMachine).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SubscribeMachine[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _SubscribeMachine[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_AppendCondition","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_ContractStore","_DcbEventStore","_Event","_errors","_inMemory","_Projection","_Query","_retryOnConflict","_SubscribeMachine"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}