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

package/dist/esm/inMemory.js

@@ -1,10 +1,71 @@
-import { Effect, Layer, PubSub, Ref, Stream } from 'effect';
+import { DateTime, Effect, Layer, PubSub, Ref, Semaphore, Stream } from 'effect';
 import { makeContractStore } from "./ContractStore.js";
 import { DcbEventStore } from "./DcbEventStore.js";
 import { ORIGIN } from "./Event.js";
 import { AppendConditionFailed } from "./errors.js";
 import { matchesSequenced } from "./Query.js";
 import { DEFAULT_CATCH_UP_PAGE_SIZE, DEFAULT_POLL_INTERVAL_MILLIS, subscribeStream } from "./SubscribeMachine.js";
+/**
+ * A copy of `event` that shares no mutable structure with it: fresh `data` bytes, a
+ * fresh `tags` array, a fresh `metadata` bag and a fresh `occurredAt`. Only `type`
+ * and `uuid`, which are strings, are carried as they are.
+ *
+ * Each copy is chosen for what it does on EVERY input the type admits, not on the
+ * common one. `data` is copied through the `Uint8Array` constructor and not with
+ * `slice`, because `DcbEvent` admits any `Uint8Array` subclass and a subclass may
+ * answer `slice` with a VIEW of the same memory — Node's `Buffer` does. A
+ * `DateTime.Utc` is an ordinary object whose fields can be written past its
+ * `readonly` type, so `occurredAt` is rebuilt from its instant rather than shared.
+ *
+ * ## Why the oracle copies at BOTH edges
+ *
+ * This store is the reference the SQL engines are judged against, and a SQL engine
+ * shares nothing with its caller: it serialises on the way in and builds fresh objects
+ * on the way out. A store that kept the caller's objects instead would let a caller
+ * rewrite the log AFTER the append — mutate a `Uint8Array`, push to a `tags` array,
+ * assign into a `metadata` bag — and every later read would see the rewritten event
+ * with no append, no position and no wake behind it. A reference that can be edited
+ * after the fact judges nothing.
+ *
+ * So `append` stores a copy (the log never holds a caller's object) and every read
+ * path hands out a copy (a reader cannot reach the log through what it was given).
+ * Copying on the way in alone would close the first route and leave the second open:
+ * the same object would then be shared by every reader of the log.
+ */
+const copyEvent = event => ({
+  type: event.type,
+  data: new Uint8Array(event.data),
+  tags: [...event.tags],
+  uuid: event.uuid,
+  occurredAt: DateTime.makeUnsafe(DateTime.toEpochMillis(event.occurredAt)),
+  metadata: {
+    ...event.metadata
+  }
+});
+/**
+ * A copy of `query` that shares no array with it, taking only the keys the grammar
+ * defines.
+ *
+ * `subscribe` is the one verb that holds a query beyond its own call: the fetch seam
+ * judges it again on every page for as long as the subscription runs. Each SQL engine
+ * compiles its plan once, when the subscription starts, so an edit the caller makes
+ * to its own object afterwards reaches nothing there. The oracle has to answer the
+ * same, for the reason it copies events (above): a reference that the caller can
+ * change mid-stream judges nothing. Only `types` and `tags` are carried because they
+ * are all `matchesQueryItem` reads, and a key the grammar does not define was
+ * already refused at the contract decorator before this runs.
+ */
+const copyQuery = query => ({
+  items: query.items.map(item => ({
+    types: [...item.types],
+    tags: [...item.tags]
+  }))
+});
+/** A `SequencedEvent` whose event is a `copyEvent` of the stored one. */
+const copySequenced = sequenced => ({
+  event: copyEvent(sequenced.event),
+  position: sequenced.position
+});
 /** Filter a snapshot by `query` and `after` (strict `position > after`). */
 const filterLog = (log, query, after) => log.filter(sequenced => (after === undefined || sequenced.position > after) && matchesSequenced(sequenced, query));
 /** The position of the last event in a slice, or `undefined` when empty. */
@@ -22,7 +83,7 @@ const readSnapshot = (log, query, options) => {
   // when there is nothing to report.
   const head = (options?.limit === undefined ? lastPosition(log) : lastPosition(limited)) ?? ORIGIN;
   return {
-    events: Stream.fromIterable(limited),
+    events: Stream.fromIterable(limited.map(copySequenced)),
     head
   };
 };
@@ -74,7 +135,7 @@ const fetchPage = (log, query, from, limit) => {
   for (let index = firstIndexAfter(log, from); index < log.length && page.length < limit; index += 1) {
     const sequenced = log[index];
     if (matchesSequenced(sequenced, query)) {
-      page.push(sequenced);
+      page.push(copySequenced(sequenced));
     }
   }
   return page;
@@ -91,7 +152,7 @@ const make = options => Effect.gen(function* () {
   const catchUpPageSize = options?.catchUpPageSize ?? DEFAULT_CATCH_UP_PAGE_SIZE;
   const pollInterval = options?.pollInterval ?? DEFAULT_POLL_INTERVAL_MILLIS;
   const log = yield* Ref.make([]);
-  const mutex = yield* Effect.makeSemaphore(1);
+  const mutex = yield* Semaphore.make(1);
   const hub = yield* PubSub.unbounded();
   const nextPosition = yield* Ref.make(1n);
   const read = (query, options) =>
@@ -99,45 +160,51 @@ const make = options => Effect.gen(function* () {
   // 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.map(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.gen(function* () {
-    const snapshot = yield* 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 AppendConditionFailed({
-          condition
-        });
+  const append = (events, condition) => Effect.suspend(() => {
+    // The events are copied when the append STARTS, before it waits for the
+    // permit, as each SQL engine serialises them before its first suspension:
+    // an edit the caller makes while this append is queued must not reach the
+    // log here when it could not reach theirs.
+    const owned = events.map(copyEvent);
+    // Critical section: check + commit are atomic (the exactly-one-wins guarantee).
+    return mutex.withPermits(1)(Effect.gen(function* () {
+      const snapshot = yield* 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 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* Ref.get(nextPosition);
-    const appended = events.map((event, index) => ({
-      event,
-      position: start + BigInt(index)
+      // 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* Ref.get(nextPosition);
+      const appended = owned.map((event, index) => ({
+        event,
+        position: start + BigInt(index)
+      }));
+      const end = start + BigInt(events.length);
+      yield* Ref.set(log, [...snapshot, ...appended]);
+      yield* 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* PubSub.publishAll(hub, appended);
+      }
+      // `events` is non-empty, so the last new position is `end - 1`.
+      return end - 1n;
     }));
-    const end = start + BigInt(events.length);
-    yield* Ref.set(log, [...snapshot, ...appended]);
-    yield* 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* 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
@@ -152,11 +219,14 @@ const make = options => Effect.gen(function* () {
   // 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.
-  Stream.unwrapScoped(Effect.gen(function* () {
+  Stream.unwrap(Effect.gen(function* () {
+    // Taken when the subscription starts, as the SQL engines compile theirs
+    // (see `copyQuery`).
+    const judged = copyQuery(query);
     const wakes = yield* PubSub.subscribe(hub);
     return subscribeStream({
-      fetch: (from, limit) => Effect.map(Ref.get(log), snapshot => fetchPage(snapshot, query, from, limit)),
-      listen: Stream.fromQueue(wakes),
+      fetch: (from, limit) => Effect.map(Ref.get(log), snapshot => fetchPage(snapshot, judged, from, limit)),
+      listen: Stream.fromSubscription(wakes),
       pollInterval,
       catchUpPageSize
     }, after);

package/dist/esm/inMemory.js.map

@@ -1 +1 @@
-{"version":3,"file":"inMemory.js","names":["Effect","Layer","PubSub","Ref","Stream","makeContractStore","DcbEventStore","ORIGIN","AppendConditionFailed","matchesSequenced","DEFAULT_CATCH_UP_PAGE_SIZE","DEFAULT_POLL_INTERVAL_MILLIS","subscribeStream","filterLog","log","query","after","filter","sequenced","undefined","position","lastPosition","events","at","readSnapshot","options","matched","limited","limit","slice","head","fromIterable","firstIndexAfter","low","high","length","mid","fetchPage","from","page","index","push","make","gen","beforeCommit","void","suppressWake","catchUpPageSize","pollInterval","mutex","makeSemaphore","hub","unbounded","nextPosition","read","withPermits","map","get","snapshot","append","condition","conflicts","failIfEventsMatch","start","appended","event","BigInt","end","set","publishAll","subscribe","unwrapScoped","wakes","fetch","listen","fromQueue","DcbEventStoreInMemory","effect","makeInMemoryTestLayer"],"sources":["../../src/inMemory.ts"],"sourcesContent":[null],"mappings":"AA2BA,SAASA,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAEC,GAAG,EAAEC,MAAM,QAAQ,QAAQ;AAE3D,SAASC,iBAAiB,QAA+B,oBAAiB;AAE1E,SAASC,aAAa,QAAQ,oBAAiB;AAE/C,SAASC,MAAM,QAAQ,YAAS;AAChC,SAASC,qBAAqB,QAAQ,aAAU;AAEhD,SAASC,gBAAgB,QAAQ,YAAS;AAC1C,SACEC,0BAA0B,EAC1BC,4BAA4B,EAC5BC,eAAe,QACV,uBAAoB;AAE3B;AACA,MAAMC,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,KAClDP,gBAAgB,CAACS,SAAS,EAAEH,KAAK,CAAC,CACrC;AAEH;AACA,MAAMM,YAAY,GAChBC,MAAqC,IACZA,MAAM,CAACC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAEH,QAAQ;AAElD;;;;;AAKA,MAAMI,YAAY,GAAGA,CACnBV,GAAkC,EAClCC,KAAY,EACZU,OAAgC,KAChB;EAChB,MAAMC,OAAO,GAAGb,SAAS,CAACC,GAAG,EAAEC,KAAK,EAAEU,OAAO,EAAET,KAAK,CAAC;EACrD,MAAMW,OAAO,GACXF,OAAO,EAAEG,KAAK,KAAKT,SAAS,GAAGO,OAAO,GAAGA,OAAO,CAACG,KAAK,CAAC,CAAC,EAAEJ,OAAO,CAACG,KAAK,CAAC;EAE1E;EACA;EACA;EACA,MAAME,IAAI,GACR,CAACL,OAAO,EAAEG,KAAK,KAAKT,SAAS,GACzBE,YAAY,CAACP,GAAG,CAAC,GACjBO,YAAY,CAACM,OAAO,CAAC,KAAKpB,MAAM;EAEtC,OAAO;IAAEe,MAAM,EAAElB,MAAM,CAAC2B,YAAY,CAACJ,OAAO,CAAC;IAAEG;EAAI,CAAE;AACvD,CAAC;AAED;;;;;;;;;AASA,MAAME,eAAe,GAAGA,CACtBlB,GAAkC,EAClCE,KAAe,KACL;EACV,IAAIiB,GAAG,GAAG,CAAC;EACX,IAAIC,IAAI,GAAGpB,GAAG,CAACqB,MAAM;EACrB,OAAOF,GAAG,GAAGC,IAAI,EAAE;IACjB;IACA,MAAME,GAAG,GAAIH,GAAG,GAAGC,IAAI,KAAM,CAAC;IAC9B,IAAIpB,GAAG,CAACsB,GAAG,CAAC,CAAChB,QAAQ,GAAGJ,KAAK,EAAE;MAC7BkB,IAAI,GAAGE,GAAG;IACZ,CAAC,MAAM;MACLH,GAAG,GAAGG,GAAG,GAAG,CAAC;IACf;EACF;EACA,OAAOH,GAAG;AACZ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;AAoBA,MAAMI,SAAS,GAAGA,CAChBvB,GAAkC,EAClCC,KAAY,EACZuB,IAAc,EACdV,KAAgB,KACiB;EACjC,MAAMW,IAAI,GAA0B,EAAE;EACtC,KACE,IAAIC,KAAK,GAAGR,eAAe,CAAClB,GAAG,EAAEwB,IAAI,CAAC,EACtCE,KAAK,GAAG1B,GAAG,CAACqB,MAAM,IAAII,IAAI,CAACJ,MAAM,GAAGP,KAAK,EACzCY,KAAK,IAAI,CAAC,EACV;IACA,MAAMtB,SAAS,GAAGJ,GAAG,CAAC0B,KAAK,CAAC;IAC5B,IAAI/B,gBAAgB,CAACS,SAAS,EAAEH,KAAK,CAAC,EAAE;MACtCwB,IAAI,CAACE,IAAI,CAACvB,SAAS,CAAC;IACtB;EACF;EACA,OAAOqB,IAAI;AACb,CAAC;AA8DD;;;;;;AAMA,MAAMG,IAAI,GACRjB,OAA8B,IAE9BzB,MAAM,CAAC2C,GAAG,CAAC,aAAS;EAClB,MAAMC,YAAY,GAAGnB,OAAO,EAAEmB,YAAY,IAAI5C,MAAM,CAAC6C,IAAI;EACzD,MAAMC,YAAY,GAAGrB,OAAO,EAAEqB,YAAY,IAAI,KAAK;EACnD,MAAMC,eAAe,GACnBtB,OAAO,EAAEsB,eAAe,IAAIrC,0BAA0B;EACxD,MAAMsC,YAAY,GAAGvB,OAAO,EAAEuB,YAAY,IAAIrC,4BAA4B;EAC1E,MAAMG,GAAG,GAAG,OAAOX,GAAG,CAACuC,IAAI,CAAgC,EAAE,CAAC;EAC9D,MAAMO,KAAK,GAAG,OAAOjD,MAAM,CAACkD,aAAa,CAAC,CAAC,CAAC;EAC5C,MAAMC,GAAG,GAAG,OAAOjD,MAAM,CAACkD,SAAS,EAAkB;EACrD,MAAMC,YAAY,GAAG,OAAOlD,GAAG,CAACuC,IAAI,CAAS,EAAE,CAAC;EAEhD,MAAMY,IAAI,GAAGA,CACXvC,KAAY,EACZU,OAAqB;EAErB;EACA;EACA;EACAwB,KAAK,CAACM,WAAW,CAAC,CAAC,CAAC,CAClBvD,MAAM,CAACwD,GAAG,CAACrD,GAAG,CAACsD,GAAG,CAAC3C,GAAG,CAAC,EAAG4C,QAAQ,IAChClC,YAAY,CAACkC,QAAQ,EAAE3C,KAAK,EAAEU,OAAO,CAAC,CACvC,CACF;EAEH,MAAMkC,MAAM,GAAGA,CACbrC,MAA2C,EAC3CsC,SAA2B;EAE3B;EACAX,KAAK,CAACM,WAAW,CAAC,CAAC,CAAC,CAClBvD,MAAM,CAAC2C,GAAG,CAAC,aAAS;IAClB,MAAMe,QAAQ,GAAG,OAAOvD,GAAG,CAACsD,GAAG,CAAC3C,GAAG,CAAC;IAEpC,IAAI8C,SAAS,KAAKzC,SAAS,EAAE;MAC3B,MAAM0C,SAAS,GAAGhD,SAAS,CACzB6C,QAAQ,EACRE,SAAS,CAACE,iBAAiB,EAC3BF,SAAS,CAAC5C,KAAK,CAChB;MACD;MACA;MACA;MACA,IAAI6C,SAAS,CAAC1B,MAAM,GAAG,CAAC,EAAE;QACxB,OAAO,OAAO,IAAI3B,qBAAqB,CAAC;UAAEoD;QAAS,CAAE,CAAC;MACxD;IACF;IAEA;IACA;IACA;IACA;IACA;IACA,OAAOhB,YAAY;IAEnB,MAAMmB,KAAK,GAAG,OAAO5D,GAAG,CAACsD,GAAG,CAACJ,YAAY,CAAC;IAC1C,MAAMW,QAAQ,GAA0B1C,MAAM,CAACkC,GAAG,CAChD,CAACS,KAAK,EAAEzB,KAAK,MAAM;MACjByB,KAAK;MACL7C,QAAQ,EAAG2C,KAAK,GAAGG,MAAM,CAAC1B,KAAK;KAChC,CAAC,CACH;IACD,MAAM2B,GAAG,GAAGJ,KAAK,GAAGG,MAAM,CAAC5C,MAAM,CAACa,MAAM,CAAC;IACzC,OAAOhC,GAAG,CAACiE,GAAG,CAACtD,GAAG,EAAE,CAAC,GAAG4C,QAAQ,EAAE,GAAGM,QAAQ,CAAC,CAAC;IAC/C,OAAO7D,GAAG,CAACiE,GAAG,CAACf,YAAY,EAAEc,GAAG,CAAC;IACjC;IACA;IACA;IACA;IACA,IAAI,CAACrB,YAAY,EAAE;MACjB,OAAO5C,MAAM,CAACmE,UAAU,CAAClB,GAAG,EAAEa,QAAQ,CAAC;IACzC;IACA;IACA,OAAQG,GAAG,GAAG,EAAE;EAClB,CAAC,CAAC,CACH;EAEH,MAAMG,SAAS,GAAGA,CAChBvD,KAAY,EACZC,KAAgB;EAEhB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACAZ,MAAM,CAACmE,YAAY,CACjBvE,MAAM,CAAC2C,GAAG,CAAC,aAAS;IAClB,MAAM6B,KAAK,GAAG,OAAOtE,MAAM,CAACoE,SAAS,CAACnB,GAAG,CAAC;IAC1C,OAAOvC,eAAe,CACpB;MACE6D,KAAK,EAAEA,CAACnC,IAAI,EAAEV,KAAK,KACjB5B,MAAM,CAACwD,GAAG,CAACrD,GAAG,CAACsD,GAAG,CAAC3C,GAAG,CAAC,EAAG4C,QAAQ,IAChCrB,SAAS,CAACqB,QAAQ,EAAE3C,KAAK,EAAEuB,IAAI,EAAEV,KAAK,CAAC,CACxC;MACH8C,MAAM,EAAEtE,MAAM,CAACuE,SAAS,CAACH,KAAK,CAAC;MAC/BxB,YAAY;MACZD;KACD,EACD/B,KAAK,CACN;EACH,CAAC,CAAC,CACH;EAEH,OAAO;IAAEsC,IAAI;IAAEK,MAAM;IAAEW;EAAS,CAAW;AAC7C,CAAC,CAAC;AAEJ;AACA,OAAO,MAAMM,qBAAqB,gBAA+B3E,KAAK,CAAC4E,MAAM,CAC3EvE,aAAa,eACbN,MAAM,CAACwD,GAAG,cAACd,IAAI,EAAE,EAAErC,iBAAiB,CAAC,CACtC;AAED;;;;;;;;;;;AAWA,OAAO,MAAMyE,qBAAqB,GAChCrD,OAA6B,IAE7BxB,KAAK,CAAC4E,MAAM,CAACvE,aAAa,EAAEN,MAAM,CAACwD,GAAG,CAACd,IAAI,CAACjB,OAAO,CAAC,EAAEpB,iBAAiB,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"inMemory.js","names":["DateTime","Effect","Layer","PubSub","Ref","Semaphore","Stream","makeContractStore","DcbEventStore","ORIGIN","AppendConditionFailed","matchesSequenced","DEFAULT_CATCH_UP_PAGE_SIZE","DEFAULT_POLL_INTERVAL_MILLIS","subscribeStream","copyEvent","event","type","data","Uint8Array","tags","uuid","occurredAt","makeUnsafe","toEpochMillis","metadata","copyQuery","query","items","map","item","types","copySequenced","sequenced","position","filterLog","log","after","filter","undefined","lastPosition","events","at","readSnapshot","options","matched","limited","limit","slice","head","fromIterable","firstIndexAfter","low","high","length","mid","fetchPage","from","page","index","push","make","gen","beforeCommit","void","suppressWake","catchUpPageSize","pollInterval","mutex","hub","unbounded","nextPosition","read","withPermits","get","snapshot","append","condition","suspend","owned","conflicts","failIfEventsMatch","start","appended","BigInt","end","set","publishAll","subscribe","unwrap","judged","wakes","fetch","listen","fromSubscription","DcbEventStoreInMemory","effect","makeInMemoryTestLayer"],"sources":["../../src/inMemory.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/index.js

@@ -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/esm/retryOnConflict.js

@@ -35,21 +35,15 @@
  * 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, Predicate, Schedule } from 'effect';
 /**
  * The default conflict backoff: exponential from 20ms, jittered, capped at five
  * retries.
  *
- * `Schedule.intersect` continues only while BOTH schedules continue, so the
- * `recurs(5)` arm is what bounds the attempts and the exponential arm is what
- * spaces them. Jitter matters more here than in a typical backoff: contending
+ * `Schedule.max` continues only while BOTH schedules continue, waiting the longer
+ * of their two delays, so the `recurs(5)` arm is what bounds the attempts and the
+ * exponential arm is what spaces them. Jitter matters more here than in a typical backoff: contending
  * deciders conflict precisely because they read the same boundary at the same
  * time, so an unjittered backoff would re-synchronise them into the same conflict
  * on every round. The figures are the conventional starting point (Emmett,
@@ -57,7 +51,7 @@ import { Effect, Predicate, Schedule } from 'effect';
  * command with a tighter latency budget, or one contending harder, should pass its
  * own schedule.
  */
-const conflictBackoff = /*#__PURE__*/Schedule.intersect(/*#__PURE__*/Schedule.jittered(/*#__PURE__*/Schedule.exponential('20 millis', 2)), /*#__PURE__*/Schedule.recurs(5));
+const conflictBackoff = /*#__PURE__*/Schedule.max([/*#__PURE__*/Schedule.jittered(/*#__PURE__*/Schedule.exponential('20 millis', 2)), /*#__PURE__*/Schedule.recurs(5)]);
 /**
  * Retry `command` while — and only while — it fails `AppendConditionFailed`.
  *

package/dist/esm/retryOnConflict.js.map

@@ -1 +1 @@
-{"version":3,"file":"retryOnConflict.js","names":["Effect","Predicate","Schedule","conflictBackoff","intersect","jittered","exponential","recurs","retryOnConflict","command","schedule","retry","while","isTagged"],"sources":["../../src/retryOnConflict.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAASA,MAAM,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,QAAQ;AAGpD;;;;;;;;;;;;;;AAcA,MAAMC,eAAe,gBAAGD,QAAQ,CAACE,SAAS,cACxCF,QAAQ,CAACG,QAAQ,cAACH,QAAQ,CAACI,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,eACvDJ,QAAQ,CAACK,MAAM,CAAC,CAAC,CAAC,CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,MAAMC,eAAe,GAAGA,CAC7BC,OAAuD,EACvDC,QAAA,GAIIP,eAAe,KAEnBH,MAAM,CAACW,KAAK,CAACF,OAAO,EAAE;EACpBC,QAAQ;EACRE,KAAK,EAAEX,SAAS,CAACY,QAAQ,CAAC,uBAAuB;CAClD,CAAC","ignoreList":[]}
+{"version":3,"file":"retryOnConflict.js","names":["Effect","Predicate","Schedule","conflictBackoff","max","jittered","exponential","recurs","retryOnConflict","command","schedule","retry","while","isTagged"],"sources":["../../src/retryOnConflict.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAASA,MAAM,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,QAAQ;AAGpD;;;;;;;;;;;;;;AAcA,MAAMC,eAAe,gBAAGD,QAAQ,CAACE,GAAG,CAAC,cACnCF,QAAQ,CAACG,QAAQ,cAACH,QAAQ,CAACI,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,eACvDJ,QAAQ,CAACK,MAAM,CAAC,CAAC,CAAC,CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,MAAMC,eAAe,GAAGA,CAC7BC,OAAuD,EACvDC,QAAA,GAKIP,eAAe,KAEnBH,MAAM,CAACW,KAAK,CAACF,OAAO,EAAE;EACpBC,QAAQ;EACRE,KAAK,EAAEX,SAAS,CAACY,QAAQ,CAAC,uBAAuB;CAClD,CAAC","ignoreList":[]}

package/dist/esm/testing.js

@@ -20,10 +20,10 @@ 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 const EPOCH = /*#__PURE__*/DateTime.unsafeMake(0);
+export const EPOCH = /*#__PURE__*/DateTime.makeUnsafe(0);
 /**
  * Build a fresh, deterministic uuid generator: a zero-based counter producing
  * RFC-4122 v4-shaped ids `00000000-0000-4000-8000-<counter as 12 hex digits>`,

package/dist/esm/testing.js.map

@@ -1 +1 @@
-{"version":3,"file":"testing.js","names":["DateTime","EPOCH","unsafeMake","makeSequentialUuid","counter","suffix","toString","padStart"],"sources":["../../src/testing.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;AAgBA,SAASA,QAAQ,QAAQ,QAAQ;AAEjC;;;;;;;;AAQA,OAAO,MAAMC,KAAK,gBAAGD,QAAQ,CAACE,UAAU,CAAC,CAAC,CAAC;AAE3C;;;;;;;;;;;AAWA,OAAO,MAAMC,kBAAkB,GAAGA,CAAA,KAAqB;EACrD,IAAIC,OAAO,GAAG,CAAC;EACf,OAAO,MAAK;IACV,MAAMC,MAAM,GAAGD,OAAO,CAACE,QAAQ,CAAC,EAAE,CAAC,CAACC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC;IACrDH,OAAO,IAAI,CAAC;IACZ,OAAO,2BAA2BC,MAAM,EAAE;EAC5C,CAAC;AACH,CAAC","ignoreList":[]}
+{"version":3,"file":"testing.js","names":["DateTime","EPOCH","makeUnsafe","makeSequentialUuid","counter","suffix","toString","padStart"],"sources":["../../src/testing.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;AAgBA,SAASA,QAAQ,QAAQ,QAAQ;AAEjC;;;;;;;;AAQA,OAAO,MAAMC,KAAK,gBAAGD,QAAQ,CAACE,UAAU,CAAC,CAAC,CAAC;AAE3C;;;;;;;;;;;AAWA,OAAO,MAAMC,kBAAkB,GAAGA,CAAA,KAAqB;EACrD,IAAIC,OAAO,GAAG,CAAC;EACf,OAAO,MAAK;IACV,MAAMC,MAAM,GAAGD,OAAO,CAACE,QAAQ,CAAC,EAAE,CAAC,CAACC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC;IACrDH,OAAO,IAAI,CAAC;IACZ,OAAO,2BAA2BC,MAAM,EAAE;EAC5C,CAAC;AACH,CAAC","ignoreList":[]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kairos-es/core",
-  "version": "1.0.0-alpha.3",
-  "description": "DCB-first event-sourcing contract and in-memory store for Effect v3",
+  "version": "1.0.0-alpha.5",
+  "description": "DCB-first event-sourcing contract and in-memory store for Effect 4",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
@@ -11,28 +11,38 @@
   "sideEffects": [],
   "homepage": "https://github.com/neverbland/kairos-es",
   "peerDependencies": {
-    "effect": "^3.22.0"
+    "effect": "^4.0.5"
   },
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
-  "types": "./dist/dts/index.d.ts",
+  "types": "./dist/dts-cjs/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/dts/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "default": "./dist/cjs/index.js"
+      "import": {
+        "types": "./dist/dts-esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/dts-cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
     },
     "./testing": {
-      "types": "./dist/dts/testing.d.ts",
-      "import": "./dist/esm/testing.js",
-      "default": "./dist/cjs/testing.js"
+      "import": {
+        "types": "./dist/dts-esm/testing.d.ts",
+        "default": "./dist/esm/testing.js"
+      },
+      "require": {
+        "types": "./dist/dts-cjs/testing.d.ts",
+        "default": "./dist/cjs/testing.js"
+      }
     },
     "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
       "testing": [
-        "./dist/dts/testing.d.ts"
+        "./dist/dts-cjs/testing.d.ts"
       ]
     }
   }

package/src/AppendCondition.ts

@@ -13,6 +13,6 @@ import { Query } from './Query'
 
 export const AppendCondition = Schema.Struct({
   failIfEventsMatch: Query,
-  after: Schema.optionalWith(Position, { exact: true }),
+  after: Schema.optionalKey(Position),
 })
 export type AppendCondition = typeof AppendCondition.Type

package/src/AppendIsOwned.ts

@@ -30,15 +30,15 @@
  *
  * ## Present means refused, so a sanctioned append REMOVES the marker
  *
- * The check reads the tag through `Effect.serviceOption`, so its ABSENCE is the
+ * The check reads the service through `Effect.serviceOption`, so its ABSENCE is the
  * normal case and costs the `append` signature nothing — `DcbEventStore.append`
  * keeps `R = never` and no caller provides anything. Presence is what refuses.
  *
  * That shape decides how the two legitimate appends inside a bracket get through,
  * and there is only one route: run with the marker STRIPPED from the context
- * (`Effect.mapInputContext` over `Context.omit(AppendIsOwned)`). The bracket's own
+ * (`Effect.updateContext` over `Context.omit(AppendIsOwned)`). The bracket's own
  * closing append is issued outside the scope it provided the marker in, and the
- * codec's escape hatch strips it explicitly. Neither needs a second tag, a
+ * codec's escape hatch strips it explicitly. Neither needs a second service, a
  * sanctioning flag or a mutable cell, and there is no way to be exempt by
  * accident: an append is either lexically outside the marked region or it says in
  * as many words that it is removing the marker.
@@ -50,13 +50,13 @@ import { Context, Effect } from 'effect'
  * owns it.
  *
  * `by` is a human-readable owner name and exists for the defect message alone —
- * the refusal is decided by the tag's PRESENCE, never by this value, so nothing
+ * the refusal is decided by the service's PRESENCE, never by this value, so nothing
  * branches on it and no caller need agree on a vocabulary for it.
  */
-export class AppendIsOwned extends Context.Tag('@kairos-es/core/AppendIsOwned')<
+export class AppendIsOwned extends Context.Service<
   AppendIsOwned,
   { readonly by: string }
->() {}
+>()('@kairos-es/core/AppendIsOwned') {}
 
 /**
  * Die if an append is already owned here; do nothing otherwise.
@@ -70,7 +70,7 @@ export class AppendIsOwned extends Context.Tag('@kairos-es/core/AppendIsOwned')<
  * its escape hatch for a deliberate second append — which is what makes a defect
  * affordable here.
  *
- * `Effect.serviceOption` is what keeps this free: it reads the tag if present and
+ * `Effect.serviceOption` is what keeps this free: it reads the service if present and
  * adds NOTHING to the requirement channel, so every existing append is unchanged
  * and unprovisioned.
  */

package/src/ContractStore.ts

@@ -8,10 +8,13 @@
  * 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 is a DEFECT in every engine;
+ *   guard query, subscribe) — a non-servable query, or one carrying a key the
+ *   grammar does not define, is a DEFECT in every engine, and an append condition
+ *   carrying a key `AppendCondition` does not define is refused alongside it;
  * - `ReadLimit` decode on `read`'s `limit` — a negative/non-integer limit is a
  *   DEFECT (so `read` keeps `E = never`), validated through the branded schema
  *   even at an untyped boundary that reaches the store as `unknown`;
@@ -34,7 +37,7 @@
  */
 import type { Array as Arr, Scope } from 'effect'
 import { Effect, Predicate, Schema, Stream } from 'effect'
-import type { AppendCondition } from './AppendCondition'
+import { AppendCondition } from './AppendCondition'
 import { assertAppendNotOwned } from './AppendIsOwned'
 import type { DcbEventStore, ReadOptions, ReadResponse } from './DcbEventStore'
 import type { DcbEvent, Position, SequencedEvent } from './Event'
@@ -73,7 +76,7 @@ export interface RawDcbEventStore<E> {
  */
 export const makeContractStore = <E>(
   raw: RawDcbEventStore<E>,
-): DcbEventStore['Type'] => ({
+): DcbEventStore['Service'] => ({
   read: (query, options) =>
     Effect.suspend(() => {
       // Defects (surface when the Effect runs), keeping `read` at `E = never`.
@@ -87,8 +90,8 @@ export const makeContractStore = <E>(
 
   append: (events, condition) =>
     // The ownership refusal runs FIRST and sits OUTSIDE the suspend, because it is
-    // the only one of append's four checks that is EFFECTFUL: it consults a
-    // `Context.Tag` rather than inspecting the arguments. `Effect.flatMap` over an
+    // the only one of append's checks that is EFFECTFUL: it consults a
+    // `Context.Service` rather than inspecting the arguments. `Effect.flatMap` over an
     // already-lazy effect defers it exactly as the suspend defers the throws below,
     // so nothing runs at the call site either way; what it buys is that the
     // "you are inside a bracket" defect arrives before any argument is judged, which
@@ -113,8 +116,22 @@ export const makeContractStore = <E>(
               'plain-data caller bypassing the type — a defect, not a conflict.',
           )
         }
-        // A non-servable guard query is a defect in every engine.
+        // A non-servable guard query is a defect in every engine, and so is a
+        // condition carrying a key `AppendCondition` does not define: an author
+        // who wrote one believes they added a condition, and every engine would
+        // ignore it. Known keys come off the schema, as `servableQueryFault`
+        // reads its own (`Query.ts` owns the argument).
         if (condition !== undefined) {
+          const unknown = Object.keys(condition).find(
+            (key) => !Object.hasOwn(AppendCondition.fields, key),
+          )
+          if (unknown !== undefined) {
+            throw new Error(
+              `makeContractStore.append: the append condition carries the key ${JSON.stringify(unknown)}, ` +
+                'which `AppendCondition` does not define; an unknown key would be ' +
+                'silently ignored by every engine rather than honoured, so it is refused',
+            )
+          }
           assertServableQuery(condition.failIfEventsMatch)
         }
         // Only `AppendConditionFailed` belongs on the contract error channel;
@@ -140,7 +157,7 @@ export const makeContractStore = <E>(
         // engine's channel simply answers false and dies as it should. It also
         // narrows the raw `AppendConditionFailed | E` to the contract's single
         // error, which is what keeps `append` at `E = AppendConditionFailed`.
-        return Effect.catchAll(raw.append(events, condition), (error) =>
+        return Effect.catch(raw.append(events, condition), (error) =>
           Predicate.isTagged('AppendConditionFailed')(error)
             ? Effect.fail(error)
             : Effect.die(error),

package/src/DcbEventStore.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`).
@@ -42,7 +42,7 @@ export interface ReadResponse {
   readonly head: Position
 }
 
-export class DcbEventStore extends Context.Tag('@kairos-es/core/DcbEventStore')<
+export class DcbEventStore extends Context.Service<
   DcbEventStore,
   {
     /**
@@ -74,4 +74,4 @@ export class DcbEventStore extends Context.Tag('@kairos-es/core/DcbEventStore')<
       after?: Position,
     ) => Stream.Stream<SequencedEvent, never, Scope.Scope>
   }
->() {}
+>()('@kairos-es/core/DcbEventStore') {}