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

package/README.md

@@ -1,6 +1,6 @@
 # @kairos-es/core
 
-DCB-first event-sourcing contract and in-memory store for Effect v3.
+DCB-first event-sourcing contract and in-memory store for Effect 4.
 
 ## Installation
 
@@ -8,12 +8,12 @@ DCB-first event-sourcing contract and in-memory store for Effect v3.
 Effect instance (per [ADR-0003](../../docs/adr)):
 
 ```sh
-pnpm add @kairos-es/core@alpha effect@^3.22.0
+pnpm add @kairos-es/core@alpha effect@^4.0.5
 ```
 
 Provides the `DcbEventStore` contract (branded `Position` / `Tag` / `EventType`,
 the `DcbEvent` / `Query` / `AppendCondition` schemas, the errors and the
-`Context.Tag`), the pure `Projection` / `composeProjections` fold primitives
+`Context.Service`), the pure `Projection` / `composeProjections` fold primitives
 (plus `unionQueries`, the OR-merge `composeProjections` folds a record through,
 reachable without one — a caller accumulating queries rather than projections
 needs it, and hand-rolling that merge silently drops a wildcard, an empty item

package/dist/cjs/AppendCondition.js

@@ -19,8 +19,6 @@ var _Query = require("./Query.js");
 
 const AppendCondition = exports.AppendCondition = /*#__PURE__*/_effect.Schema.Struct({
   failIfEventsMatch: _Query.Query,
-  after: /*#__PURE__*/_effect.Schema.optionalWith(_Event.Position, {
-    exact: true
-  })
+  after: /*#__PURE__*/_effect.Schema.optionalKey(_Event.Position)
 });
 //# sourceMappingURL=AppendCondition.js.map

package/dist/cjs/AppendCondition.js.map

@@ -1 +1 @@
-{"version":3,"file":"AppendCondition.js","names":["_effect","require","_Event","_Query","AppendCondition","exports","Schema","Struct","failIfEventsMatch","Query","after","optionalWith","Position","exact"],"sources":["../../src/AppendCondition.ts"],"sourcesContent":[null],"mappings":";;;;;;AASA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AAXA;;;;;;;;;;AAaO,MAAMG,eAAe,GAAAC,OAAA,CAAAD,eAAA,gBAAGE,cAAM,CAACC,MAAM,CAAC;EAC3CC,iBAAiB,EAAEC,YAAK;EACxBC,KAAK,eAAEJ,cAAM,CAACK,YAAY,CAACC,eAAQ,EAAE;IAAEC,KAAK,EAAE;EAAI,CAAE;CACrD,CAAC","ignoreList":[]}
+{"version":3,"file":"AppendCondition.js","names":["_effect","require","_Event","_Query","AppendCondition","exports","Schema","Struct","failIfEventsMatch","Query","after","optionalKey","Position"],"sources":["../../src/AppendCondition.ts"],"sourcesContent":[null],"mappings":";;;;;;AASA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AAXA;;;;;;;;;;AAaO,MAAMG,eAAe,GAAAC,OAAA,CAAAD,eAAA,gBAAGE,cAAM,CAACC,MAAM,CAAC;EAC3CC,iBAAiB,EAAEC,YAAK;EACxBC,KAAK,eAAEJ,cAAM,CAACK,WAAW,CAACC,eAAQ;CACnC,CAAC","ignoreList":[]}

package/dist/cjs/AppendIsOwned.js

@@ -37,15 +37,15 @@ var _effect = require("effect");
  *
  * ## 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.
@@ -56,10 +56,10 @@ var _effect = require("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.
  */
-class AppendIsOwned extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/core/AppendIsOwned')() {}
+class AppendIsOwned extends /*#__PURE__*/_effect.Context.Service()('@kairos-es/core/AppendIsOwned') {}
 /**
  * Die if an append is already owned here; do nothing otherwise.
  *
@@ -72,7 +72,7 @@ class AppendIsOwned extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/core/Ap
  * 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/dist/cjs/AppendIsOwned.js.map

@@ -1 +1 @@
-{"version":3,"file":"AppendIsOwned.js","names":["_effect","require","AppendIsOwned","Context","Tag","exports","assertAppendNotOwned","Effect","flatMap","serviceOption","owner","_tag","void","die","Error","value","by"],"sources":["../../src/AppendIsOwned.ts"],"sourcesContent":[null],"mappings":";;;;;;AA6CA,IAAAA,OAAA,GAAAC,OAAA;AA7CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA;;;;;;;;AAQM,MAAOC,aAAc,sBAAQC,eAAO,CAACC,GAAG,CAAC,+BAA+B,CAAC,EAG5E;AAEH;;;;;;;;;;;;;;;;AAAAC,OAAA,CAAAH,aAAA,GAAAA,aAAA;AAgBO,MAAMI,oBAAoB,GAAAD,OAAA,CAAAC,oBAAA,gBAAwBC,cAAM,CAACC,OAAO,cACrED,cAAM,CAACE,aAAa,CAACP,aAAa,CAAC,EAClCQ,KAAK,IACJA,KAAK,CAACC,IAAI,KAAK,MAAM,GACjBJ,cAAM,CAACK,IAAI,GACXL,cAAM,CAACM,GAAG,CACR,IAAIC,KAAK,CACP,kEAAkEJ,KAAK,CAACK,KAAK,CAACC,EAAE,MAAM,GACpF,4EAA4E,GAC5E,0EAA0E,GAC1E,4EAA4E,GAC5E,0EAA0E,GAC1E,sEAAsE,CACzE,CACF,CACR","ignoreList":[]}
+{"version":3,"file":"AppendIsOwned.js","names":["_effect","require","AppendIsOwned","Context","Service","exports","assertAppendNotOwned","Effect","flatMap","serviceOption","owner","_tag","void","die","Error","value","by"],"sources":["../../src/AppendIsOwned.ts"],"sourcesContent":[null],"mappings":";;;;;;AA6CA,IAAAA,OAAA,GAAAC,OAAA;AA7CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA;;;;;;;;AAQM,MAAOC,aAAc,sBAAQC,eAAO,CAACC,OAAO,EAG/C,CAAC,+BAA+B,CAAC;AAEpC;;;;;;;;;;;;;;;;AAAAC,OAAA,CAAAH,aAAA,GAAAA,aAAA;AAgBO,MAAMI,oBAAoB,GAAAD,OAAA,CAAAC,oBAAA,gBAAwBC,cAAM,CAACC,OAAO,cACrED,cAAM,CAACE,aAAa,CAACP,aAAa,CAAC,EAClCQ,KAAK,IACJA,KAAK,CAACC,IAAI,KAAK,MAAM,GACjBJ,cAAM,CAACK,IAAI,GACXL,cAAM,CAACM,GAAG,CACR,IAAIC,KAAK,CACP,kEAAkEJ,KAAK,CAACK,KAAK,CAACC,EAAE,MAAM,GACpF,4EAA4E,GAC5E,0EAA0E,GAC1E,4EAA4E,GAC5E,0EAA0E,GAC1E,sEAAsE,CACzE,CACF,CACR","ignoreList":[]}

package/dist/cjs/ContractStore.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.makeContractStore = void 0;
 var _effect = require("effect");
+var _AppendCondition = require("./AppendCondition.js");
 var _AppendIsOwned = require("./AppendIsOwned.js");
 var _Event = require("./Event.js");
 var _Query = require("./Query.js");
@@ -26,8 +27,8 @@ const makeContractStore = raw => ({
   }),
   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
@@ -47,8 +48,16 @@ const makeContractStore = raw => ({
     if (events.length === 0) {
       throw new Error('makeContractStore.append: the events batch is empty; append requires ' + 'at least one event (a NonEmptyReadonlyArray). An empty batch is a ' + '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.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');
+      }
       (0, _Query.assertServableQuery)(condition.failIfEventsMatch);
     }
     // Only `AppendConditionFailed` belongs on the contract error channel;
@@ -74,7 +83,7 @@ const makeContractStore = raw => ({
     // 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.Effect.catchAll(raw.append(events, condition), error => _effect.Predicate.isTagged('AppendConditionFailed')(error) ? _effect.Effect.fail(error) : _effect.Effect.die(error));
+    return _effect.Effect.catch(raw.append(events, condition), error => _effect.Predicate.isTagged('AppendConditionFailed')(error) ? _effect.Effect.fail(error) : _effect.Effect.die(error));
   })),
   subscribe: (query, after) =>
   // `Effect.sync` runs when the stream is executed; a throw from

package/dist/cjs/ContractStore.js.map

@@ -1 +1 @@
-{"version":3,"file":"ContractStore.js","names":["_effect","require","_AppendIsOwned","_Event","_Query","decodeReadLimit","Schema","decodeUnknownSync","ReadLimit","makeContractStore","raw","read","query","options","Effect","suspend","assertServableQuery","limit","undefined","orDie","append","events","condition","flatMap","assertAppendNotOwned","length","Error","failIfEventsMatch","catchAll","error","Predicate","isTagged","fail","die","subscribe","after","Stream","unwrap","sync","exports"],"sources":["../../src/ContractStore.ts"],"sourcesContent":[null],"mappings":";;;;;;AAmCA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,cAAA,GAAAD,OAAA;AAGA,IAAAE,MAAA,GAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AAEA;AACA,MAAMI,eAAe,gBAAGC,cAAM,CAACC,iBAAiB,CAACC,gBAAS,CAAC;AAwB3D;;;;AAIO,MAAMC,iBAAiB,GAC5BC,GAAwB,KACG;EAC3BC,IAAI,EAAEA,CAACC,KAAK,EAAEC,OAAO,KACnBC,cAAM,CAACC,OAAO,CAAC,MAAK;IAClB;IACA,IAAAC,0BAAmB,EAACJ,KAAK,CAAC;IAC1B,IAAIC,OAAO,EAAEI,KAAK,KAAKC,SAAS,EAAE;MAChCb,eAAe,CAACQ,OAAO,CAACI,KAAK,CAAC;IAChC;IACA;IACA,OAAOH,cAAM,CAACK,KAAK,CAACT,GAAG,CAACC,IAAI,CAACC,KAAK,EAAEC,OAAO,CAAC,CAAC;EAC/C,CAAC,CAAC;EAEJO,MAAM,EAAEA,CAACC,MAAM,EAAEC,SAAS;EACxB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACAR,cAAM,CAACS,OAAO,CAACC,mCAAoB,EAAE,MACnCV,cAAM,CAACC,OAAO,CAAC,MAAK;IAClB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAIM,MAAM,CAACI,MAAM,KAAK,CAAC,EAAE;MACvB,MAAM,IAAIC,KAAK,CACb,uEAAuE,GACrE,oEAAoE,GACpE,kEAAkE,CACrE;IACH;IACA;IACA,IAAIJ,SAAS,KAAKJ,SAAS,EAAE;MAC3B,IAAAF,0BAAmB,EAACM,SAAS,CAACK,iBAAiB,CAAC;IAClD;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,OAAOb,cAAM,CAACc,QAAQ,CAAClB,GAAG,CAACU,MAAM,CAACC,MAAM,EAAEC,SAAS,CAAC,EAAGO,KAAK,IAC1DC,iBAAS,CAACC,QAAQ,CAAC,uBAAuB,CAAC,CAACF,KAAK,CAAC,GAC9Cf,cAAM,CAACkB,IAAI,CAACH,KAAK,CAAC,GAClBf,cAAM,CAACmB,GAAG,CAACJ,KAAK,CAAC,CACtB;EACH,CAAC,CAAC,CACH;EAEHK,SAAS,EAAEA,CAACtB,KAAK,EAAEuB,KAAK;EACtB;EACA;EACA;EACA;EACAC,cAAM,CAACC,MAAM,CACXvB,cAAM,CAACwB,IAAI,CAAC,MAAK;IACf,IAAAtB,0BAAmB,EAACJ,KAAK,CAAC;IAC1B,OAAOwB,cAAM,CAACjB,KAAK,CAACT,GAAG,CAACwB,SAAS,CAACtB,KAAK,EAAEuB,KAAK,CAAC,CAAC;EAClD,CAAC,CAAC;CAEP,CAAC;AAAAI,OAAA,CAAA9B,iBAAA,GAAAA,iBAAA","ignoreList":[]}
+{"version":3,"file":"ContractStore.js","names":["_effect","require","_AppendCondition","_AppendIsOwned","_Event","_Query","decodeReadLimit","Schema","decodeUnknownSync","ReadLimit","makeContractStore","raw","read","query","options","Effect","suspend","assertServableQuery","limit","undefined","orDie","append","events","condition","flatMap","assertAppendNotOwned","length","Error","unknown","Object","keys","find","key","hasOwn","AppendCondition","fields","JSON","stringify","failIfEventsMatch","catch","error","Predicate","isTagged","fail","die","subscribe","after","Stream","unwrap","sync","exports"],"sources":["../../src/ContractStore.ts"],"sourcesContent":[null],"mappings":";;;;;;AAsCA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,cAAA,GAAAF,OAAA;AAGA,IAAAG,MAAA,GAAAH,OAAA;AAEA,IAAAI,MAAA,GAAAJ,OAAA;AAEA;AACA,MAAMK,eAAe,gBAAGC,cAAM,CAACC,iBAAiB,CAACC,gBAAS,CAAC;AAwB3D;;;;AAIO,MAAMC,iBAAiB,GAC5BC,GAAwB,KACM;EAC9BC,IAAI,EAAEA,CAACC,KAAK,EAAEC,OAAO,KACnBC,cAAM,CAACC,OAAO,CAAC,MAAK;IAClB;IACA,IAAAC,0BAAmB,EAACJ,KAAK,CAAC;IAC1B,IAAIC,OAAO,EAAEI,KAAK,KAAKC,SAAS,EAAE;MAChCb,eAAe,CAACQ,OAAO,CAACI,KAAK,CAAC;IAChC;IACA;IACA,OAAOH,cAAM,CAACK,KAAK,CAACT,GAAG,CAACC,IAAI,CAACC,KAAK,EAAEC,OAAO,CAAC,CAAC;EAC/C,CAAC,CAAC;EAEJO,MAAM,EAAEA,CAACC,MAAM,EAAEC,SAAS;EACxB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACAR,cAAM,CAACS,OAAO,CAACC,mCAAoB,EAAE,MACnCV,cAAM,CAACC,OAAO,CAAC,MAAK;IAClB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAIM,MAAM,CAACI,MAAM,KAAK,CAAC,EAAE;MACvB,MAAM,IAAIC,KAAK,CACb,uEAAuE,GACrE,oEAAoE,GACpE,kEAAkE,CACrE;IACH;IACA;IACA;IACA;IACA;IACA;IACA,IAAIJ,SAAS,KAAKJ,SAAS,EAAE;MAC3B,MAAMS,OAAO,GAAGC,MAAM,CAACC,IAAI,CAACP,SAAS,CAAC,CAACQ,IAAI,CACxCC,GAAG,IAAK,CAACH,MAAM,CAACI,MAAM,CAACC,gCAAe,CAACC,MAAM,EAAEH,GAAG,CAAC,CACrD;MACD,IAAIJ,OAAO,KAAKT,SAAS,EAAE;QACzB,MAAM,IAAIQ,KAAK,CACb,kEAAkES,IAAI,CAACC,SAAS,CAACT,OAAO,CAAC,IAAI,GAC3F,mEAAmE,GACnE,yEAAyE,CAC5E;MACH;MACA,IAAAX,0BAAmB,EAACM,SAAS,CAACe,iBAAiB,CAAC;IAClD;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,OAAOvB,cAAM,CAACwB,KAAK,CAAC5B,GAAG,CAACU,MAAM,CAACC,MAAM,EAAEC,SAAS,CAAC,EAAGiB,KAAK,IACvDC,iBAAS,CAACC,QAAQ,CAAC,uBAAuB,CAAC,CAACF,KAAK,CAAC,GAC9CzB,cAAM,CAAC4B,IAAI,CAACH,KAAK,CAAC,GAClBzB,cAAM,CAAC6B,GAAG,CAACJ,KAAK,CAAC,CACtB;EACH,CAAC,CAAC,CACH;EAEHK,SAAS,EAAEA,CAAChC,KAAK,EAAEiC,KAAK;EACtB;EACA;EACA;EACA;EACAC,cAAM,CAACC,MAAM,CACXjC,cAAM,CAACkC,IAAI,CAAC,MAAK;IACf,IAAAhC,0BAAmB,EAACJ,KAAK,CAAC;IAC1B,OAAOkC,cAAM,CAAC3B,KAAK,CAACT,GAAG,CAACkC,SAAS,CAAChC,KAAK,EAAEiC,KAAK,CAAC,CAAC;EAClD,CAAC,CAAC;CAEP,CAAC;AAAAI,OAAA,CAAAxC,iBAAA,GAAAA,iBAAA","ignoreList":[]}

package/dist/cjs/DcbEventStore.js

@@ -5,6 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.DcbEventStore = void 0;
 var _effect = require("effect");
-class DcbEventStore extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/core/DcbEventStore')() {}
+class DcbEventStore extends /*#__PURE__*/_effect.Context.Service()('@kairos-es/core/DcbEventStore') {}
 exports.DcbEventStore = DcbEventStore;
 //# sourceMappingURL=DcbEventStore.js.map

package/dist/cjs/DcbEventStore.js.map

@@ -1 +1 @@
-{"version":3,"file":"DcbEventStore.js","names":["_effect","require","DcbEventStore","Context","Tag","exports"],"sources":["../../src/DcbEventStore.ts"],"sourcesContent":[null],"mappings":";;;;;;AAiBA,IAAAA,OAAA,GAAAC,OAAA;AA2BM,MAAOC,aAAc,sBAAQC,eAAO,CAACC,GAAG,CAAC,+BAA+B,CAAC,EAgC5E;AAAAC,OAAA,CAAAH,aAAA,GAAAA,aAAA","ignoreList":[]}
+{"version":3,"file":"DcbEventStore.js","names":["_effect","require","DcbEventStore","Context","Service","exports"],"sources":["../../src/DcbEventStore.ts"],"sourcesContent":[null],"mappings":";;;;;;AAiBA,IAAAA,OAAA,GAAAC,OAAA;AA2BM,MAAOC,aAAc,sBAAQC,eAAO,CAACC,OAAO,EAgC/C,CAAC,+BAA+B,CAAC;AAAAC,OAAA,CAAAH,aAAA,GAAAA,aAAA","ignoreList":[]}

package/dist/cjs/Event.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.tagIdentity = exports.Tag = exports.SequencedEvent = exports.ReadLimit = exports.Position = exports.ORIGIN = exports.EventType = exports.DcbEvent = void 0;
+exports.tagIdentity = exports.Tag = exports.SequencedEvent = exports.ReadLimit = exports.Position = exports.ORIGIN = exports.Metadata = exports.EventType = exports.DcbEvent = void 0;
 var _effect = require("effect");
 /**
  * Core domain types for the DCB event log: branded scalars and the wire
@@ -19,11 +19,28 @@ var _effect = require("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.
  */
-const Position = exports.Position = /*#__PURE__*/_effect.Schema.BigInt.pipe(/*#__PURE__*/_effect.Schema.nonNegativeBigInt(), /*#__PURE__*/_effect.Schema.brand('Position'));
+const Position = exports.Position = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_effect.Schema.decodeTo(_effect.Schema.BigInt, /*#__PURE__*/_effect.SchemaTransformation.transformEffect({
+  decode: (s, options) => _effect.Option.match(_effect.BigInt.fromString(s), {
+    onNone: () => _effect.Effect.fail(new _effect.SchemaIssue.InvalidValue({
+      message: `Unable to decode ${JSON.stringify(s)} into a bigint`
+    }, s, options)),
+    onSome: _effect.Effect.succeed
+  }),
+  encode: b => _effect.Effect.succeed(String(b))
+})), /*#__PURE__*/_effect.Schema.check(/*#__PURE__*/_effect.Schema.isGreaterThanOrEqualToBigInt(0n)), /*#__PURE__*/_effect.Schema.brand('Position'));
 /** The sentinel position meaning "before the first event". */
 const ORIGIN = exports.ORIGIN = /*#__PURE__*/Position.make(0n);
 /**
@@ -32,9 +49,9 @@ const ORIGIN = exports.ORIGIN = /*#__PURE__*/Position.make(0n);
  * event sourcing; a query matches an event when the event carries all of an
  * item's tags (superset test).
  */
-const Tag = exports.Tag = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_effect.Schema.pattern(/^[^:]+:.+/, {
+const Tag = exports.Tag = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_effect.Schema.check(/*#__PURE__*/_effect.Schema.isPattern(/^[^:]+:.+/, {
   identifier: 'Tag'
-}), /*#__PURE__*/_effect.Schema.brand('Tag'));
+})), /*#__PURE__*/_effect.Schema.brand('Tag'));
 const tagIdentity = key => {
   if (key.length === 0 || key.includes(':')) {
     throw new Error(`tagIdentity: key must be non-empty and contain no ':' (got ${JSON.stringify(key)})`);
@@ -60,26 +77,85 @@ const tagIdentity = key => {
  * `ReadLimit.make(n)`.
  */
 exports.tagIdentity = tagIdentity;
-const ReadLimit = exports.ReadLimit = /*#__PURE__*/_effect.Schema.Int.pipe(/*#__PURE__*/_effect.Schema.greaterThanOrEqualTo(0), /*#__PURE__*/_effect.Schema.brand('ReadLimit'));
+const ReadLimit = exports.ReadLimit = /*#__PURE__*/_effect.Schema.Int.pipe(/*#__PURE__*/_effect.Schema.check(/*#__PURE__*/_effect.Schema.isGreaterThanOrEqualTo(0)), /*#__PURE__*/_effect.Schema.brand('ReadLimit'));
 /**
  * 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.
  */
-const EventType = exports.EventType = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_effect.Schema.nonEmptyString(), /*#__PURE__*/_effect.Schema.brand('EventType'));
+const EventType = exports.EventType = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_effect.Schema.check(/*#__PURE__*/_effect.Schema.isNonEmpty()), /*#__PURE__*/_effect.Schema.brand('EventType'));
+/**
+ * An event's metadata: a flat bag of strings carrying the circumstances under
+ * which the event was RECORDED, never anything the business asserts (ADR-0017).
+ * Payload is what happened; metadata is the context of the recording — a
+ * `traceparent`, a correlation or causation id, a deployment revision.
+ *
+ * Values are strings, not `unknown`, for cross-engine parity rather than taste:
+ * both SQL engines carry the bag as a JSON document, and `JSON.stringify` drops
+ * `undefined`, throws on `bigint` and turns `NaN` into `null`, none of which the
+ * in-memory oracle does.
+ *
+ * The key schema carries no refinement, deliberately: a refinement on a
+ * `Schema.Record` key acts as a FILTER on decode, silently dropping a key that
+ * fails it rather than failing the decode. Constraining keys, if ever wanted,
+ * has to be a validating step of its own.
+ *
+ * Two engine limits a consumer must know, because the bag is typically filled
+ * from outside the application at a request edge. Postgres refuses a NUL
+ * character (U+0000) and an unpaired surrogate in any string it stores, so an
+ * event whose bag holds one fails to append there while the in-memory and
+ * SQLite engines accept it; sanitise untrusted values before they reach the
+ * bag. And key ORDER is not preserved: Postgres stores an object's keys in an
+ * order of its own, so compare bags as unordered and never rely on the order
+ * `Object.keys` returns.
+ *
+ * Metadata is never part of a `Query` or an `AppendCondition` — a store refuses
+ * either when it carries a key the grammar does not define, so a metadata
+ * predicate cannot be written and silently ignored — never reaches a codec's
+ * `tagsFor`, and no store offers a way to rewrite it once appended. ADR-0017
+ * owns why each of those is mechanical rather than preferential.
+ *
+ * ## The one home of the shape rule
+ *
+ * The bag is a JSON OBJECT whose every value is a STRING, and this schema is
+ * where that rule is stated. At runtime it is checked in ONE place, at write: the
+ * codec's `toEvent` decodes every bag through this schema and refuses one that
+ * fails on its own error channel, so a value smuggled past the type (through an
+ * `any`) stops there. The schema judges a bag's OWN enumerable keys, so an object
+ * that keeps its entries anywhere else — a `Map`, a `Date` — reads as the empty
+ * bag rather than failing. A store checks no values: an event built by hand and handed
+ * to `append` directly carries whatever it carries, and what each engine then does
+ * with a non-string value differs — one may store it and read it back differently
+ * from another, and a `bigint` makes a SQL engine's append fail. Each
+ * SQL engine keeps a container check of its own on read — the column must hold a
+ * JSON object — because that defends against a writer outside the library and is
+ * about the column, not the values. A VALUE check must never be added on read
+ * alone: it would make an event the store accepted unreadable for ever, so a
+ * value check belongs at write or nowhere.
+ */
+const Metadata = exports.Metadata = /*#__PURE__*/_effect.Schema.Record(_effect.Schema.String, _effect.Schema.String);
 /**
  * An event as stored: an opaque payload plus its type, tags, a
- * producer-supplied `uuid`, and producer-supplied `occurredAt` domain time.
+ * producer-supplied `uuid`, producer-supplied `occurredAt` domain time, and its
+ * `metadata` bag.
  *
  * `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
+ * invisible to `toEqual`, which ignores `undefined` properties, so an optional
+ * field could drift across the three engines with the round-trip suite green.
+ * Core only carries it; the codec's `toEvent` is where it is resolved.
  */
 const DcbEvent = exports.DcbEvent = /*#__PURE__*/_effect.Schema.Struct({
   type: EventType,
-  data: _effect.Schema.Uint8ArrayFromSelf,
+  data: _effect.Schema.Uint8Array,
   tags: /*#__PURE__*/_effect.Schema.Array(Tag),
-  uuid: _effect.Schema.UUID,
-  occurredAt: _effect.Schema.DateTimeUtc
+  uuid: /*#__PURE__*/_effect.Schema.String.check(/*#__PURE__*/_effect.Schema.isGUID()),
+  occurredAt: _effect.Schema.DateTimeUtcFromString,
+  metadata: Metadata
 });
 /** A persisted event: the event together with the position it was written at. */
 const SequencedEvent = exports.SequencedEvent = /*#__PURE__*/_effect.Schema.Struct({

package/dist/cjs/Event.js.map

@@ -1 +1 @@
-{"version":3,"file":"Event.js","names":["_effect","require","Position","exports","Schema","BigInt","pipe","nonNegativeBigInt","brand","ORIGIN","make","Tag","String","pattern","identifier","tagIdentity","key","length","includes","Error","JSON","stringify","value","ReadLimit","Int","greaterThanOrEqualTo","EventType","nonEmptyString","DcbEvent","Struct","type","data","Uint8ArrayFromSelf","tags","Array","uuid","UUID","occurredAt","DateTimeUtc","SequencedEvent","event","position"],"sources":["../../src/Event.ts"],"sourcesContent":[null],"mappings":";;;;;;AAQA,IAAAA,OAAA,GAAAC,OAAA;AARA;;;;;;;;;AAUA;;;;;;;;;AASO,MAAMC,QAAQ,GAAAC,OAAA,CAAAD,QAAA,gBAAGE,cAAM,CAACC,MAAM,CAACC,IAAI,cACxCF,cAAM,CAACG,iBAAiB,EAAE,eAC1BH,cAAM,CAACI,KAAK,CAAC,UAAU,CAAC,CACzB;AAGD;AACO,MAAMC,MAAM,GAAAN,OAAA,CAAAM,MAAA,gBAAaP,QAAQ,CAACQ,IAAI,CAAC,EAAE,CAAC;AAEjD;;;;;;AAMO,MAAMC,GAAG,GAAAR,OAAA,CAAAQ,GAAA,gBAAGP,cAAM,CAACQ,MAAM,CAACN,IAAI,cACnCF,cAAM,CAACS,OAAO,CAAC,WAAW,EAAE;EAAEC,UAAU,EAAE;AAAK,CAAE,CAAC,eAClDV,cAAM,CAACI,KAAK,CAAC,KAAK,CAAC,CACpB;AA8BM,MAAMO,WAAW,GAAIC,GAAW,IAAiB;EACtD,IAAIA,GAAG,CAACC,MAAM,KAAK,CAAC,IAAID,GAAG,CAACE,QAAQ,CAAC,GAAG,CAAC,EAAE;IACzC,MAAM,IAAIC,KAAK,CACb,8DAA8DC,IAAI,CAACC,SAAS,CAACL,GAAG,CAAC,GAAG,CACrF;EACH;EACA,OAAO;IACLA,GAAG;IACHN,IAAI,EAAGY,KAAK,IAAI;MACd,IAAIA,KAAK,CAACL,MAAM,KAAK,CAAC,IAAIK,KAAK,CAACJ,QAAQ,CAAC,GAAG,CAAC,EAAE;QAC7C,MAAM,IAAIC,KAAK,CACb,eAAeC,IAAI,CAACC,SAAS,CAACL,GAAG,CAAC,2DAA2DI,IAAI,CAACC,SAAS,CAACC,KAAK,CAAC,GAAG,CACtH;MACH;MACA,OAAOX,GAAG,CAACD,IAAI,CAAC,GAAGM,GAAG,IAAIM,KAAK,EAAE,CAAC;IACpC;GACD;AACH,CAAC;AAED;;;;;;;;;;AAAAnB,OAAA,CAAAY,WAAA,GAAAA,WAAA;AAUO,MAAMQ,SAAS,GAAApB,OAAA,CAAAoB,SAAA,gBAAGnB,cAAM,CAACoB,GAAG,CAAClB,IAAI,cACtCF,cAAM,CAACqB,oBAAoB,CAAC,CAAC,CAAC,eAC9BrB,cAAM,CAACI,KAAK,CAAC,WAAW,CAAC,CAC1B;AAGD;;;;AAIO,MAAMkB,SAAS,GAAAvB,OAAA,CAAAuB,SAAA,gBAAGtB,cAAM,CAACQ,MAAM,CAACN,IAAI,cACzCF,cAAM,CAACuB,cAAc,EAAE,eACvBvB,cAAM,CAACI,KAAK,CAAC,WAAW,CAAC,CAC1B;AAGD;;;;;;;;AAQO,MAAMoB,QAAQ,GAAAzB,OAAA,CAAAyB,QAAA,gBAAGxB,cAAM,CAACyB,MAAM,CAAC;EACpCC,IAAI,EAAEJ,SAAS;EACfK,IAAI,EAAE3B,cAAM,CAAC4B,kBAAkB;EAC/BC,IAAI,eAAE7B,cAAM,CAAC8B,KAAK,CAACvB,GAAG,CAAC;EACvBwB,IAAI,EAAE/B,cAAM,CAACgC,IAAI;EACjBC,UAAU,EAAEjC,cAAM,CAACkC;CACpB,CAAC;AAGF;AACO,MAAMC,cAAc,GAAApC,OAAA,CAAAoC,cAAA,gBAAGnC,cAAM,CAACyB,MAAM,CAAC;EAC1CW,KAAK,EAAEZ,QAAQ;EACfa,QAAQ,EAAEvC;CACX,CAAC","ignoreList":[]}
+{"version":3,"file":"Event.js","names":["_effect","require","Position","exports","Schema","String","pipe","decodeTo","BigInt","SchemaTransformation","transformEffect","decode","s","options","Option","match","BigInt_","fromString","onNone","Effect","fail","SchemaIssue","InvalidValue","message","JSON","stringify","onSome","succeed","encode","b","check","isGreaterThanOrEqualToBigInt","brand","ORIGIN","make","Tag","isPattern","identifier","tagIdentity","key","length","includes","Error","value","ReadLimit","Int","isGreaterThanOrEqualTo","EventType","isNonEmpty","Metadata","Record","DcbEvent","Struct","type","data","Uint8Array","tags","Array","uuid","isGUID","occurredAt","DateTimeUtcFromString","metadata","SequencedEvent","event","position"],"sources":["../../src/Event.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/Projection.js

@@ -24,15 +24,21 @@ const AnyProjection = exports.AnyProjection = {
    */
   of: projection => projection
 };
-/** Merge two queries by OR-ing their items; either wildcard yields a wildcard. */
-const mergeQuery = (left, right) => {
-  if (left.items.length === 0 || right.items.length === 0) {
-    return WILDCARD;
-  }
-  return {
-    items: [...left.items, ...right.items]
-  };
-};
+/**
+ * Merge two queries by OR-ing their items; either wildcard yields a wildcard.
+ *
+ * Every other key on either envelope is carried into the result. The grammar's
+ * envelope has no key but `items`, so anything else is a key the store boundary
+ * refuses (`servableQueryFault`); a merge that rebuilt the envelope from `items`
+ * alone would drop that key before the boundary saw it, and a slice composed with
+ * another would then have its smuggled predicate ignored in silence — the outcome
+ * the refusal exists to prevent.
+ */
+const mergeQuery = (left, right) => ({
+  ...left,
+  ...right,
+  items: left.items.length === 0 || right.items.length === 0 ? WILDCARD.items : [...left.items, ...right.items]
+});
 /**
  * OR-merge a list of queries into one. The empty list is the wildcard.
  *

package/dist/cjs/Projection.js.map

@@ -1 +1 @@
-{"version":3,"file":"Projection.js","names":["_Query","require","WILDCARD","items","AnyProjection","exports","of","projection","mergeQuery","left","right","length","unionQueries","queries","reduce","acc","q","composeProjections","projections","keys","Object","initialState","fromEntries","map","key","mergedQuery","query","evolve","state","decoded","next","matchesSequenced","sequenced"],"sources":["../../src/Projection.ts"],"sourcesContent":[null],"mappings":";;;;;;AA4BA,IAAAA,MAAA,GAAAC,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,QAAQ,GAAU;EAAEC,KAAK,EAAE;AAAE,CAAE;AAqD9B,MAAMC,aAAa,GAAAC,OAAA,CAAAD,aAAA,GAAG;EAC3B;;;;;;;EAOAE,EAAE,EAAMC,UAAyB,IAC/BA;CACM;AAaV;AACA,MAAMC,UAAU,GAAGA,CAACC,IAAW,EAAEC,KAAY,KAAW;EACtD,IAAID,IAAI,CAACN,KAAK,CAACQ,MAAM,KAAK,CAAC,IAAID,KAAK,CAACP,KAAK,CAACQ,MAAM,KAAK,CAAC,EAAE;IACvD,OAAOT,QAAQ;EACjB;EACA,OAAO;IAAEC,KAAK,EAAE,CAAC,GAAGM,IAAI,CAACN,KAAK,EAAE,GAAGO,KAAK,CAACP,KAAK;EAAC,CAAE;AACnD,CAAC;AAED;;;;;;;;;;;;;;;AAeO,MAAMS,YAAY,GAAIC,OAA6B,IACxDA,OAAO,CAACF,MAAM,KAAK,CAAC,GAChBT,QAAQ,GACRW,OAAO,CAACC,MAAM,CAAC,CAACC,GAAG,EAAEC,CAAC,KAAKR,UAAU,CAACO,GAAG,EAAEC,CAAC,CAAC,CAAC;AAEpD;;;;;;;;;;;AAAAX,OAAA,CAAAO,YAAA,GAAAA,YAAA;AAWO,MAAMK,kBAAkB,GAC7BC,WAAc,IACmB;EACjC,MAAMC,IAAI,GAAGC,MAAM,CAACD,IAAI,CAACD,WAAW,CAAoC;EAExE,MAAMG,YAAY,GAAGD,MAAM,CAACE,WAAW,CACrCH,IAAI,CAACI,GAAG,CAAEC,GAAG,IAAK,CAACA,GAAG,EAAEN,WAAW,CAACM,GAAG,CAAC,CAACH,YAAY,CAAC,CAAC,CACnC;EAEtB,MAAMI,WAAW,GAAGb,YAAY,CAACO,IAAI,CAACI,GAAG,CAAEC,GAAG,IAAKN,WAAW,CAACM,GAAG,CAAC,CAACE,KAAK,CAAC,CAAC;EAE3E,OAAO;IACLL,YAAY;IACZK,KAAK,EAAED,WAAW;IAClBE,MAAM,EAAEA,CAACC,KAAK,EAAEC,OAAO,KAAI;MACzB,MAAMC,IAAI,GAAG;QAAE,GAAGF;MAAK,CAAuC;MAC9D,KAAK,MAAMJ,GAAG,IAAIL,IAAI,EAAE;QACtB,MAAMZ,UAAU,GAAGW,WAAW,CAACM,GAAG,CAAC;QACnC,IAAI,CAAC,IAAAO,uBAAgB,EAACF,OAAO,CAACG,SAAS,EAAEzB,UAAU,CAACmB,KAAK,CAAC,EAAE;UAC1D;QACF;QACAI,IAAI,CAACN,GAAG,CAAC,GAAGjB,UAAU,CAACoB,MAAM,CAACC,KAAK,CAACJ,GAAG,CAAC,EAAEK,OAAO,CAEhD;MACH;MACA,OAAOC,IAAI;IACb;GACD;AACH,CAAC;AAAAzB,OAAA,CAAAY,kBAAA,GAAAA,kBAAA","ignoreList":[]}
+{"version":3,"file":"Projection.js","names":["_Query","require","WILDCARD","items","AnyProjection","exports","of","projection","mergeQuery","left","right","length","unionQueries","queries","reduce","acc","q","composeProjections","projections","keys","Object","initialState","fromEntries","map","key","mergedQuery","query","evolve","state","decoded","next","matchesSequenced","sequenced"],"sources":["../../src/Projection.ts"],"sourcesContent":[null],"mappings":";;;;;;AA4BA,IAAAA,MAAA,GAAAC,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,QAAQ,GAAU;EAAEC,KAAK,EAAE;AAAE,CAAE;AAqD9B,MAAMC,aAAa,GAAAC,OAAA,CAAAD,aAAA,GAAG;EAC3B;;;;;;;EAOAE,EAAE,EAAMC,UAAyB,IAC/BA;CACM;AAaV;;;;;;;;;;AAUA,MAAMC,UAAU,GAAGA,CAACC,IAAW,EAAEC,KAAY,MAAa;EACxD,GAAGD,IAAI;EACP,GAAGC,KAAK;EACRP,KAAK,EACHM,IAAI,CAACN,KAAK,CAACQ,MAAM,KAAK,CAAC,IAAID,KAAK,CAACP,KAAK,CAACQ,MAAM,KAAK,CAAC,GAC/CT,QAAQ,CAACC,KAAK,GACd,CAAC,GAAGM,IAAI,CAACN,KAAK,EAAE,GAAGO,KAAK,CAACP,KAAK;CACrC,CAAC;AAEF;;;;;;;;;;;;;;;AAeO,MAAMS,YAAY,GAAIC,OAA6B,IACxDA,OAAO,CAACF,MAAM,KAAK,CAAC,GAChBT,QAAQ,GACRW,OAAO,CAACC,MAAM,CAAC,CAACC,GAAG,EAAEC,CAAC,KAAKR,UAAU,CAACO,GAAG,EAAEC,CAAC,CAAC,CAAC;AAEpD;;;;;;;;;;;AAAAX,OAAA,CAAAO,YAAA,GAAAA,YAAA;AAWO,MAAMK,kBAAkB,GAC7BC,WAAc,IACmB;EACjC,MAAMC,IAAI,GAAGC,MAAM,CAACD,IAAI,CAACD,WAAW,CAAoC;EAExE,MAAMG,YAAY,GAAGD,MAAM,CAACE,WAAW,CACrCH,IAAI,CAACI,GAAG,CAAEC,GAAG,IAAK,CAACA,GAAG,EAAEN,WAAW,CAACM,GAAG,CAAC,CAACH,YAAY,CAAC,CAAC,CACnC;EAEtB,MAAMI,WAAW,GAAGb,YAAY,CAACO,IAAI,CAACI,GAAG,CAAEC,GAAG,IAAKN,WAAW,CAACM,GAAG,CAAC,CAACE,KAAK,CAAC,CAAC;EAE3E,OAAO;IACLL,YAAY;IACZK,KAAK,EAAED,WAAW;IAClBE,MAAM,EAAEA,CAACC,KAAK,EAAEC,OAAO,KAAI;MACzB,MAAMC,IAAI,GAAG;QAAE,GAAGF;MAAK,CAAuC;MAC9D,KAAK,MAAMJ,GAAG,IAAIL,IAAI,EAAE;QACtB,MAAMZ,UAAU,GAAGW,WAAW,CAACM,GAAG,CAAC;QACnC,IAAI,CAAC,IAAAO,uBAAgB,EAACF,OAAO,CAACG,SAAS,EAAEzB,UAAU,CAACmB,KAAK,CAAC,EAAE;UAC1D;QACF;QACAI,IAAI,CAACN,GAAG,CAAC,GAAGjB,UAAU,CAACoB,MAAM,CAACC,KAAK,CAACJ,GAAG,CAAC,EAAEK,OAAO,CAEhD;MACH;MACA,OAAOC,IAAI;IACb;GACD;AACH,CAAC;AAAAzB,OAAA,CAAAY,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/dist/cjs/Query.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.servableQueryFault = exports.query = exports.matchesSequenced = exports.matchesQueryItem = exports.matchesQuery = exports.classifyServableQuery = exports.assertServableQuery = exports.QueryItem = exports.Query = void 0;
+exports.unknownQueryKeyFault = exports.servableQueryFault = exports.query = exports.matchesSequenced = exports.matchesQueryItem = exports.matchesQuery = exports.classifyServableQuery = exports.assertServableQuery = exports.QueryItem = exports.Query = void 0;
 var _effect = require("effect");
 var _Event = require("./Event.js");
 /**
@@ -77,6 +77,9 @@ const matchesSequenced = (sequenced, query) => matchesQuery(sequenced.event, que
  * (`Query.ts` module docs) but which plain-data assembly — e.g. decision-model
  * composition, `Projection.ts:31-36` — can still bypass.
  *
+ * A query, or any of its items, carrying a key the grammar does not define is
+ * refused before anything else is judged (`unknownKeyFault` below says why).
+ *
  * The servable grammar is exactly one of:
  * - the wildcard (`items.length === 0`), which matches every event;
  * - a *single* item (`items.length === 1`), any types/tags, including a
@@ -103,6 +106,55 @@ const assertServableQuery = query => {
     throw new Error(fault);
   }
 };
+/**
+ * The refusal of a key `schemaFields` does not define, or `undefined` when `value`
+ * carries none. `where` names the level for the message.
+ *
+ * ## Why an unknown key is refused rather than ignored
+ *
+ * A `Query` is plain data, so nothing at runtime stops a caller adding a key the
+ * grammar does not have — a `metadata` predicate on an item is the one this repo
+ * expects, since metadata is the field an author most plausibly wants to filter on
+ * and must not (ADR-0017). Ignored, that key is a predicate the author believes they
+ * wrote and no engine honours, and on the append side it is worse: the Postgres
+ * guard embeds its match as literal plpgsql text that no type reaches, so a key a
+ * read path one day learned to honour would still be dropped by the guard, and the
+ * optimistic-concurrency check would escape in silence. Refusing every key the
+ * grammar does not define closes that route — a SMUGGLED key — at the one boundary
+ * every engine shares, before any engine could disagree. "Every key" means every
+ * key `Object.keys` returns: an own, enumerable, string key, which is what a plain
+ * object literal or a spread builds. A symbol key, a non-enumerable key or an
+ * inherited one is not judged, and no engine reads one either. Core's own query
+ * merge (`unionQueries`, `composeProjections`) carries an envelope's unknown key
+ * into the merged query rather than dropping it, so composing slices cannot launder
+ * a smuggled key past this check.
+ *
+ * It does not close the neighbouring one, and cannot: a field ADDED to the grammar's
+ * schema is a known key from that edit on and passes here, while the plpgsql guard
+ * still has to be taught it by hand. That exposure is the Postgres guard's, and its
+ * own comment in that engine's DDL says so.
+ *
+ * The known keys are read off the SCHEMA's own `fields` rather than listed here, so
+ * a field added to the grammar is admitted by the same edit that adds it. Only key
+ * NAMES are judged: an exact-optional key written as `undefined` is a known key and
+ * passes, because which values a key admits is the type's business, not this rule's.
+ */
+exports.assertServableQuery = assertServableQuery;
+const unknownKeyFault = (where, value, schemaFields) => {
+  const unknown = Object.keys(value).find(key => !Object.hasOwn(schemaFields, key));
+  return unknown === undefined ? undefined : `assertServableQuery: ${where} carries the key ${JSON.stringify(unknown)}, which ` + 'the query grammar does not define; an unknown key would be silently ignored ' + 'by every engine rather than honoured, so it is refused';
+};
+/**
+ * The unknown-key half of `servableQueryFault`, on its own: the refusal of a key the
+ * grammar does not define on the envelope or on any item, or `undefined`.
+ *
+ * It is the same rule and not a second statement of it — `servableQueryFault` calls
+ * this first. It is exported because ONE caller has to tell the two halves apart:
+ * the codec's read ledger refuses an unservable SHAPE on its own error channel, and
+ * must not report an unknown key as one. An unknown key is not something a slice's
+ * tags can fix, so the ledger leaves it to the store, which refuses it as a defect.
+ */
+const unknownQueryKeyFault = query => unknownKeyFault('a query', query, Query.fields) ?? query.items.reduce((fault, item) => fault ?? unknownKeyFault('a query item', item, QueryItem.fields), undefined);
 /**
  * The servable grammar as a TOTAL function: the reason `query` cannot be served,
  * or `undefined` when it can.
@@ -123,8 +175,12 @@ const assertServableQuery = query => {
  * side's own (`projectionWiringFault` returns `string | undefined` for the same
  * reason), so a fault is one exit route and one return type.
  */
-exports.assertServableQuery = assertServableQuery;
+exports.unknownQueryKeyFault = unknownQueryKeyFault;
 const servableQueryFault = query => {
+  const unknownKey = unknownQueryKeyFault(query);
+  if (unknownKey !== undefined) {
+    return unknownKey;
+  }
   const {
     items
   } = query;
@@ -182,7 +238,7 @@ const classifyServableQuery = query => {
   }
   const only = query.items.length === 1 ? query.items[0] : undefined;
   if (only !== undefined && only.tags.length === 0) {
-    return _effect.Array.isNonEmptyReadonlyArray(only.types) ? {
+    return _effect.Array.isReadonlyArrayNonEmpty(only.types) ? {
       kind: 'typeOnly',
       types: only.types
     } : {

package/dist/cjs/Query.js.map

@@ -1 +1 @@
-{"version":3,"file":"Query.js","names":["_effect","require","_Event","QueryItem","exports","Schema","Struct","types","Array","EventType","tags","Tag","Query","items","matchesQueryItem","event","item","typeOk","length","includes","type","eventTags","Set","every","tag","has","matchesQuery","query","some","matchesSequenced","sequenced","assertServableQuery","fault","servableQueryFault","undefined","Error","classifyServableQuery","kind","only","Arr","isNonEmptyReadonlyArray","fields","all","or"],"sources":["../../src/Query.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"Query.js","names":["_effect","require","_Event","QueryItem","exports","Schema","Struct","types","Array","EventType","tags","Tag","Query","items","matchesQueryItem","event","item","typeOk","length","includes","type","eventTags","Set","every","tag","has","matchesQuery","query","some","matchesSequenced","sequenced","assertServableQuery","fault","servableQueryFault","undefined","Error","unknownKeyFault","where","value","schemaFields","unknown","Object","keys","find","key","hasOwn","JSON","stringify","unknownQueryKeyFault","fields","reduce","unknownKey","classifyServableQuery","kind","only","Arr","isReadonlyArrayNonEmpty","all","or"],"sources":["../../src/Query.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/SubscribeMachine.js

@@ -114,12 +114,12 @@ const DEFAULT_POLL_INTERVAL_MILLIS = exports.DEFAULT_POLL_INTERVAL_MILLIS = 1000
  * 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
+ * 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 `positive` and
- * `finite` matter: at zero or below the loop would spin without ever waiting for 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
@@ -127,17 +127,13 @@ const DEFAULT_POLL_INTERVAL_MILLIS = exports.DEFAULT_POLL_INTERVAL_MILLIS = 1000
  * 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
+ * `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`.
  */
 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
-  })
+  pollInterval: /*#__PURE__*/_effect.Schema.optionalKey(/*#__PURE__*/_effect.Schema.Number.check(/*#__PURE__*/_effect.Schema.isGreaterThan(0), /*#__PURE__*/_effect.Schema.isFinite())),
+  catchUpPageSize: /*#__PURE__*/_effect.Schema.optionalKey(/*#__PURE__*/_effect.Schema.Int.check(/*#__PURE__*/_effect.Schema.isGreaterThan(0)))
 };
 /**
  * Retry a TRANSIENT poll fault (an `E` from one reconcile read) on a capped
@@ -146,16 +142,16 @@ const subscriptionTuningFields = exports.subscriptionTuningFields = {
  * 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)));
+const POLL_RETRY_SCHEDULE = /*#__PURE__*/_effect.Schedule.max([/*#__PURE__*/_effect.Schedule.min([/*#__PURE__*/_effect.Schedule.exponential('100 millis', 2), /*#__PURE__*/_effect.Schedule.spaced('2 seconds')]), /*#__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
+ * The cursor threads through the `Stream.paginate` state, starting at `after` and
+ * advancing to the last delivered position 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; `makeContractStore` dies it
  * (subscribe is `E = never` on the contract).
  */
-const subscribeStream = (deps, after) => _effect.Stream.unwrapScoped(_effect.Effect.gen(function* () {
+const subscribeStream = (deps, after) => _effect.Stream.unwrap(_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
@@ -171,7 +167,7 @@ const subscribeStream = (deps, after) => _effect.Stream.unwrapScoped(_effect.Eff
   // 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')))));
+  const listener = (deps.listen ?? _effect.Stream.never).pipe(_effect.Stream.tap(() => _effect.Queue.offer(wake, undefined)), _effect.Stream.retry(_effect.Schedule.min([_effect.Schedule.exponential('50 millis'), _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.
@@ -203,7 +199,7 @@ const subscribeStream = (deps, after) => _effect.Stream.unwrapScoped(_effect.Eff
   }).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
+   * the advanced cursor — a pure `Position → Effect<[events, 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.
    *
@@ -211,25 +207,27 @@ const subscribeStream = (deps, after) => _effect.Stream.unwrapScoped(_effect.Eff
    * 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
+   * only completes by returning a non-empty batch; the scope interrupts it on
    * close.
    */
   const nextBatch = from => _effect.Effect.gen(function* () {
     while (true) {
-      yield* _effect.Queue.takeAll(wake);
+      // `Queue.clear` and not `Queue.takeAll`: the drain must NOT wait, and
+      // `takeAll` suspends until at least one signal is present.
+      yield* _effect.Queue.clear(wake);
       const {
         events,
         last
       } = yield* drainFrom(from);
       if (events.length > 0) {
-        return [_effect.Chunk.fromIterable(events), last];
+        return [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));
+  return _effect.Stream.paginate(after ?? _Event.ORIGIN, from => _effect.Effect.map(nextBatch(from), ([events, last]) => [events, _effect.Option.some(last)]));
 }));
 exports.subscribeStream = subscribeStream;
 //# sourceMappingURL=SubscribeMachine.js.map