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

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

@@ -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.
  *
@@ -223,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","unknownQueryKeyFault","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","union","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,7 +1,7 @@
 /**
  * Event production (codec edge-helper): turn a typed payload into a wire
- * `DcbEvent`. Encode is `Schema.encode(def.schema)` (a `ParseError` becomes a
- * `CodecError`; any encryption transform runs here, *before* serialisation)
+ * `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
@@ -60,7 +60,7 @@ export const toEvent = (def, payload, options) => Effect.gen(function* () {
   // 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.decodeUnknown(Metadata)(given).pipe(Effect.mapError(cause => new CodecError({
+    ...(yield* Schema.decodeUnknownEffect(Metadata)(given).pipe(Effect.mapError(cause => new CodecError({
       reason: 'metadata',
       cause
     }))))
@@ -78,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
   })));

package/dist/esm/toEvent.js.map

@@ -1 +1 @@
-{"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","decodeUnknown","pipe","mapError","cause","reason","tags","try","tagsFor","catch","serializer","encoded","encode","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,aAAa,CAACnB,QAAQ,CAAC,CAACc,KAAK,CAAC,CAACM,IAAI,CACnDlB,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,MAAM,CAACpB,GAAG,CAACqB,MAAM,CAAC,CAACpB,OAAO,CAAC,CAACS,IAAI,CAC5DlB,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":[]}
+{"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.4",
+  "version": "1.0.0-alpha.6",
   "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.4"
+    "effect": "^4.0.5",
+    "@kairos-es/core": "^1.0.0-alpha.6"
   },
   "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

@@ -38,6 +38,6 @@
 import type { Metadata } from '@kairos-es/core'
 import { Context } from 'effect'
 
-export class MetadataSource extends Context.Tag(
+export class MetadataSource extends Context.Service<MetadataSource, Metadata>()(
   '@kairos-es/codec/MetadataSource',
-)<MetadataSource, Metadata>() {}
+) {}

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> =>

package/src/deserialiseThenDecode.ts

@@ -1,7 +1,7 @@
 /**
  * The two-step every decode in this package performs, in one implementation:
  * deserialise the wire bytes through the `Serializer` its caller already holds,
- * then `Schema.decodeUnknown` the result, each half's failure wrapped as the
+ * then `Schema.decodeUnknownEffect` the result, each half's failure wrapped as the
  * `CodecError` whose `reason` says WHICH half failed.
  *
  * **What it is the single home of.** The two `reason` strings `'deserialise'`
@@ -17,7 +17,7 @@
  * as a function and not as a second test.
  *
  * **The order is contract, not accident.** Deserialise has to run first because
- * `Schema.decodeUnknown` has nothing to read until it has, and the observable
+ * `Schema.decodeUnknownEffect` has nothing to read until it has, and the observable
  * consequence is that the two reasons PARTITION the causes an operator acts on:
  * rotten bytes are always `'deserialise'` and never `'decode'`, so a storage or
  * producer problem never arrives dressed as schema drift. Swapping the labels
@@ -60,8 +60,8 @@ import { CodecError } from './errors'
 import type { Serializer } from './Serializer'
 
 export const deserialiseThenDecode = <R>(
-  serializer: Context.Tag.Service<Serializer>,
-  schema: Schema.Schema<unknown, unknown, R>,
+  serializer: Context.Service.Shape<typeof Serializer>,
+  schema: Schema.Decoder<unknown, R>,
   bytes: Uint8Array,
 ): Effect.Effect<unknown, CodecError, R> =>
   Effect.try({
@@ -69,7 +69,7 @@ export const deserialiseThenDecode = <R>(
     catch: (cause) => new CodecError({ reason: 'deserialise', cause }),
   }).pipe(
     Effect.flatMap((raw) =>
-      Schema.decodeUnknown(schema)(raw).pipe(
+      Schema.decodeUnknownEffect(schema)(raw).pipe(
         Effect.mapError((cause) => new CodecError({ reason: 'decode', cause })),
       ),
     ),

package/src/errors.ts

@@ -3,7 +3,8 @@
  * never defects.
  *
  * `CodecError` covers every serialisation/`Schema` failure on the codec path
- * (deserialise threw, `Schema.decode`/`encode` produced a `ParseError`, a
+ * (deserialise threw, `Schema.decodeUnknownEffect`/`encodeEffect` produced a
+ * `SchemaError`, a
  * wrong/absent encryption key surfaced through a `Schema` transform, or a
  * `tagsFor` mapper threw while deriving an event's tags). It carries a
  * human-readable `reason` and the underlying `cause` (exact-optional).
@@ -42,9 +43,10 @@ export class CodecError extends Data.TaggedError('CodecError')<{
    *
    * A GETTER rather than a second field, so `reason` stays the single declaration.
    * It is visible because `Data.TaggedError`'s constructor is
-   * `super(args?.message, …)` followed by `Object.assign(this, args)` (verified
-   * against `effect@3.22`'s `Data.ts`): the args above carry no `message`, so
-   * nothing shadows this prototype accessor with an own property.
+   * `super(args?.message, …)` followed by copying the args' own enumerable keys
+   * onto the instance (verified against `effect@4`'s `internal/core.ts`): the
+   * args above carry no `message`, so nothing shadows this prototype accessor
+   * with an own property.
    */
   override get message(): string {
     return this.reason

package/src/event.ts

@@ -1,6 +1,6 @@
 /**
  * Event definitions: a tagged `Schema` built through `event(type, fields,
- * tagsFor)`. Each def is a `Schema<Payload, Wire, R>` plus its branded versioned
+ * tagsFor)`. Each def is a `Schema.Codec<Payload, Wire, R, R>` plus its branded versioned
  * `type` (ADR-0005) captured *beside* the payload, and a required `tagsFor`
  * mapper deriving the event's tags from its decoded payload (ADR-0006).
  *
@@ -42,22 +42,32 @@ export type TagsFor<A> = (payload: A) => Arr.NonEmptyReadonlyArray<Tag>
 /**
  * An event definition: its branded `type`, the `Schema` mapping its typed
  * payload `A` to its wire encoding `I` (requiring `R`), and the `tagsFor` mapper
- * that derives the event's tags from a decoded payload. `Schema` is invariant in
- * `A`/`I`, so `EventDef` cannot be `out A`/`out I`.
+ * that derives the event's tags from a decoded payload.
+ *
+ * `R` is ONE requirement for both directions, which is why the schema is a
+ * `Schema.Codec<A, I, R, R>` rather than leaving decoding and encoding services
+ * apart. A def is decoded on the read path and encoded by `toEvent`, so a
+ * consumer providing a def's services provides them for both; an application
+ * encryption transform needs its key either way. A struct whose two directions
+ * differ still fits, the codec being covariant in both, and `R` is then their
+ * union.
+ *
+ * `tagsFor` CONSUMES an `A`, so `EventDef` is invariant in `A` whatever the
+ * schema's own variance, and is therefore not declared `out A`.
  */
 export interface EventDef<A = unknown, I = unknown, R = never> {
   readonly type: EventType
-  readonly schema: Schema.Schema<A, I, R>
+  readonly schema: Schema.Codec<A, I, R, R>
   readonly tagsFor: TagsFor<A>
 }
 
 /**
- * The heterogeneous bound (mirrors `Schema.Schema.Any`) for arrays/records of
- * mixed defs, where the precise `A`/`I` differ per element. `tagsFor` erases to
- * `(a: any) => …`, which is harmless: only the write path (`toEvent`) calls it,
- * and the registry/decode path never does (stored events already carry tags).
+ * The heterogeneous bound for arrays/records of mixed defs, where the precise
+ * `A`/`I` differ per element. `tagsFor` erases to `(a: any) => …`, which is
+ * harmless: only the write path (`toEvent`) calls it, and the registry/decode
+ * path never does (stored events already carry tags).
  */
-// biome-ignore lint/suspicious/noExplicitAny: the sanctioned heterogeneous bound (mirrors Schema.Schema.Any); A/I differ per element, so any is the only sound erasure.
+// biome-ignore lint/suspicious/noExplicitAny: the sanctioned heterogeneous bound; A/I differ per element and tagsFor consumes A, so any is the only sound erasure.
 export type EventDefAny = EventDef<any, any, unknown>
 
 /**

package/src/precondition.ts

@@ -148,7 +148,7 @@ import type { Uuid } from './Uuid'
  * path meant to deny the input cheaply. Wrap such work in `Effect.suspend`.
  */
 export interface Precondition<Id, Service, E, R> {
-  readonly tag: Context.Tag<Id, Service>
+  readonly tag: Context.Key<Id, Service>
   readonly evaluate: Effect.Effect<Service, E, R>
 }
 
@@ -243,7 +243,7 @@ export const decideOnly = <
  * 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.
@@ -275,7 +275,7 @@ export const unsafeAppend = (
     // 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(
+    Effect.updateContext(
       store.append(events),
       (context: Context.Context<never>) => Context.omit(AppendIsOwned)(context),
     ),

package/src/projection.ts

@@ -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.
@@ -35,7 +35,7 @@ import type { EventDef } from './event'
  */
 export interface SliceProjection<out S = unknown, out R = unknown>
   extends AnyProjection<S> {
-  readonly schemas: ReadonlyMap<string, Schema.Schema<unknown, unknown, R>>
+  readonly schemas: ReadonlyMap<string, Schema.Decoder<unknown, R>>
 }
 
 /** The fluent builder: accumulate `.on(def, fold)` steps, then `.build()`. */
@@ -75,7 +75,7 @@ export const projection = <S>(initialState: S): ProjectionBuilder<S, never> => {
   // threading `R` means the implementation states the same widening the
   // `ProjectionBuilder` interface promises, and `on` returns without a cast.
   const make = <R>(
-    schemas: ReadonlyMap<string, Schema.Schema<unknown, unknown, R>>,
+    schemas: ReadonlyMap<string, Schema.Decoder<unknown, R>>,
     folds: ReadonlyMap<string, (state: S, payload: unknown) => S>,
   ): ProjectionBuilder<S, R> => ({
     on: <A, I, R2>(
@@ -101,25 +101,20 @@ export const projection = <S>(initialState: S): ProjectionBuilder<S, never> => {
       // 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<
-        string,
-        Schema.Schema<unknown, unknown, R | R2>
-      >(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
-      // 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.
-      nextSchemas.set(
-        def.type,
-        def.schema as unknown as Schema.Schema<unknown, unknown, R2>,
+      const nextSchemas = new Map<string, Schema.Decoder<unknown, R | R2>>(
+        schemas,
       )
+      // 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`. 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
       // map holds folds over `unknown`, and `evolve` supplies the payload the