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

package/dist/{dts → dts-cjs}/ContractStore.d.ts

@@ -8,7 +8,8 @@
  * channel (`never` for the pure in-memory engine; `SqlError` for either SQL one).
  * The decorator wraps those mechanics with the policy the contract demands — the
  * policy the first two engines hand-duplicated, with the Postgres one even
- * needing a bespoke `catchAll`/`instanceof`:
+ * needing a bespoke `catchAll`/`instanceof` (Effect 3's `catchAll`, which Effect 4
+ * names `catch`):
  *
  * - `assertServableQuery` at every verb's entry (read, the append condition's
  *   guard query, subscribe) — a non-servable query, or one carrying a key the
@@ -57,5 +58,5 @@ export interface RawDcbEventStore<E> {
  * Wrap a raw engine's mechanics with the shared contract-enforcement policy,
  * producing a full `DcbEventStore` service value.
  */
-export declare const makeContractStore: <E>(raw: RawDcbEventStore<E>) => DcbEventStore["Type"];
+export declare const makeContractStore: <E>(raw: RawDcbEventStore<E>) => DcbEventStore["Service"];
 //# sourceMappingURL=ContractStore.d.ts.map

package/dist/dts-cjs/ContractStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractStore.d.ts","sourceRoot":"","sources":["../../src/ContractStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,EAAE,MAAM,EAAqB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAEjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACrD,OAAO,EAAuB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAA;AAKzD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,CACb,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,WAAW,KAClB,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAA;IACnC,QAAQ,CAAC,MAAM,EAAE,CACf,MAAM,EAAE,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAC3C,SAAS,CAAC,EAAE,eAAe,KACxB,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,qBAAqB,GAAG,CAAC,CAAC,CAAA;IACvD,QAAQ,CAAC,SAAS,EAAE,CAClB,KAAK,EAAE,KAAK,EACZ,KAAK,CAAC,EAAE,QAAQ,KACb,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;CACnD;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EACjC,KAAK,gBAAgB,CAAC,CAAC,CAAC,KACvB,aAAa,CAAC,SAAS,CAoGxB,CAAA"}

package/dist/{dts → dts-cjs}/DcbEventStore.d.ts

@@ -1,5 +1,5 @@
 /**
- * The `DcbEventStore` contract: a `Context.Tag` with no bundled implementation.
+ * The `DcbEventStore` contract: a `Context.Service` with no bundled implementation.
  * Consumers supply a `Layer` (the in-memory one lives in this package; each SQL
  * engine is a package of its own — `@kairos-es/store-postgres` and
  * `@kairos-es/store-sqlite`).
@@ -39,7 +39,7 @@ export interface ReadResponse {
     readonly events: Stream.Stream<SequencedEvent>;
     readonly head: Position;
 }
-declare const DcbEventStore_base: Context.TagClass<DcbEventStore, "@kairos-es/core/DcbEventStore", {
+declare const DcbEventStore_base: Context.ServiceClass<DcbEventStore, "@kairos-es/core/DcbEventStore", {
     /**
      * Read events matching `query` (empty query = all), optionally bounded by
      * `after`/`limit`. See head semantics in the module docs.

package/dist/{dts → dts-cjs}/DcbEventStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DcbEventStore.d.ts","sourceRoot":"","sources":["../../src/DcbEventStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAA;IACzB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;IAC9C,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CACxB;;IAKG;;;OAGG;mBACY,CACb,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,WAAW,KAClB,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;IAEhC;;;;OAIG;qBACc,CACf,MAAM,EAAE,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAC3C,SAAS,CAAC,EAAE,eAAe,KACxB,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAEnD;;;;OAIG;wBACiB,CAClB,KAAK,EAAE,KAAK,EACZ,KAAK,CAAC,EAAE,QAAQ,KACb,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;;AA9B1D,qBAAa,aAAc,SAAQ,kBAgChC;CAAG"}
+{"version":3,"file":"DcbEventStore.d.ts","sourceRoot":"","sources":["../../src/DcbEventStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAA;IACzB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;IAC9C,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CACxB;;IAKG;;;OAGG;mBACY,CACb,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,WAAW,KAClB,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;IAEhC;;;;OAIG;qBACc,CACf,MAAM,EAAE,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAC3C,SAAS,CAAC,EAAE,eAAe,KACxB,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAEnD;;;;OAIG;wBACiB,CAClB,KAAK,EAAE,KAAK,EACZ,KAAK,CAAC,EAAE,QAAQ,KACb,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;;AA9B1D,qBAAa,aAAc,SAAQ,kBAgCC;CAAG"}

package/dist/{dts → dts-cjs}/Event.d.ts

@@ -12,11 +12,20 @@ import { Schema } from 'effect';
  *
  * The log is 64-bit (`bigserial` in Postgres) and exceeds JS `number` safety at
  * 2^53, so positions are a `bigint`. They are compared, never arithmetic'd.
- * `Schema.BigInt` encodes to a decimal string (JSON-safe) and decodes to
+ * Encoded, a position is a decimal string (JSON-safe, `String(b)`); decoded, a
  * `bigint`. `0n` is the "before the first event" sentinel used by `after` and by
  * an empty store's head.
+ *
+ * The string-to-`bigint` step is hand-built rather than Effect 4's
+ * `Schema.BigIntFromString`, because that schema accepts only `^-?\d+$` and so
+ * refuses inputs the encoded side has always admitted — `" 5"`, `"+5"`,
+ * `"0x10"`. The decode here is the global `BigInt(s)` behind a blank-string
+ * refusal, which is `BigInt.fromString` and is exactly what Effect 3's
+ * `Schema.BigInt` ran, so a position string any earlier release decoded still
+ * decodes to the same value. The non-negative check then runs on the `bigint`,
+ * as it always did.
  */
-export declare const Position: Schema.brand<Schema.filter<typeof Schema.BigInt>, "Position">;
+export declare const Position: Schema.brand<Schema.decodeTo<Schema.BigInt, Schema.String, never, never>, "Position">;
 export type Position = typeof Position.Type;
 /** The sentinel position meaning "before the first event". */
 export declare const ORIGIN: Position;
@@ -26,7 +35,7 @@ export declare const ORIGIN: Position;
  * event sourcing; a query matches an event when the event carries all of an
  * item's tags (superset test).
  */
-export declare const Tag: Schema.brand<Schema.filter<typeof Schema.String>, "Tag">;
+export declare const Tag: Schema.brand<Schema.String, "Tag">;
 export type Tag = typeof Tag.Type;
 /**
  * A reusable tag identity: a `key` plus a `.make(value)` that composes the
@@ -65,13 +74,13 @@ export declare const tagIdentity: (key: string) => TagIdentity;
  * error channel (`read` keeps `E = never`). Constructed at call sites with
  * `ReadLimit.make(n)`.
  */
-export declare const ReadLimit: Schema.brand<Schema.filter<typeof Schema.Int>, "ReadLimit">;
+export declare const ReadLimit: Schema.brand<Schema.Int, "ReadLimit">;
 export type ReadLimit = typeof ReadLimit.Type;
 /**
  * An event type name, a branded non-empty string. Versioning is by convention
  * in the name (e.g. `course-registered.v2`); only non-emptiness is enforced.
  */
-export declare const EventType: Schema.brand<Schema.filter<typeof Schema.String>, "EventType">;
+export declare const EventType: Schema.brand<Schema.String, "EventType">;
 export type EventType = typeof EventType.Type;
 /**
  * An event's metadata: a flat bag of strings carrying the circumstances under
@@ -122,7 +131,7 @@ export type EventType = typeof EventType.Type;
  * alone: it would make an event the store accepted unreadable for ever, so a
  * value check belongs at write or nowhere.
  */
-export declare const Metadata: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+export declare const Metadata: Schema.$Record<Schema.String, Schema.String>;
 export type Metadata = typeof Metadata.Type;
 /**
  * An event as stored: an opaque payload plus its type, tags, a
@@ -131,6 +140,8 @@ export type Metadata = typeof Metadata.Type;
  *
  * `data` is `Uint8Array` (opaque bytes); the store does not interpret it.
  * `uuid` is producer-supplied to keep `core` deterministic (no RNG in core).
+ * It is checked for UUID SHAPE only (`isGUID`), not for a version nibble: a
+ * stricter check would refuse ids an existing log already holds.
  * `occurredAt` is informational only; ordering is by position alone.
  * `metadata` mirrors `tags` rather than `data`: REQUIRED, with an empty bag
  * legal. Required because an absent-versus-empty divergence between engines is
@@ -139,25 +150,25 @@ export type Metadata = typeof Metadata.Type;
  * Core only carries it; the codec's `toEvent` is where it is resolved.
  */
 export declare const DcbEvent: Schema.Struct<{
-    type: Schema.brand<Schema.filter<typeof Schema.String>, "EventType">;
-    data: typeof Schema.Uint8ArrayFromSelf;
-    tags: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "Tag">>;
-    uuid: typeof Schema.UUID;
-    occurredAt: typeof Schema.DateTimeUtc;
-    metadata: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    readonly type: Schema.brand<Schema.String, "EventType">;
+    readonly data: Schema.Uint8Array;
+    readonly tags: Schema.$Array<Schema.brand<Schema.String, "Tag">>;
+    readonly uuid: Schema.String;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+    readonly metadata: Schema.$Record<Schema.String, Schema.String>;
 }>;
 export type DcbEvent = typeof DcbEvent.Type;
 /** A persisted event: the event together with the position it was written at. */
 export declare const SequencedEvent: Schema.Struct<{
-    event: Schema.Struct<{
-        type: Schema.brand<Schema.filter<typeof Schema.String>, "EventType">;
-        data: typeof Schema.Uint8ArrayFromSelf;
-        tags: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "Tag">>;
-        uuid: typeof Schema.UUID;
-        occurredAt: typeof Schema.DateTimeUtc;
-        metadata: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    readonly event: Schema.Struct<{
+        readonly type: Schema.brand<Schema.String, "EventType">;
+        readonly data: Schema.Uint8Array;
+        readonly tags: Schema.$Array<Schema.brand<Schema.String, "Tag">>;
+        readonly uuid: Schema.String;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly metadata: Schema.$Record<Schema.String, Schema.String>;
     }>;
-    position: Schema.brand<Schema.filter<typeof Schema.BigInt>, "Position">;
+    readonly position: Schema.brand<Schema.decodeTo<Schema.BigInt, Schema.String, never, never>, "Position">;
 }>;
 export type SequencedEvent = typeof SequencedEvent.Type;
 //# sourceMappingURL=Event.d.ts.map

package/dist/dts-cjs/Event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.d.ts","sourceRoot":"","sources":["../../src/Event.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAIL,MAAM,EAGP,MAAM,QAAQ,CAAA;AAEf;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,uFAuBpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,8DAA8D;AAC9D,eAAO,MAAM,MAAM,EAAE,QAA4B,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,GAAG,oCAGf,CAAA;AACD,MAAM,MAAM,GAAG,GAAG,OAAO,GAAG,CAAC,IAAI,CAAA;AAEjC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,GAAG,CAAA;CACtC;AAED,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,WAiBzC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,uCAGrB,CAAA;AACD,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,SAAS,0CAGrB,CAAA;AACD,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,QAAQ,8CAA8C,CAAA;AACnE,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ;;;;;;;EAOnB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,iFAAiF;AACjF,eAAO,MAAM,cAAc;;;;;;;;;;EAGzB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA"}

package/dist/{dts → dts-cjs}/Query.d.ts

@@ -29,15 +29,15 @@ import { type DcbEvent, EventType, type SequencedEvent, Tag } from './Event.js';
  * (superset test, empty = no tag constraint).
  */
 export declare const QueryItem: Schema.Struct<{
-    types: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "EventType">>;
-    tags: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "Tag">>;
+    readonly types: Schema.$Array<Schema.brand<Schema.String, "EventType">>;
+    readonly tags: Schema.$Array<Schema.brand<Schema.String, "Tag">>;
 }>;
 export type QueryItem = typeof QueryItem.Type;
 /** A query: an OR of items. Empty `items` matches everything. */
 export declare const Query: Schema.Struct<{
-    items: Schema.Array$<Schema.Struct<{
-        types: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "EventType">>;
-        tags: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "Tag">>;
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly types: Schema.$Array<Schema.brand<Schema.String, "EventType">>;
+        readonly tags: Schema.$Array<Schema.brand<Schema.String, "Tag">>;
     }>>;
 }>;
 export type Query = typeof Query.Type;

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

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

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

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

package/dist/{dts → dts-cjs}/inMemory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inMemory.d.ts","sourceRoot":"","sources":["../../src/inMemory.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAY,MAAM,EAAE,KAAK,EAAuB,MAAM,QAAQ,CAAA;AAIrE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAuL/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC3C,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAC/B;AAuID,sEAAsE;AACtE,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,KAAK,CAAC,aAAa,CAG5D,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,GAChC,SAAS,oBAAoB,KAC5B,KAAK,CAAC,KAAK,CAAC,aAAa,CAC+C,CAAA"}
+{"version":3,"file":"inMemory.d.ts","sourceRoot":"","sources":["../../src/inMemory.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAY,MAAM,EAAE,KAAK,EAAkC,MAAM,QAAQ,CAAA;AAIhF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAuL/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC3C,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAC/B;AAuID,sEAAsE;AACtE,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,KAAK,CAAC,aAAa,CAG5D,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,GAChC,SAAS,oBAAoB,KAC5B,KAAK,CAAC,KAAK,CAAC,aAAa,CAC+C,CAAA"}

package/dist/{dts → dts-cjs}/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * @kairos-es/core: DCB-first event-sourcing contract and in-memory store for
- * Effect v3.
+ * Effect.
  *
  * Exposes the domain types (`DcbEvent`, `SequencedEvent`, `Position`, `Tag`,
  * `EventType`), the selection language (`Query`, `QueryItem`, the pure match

package/dist/dts-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/{dts → dts-cjs}/retryOnConflict.d.ts

@@ -35,12 +35,6 @@
  * jitter draws from `Random.next`, a default service on the same footing as the
  * clock rather than a host `Math.random`. No `node:*`, no wall-clock reading, no
  * ungoverned RNG.
- *
- * Effect v3 caveat: the `Schedule` API below is the THREE-type-parameter
- * `Schedule<Out, In, R>` that `effect@3` exports, with `Schedule.intersect`. The
- * currently-published docs show a newer four-type-parameter `Schedule` without
- * `intersect` — do not copy them; this file is written against the installed
- * `effect@3` type definitions.
  */
 import { Effect, Schedule } from 'effect';
 import type { AppendConditionFailed } from './errors.js';
@@ -66,5 +60,5 @@ import type { AppendConditionFailed } from './errors.js';
  * error when a consumer's graph loads both builds — a conflict would then escape
  * unretried and silently.
  */
-export declare const retryOnConflict: <A, E, R>(command: Effect.Effect<A, AppendConditionFailed | E, R>, schedule?: Schedule.Schedule<unknown, AppendConditionFailed | E, R>) => Effect.Effect<A, AppendConditionFailed | E, R>;
+export declare const retryOnConflict: <A, E, R>(command: Effect.Effect<A, AppendConditionFailed | E, R>, schedule?: Schedule.Schedule<unknown, AppendConditionFailed | E, never, R>) => Effect.Effect<A, AppendConditionFailed | E, R>;
 //# sourceMappingURL=retryOnConflict.d.ts.map

package/dist/dts-cjs/retryOnConflict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retryOnConflict.d.ts","sourceRoot":"","sources":["../../src/retryOnConflict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,EAAE,MAAM,EAAa,QAAQ,EAAE,MAAM,QAAQ,CAAA;AACpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAqBrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EACrC,SAAS,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,qBAAqB,GAAG,CAAC,EAAE,CAAC,CAAC,EACvD,WAAU,QAAQ,CAAC,QAAQ,CACzB,OAAO,EACP,qBAAqB,GAAG,CAAC,EACzB,KAAK,EACL,CAAC,CACgB,KAClB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,qBAAqB,GAAG,CAAC,EAAE,CAAC,CAI5C,CAAA"}

package/dist/{dts → dts-cjs}/testing.d.ts

@@ -20,7 +20,7 @@ import { DateTime } from 'effect';
  *
  * Ordering in the log is by `position` alone, so an event's `occurredAt` is
  * informational; pinning it to the epoch keeps serialised bytes and comparisons
- * stable across runs. Built via `DateTime.unsafeMake(0)` (the value is a
+ * stable across runs. Built via `DateTime.makeUnsafe(0)` (the value is a
  * compile-time constant, not read from the host clock).
  */
 export declare const EPOCH: DateTime.Utc;

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

@@ -0,0 +1,21 @@
+/**
+ * The optimistic-concurrency guard for `append`. The append fails if any event
+ * matching `failIfEventsMatch` exists strictly after `after`. This is the whole
+ * DCB consistency mechanism: "fail if anything I based my decision on has
+ * changed since I read it."
+ *
+ * `after` is exact-optional (absent, never `undefined`) per
+ * `exactOptionalPropertyTypes`. Absent means "scan the whole log".
+ */
+import { Schema } from 'effect';
+export declare const AppendCondition: Schema.Struct<{
+    readonly failIfEventsMatch: Schema.Struct<{
+        readonly items: Schema.$Array<Schema.Struct<{
+            readonly types: Schema.$Array<Schema.brand<Schema.String, "EventType">>;
+            readonly tags: Schema.$Array<Schema.brand<Schema.String, "Tag">>;
+        }>>;
+    }>;
+    readonly after: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.BigInt, Schema.String, never, never>, "Position">>;
+}>;
+export type AppendCondition = typeof AppendCondition.Type;
+//# sourceMappingURL=AppendCondition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppendCondition.d.ts","sourceRoot":"","sources":["../../src/AppendCondition.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,eAAO,MAAM,eAAe;;;;;;;;EAG1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA"}