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

package/dist/esm/event.js.map

@@ -1 +1 @@
-{"version":3,"file":"event.js","names":["Schema","event","type","fields","tagsFor","schema","Struct"],"sources":["../../src/event.ts"],"sourcesContent":[null],"mappings":"AA+BA,SAASA,MAAM,QAAQ,QAAQ;AA+B/B;;;;;;;;AAQA,OAAO,MAAMC,KAAK,GAAGA,CAInBC,IAAU,EACVC,MAAc,EACdC,OAA4C,KAK1C;EACF,MAAMC,MAAM,GAAGL,MAAM,CAACM,MAAM,CAACH,MAAM,CAAC;EACpC,OAAO;IACL;IACAD,IAAI,EAAEA,IAAwB;IAC9BG,MAAM;IACND;GACD;AACH,CAAC","ignoreList":[]}
+{"version":3,"file":"event.js","names":["Schema","event","type","fields","tagsFor","schema","Struct"],"sources":["../../src/event.ts"],"sourcesContent":[null],"mappings":"AA+BA,SAASA,MAAM,QAAQ,QAAQ;AAyC/B;;;;;;;;AAQA,OAAO,MAAMC,KAAK,GAAGA,CAInBC,IAAU,EACVC,MAAc,EACdC,OAA4C,KAK1C;EACF,MAAMC,MAAM,GAAGL,MAAM,CAACM,MAAM,CAACH,MAAM,CAAC;EACpC,OAAO;IACL;IACAD,IAAI,EAAEA,IAAwB;IAC9BG,MAAM;IACND;GACD;AACH,CAAC","ignoreList":[]}

package/dist/esm/index.js

@@ -17,8 +17,9 @@
  *   on this path: the type is discovered at runtime, so no def was named to
  *   narrow it (see `registry.ts`).
  *
- * `toEvent(def, payload, { uuid?, occurredAt? })` produces a wire event (encode
- * -> serialise, tags derived from `def.tagsFor`, clock + uuid from services).
+ * `toEvent(def, payload, { uuid?, occurredAt?, metadata? })` produces a wire
+ * event (encode -> serialise, tags derived from `def.tagsFor`, clock + uuid from
+ * services, metadata from the call or the optional ambient `MetadataSource`).
  * Serialisation is a pluggable `Serializer` (JSON
  * default). Encryption, when needed, is an *application*-authored `Schema`
  * transform on a payload field; the codec only propagates its requirement and
@@ -122,6 +123,7 @@ export { buildDecisionModel, modelAtHead } from "./decisionModel.js";
 export { decodeSlices } from "./decode.js";
 export { CodecError, UnknownEventType } from "./errors.js";
 export { event } from "./event.js";
+export { MetadataSource } from "./MetadataSource.js";
 export { decideOnly, transact, unsafeAppend } from "./precondition.js";
 export { projection } from "./projection.js";
 export { NoReadsRecorded, ReadLedger, TaglessSliceInLedger } from "./readLedger.js";

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["decider","runDecider","Decision","isUnchanged","Unchanged","UnchangedTypeId","buildDecisionModel","modelAtHead","decodeSlices","CodecError","UnknownEventType","event","decideOnly","transact","unsafeAppend","projection","NoReadsRecorded","ReadLedger","TaglessSliceInLedger","makeRegistry","Serializer","SerializerDefault","toEvent","Uuid","UuidLive","UuidTest"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuHA,SAAuBA,OAAO,EAAEC,UAAU,QAAQ,cAAW;AAC7D,SACEC,QAAQ,EAGRC,WAAW,EACXC,SAAS,EACTC,eAAe,QACV,eAAY;AACnB,SACEC,kBAAkB,EAClBC,WAAW,QAEN,oBAAiB;AACxB,SAASC,YAAY,QAAQ,aAAU;AACvC,SAASC,UAAU,EAAEC,gBAAgB,QAAQ,aAAU;AACvD,SAA0CC,KAAK,QAAsB,YAAS;AAC9E,SACEC,UAAU,EAEVC,QAAQ,EACRC,YAAY,QACP,mBAAgB;AACvB,SAEEC,UAAU,QAEL,iBAAc;AACrB,SAGEC,eAAe,EACfC,UAAU,EACVC,oBAAoB,QACf,iBAAc;AACrB,SAASC,YAAY,QAAuB,eAAY;AACxD,SAASC,UAAU,EAAEC,iBAAiB,QAAQ,iBAAc;AAC5D,SAASC,OAAO,QAAQ,cAAW;AACnC,SAASC,IAAI,EAAEC,QAAQ,EAAEC,QAAQ,QAAQ,WAAQ","ignoreList":[]}
+{"version":3,"file":"index.js","names":["decider","runDecider","Decision","isUnchanged","Unchanged","UnchangedTypeId","buildDecisionModel","modelAtHead","decodeSlices","CodecError","UnknownEventType","event","MetadataSource","decideOnly","transact","unsafeAppend","projection","NoReadsRecorded","ReadLedger","TaglessSliceInLedger","makeRegistry","Serializer","SerializerDefault","toEvent","Uuid","UuidLive","UuidTest"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwHA,SAAuBA,OAAO,EAAEC,UAAU,QAAQ,cAAW;AAC7D,SACEC,QAAQ,EAGRC,WAAW,EACXC,SAAS,EACTC,eAAe,QACV,eAAY;AACnB,SACEC,kBAAkB,EAClBC,WAAW,QAEN,oBAAiB;AACxB,SAASC,YAAY,QAAQ,aAAU;AACvC,SAASC,UAAU,EAAEC,gBAAgB,QAAQ,aAAU;AACvD,SAA0CC,KAAK,QAAsB,YAAS;AAC9E,SAASC,cAAc,QAAQ,qBAAkB;AACjD,SACEC,UAAU,EAEVC,QAAQ,EACRC,YAAY,QACP,mBAAgB;AACvB,SAEEC,UAAU,QAEL,iBAAc;AACrB,SAGEC,eAAe,EACfC,UAAU,EACVC,oBAAoB,QACf,iBAAc;AACrB,SAASC,YAAY,QAAuB,eAAY;AACxD,SAASC,UAAU,EAAEC,iBAAiB,QAAQ,iBAAc;AAC5D,SAASC,OAAO,QAAQ,cAAW;AACnC,SAASC,IAAI,EAAEC,QAAQ,EAAEC,QAAQ,QAAQ,WAAQ","ignoreList":[]}

package/dist/esm/precondition.js

@@ -80,7 +80,7 @@ export const decideOnly = (decider, command) => Effect.gen(function* () {
  * condition here. If that turns up in practice, a composing override is the
  * additive answer and this hatch is not it.
  *
- * `Effect.mapInputContext` over
+ * `Effect.updateContext` over
  * `Context.omit(AppendIsOwned)` is what lets it through the store's ownership
  * refusal — the one route, and `AppendIsOwned.ts` owns why removing the marker is
  * the shape rather than a second tag or a sanctioning flag.
@@ -109,7 +109,7 @@ reason) => Effect.flatMap(DcbEventStore, store =>
 // channel), so nothing here will fail to compile if this is deleted — what
 // catches it is `test/appendOwnership.test.ts` in the source repository, not the
 // type checker.
-Effect.mapInputContext(store.append(events), context => Context.omit(AppendIsOwned)(context)));
+Effect.updateContext(store.append(events), context => Context.omit(AppendIsOwned)(context)));
 /**
  * Open a bracket over ONE decision: evaluate the precondition inside it, hand its
  * output to the body under the precondition's tag, and append what the body

package/dist/esm/precondition.js.map

@@ -1 +1 @@
-{"version":3,"file":"precondition.js","names":["AppendIsOwned","DcbEventStore","Context","Effect","Layer","isUnchanged","modelAtHead","deriveLayeredCondition","makeReadLedger","NoReadsRecorded","ReadLedger","decideOnly","decider","command","gen","state","projections","decide","unsafeAppend","events","reason","flatMap","store","mapInputContext","append","context","omit","transact","precondition","body","ledger","output","proof","evaluate","pipe","provideService","tag","provide","merge","layer","succeed","by","condition","hops","undefined"],"sources":["../../src/precondition.ts"],"sourcesContent":[null],"mappings":"AAwGA,SAASA,aAAa,EAAEC,aAAa,QAAQ,iBAAiB;AAE9D,SAASC,OAAO,EAAEC,MAAM,EAAEC,KAAK,QAAQ,QAAQ;AAE/C,SAGEC,WAAW,QACN,eAAY;AACnB,SAASC,WAAW,QAA4B,oBAAiB;AAGjE,SACEC,sBAAsB,EACtBC,cAAc,EACdC,eAAe,EACfC,UAAU,QAEL,iBAAc;AAgCrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,OAAO,MAAMC,UAAU,GAAGA,CAOxBC,OAAqC,EACrCC,OAAgB,KAMhBV,MAAM,CAACW,GAAG,CAAC,aAAS;EAClB,OAAOJ,UAAU;EAEjB,MAAM;IAAEK;EAAK,CAAE,GAAG,OAAOT,WAAW,CAACM,OAAO,CAACI,WAAW,CAACH,OAAO,CAAC,CAAC;EAClE,OAAO,OAAOD,OAAO,CAACK,MAAM,CAACF,KAAK,EAAEF,OAAO,CAAC;AAC9C,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,MAAMK,YAAY,GAAGA,CAC1BC,MAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAC,MAAc,KAEdjB,MAAM,CAACkB,OAAO,CAACpB,aAAa,EAAGqB,KAAK;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAnB,MAAM,CAACoB,eAAe,CACpBD,KAAK,CAACE,MAAM,CAACL,MAAM,CAAC,EACnBM,OAA+B,IAAKvB,OAAO,CAACwB,IAAI,CAAC1B,aAAa,CAAC,CAACyB,OAAO,CAAC,CAC1E,CACF;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,MAAME,QAAQ,GACGC,YAA+C,IAEnEC,IAA4B,IAQ5B1B,MAAM,CAACW,GAAG,CAAC,aAAS;EAClB,MAAMQ,KAAK,GAAG,OAAOrB,aAAa;EAClC,MAAM6B,MAAM,GAAG,OAAOtB,cAAc;EAEpC,MAAMuB,MAAM,GAAmB,OAAO5B,MAAM,CAACW,GAAG,CAAC,aAAS;IACxD;IACA;IACA;IACA,MAAMkB,KAAK,GAAG,OAAOJ,YAAY,CAACK,QAAQ;IAC1C,OAAO,OAAOJ,IAAI,CAACK,IAAI,CAAC/B,MAAM,CAACgC,cAAc,CAACP,YAAY,CAACQ,GAAG,EAAEJ,KAAK,CAAC,CAAC;EACzE,CAAC,CAAC,CAACE,IAAI;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA/B,MAAM,CAACkC,OAAO,CACZjC,KAAK,CAACkC,KAAK,CACTR,MAAM,CAACS,KAAK,EACZnC,KAAK,CAACoC,OAAO,CAACxC,aAAa,EAAE;IAAEyC,EAAE,EAAE;EAAU,CAAE,CAAC,CACjD,CACF,CACF;EAED;EACA;EACA;EACA;EACA;EACA;EACA,IAAIpC,WAAW,CAAC0B,MAAM,CAAC,EAAE;IACvB,OAAOA,MAA2B;EACpC;EAEA,MAAMW,SAAS,GAAGnC,sBAAsB,CAAC,OAAOuB,MAAM,CAACa,IAAI,CAAC;EAC5D,IAAID,SAAS,KAAKE,SAAS,EAAE;IAC3B,OAAO,OAAO,IAAInC,eAAe,EAAE;EACrC;EAEA,OAAQ,OAAOa,KAAK,CAACE,MAAM,CAACO,MAAM,EAAEW,SAAS,CAAC;AAChD,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"precondition.js","names":["AppendIsOwned","DcbEventStore","Context","Effect","Layer","isUnchanged","modelAtHead","deriveLayeredCondition","makeReadLedger","NoReadsRecorded","ReadLedger","decideOnly","decider","command","gen","state","projections","decide","unsafeAppend","events","reason","flatMap","store","updateContext","append","context","omit","transact","precondition","body","ledger","output","proof","evaluate","pipe","provideService","tag","provide","merge","layer","succeed","by","condition","hops","undefined"],"sources":["../../src/precondition.ts"],"sourcesContent":[null],"mappings":"AAwGA,SAASA,aAAa,EAAEC,aAAa,QAAQ,iBAAiB;AAE9D,SAASC,OAAO,EAAEC,MAAM,EAAEC,KAAK,QAAQ,QAAQ;AAE/C,SAGEC,WAAW,QACN,eAAY;AACnB,SAASC,WAAW,QAA4B,oBAAiB;AAGjE,SACEC,sBAAsB,EACtBC,cAAc,EACdC,eAAe,EACfC,UAAU,QAEL,iBAAc;AAgCrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,OAAO,MAAMC,UAAU,GAAGA,CAOxBC,OAAqC,EACrCC,OAAgB,KAMhBV,MAAM,CAACW,GAAG,CAAC,aAAS;EAClB,OAAOJ,UAAU;EAEjB,MAAM;IAAEK;EAAK,CAAE,GAAG,OAAOT,WAAW,CAACM,OAAO,CAACI,WAAW,CAACH,OAAO,CAAC,CAAC;EAClE,OAAO,OAAOD,OAAO,CAACK,MAAM,CAACF,KAAK,EAAEF,OAAO,CAAC;AAC9C,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,MAAMK,YAAY,GAAGA,CAC1BC,MAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAC,MAAc,KAEdjB,MAAM,CAACkB,OAAO,CAACpB,aAAa,EAAGqB,KAAK;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAnB,MAAM,CAACoB,aAAa,CAClBD,KAAK,CAACE,MAAM,CAACL,MAAM,CAAC,EACnBM,OAA+B,IAAKvB,OAAO,CAACwB,IAAI,CAAC1B,aAAa,CAAC,CAACyB,OAAO,CAAC,CAC1E,CACF;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,MAAME,QAAQ,GACGC,YAA+C,IAEnEC,IAA4B,IAQ5B1B,MAAM,CAACW,GAAG,CAAC,aAAS;EAClB,MAAMQ,KAAK,GAAG,OAAOrB,aAAa;EAClC,MAAM6B,MAAM,GAAG,OAAOtB,cAAc;EAEpC,MAAMuB,MAAM,GAAmB,OAAO5B,MAAM,CAACW,GAAG,CAAC,aAAS;IACxD;IACA;IACA;IACA,MAAMkB,KAAK,GAAG,OAAOJ,YAAY,CAACK,QAAQ;IAC1C,OAAO,OAAOJ,IAAI,CAACK,IAAI,CAAC/B,MAAM,CAACgC,cAAc,CAACP,YAAY,CAACQ,GAAG,EAAEJ,KAAK,CAAC,CAAC;EACzE,CAAC,CAAC,CAACE,IAAI;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA/B,MAAM,CAACkC,OAAO,CACZjC,KAAK,CAACkC,KAAK,CACTR,MAAM,CAACS,KAAK,EACZnC,KAAK,CAACoC,OAAO,CAACxC,aAAa,EAAE;IAAEyC,EAAE,EAAE;EAAU,CAAE,CAAC,CACjD,CACF,CACF;EAED;EACA;EACA;EACA;EACA;EACA;EACA,IAAIpC,WAAW,CAAC0B,MAAM,CAAC,EAAE;IACvB,OAAOA,MAA2B;EACpC;EAEA,MAAMW,SAAS,GAAGnC,sBAAsB,CAAC,OAAOuB,MAAM,CAACa,IAAI,CAAC;EAC5D,IAAID,SAAS,KAAKE,SAAS,EAAE;IAC3B,OAAO,OAAO,IAAInC,eAAe,EAAE;EACrC;EAEA,OAAQ,OAAOa,KAAK,CAACE,MAAM,CAACO,MAAM,EAAEW,SAAS,CAAC;AAChD,CAAC,CAAC","ignoreList":[]}

package/dist/esm/projection.js

@@ -5,7 +5,7 @@
  * A `SliceProjection<S, R>` is a core `AnyProjection<S>` (directly composable —
  * its `evolve` folds a `DecodedEvent`) enriched with the `type -> Schema` map
  * `decodeSlices` merges and decodes through. That map's value type carries `R`
- * covariantly (`Schema<unknown, unknown, R>`), so the union of the defs'
+ * covariantly (`Schema.Decoder<unknown, R>`), so the union of the defs'
  * requirements flows to the decision model with no cast (and no phantom marker).
  * Because `evolve` is already erased, a built slice drops straight into
  * `composeProjections` — no `AnyProjection.of` ceremony.
@@ -50,18 +50,17 @@ export const projection = initialState => {
       // The entry type is annotated `R | R2` rather than inferred, and that
       // annotation is what carries the requirement forward — `build` reads `R`
       // straight off this map, so `RequirementOf` ultimately reads it from here.
-      // Widening the copied `R` entries into it costs nothing: `Schema` is
-      // declared `<in out A, in out I, out R>` upstream, hence covariant in its
+      // Widening the copied `R` entries into it costs nothing: `Schema.Decoder`
+      // is declared `<out T, out RD>` upstream, hence covariant in its
       // requirement.
       const nextSchemas = new Map(schemas);
-      // Erasing `A`/`I` is the one unavoidable cast, and `as unknown as` is what
-      // it takes: `Schema` is INVARIANT in both, so `Schema<A, I, R2>` and
-      // `Schema<unknown, unknown, R2>` are unrelated in either direction. It is
+      // Erasing `A`/`I` needs no cast: a `Schema.Codec` is covariant in both, so
+      // `Codec<A, I, R2, R2>` is already a `Decoder<unknown, R2>`. The erasure is
       // sound because the payload is only ever read back through `evolve`, which
-      // re-narrows by event type via the matching `fold`. The target names `R2`
-      // and not `never` because `R2` is what the def actually requires — an
-      // `Encrypted` field's `CipherKey` is not nothing — so the cast erases only
-      // what it has to and states the rest truthfully.
+      // re-narrows by event type via the matching `fold`. What survives it is
+      // `R2`, the def's DECODING requirement — an `Encrypted` field's `CipherKey`
+      // is not nothing — and that is the half a slice ever spends, since a slice
+      // decodes and never encodes.
       nextSchemas.set(def.type, def.schema);
       const nextFolds = new Map(folds);
       // Contravariance in the payload parameter, so this one is a cast too: the

package/dist/esm/projection.js.map

@@ -1 +1 @@
-{"version":3,"file":"projection.js","names":["EventType","projection","initialState","make","schemas","folds","on","def","fold","has","type","Error","nextSchemas","Map","set","schema","nextFolds","build","options","types","keys","map","t","query","items","tags","evolve","state","decoded","get","sequenced","event","undefined","payload"],"sources":["../../src/projection.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;AAmBA,SAGEA,SAAS,QAGJ,iBAAiB;AAoCxB;;;;AAIA,OAAO,MAAMC,UAAU,GAAOC,YAAe,IAAiC;EAC5E;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,IAAI,GAAGA,CACXC,OAAgE,EAChEC,KAA6D,MAChC;IAC7BC,EAAE,EAAEA,CACFC,GAAuB,EACvBC,IAAiC,KACD;MAChC;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,IAAIJ,OAAO,CAACK,GAAG,CAACF,GAAG,CAACG,IAAI,CAAC,EAAE;QACzB,MAAM,IAAIC,KAAK,CACb,yBAAyBJ,GAAG,CAACG,IAAI,mCAAmC,GAClE,gEAAgE,GAChE,gCAAgC,CACnC;MACH;MACA;MACA;MACA;MACA;MACA;MACA;MACA,MAAME,WAAW,GAAG,IAAIC,GAAG,CAGzBT,OAAO,CAAC;MACV;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACAQ,WAAW,CAACE,GAAG,CACbP,GAAG,CAACG,IAAI,EACRH,GAAG,CAACQ,MAAwD,CAC7D;MACD,MAAMC,SAAS,GAAG,IAAIH,GAAG,CAACR,KAAK,CAAC;MAChC;MACA;MACA;MACAW,SAAS,CAACF,GAAG,CAACP,GAAG,CAACG,IAAI,EAAEF,IAAyC,CAAC;MAClE,OAAOL,IAAI,CAASS,WAAW,EAAEI,SAAS,CAAC;IAC7C,CAAC;IACDC,KAAK,EAAGC,OAAO,IAAI;MACjB;MACA;MACA,MAAMC,KAAK,GAAG,CAAC,GAAGf,OAAO,CAACgB,IAAI,EAAE,CAAC,CAACC,GAAG,CAAEC,CAAC,IAAKtB,SAAS,CAACG,IAAI,CAACmB,CAAC,CAAC,CAAC;MAC/D,MAAMC,KAAK,GAAU;QACnBC,KAAK,EAAE,CAAC;UAAEL,KAAK;UAAEM,IAAI,EAAEP,OAAO,EAAEO,IAAI,IAAI;QAAE,CAAE;OAC7C;MACD,OAAO;QACLvB,YAAY;QACZqB,KAAK;QACL;QACA;QACA;QACA;QACA;QACA;QACAnB,OAAO,EAAE,IAAIS,GAAG,CAACT,OAAO,CAAC;QACzB;QACA;QACA;QACA;QACA;QACA;QACAsB,MAAM,EAAEA,CAACC,KAAK,EAAEC,OAAqB,KAAI;UACvC,MAAMpB,IAAI,GAAGH,KAAK,CAACwB,GAAG,CAACD,OAAO,CAACE,SAAS,CAACC,KAAK,CAACrB,IAAI,CAAC;UACpD,OAAOF,IAAI,KAAKwB,SAAS,GAAGL,KAAK,GAAGnB,IAAI,CAACmB,KAAU,EAAEC,OAAO,CAACK,OAAO,CAAC;QACvE;OACD;IACH;GACD,CAAC;EACF;EACA;EACA,OAAO9B,IAAI,CAAQ,IAAIU,GAAG,EAAE,EAAE,IAAIA,GAAG,EAAE,CAAC;AAC1C,CAAC","ignoreList":[]}
+{"version":3,"file":"projection.js","names":["EventType","projection","initialState","make","schemas","folds","on","def","fold","has","type","Error","nextSchemas","Map","set","schema","nextFolds","build","options","types","keys","map","t","query","items","tags","evolve","state","decoded","get","sequenced","event","undefined","payload"],"sources":["../../src/projection.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;AAmBA,SAGEA,SAAS,QAGJ,iBAAiB;AAoCxB;;;;AAIA,OAAO,MAAMC,UAAU,GAAOC,YAAe,IAAiC;EAC5E;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,IAAI,GAAGA,CACXC,OAAwD,EACxDC,KAA6D,MAChC;IAC7BC,EAAE,EAAEA,CACFC,GAAuB,EACvBC,IAAiC,KACD;MAChC;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,IAAIJ,OAAO,CAACK,GAAG,CAACF,GAAG,CAACG,IAAI,CAAC,EAAE;QACzB,MAAM,IAAIC,KAAK,CACb,yBAAyBJ,GAAG,CAACG,IAAI,mCAAmC,GAClE,gEAAgE,GAChE,gCAAgC,CACnC;MACH;MACA;MACA;MACA;MACA;MACA;MACA;MACA,MAAME,WAAW,GAAG,IAAIC,GAAG,CACzBT,OAAO,CACR;MACD;MACA;MACA;MACA;MACA;MACA;MACA;MACAQ,WAAW,CAACE,GAAG,CAACP,GAAG,CAACG,IAAI,EAAEH,GAAG,CAACQ,MAAM,CAAC;MACrC,MAAMC,SAAS,GAAG,IAAIH,GAAG,CAACR,KAAK,CAAC;MAChC;MACA;MACA;MACAW,SAAS,CAACF,GAAG,CAACP,GAAG,CAACG,IAAI,EAAEF,IAAyC,CAAC;MAClE,OAAOL,IAAI,CAASS,WAAW,EAAEI,SAAS,CAAC;IAC7C,CAAC;IACDC,KAAK,EAAGC,OAAO,IAAI;MACjB;MACA;MACA,MAAMC,KAAK,GAAG,CAAC,GAAGf,OAAO,CAACgB,IAAI,EAAE,CAAC,CAACC,GAAG,CAAEC,CAAC,IAAKtB,SAAS,CAACG,IAAI,CAACmB,CAAC,CAAC,CAAC;MAC/D,MAAMC,KAAK,GAAU;QACnBC,KAAK,EAAE,CAAC;UAAEL,KAAK;UAAEM,IAAI,EAAEP,OAAO,EAAEO,IAAI,IAAI;QAAE,CAAE;OAC7C;MACD,OAAO;QACLvB,YAAY;QACZqB,KAAK;QACL;QACA;QACA;QACA;QACA;QACA;QACAnB,OAAO,EAAE,IAAIS,GAAG,CAACT,OAAO,CAAC;QACzB;QACA;QACA;QACA;QACA;QACA;QACAsB,MAAM,EAAEA,CAACC,KAAK,EAAEC,OAAqB,KAAI;UACvC,MAAMpB,IAAI,GAAGH,KAAK,CAACwB,GAAG,CAACD,OAAO,CAACE,SAAS,CAACC,KAAK,CAACrB,IAAI,CAAC;UACpD,OAAOF,IAAI,KAAKwB,SAAS,GAAGL,KAAK,GAAGnB,IAAI,CAACmB,KAAU,EAAEC,OAAO,CAACK,OAAO,CAAC;QACvE;OACD;IACH;GACD,CAAC;EACF;EACA;EACA,OAAO9B,IAAI,CAAQ,IAAIU,GAAG,EAAE,EAAE,IAAIA,GAAG,EAAE,CAAC;AAC1C,CAAC","ignoreList":[]}

package/dist/esm/readLedger.js

@@ -1,4 +1,4 @@
-import { composeProjections, ORIGIN, servableQueryFault, unionQueries } from '@kairos-es/core';
+import { composeProjections, ORIGIN, servableQueryFault, unionQueries, unknownQueryKeyFault } from '@kairos-es/core';
 import { Context, Data, Effect, Layer, Option, Ref } from 'effect';
 /**
  * The ambient ledger, present only inside a bracket.
@@ -8,7 +8,7 @@ import { Context, Data, Effect, Layer, Option, Ref } from 'effect';
  * requirement channel nothing is exactly what makes this change additive.
  * `modelAtHead` is that path and is why the rule exists.
  *
- * A BRACKET-ONLY function is the opposite case and yields the tag deliberately.
+ * A BRACKET-ONLY function is the opposite case and yields the service deliberately.
  * `decideOnly` does, and naming the requirement is what turns *"call me inside a
  * bracket"* from a runtime defect into a compile error — presence being the one
  * direction the type system can decide here. So the test is what the function
@@ -18,7 +18,7 @@ import { Context, Data, Effect, Layer, Option, Ref } from 'effect';
  * Recording is two-phase, and `record`'s own doc below owns why and what shape the
  * second phase takes.
  */
-export class ReadLedger extends /*#__PURE__*/Context.Tag('@kairos-es/codec/ReadLedger')() {}
+export class ReadLedger extends /*#__PURE__*/Context.Service()('@kairos-es/codec/ReadLedger') {}
 /**
  * Raised when a bracket closes having recorded no read at all.
  *
@@ -163,8 +163,23 @@ const NO_CLOSE = () => Effect.void;
 export const recordQuery = query => withLedger(NO_CLOSE, ledger => ledger.record(query));
 /** The tagless slice keys in a record, in declaration order. */
 const taglessKeys = projections => Object.entries(projections).filter(([, projection]) => projection.query.items.some(item => item.tags.length === 0)).map(([key]) => key);
-/** Would recording this record's query leave the accumulated union unservable? */
-const unionWouldBeUnservable = (existing, incoming) => servableQueryFault(unionQueries([...existing.map(h => h.query), incoming])) !== undefined;
+/**
+ * Would recording this record's query leave the accumulated union unservable in
+ * its SHAPE — the one fault a slice's tags can fix, and so the one this ledger
+ * reports?
+ *
+ * An unknown key anywhere in the union answers no. It is not a tagless slice and no
+ * slice's tags would fix it, and the store refuses it as a defect naming the key at
+ * the read of the hop that carries it, so an earlier hop's key has already been
+ * refused once by the time a later record is judged. Judged here it would surface
+ * as this ledger's error, on the error channel, naming a slice with nothing wrong
+ * with it — and a hop is recorded before its read runs, so an earlier hop's key
+ * would go on doing that to every clean read after it.
+ */
+const unionWouldBeUnservable = (existing, incoming) => {
+  const union = unionQueries([...existing.map(h => h.query), incoming]);
+  return unknownQueryKeyFault(union) === undefined && servableQueryFault(union) !== undefined;
+};
 /**
  * Refuse a read that would leave the bracket's accumulated union unservable,
  * BEFORE the read is paid for.
@@ -208,5 +223,5 @@ export const assertServableAddition = projections => withLedger(undefined, ledge
  * current behaviour is the hazard derives from every hop the bracket walked rather
  * than from its own single read.
  */
-export const ambientLayeredCondition = /*#__PURE__*/withLedger(/*#__PURE__*/Option.none(), ledger => Effect.map(ledger.hops, hops => Option.fromNullable(deriveLayeredCondition(hops))));
+export const ambientLayeredCondition = /*#__PURE__*/withLedger(/*#__PURE__*/Option.none(), ledger => Effect.map(ledger.hops, hops => Option.fromNullishOr(deriveLayeredCondition(hops))));
 //# sourceMappingURL=readLedger.js.map

package/dist/esm/readLedger.js.map

@@ -1 +1 @@
-{"version":3,"file":"readLedger.js","names":["composeProjections","ORIGIN","servableQueryFault","unionQueries","Context","Data","Effect","Layer","Option","Ref","ReadLedger","Tag","NoReadsRecorded","TaggedError","message","TaglessSliceInLedger","sliceKey","deriveLayeredCondition","hops","length","undefined","merged","map","hop","query","arrived","flatMap","head","after","reduce","a","b","failIfEventsMatch","makeReadLedger","gen","ref","make","layer","succeed","record","modify","update","current","index","get","withLedger","absent","f","serviceOption","ledger","isNone","value","NO_CLOSE","void","recordQuery","taglessKeys","projections","Object","entries","filter","projection","items","some","item","tags","key","unionWouldBeUnservable","existing","incoming","h","assertServableAddition","offending","ambientLayeredCondition","none","fromNullable"],"sources":["../../src/readLedger.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"readLedger.js","names":["composeProjections","ORIGIN","servableQueryFault","unionQueries","unknownQueryKeyFault","Context","Data","Effect","Layer","Option","Ref","ReadLedger","Service","NoReadsRecorded","TaggedError","message","TaglessSliceInLedger","sliceKey","deriveLayeredCondition","hops","length","undefined","merged","map","hop","query","arrived","flatMap","head","after","reduce","a","b","failIfEventsMatch","makeReadLedger","gen","ref","make","layer","succeed","record","modify","update","current","index","get","withLedger","absent","f","serviceOption","ledger","isNone","value","NO_CLOSE","void","recordQuery","taglessKeys","projections","Object","entries","filter","projection","items","some","item","tags","key","unionWouldBeUnservable","existing","incoming","union","h","assertServableAddition","offending","ambientLayeredCondition","none","fromNullishOr"],"sources":["../../src/readLedger.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","names":["Effect","deserialiseThenDecode","UnknownEventType","Serializer","makeRegistry","defs","map","Map","def","has","type","Error","set","schema","decode","event","gen","get","undefined","fail","serializer","payload","data"],"sources":["../../src/registry.ts"],"sourcesContent":[null],"mappings":"AA2BA,SAASA,MAAM,QAAqB,QAAQ;AAC5C,SAASC,qBAAqB,QAAQ,4BAAyB;AAC/D,SAA0BC,gBAAgB,QAAQ,aAAU;AAE5D,SAASC,UAAU,QAAQ,iBAAc;AAqBzC,OAAO,MAAMC,YAAY,GACvBC,IAAU,IAC2B;EACrC,MAAMC,GAAG,GAAG,IAAIC,GAAG,EAAoD;EACvE,KAAK,MAAMC,GAAG,IAAIH,IAAI,EAAE;IACtB,IAAIC,GAAG,CAACG,GAAG,CAACD,GAAG,CAACE,IAAI,CAAC,EAAE;MACrB,MAAM,IAAIC,KAAK,CAAC,yBAAyBH,GAAG,CAACE,IAAI,eAAe,CAAC;IACnE;IACAJ,GAAG,CAACM,GAAG,CAACJ,GAAG,CAACE,IAAI,EAAEF,GAAG,CAACK,MAAM,CAAC;EAC/B;EACA,OAAO;IACLC,MAAM,EAAGC,KAAK,IACZf,MAAM,CAACgB,GAAG,CAAC,aAAS;MAClB,MAAMH,MAAM,GAAGP,GAAG,CAACW,GAAG,CAACF,KAAK,CAACL,IAAI,CAAC;MAClC,IAAIG,MAAM,KAAKK,SAAS,EAAE;QACxB,OAAO,OAAOlB,MAAM,CAACmB,IAAI,CAAC,IAAIjB,gBAAgB,CAAC;UAAEQ,IAAI,EAAEK,KAAK,CAACL;QAAI,CAAE,CAAC,CAAC;MACvE;MACA,MAAMU,UAAU,GAAG,OAAOjB,UAAU;MACpC,MAAMkB,OAAO,GAAG,OAAOpB,qBAAqB,CAC1CmB,UAAU,EACVP,MAAM,EACNE,KAAK,CAACO,IAAI,CACX;MACD,OAAO;QAAEZ,IAAI,EAAEK,KAAK,CAACL,IAAI;QAAEW;MAAO,CAAE;MACpC;MACA;MACA;MACA;IACF,CAAC;GAKJ;AACH,CAAC","ignoreList":[]}
+{"version":3,"file":"registry.js","names":["Effect","deserialiseThenDecode","UnknownEventType","Serializer","makeRegistry","defs","map","Map","def","has","type","Error","set","schema","decode","event","gen","get","undefined","fail","serializer","payload","data"],"sources":["../../src/registry.ts"],"sourcesContent":[null],"mappings":"AA2BA,SAASA,MAAM,QAAqB,QAAQ;AAC5C,SAASC,qBAAqB,QAAQ,4BAAyB;AAC/D,SAA0BC,gBAAgB,QAAQ,aAAU;AAE5D,SAASC,UAAU,QAAQ,iBAAc;AAqBzC,OAAO,MAAMC,YAAY,GACvBC,IAAU,IAC2B;EACrC,MAAMC,GAAG,GAAG,IAAIC,GAAG,EAA4C;EAC/D,KAAK,MAAMC,GAAG,IAAIH,IAAI,EAAE;IACtB,IAAIC,GAAG,CAACG,GAAG,CAACD,GAAG,CAACE,IAAI,CAAC,EAAE;MACrB,MAAM,IAAIC,KAAK,CAAC,yBAAyBH,GAAG,CAACE,IAAI,eAAe,CAAC;IACnE;IACAJ,GAAG,CAACM,GAAG,CAACJ,GAAG,CAACE,IAAI,EAAEF,GAAG,CAACK,MAAM,CAAC;EAC/B;EACA,OAAO;IACLC,MAAM,EAAGC,KAAK,IACZf,MAAM,CAACgB,GAAG,CAAC,aAAS;MAClB,MAAMH,MAAM,GAAGP,GAAG,CAACW,GAAG,CAACF,KAAK,CAACL,IAAI,CAAC;MAClC,IAAIG,MAAM,KAAKK,SAAS,EAAE;QACxB,OAAO,OAAOlB,MAAM,CAACmB,IAAI,CAAC,IAAIjB,gBAAgB,CAAC;UAAEQ,IAAI,EAAEK,KAAK,CAACL;QAAI,CAAE,CAAC,CAAC;MACvE;MACA,MAAMU,UAAU,GAAG,OAAOjB,UAAU;MACpC,MAAMkB,OAAO,GAAG,OAAOpB,qBAAqB,CAC1CmB,UAAU,EACVP,MAAM,EACNE,KAAK,CAACO,IAAI,CACX;MACD,OAAO;QAAEZ,IAAI,EAAEK,KAAK,CAACL,IAAI;QAAEW;MAAO,CAAE;MACpC;MACA;MACA;MACA;IACF,CAAC;GAKJ;AACH,CAAC","ignoreList":[]}

package/dist/esm/toEvent.js

@@ -1,5 +1,27 @@
-import { DateTime, Effect, Schema } from 'effect';
+/**
+ * Event production (codec edge-helper): turn a typed payload into a wire
+ * `DcbEvent`. Encode is `Schema.encodeEffect(def.schema)` (a `SchemaError`
+ * becomes a `CodecError`; any encryption transform runs here, *before* serialisation)
+ * then `serialiser.serialise`. The wire `tags` are derived from the def's
+ * required `tagsFor` mapper (ADR-0006) — they are never hand-passed, so two
+ * command sites emitting the same event type cannot tag it differently. A mapper
+ * that throws (e.g. an ill-formed `key:value` rejected by `Tag.make`) is
+ * surfaced on the `CodecError` channel, not as a defect. `uuid`
+ * comes from `options.uuid` or the `Uuid` service; `occurredAt` from
+ * `options.occurredAt` or the Effect clock (`DateTime.now`), keeping `core`
+ * clock- and RNG-free while staying overridable for backdated imports.
+ * `metadata` comes from `options.metadata` or the OPTIONAL ambient
+ * `MetadataSource` service, and is `{}` when neither supplies it (ADR-0017). A
+ * bag core's `Metadata` schema refuses, such as one holding a value that is not a
+ * string, fails on the `CodecError` channel (`reason: 'metadata'`), whichever of
+ * the two supplied it. It never reaches `tagsFor`, the
+ * event's schema or the serialiser, so it can enter neither the tag junction
+ * table nor the encryption seam.
+ */
+import { Metadata } from '@kairos-es/core';
+import { DateTime, Effect, Option, Schema } from 'effect';
 import { CodecError } from "./errors.js";
+import { MetadataSource } from "./MetadataSource.js";
 import { Serializer } from "./Serializer.js";
 import { Uuid } from "./Uuid.js";
 /**
@@ -10,10 +32,40 @@ import { Uuid } from "./Uuid.js";
  * wire-envelope fields (the query surface), so a `tagsFor` mapper may only key
  * off cleartext payload fields (ADR-0006). `uuid` / `occurredAt` are
  * exact-optional overrides; absent, they come from the `Uuid` service and the
- * Effect clock.
+ * Effect clock. `metadata` is an exact-optional override too; absent, it comes
+ * from the ambient `MetadataSource` if one is provided and is `{}` otherwise.
+ * The ambient read adds nothing to the requirement channel. A bag core's
+ * `Metadata` schema refuses fails as a `CodecError` with `reason: 'metadata'`.
  */
 export const toEvent = (def, payload, options) => Effect.gen(function* () {
-  // Derive tags first. A mapper is app code that can throw (e.g. `Tag.make`
+  // Resolve metadata before anything else. Per-call wins, ambient fills,
+  // absent yields `{}`. `serviceOption` keeps `MetadataSource` out of the
+  // requirement channel.
+  //
+  // The bag is then CHECKED against core's `Metadata` schema, whichever arm
+  // supplied it. The type holds a typed caller to a bag of strings, but an
+  // `any` or untyped JavaScript gets past it, and the engines then disagree
+  // about what they stored: the cross-engine parity of this field rests on its
+  // values being strings, and this is the one place a value is refused. It is
+  // refused HERE, at write, and never on read: a read-side check would make an
+  // event the store had accepted unreadable for ever. A bad bag is the
+  // caller's mistake, so it fails on the `CodecError` channel exactly as a
+  // throwing `tagsFor` does, never as a defect. Checking consumes no sequence,
+  // so placing it above the tag derivation leaves the property below intact.
+  //
+  // The bag is COPIED, never stamped by reference: an ambient bag would
+  // otherwise be ONE object shared by every event of a request, and the
+  // caller's own object would be shared with the event it built, so a mutation
+  // of either before the append would rewrite the other. (After the append no
+  // store shares anything with its caller; that is each store's guarantee.)
+  const given = options?.metadata === undefined ? Option.getOrElse(yield* Effect.serviceOption(MetadataSource), () => ({})) : options.metadata;
+  const metadata = {
+    ...(yield* Schema.decodeUnknownEffect(Metadata)(given).pipe(Effect.mapError(cause => new CodecError({
+      reason: 'metadata',
+      cause
+    }))))
+  };
+  // Derive tags next. A mapper is app code that can throw (e.g. `Tag.make`
   // rejects an ill-formed `key:value`), and the codec's contract is that such
   // failures are values on the `CodecError` channel, never defects (errors.ts).
   // Deriving before the uuid/clock effects also means a bad tag fails without
@@ -26,7 +78,7 @@ export const toEvent = (def, payload, options) => Effect.gen(function* () {
     })
   });
   const serializer = yield* Serializer;
-  const encoded = yield* Schema.encode(def.schema)(payload).pipe(Effect.mapError(cause => new CodecError({
+  const encoded = yield* Schema.encodeEffect(def.schema)(payload).pipe(Effect.mapError(cause => new CodecError({
     reason: 'encode',
     cause
   })));
@@ -38,7 +90,8 @@ export const toEvent = (def, payload, options) => Effect.gen(function* () {
     data,
     tags,
     uuid,
-    occurredAt
+    occurredAt,
+    metadata
   };
 });
 //# sourceMappingURL=toEvent.js.map

package/dist/esm/toEvent.js.map

@@ -1 +1 @@
-{"version":3,"file":"toEvent.js","names":["DateTime","Effect","Schema","CodecError","Serializer","Uuid","toEvent","def","payload","options","gen","tags","try","tagsFor","catch","cause","reason","serializer","encoded","encode","schema","pipe","mapError","data","serialise","uuid","generate","occurredAt","now","type"],"sources":["../../src/toEvent.ts"],"sourcesContent":[null],"mappings":"AAcA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,MAAM,QAAQ,QAAQ;AACjD,SAASC,UAAU,QAAQ,aAAU;AAErC,SAASC,UAAU,QAAQ,iBAAc;AACzC,SAASC,IAAI,QAAQ,WAAQ;AAE7B;;;;;;;;;;AAUA,OAAO,MAAMC,OAAO,GAAGA,CACrBC,GAAsB,EACtBC,OAAU,EACVC,OAGC,KAEDR,MAAM,CAACS,GAAG,CAAC,aAAS;EAClB;EACA;EACA;EACA;EACA;EACA,MAAMC,IAAI,GAAG,OAAOV,MAAM,CAACW,GAAG,CAAC;IAC7BA,GAAG,EAAEA,CAAA,KAAML,GAAG,CAACM,OAAO,CAACL,OAAO,CAAC;IAC/BM,KAAK,EAAGC,KAAK,IAAK,IAAIZ,UAAU,CAAC;MAAEa,MAAM,EAAE,MAAM;MAAED;IAAK,CAAE;GAC3D,CAAC;EACF,MAAME,UAAU,GAAG,OAAOb,UAAU;EACpC,MAAMc,OAAO,GAAG,OAAOhB,MAAM,CAACiB,MAAM,CAACZ,GAAG,CAACa,MAAM,CAAC,CAACZ,OAAO,CAAC,CAACa,IAAI,CAC5DpB,MAAM,CAACqB,QAAQ,CAAEP,KAAK,IAAK,IAAIZ,UAAU,CAAC;IAAEa,MAAM,EAAE,QAAQ;IAAED;EAAK,CAAE,CAAC,CAAC,CACxE;EACD,MAAMQ,IAAI,GAAGN,UAAU,CAACO,SAAS,CAACN,OAAO,CAAC;EAC1C,MAAMO,IAAI,GAAGhB,OAAO,EAAEgB,IAAI,KAAK,OAAO,CAAC,OAAOpB,IAAI,EAAEqB,QAAQ,CAAC;EAC7D,MAAMC,UAAU,GAAGlB,OAAO,EAAEkB,UAAU,KAAK,OAAO3B,QAAQ,CAAC4B,GAAG,CAAC;EAC/D,OAAO;IACLC,IAAI,EAAEtB,GAAG,CAACsB,IAAI;IACdN,IAAI;IACJZ,IAAI;IACJc,IAAI;IACJE;GACD;AACH,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"toEvent.js","names":["Metadata","DateTime","Effect","Option","Schema","CodecError","MetadataSource","Serializer","Uuid","toEvent","def","payload","options","gen","given","metadata","undefined","getOrElse","serviceOption","decodeUnknownEffect","pipe","mapError","cause","reason","tags","try","tagsFor","catch","serializer","encoded","encodeEffect","schema","data","serialise","uuid","generate","occurredAt","now","type"],"sources":["../../src/toEvent.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;AAoBA,SAAwBA,QAAQ,QAAQ,iBAAiB;AACzD,SAASC,QAAQ,EAAEC,MAAM,EAAEC,MAAM,EAAEC,MAAM,QAAQ,QAAQ;AACzD,SAASC,UAAU,QAAQ,aAAU;AAErC,SAASC,cAAc,QAAQ,qBAAkB;AACjD,SAASC,UAAU,QAAQ,iBAAc;AACzC,SAASC,IAAI,QAAQ,WAAQ;AAE7B;;;;;;;;;;;;;AAaA,OAAO,MAAMC,OAAO,GAAGA,CACrBC,GAAsB,EACtBC,OAAU,EACVC,OAIC,KAEDV,MAAM,CAACW,GAAG,CAAC,aAAS;EAClB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,KAAK,GACTF,OAAO,EAAEG,QAAQ,KAAKC,SAAS,GAC3Bb,MAAM,CAACc,SAAS,CACd,OAAOf,MAAM,CAACgB,aAAa,CAACZ,cAAc,CAAC,EAC3C,OAAiB,EAAE,CAAC,CACrB,GACDM,OAAO,CAACG,QAAQ;EACtB,MAAMA,QAAQ,GAAa;IACzB,IAAI,OAAOX,MAAM,CAACe,mBAAmB,CAACnB,QAAQ,CAAC,CAACc,KAAK,CAAC,CAACM,IAAI,CACzDlB,MAAM,CAACmB,QAAQ,CACZC,KAAK,IAAK,IAAIjB,UAAU,CAAC;MAAEkB,MAAM,EAAE,UAAU;MAAED;IAAK,CAAE,CAAC,CACzD,CACF;GACF;EACD;EACA;EACA;EACA;EACA;EACA,MAAME,IAAI,GAAG,OAAOtB,MAAM,CAACuB,GAAG,CAAC;IAC7BA,GAAG,EAAEA,CAAA,KAAMf,GAAG,CAACgB,OAAO,CAACf,OAAO,CAAC;IAC/BgB,KAAK,EAAGL,KAAK,IAAK,IAAIjB,UAAU,CAAC;MAAEkB,MAAM,EAAE,MAAM;MAAED;IAAK,CAAE;GAC3D,CAAC;EACF,MAAMM,UAAU,GAAG,OAAOrB,UAAU;EACpC,MAAMsB,OAAO,GAAG,OAAOzB,MAAM,CAAC0B,YAAY,CAACpB,GAAG,CAACqB,MAAM,CAAC,CAACpB,OAAO,CAAC,CAACS,IAAI,CAClElB,MAAM,CAACmB,QAAQ,CAAEC,KAAK,IAAK,IAAIjB,UAAU,CAAC;IAAEkB,MAAM,EAAE,QAAQ;IAAED;EAAK,CAAE,CAAC,CAAC,CACxE;EACD,MAAMU,IAAI,GAAGJ,UAAU,CAACK,SAAS,CAACJ,OAAO,CAAC;EAC1C,MAAMK,IAAI,GAAGtB,OAAO,EAAEsB,IAAI,KAAK,OAAO,CAAC,OAAO1B,IAAI,EAAE2B,QAAQ,CAAC;EAC7D,MAAMC,UAAU,GAAGxB,OAAO,EAAEwB,UAAU,KAAK,OAAOnC,QAAQ,CAACoC,GAAG,CAAC;EAC/D,OAAO;IACLC,IAAI,EAAE5B,GAAG,CAAC4B,IAAI;IACdN,IAAI;IACJR,IAAI;IACJU,IAAI;IACJE,UAAU;IACVrB;GACD;AACH,CAAC,CAAC","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kairos-es/codec",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.5",
   "description": "Schema-first codec with encryption seam for kairos-es",
   "license": "BSD-3-Clause",
   "repository": {
@@ -11,17 +11,22 @@
   "sideEffects": [],
   "homepage": "https://github.com/neverbland/kairos-es",
   "peerDependencies": {
-    "effect": "^3.22.0",
-    "@kairos-es/core": "^1.0.0-alpha.3"
+    "effect": "^4.0.5",
+    "@kairos-es/core": "^1.0.0-alpha.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"
+      }
     },
     "./package.json": "./package.json"
   },

package/src/MetadataSource.ts

@@ -0,0 +1,43 @@
+/**
+ * The ambient metadata service: an OPTIONAL source of the `metadata` bag that
+ * `toEvent` stamps on an event when the call itself passes none (ADR-0017).
+ *
+ * An application provides it once, at the edge of a unit of work — an HTTP
+ * request, a job — and every event appended inside that scope carries the bag
+ * with no command handler, decider or `toEvent` call site mentioning it:
+ *
+ * ```ts
+ * handleRequest.pipe(
+ *   Effect.provideService(MetadataSource, { traceparent: header }),
+ * )
+ * ```
+ *
+ * It is read through `Effect.serviceOption`, never `yield* MetadataSource`, and
+ * that choice is the whole design. `serviceOption` returns `Effect<Option<…>>`
+ * with BOTH the requirement and the error channel as `never`, so this tag never
+ * appears in `toEvent`'s requirement channel nor in any signature above it, and
+ * no consumer is forced to provide a layer it does not want. The `Uuid` service
+ * beside this is a REQUIRED tag; adopting that shape here would put a metadata
+ * layer on every consumer of the codec. Core stays a passive carrier: the
+ * ambient read happens here, in the codec, where reading a service breaches no
+ * purity rule.
+ *
+ * A per-call `options.metadata` REPLACES this value rather than merging with it:
+ * per-call wins, ambient fills, and absent yields `{}`. A merge would make the
+ * bag an event carries depend on two sources at once, and a caller who passes a
+ * bag explicitly is stating what the event's bag is.
+ *
+ * One key is reserved, as a convention and not a column: `traceparent`. Reserved
+ * means that when a bag carries W3C trace context it carries it under that key,
+ * holding a W3C `traceparent` header value, so tracing tools match it; kairos
+ * itself never writes or reads it. Every other key is the application's: a key
+ * is kairos's to name only when kairos writes it or a standard owns the
+ * spelling, and `correlationId` / `causationId` are suggested spellings rather
+ * than reserved ones (ADR-0017).
+ */
+import type { Metadata } from '@kairos-es/core'
+import { Context } from 'effect'
+
+export class MetadataSource extends Context.Service<MetadataSource, Metadata>()(
+  '@kairos-es/codec/MetadataSource',
+) {}

package/src/Serializer.ts

@@ -1,7 +1,7 @@
 /**
  * The pluggable serialiser: the `Uint8Array` <-> value boundary applied
- * *outside* `Schema`. Encode is `Schema.encode` then `serialise`; decode is
- * `deserialise` then `Schema.decodeUnknown`. Both codec paths read the same
+ * *outside* `Schema`. Encode is `Schema.encodeEffect` then `serialise`; decode is
+ * `deserialise` then `Schema.decodeUnknownEffect`. Both codec paths read the same
  * `Serializer` from context, so encode and decode cannot mismatch; swapping
  * JSON for msgpack is a different layer with no schema or call-site changes.
  *
@@ -12,13 +12,13 @@
  */
 import { Context, Layer } from 'effect'
 
-export class Serializer extends Context.Tag('@kairos-es/codec/Serializer')<
+export class Serializer extends Context.Service<
   Serializer,
   {
     readonly serialise: (v: unknown) => Uint8Array
     readonly deserialise: (b: Uint8Array) => unknown
   }
->() {}
+>()('@kairos-es/codec/Serializer') {}
 
 const encoder = new TextEncoder()
 const decoder = new TextDecoder()

package/src/Uuid.ts

@@ -12,10 +12,10 @@
 import { makeSequentialUuid } from '@kairos-es/core/testing'
 import { Context, Effect, Layer } from 'effect'
 
-export class Uuid extends Context.Tag('@kairos-es/codec/Uuid')<
+export class Uuid extends Context.Service<
   Uuid,
   { readonly generate: Effect.Effect<string> }
->() {}
+>()('@kairos-es/codec/Uuid') {}
 
 /** Live uuid generation via WebCrypto (no `node:crypto`). */
 export const UuidLive: Layer.Layer<Uuid> = Layer.succeed(Uuid, {
@@ -25,9 +25,12 @@ export const UuidLive: Layer.Layer<Uuid> = Layer.succeed(Uuid, {
 /**
  * A deterministic uuid layer for suites, wrapping core's shared
  * `makeSequentialUuid` (the single source of truth for the counter scheme).
- * Each layer instance builds a fresh generator, so it owns its own counter and
+ * Each BUILD of the layer makes a fresh generator, so it owns its own counter and
  * yields a stable v4-shaped sequence `00000000-0000-4000-8000-<12 hex>` starting
- * at `...000000000000`. Generation is wrapped in `Effect.sync` because the
+ * at `...000000000000`. A build is not one per `Effect.provide`: Effect memoises
+ * a layer across the provisions that share a memo map, so a nested second
+ * provision of this layer continues the counter rather than restarting it, and
+ * `Layer.fresh` is the way to ask for a restart. Generation is wrapped in `Effect.sync` because the
  * generator advances its counter (a side effect on each call).
  */
 export const UuidTest: Layer.Layer<Uuid> = Layer.sync(Uuid, () => {

package/src/decider.ts

@@ -39,7 +39,7 @@
  * append condition the read produced. That IS the optimistic-concurrency
  * contract, in production and in a scenario alike — which is also why the
  * Given/When/Then surface built on it exercises the real fold and the real store
- * rather than a mock. It is a free function rather than a `Context.Tag` service,
+ * rather than a mock. It is a free function rather than a `Context.Service`,
  * so it is still not the "production command-runner service method" a retrying
  * `Layer` would need (ADR-0008): the correct retry remains
  * `retryOnConflict(runDecider(...))`, wrapping the whole cycle so a fresh read
@@ -152,7 +152,7 @@ export interface Decider<
  * unioning them. Against the shaped target `E` therefore came out as whichever
  * branch won, and every other branch was then rejected against it. Inference to
  * a NAKED type variable takes the union whole, which is why `Eff` is the
- * parameter and `Effect.Effect.Error` / `Effect.Effect.Context` recover the two
+ * parameter and `Effect.Error` / `Effect.Services` recover the two
  * channels afterwards: those do distribute across a union of effects.
  *
  * The constraint on `Eff` is load-bearing twice over. It is what still refuses a
@@ -190,9 +190,9 @@ export interface Decider<
  * them in would state the same requirement twice and make an ordinary decider
  * read as though it carried an extra one, though the set `runDecider` ends up
  * asking for is identical either way. The exclusion cannot swallow a caller's
- * own service by accident: a `Context.Tag`'s requirement type carries its key as
- * a literal `Id` field, so only a tag declared under `@kairos-es/codec/Uuid` or
- * `@kairos-es/codec/Serializer` matches — and a tag under that key IS that
+ * own service by accident: a `Context.Service` class's requirement type carries
+ * its key as a literal `key` field, so only a service declared under `@kairos-es/codec/Uuid` or
+ * `@kairos-es/codec/Serializer` matches — and a service under that key IS that
  * service, context being keyed by the same string at runtime.
  */
 export function decider<
@@ -209,8 +209,8 @@ export function decider<
 ): Decider<
   P,
   Command,
-  Effect.Effect.Error<Eff>,
-  Exclude<Effect.Effect.Context<Eff>, Serializer | Uuid>
+  Effect.Error<Eff>,
+  Exclude<Effect.Services<Eff>, Serializer | Uuid>
 >
 export function decider<
   P extends Record<string, SliceProjection>,
@@ -222,8 +222,8 @@ export function decider<
 ): Decider<
   P,
   Command,
-  Effect.Effect.Error<Eff>,
-  Exclude<Effect.Effect.Context<Eff>, Serializer | Uuid>,
+  Effect.Error<Eff>,
+  Exclude<Effect.Services<Eff>, Serializer | Uuid>,
   DecisionOutput
 >
 export function decider<P extends Record<string, SliceProjection>, Command>(

package/src/decision.ts

@@ -66,7 +66,7 @@
  *   channels; an overloaded step would lose both to `unknown`.
  *
  * `decider(…)` cannot be served by a conditional at all. Its `O` is derived from
- * the SUCCESS of an effect type variable, and `Effect.Effect.Success` of a type
+ * the SUCCESS of an effect type variable, and `Effect.Success` of a type
  * variable is itself deferred, so a wrapper that copies `decider`'s own generics
  * would get a `Decider` whose `O` nothing can resolve, and a runner result that
  * is not `Position`. So `decider` is declared TWICE, which asks the question by

package/src/decisionModel.ts

@@ -152,7 +152,7 @@ export const modelAtHead = <T extends Record<string, SliceProjection>>(
 
     const state = (yield* Stream.runFold(
       decoded,
-      composite.initialState,
+      () => composite.initialState,
       (acc, event) => composite.evolve(acc, event),
     )) as CompositeState<T>
 

package/src/decode.ts

@@ -20,10 +20,10 @@
  * than memory.
  *
  * Be precise about what adding `concurrency` here would and would not cost,
- * because the obvious reason is the wrong one. Effect v3's `mapEffect` is
+ * because the obvious reason is the wrong one. Effect's `mapEffect` is
  * order-PRESERVING even when concurrent — reordering needs the separate
- * `unordered: true` option (verified against the installed
- * `effect@3.22`'s `Stream.d.ts`, and probed at runtime) — so a bare
+ * `unordered: true` option (verified against `effect@4`'s `Channel.mapEffect`,
+ * which takes the ordered path unless that option is set) — so a bare
  * `concurrency` would NOT hand the fold its events out of position order. What
  * it would actually cost is the back-pressure above, and it would run
  * application-authored `Schema` transforms (an ADR-0004 decryption hook, say)
@@ -84,9 +84,9 @@ import { Serializer } from './Serializer'
  * last, an ordering the record does not express and its author never chose.
  * Every event of that type is then decoded against the wrong def for one of the
  * slices, and where the two shapes overlap that failure is SILENT rather than a
- * `CodecError`: `Schema.decodeUnknown` defaults `onExcessProperty` to `'ignore'`
- * (`effect@3.22`'s `ParseResult.ts` runs its excess-key loop only under
- * `'error'` or `'preserve'`), so a field the other def declared is dropped, not
+ * `CodecError`: `Schema.decodeUnknownEffect` defaults `onExcessProperty` to
+ * `'ignore'` (`effect@4`'s `SchemaAST.ts` runs its excess-key loop only under
+ * `'error'`), so a field the other def declared is dropped, not
  * reported, and the fold downstream is handed a payload quietly missing it.
  *
  * **Why a throw, and why here rather than at the read side's wiring gate.**
@@ -100,8 +100,8 @@ import { Serializer } from './Serializer'
  * the write path merges before its first `store.read`, and the read side
  * merges after that gate and before it forks the pipeline — and inside
  * their `Effect.gen`s a throw becomes a DEFECT rather than an escaping exception
- * (`effect@3.22`'s `fiberRuntime.ts` run loop converts a thrown value with
- * `core.die`), which is the classification a mis-wiring already has on both
+ * (`effect@4`'s fibre run loop catches a thrown value and converts it with
+ * `exitDie`), which is the classification a mis-wiring already has on both
  * sides of the library.
  *
  * The sentence names BOTH slices. The two halves of this mistake are in
@@ -120,11 +120,8 @@ import { Serializer } from './Serializer'
  */
 const mergeSliceSchemas = <T extends Record<string, SliceProjection>>(
   projections: T,
-): ReadonlyMap<string, Schema.Schema<unknown, unknown, RequirementOf<T>>> => {
-  const schemas = new Map<
-    string,
-    Schema.Schema<unknown, unknown, RequirementOf<T>>
-  >()
+): ReadonlyMap<string, Schema.Decoder<unknown, RequirementOf<T>>> => {
+  const schemas = new Map<string, Schema.Decoder<unknown, RequirementOf<T>>>()
   // Which slice contributed each entry, kept in lockstep with `schemas` purely
   // so the refusal can name both sides of a collision. Its presence is also what
   // the check below reads, rather than a second `schemas.has`, so the narrowing
@@ -142,10 +139,7 @@ const mergeSliceSchemas = <T extends Record<string, SliceProjection>>(
             'only by sharing one EventDef.',
         )
       }
-      schemas.set(
-        type,
-        schema as Schema.Schema<unknown, unknown, RequirementOf<T>>,
-      )
+      schemas.set(type, schema as Schema.Decoder<unknown, RequirementOf<T>>)
       contributedBy.set(type, key)
     }
   }
@@ -181,7 +175,7 @@ const mergeSliceSchemas = <T extends Record<string, SliceProjection>>(
  * "build the lookup once, reuse the stage" property explicit in the types.
  */
 const decodeEvents =
-  <RS>(schemas: ReadonlyMap<string, Schema.Schema<unknown, unknown, RS>>) =>
+  <RS>(schemas: ReadonlyMap<string, Schema.Decoder<unknown, RS>>) =>
   <E, R>(
     events: Stream.Stream<SequencedEvent, E, R>,
   ): Stream.Stream<DecodedEvent, E | CodecError, R | RS | Serializer> =>