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

package/README.md

@@ -8,7 +8,7 @@ Schema-first codec with an encryption seam for kairos-es (ADR-0004).
 single shared Effect instance (per [ADR-0003](../../docs/adr)):
 
 ```sh
-pnpm add @kairos-es/codec@alpha @kairos-es/core@alpha effect@^3.22.0
+pnpm add @kairos-es/codec@alpha @kairos-es/core@alpha effect@^4.0.5
 ```
 
 The typed-payload to opaque-bytes seam: `event(type, fields, tagsFor)` defines a
@@ -18,7 +18,32 @@ decision model or a read model folds through; `modelAtHead(slices)` reads, decod
 through each def's `Schema`, and folds purely, returning `{ state, head }`;
 `buildDecisionModel(slices)` is that same read plus the `AppendCondition` a write
 needs; and `toEvent` produces a wire event (encode, serialise, tags derived, clock
-and uuid from services).
+and uuid from services, and a metadata bag).
+
+Every event carries `metadata`, a flat bag of strings (core's `Metadata`) of context about the
+recording — a `traceparent`, a correlation id — never anything the business asserts.
+Pass it per call as `toEvent(def, payload, { metadata })`, or provide it once at the
+edge of a request with `Effect.provideService(MetadataSource, bag)`; a per-call bag
+replaces the ambient one, and with neither the event carries `{}`. A bag core's
+`Metadata` schema refuses, such as one holding a value that is not a string, fails
+`toEvent` with a `CodecError` (`reason: 'metadata'`). Metadata is cleartext, never
+queryable and never seen by `tagsFor` or by a builder fold (`.on(def, fold)`). A
+read model's `apply` sees it on each decoded event as `decoded.sequenced.event.metadata`.
+
+To read metadata in a FOLD, leave the builder and write the `SliceProjection` by
+hand: an `initialState`, a `query`, a `schemas` map from each event type it folds to
+that def's schema, and an erased `evolve(state, decoded)` that reads
+`decoded.sequenced.event.metadata`. It goes everywhere a built slice goes. Three
+things the builder does for you, a hand-written slice must do itself:
+
+- **Keep the def's requirement in the schema cast** —
+  `def.schema as unknown as Schema.Decoder<unknown, R>` with the def's own
+  `R`. Cast a def that needs a service to `never` instead, and the slice compiles
+  without that service and dies at run time.
+- **Check `decoded.sequenced.event.type` in `evolve`.** It is handed every event its
+  query matches, decoded through the schemas of every slice in the record, so an
+  event your `schemas` never named can still arrive, decoded by a neighbour's.
+- **Cast `state` back to its own type**, since `evolve` is erased.
 
 `modelAtHead` is the read side's third materialisation KIND — checkpoint-free and
 read-time, no table, no runner, nothing maintained — and `head` is its consistency

package/dist/cjs/MetadataSource.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MetadataSource = void 0;
+var _effect = require("effect");
+class MetadataSource extends /*#__PURE__*/_effect.Context.Service()('@kairos-es/codec/MetadataSource') {}
+exports.MetadataSource = MetadataSource;
+//# sourceMappingURL=MetadataSource.js.map

package/dist/cjs/MetadataSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataSource.js","names":["_effect","require","MetadataSource","Context","Service","exports"],"sources":["../../src/MetadataSource.ts"],"sourcesContent":[null],"mappings":";;;;;;AAsCA,IAAAA,OAAA,GAAAC,OAAA;AAEM,MAAOC,cAAe,sBAAQC,eAAO,CAACC,OAAO,EAA4B,CAC7E,iCAAiC,CAClC;AAAAC,OAAA,CAAAH,cAAA,GAAAA,cAAA","ignoreList":[]}

package/dist/cjs/Serializer.js

@@ -7,8 +7,8 @@ exports.SerializerDefault = exports.Serializer = void 0;
 var _effect = require("effect");
 /**
  * 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.
  *
@@ -18,7 +18,7 @@ var _effect = require("effect");
  * a trivial `Layer.succeed`.
  */
 
-class Serializer extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/codec/Serializer')() {}
+class Serializer extends /*#__PURE__*/_effect.Context.Service()('@kairos-es/codec/Serializer') {}
 exports.Serializer = Serializer;
 const encoder = /*#__PURE__*/new TextEncoder();
 const decoder = /*#__PURE__*/new TextDecoder();

package/dist/cjs/Serializer.js.map

@@ -1 +1 @@
-{"version":3,"file":"Serializer.js","names":["_effect","require","Serializer","Context","Tag","exports","encoder","TextEncoder","decoder","TextDecoder","SerializerDefault","Layer","succeed","serialise","v","encode","JSON","stringify","deserialise","b","parse","decode"],"sources":["../../src/Serializer.ts"],"sourcesContent":[null],"mappings":";;;;;;AAYA,IAAAA,OAAA,GAAAC,OAAA;AAZA;;;;;;;;;;;;;AAcM,MAAOC,UAAW,sBAAQC,eAAO,CAACC,GAAG,CAAC,6BAA6B,CAAC,EAMvE;AAAAC,OAAA,CAAAH,UAAA,GAAAA,UAAA;AAEH,MAAMI,OAAO,gBAAG,IAAIC,WAAW,EAAE;AACjC,MAAMC,OAAO,gBAAG,IAAIC,WAAW,EAAE;AAEjC;;;;;AAKO,MAAMC,iBAAiB,GAAAL,OAAA,CAAAK,iBAAA,gBAA4BC,aAAK,CAACC,OAAO,CACrEV,UAAU,EACV;EACEW,SAAS,EAAGC,CAAC,IAAKR,OAAO,CAACS,MAAM,CAACC,IAAI,CAACC,SAAS,CAACH,CAAC,CAAC,CAAC;EACnDI,WAAW,EAAGC,CAAC,IAAKH,IAAI,CAACI,KAAK,CAACZ,OAAO,CAACa,MAAM,CAACF,CAAC,CAAC;CACjD,CACF","ignoreList":[]}
+{"version":3,"file":"Serializer.js","names":["_effect","require","Serializer","Context","Service","exports","encoder","TextEncoder","decoder","TextDecoder","SerializerDefault","Layer","succeed","serialise","v","encode","JSON","stringify","deserialise","b","parse","decode"],"sources":["../../src/Serializer.ts"],"sourcesContent":[null],"mappings":";;;;;;AAYA,IAAAA,OAAA,GAAAC,OAAA;AAZA;;;;;;;;;;;;;AAcM,MAAOC,UAAW,sBAAQC,eAAO,CAACC,OAAO,EAM5C,CAAC,6BAA6B,CAAC;AAAAC,OAAA,CAAAH,UAAA,GAAAA,UAAA;AAElC,MAAMI,OAAO,gBAAG,IAAIC,WAAW,EAAE;AACjC,MAAMC,OAAO,gBAAG,IAAIC,WAAW,EAAE;AAEjC;;;;;AAKO,MAAMC,iBAAiB,GAAAL,OAAA,CAAAK,iBAAA,gBAA4BC,aAAK,CAACC,OAAO,CACrEV,UAAU,EACV;EACEW,SAAS,EAAGC,CAAC,IAAKR,OAAO,CAACS,MAAM,CAACC,IAAI,CAACC,SAAS,CAACH,CAAC,CAAC,CAAC;EACnDI,WAAW,EAAGC,CAAC,IAAKH,IAAI,CAACI,KAAK,CAACZ,OAAO,CAACa,MAAM,CAACF,CAAC,CAAC;CACjD,CACF","ignoreList":[]}

package/dist/cjs/Uuid.js

@@ -18,7 +18,7 @@ var _effect = require("effect");
  * layer gets a repeatable sequence.
  */
 
-class Uuid extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/codec/Uuid')() {}
+class Uuid extends /*#__PURE__*/_effect.Context.Service()('@kairos-es/codec/Uuid') {}
 /** Live uuid generation via WebCrypto (no `node:crypto`). */
 exports.Uuid = Uuid;
 const UuidLive = exports.UuidLive = /*#__PURE__*/_effect.Layer.succeed(Uuid, {
@@ -27,9 +27,12 @@ const UuidLive = exports.UuidLive = /*#__PURE__*/_effect.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).
  */
 const UuidTest = exports.UuidTest = /*#__PURE__*/_effect.Layer.sync(Uuid, () => {

package/dist/cjs/Uuid.js.map

@@ -1 +1 @@
-{"version":3,"file":"Uuid.js","names":["_testing","require","_effect","Uuid","Context","Tag","exports","UuidLive","Layer","succeed","generate","Effect","sync","globalThis","crypto","randomUUID","UuidTest","next","makeSequentialUuid"],"sources":["../../src/Uuid.ts"],"sourcesContent":[null],"mappings":";;;;;;AAWA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAZA;;;;;;;;;;;;AAcM,MAAOE,IAAK,sBAAQC,eAAO,CAACC,GAAG,CAAC,uBAAuB,CAAC,EAG3D;AAEH;AAAAC,OAAA,CAAAH,IAAA,GAAAA,IAAA;AACO,MAAMI,QAAQ,GAAAD,OAAA,CAAAC,QAAA,gBAAsBC,aAAK,CAACC,OAAO,CAACN,IAAI,EAAE;EAC7DO,QAAQ,eAAEC,cAAM,CAACC,IAAI,CAAC,MAAMC,UAAU,CAACC,MAAM,CAACC,UAAU,EAAE;CAC3D,CAAC;AAEF;;;;;;;;AAQO,MAAMC,QAAQ,GAAAV,OAAA,CAAAU,QAAA,gBAAsBR,aAAK,CAACI,IAAI,CAACT,IAAI,EAAE,MAAK;EAC/D,MAAMc,IAAI,GAAG,IAAAC,2BAAkB,GAAE;EACjC,OAAO;IAAER,QAAQ,EAAEC,cAAM,CAACC,IAAI,CAACK,IAAI;EAAC,CAAE;AACxC,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"Uuid.js","names":["_testing","require","_effect","Uuid","Context","Service","exports","UuidLive","Layer","succeed","generate","Effect","sync","globalThis","crypto","randomUUID","UuidTest","next","makeSequentialUuid"],"sources":["../../src/Uuid.ts"],"sourcesContent":[null],"mappings":";;;;;;AAWA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAZA;;;;;;;;;;;;AAcM,MAAOE,IAAK,sBAAQC,eAAO,CAACC,OAAO,EAGtC,CAAC,uBAAuB,CAAC;AAE5B;AAAAC,OAAA,CAAAH,IAAA,GAAAA,IAAA;AACO,MAAMI,QAAQ,GAAAD,OAAA,CAAAC,QAAA,gBAAsBC,aAAK,CAACC,OAAO,CAACN,IAAI,EAAE;EAC7DO,QAAQ,eAAEC,cAAM,CAACC,IAAI,CAAC,MAAMC,UAAU,CAACC,MAAM,CAACC,UAAU,EAAE;CAC3D,CAAC;AAEF;;;;;;;;;;;AAWO,MAAMC,QAAQ,GAAAV,OAAA,CAAAU,QAAA,gBAAsBR,aAAK,CAACI,IAAI,CAACT,IAAI,EAAE,MAAK;EAC/D,MAAMc,IAAI,GAAG,IAAAC,2BAAkB,GAAE;EACjC,OAAO;IAAER,QAAQ,EAAEC,cAAM,CAACC,IAAI,CAACK,IAAI;EAAC,CAAE;AACxC,CAAC,CAAC","ignoreList":[]}

package/dist/cjs/decider.js

@@ -50,7 +50,7 @@ var _decisionModel = require("./decisionModel.js");
  * 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

package/dist/cjs/decisionModel.js

@@ -124,7 +124,7 @@ const modelAtHead = projections => _effect.Effect.gen(function* () {
     head
   } = yield* store.read(composite.query);
   const decoded = decode(events);
-  const state = yield* _effect.Stream.runFold(decoded, composite.initialState, (acc, event) => composite.evolve(acc, event));
+  const state = yield* _effect.Stream.runFold(decoded, () => composite.initialState, (acc, event) => composite.evolve(acc, event));
   // LAZY: only once the fold has run to completion. A read that failed
   // part-way folded a PREFIX, and a head recorded for it is a claim it did not
   // earn — so the line below is unreachable on that path, deliberately.

package/dist/cjs/decisionModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"decisionModel.js","names":["_core","require","_effect","_decode","_readLedger","modelAtHead","projections","Effect","gen","store","DcbEventStore","decode","decodeSlices","composite","composeProjections","assertServableAddition","closeHop","recordQuery","query","events","head","read","decoded","state","Stream","runFold","initialState","acc","event","evolve","exports","buildDecisionModel","ambient","ambientLayeredCondition","Option","isSome","appendCondition","value","failIfEventsMatch","after"],"sources":["../../src/decisionModel.ts"],"sourcesContent":[null],"mappings":";;;;;;AAiCA,IAAAA,KAAA,GAAAC,OAAA;AAQA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAGA,IAAAG,WAAA,GAAAH,OAAA;AA7CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDO,MAAMI,WAAW,GACtBC,WAAc,IAMdC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,KAAK,GAAG,OAAOC,mBAAa;EAElC;EACA;EACA;EACA,MAAMC,MAAM,GAAG,IAAAC,oBAAY,EAACN,WAAW,CAAC;EAExC;EACA,MAAMO,SAAS,GAAG,IAAAC,wBAAkB,EAClCR,WAA4C,CAC7C;EAED;EACA;EACA;EACA;EACA;EACA;EACA;EACA,OAAO,IAAAS,kCAAsB,EAACT,WAA4C,CAAC;EAE3E;EACA;EACA;EACA,MAAMU,QAAQ,GAAG,OAAO,IAAAC,uBAAW,EAACJ,SAAS,CAACK,KAAK,CAAC;EAEpD,MAAM;IAAEC,MAAM;IAAEC;EAAI,CAAE,GAAG,OAAOX,KAAK,CAACY,IAAI,CAACR,SAAS,CAACK,KAAK,CAAC;EAE3D,MAAMI,OAAO,GAAGX,MAAM,CAACQ,MAAM,CAAC;EAE9B,MAAMI,KAAK,GAAI,OAAOC,cAAM,CAACC,OAAO,CAClCH,OAAO,EACPT,SAAS,CAACa,YAAY,EACtB,CAACC,GAAG,EAAEC,KAAK,KAAKf,SAAS,CAACgB,MAAM,CAACF,GAAG,EAAEC,KAAK,CAAC,CACvB;EAEvB;EACA;EACA;EACA,OAAOZ,QAAQ,CAACI,IAAI,CAAC;EAErB,OAAO;IAAEG,KAAK;IAAEH;EAAI,CAAE;AACxB,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAU,OAAA,CAAAzB,WAAA,GAAAA,WAAA;AA0CO,MAAM0B,kBAAkB,GAC7BzB,WAAc,IASdC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAM;IAAEe,KAAK;IAAEH;EAAI,CAAE,GAAG,OAAOf,WAAW,CAACC,WAAW,CAAC;EAEvD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAM0B,OAAO,GAAG,OAAOC,mCAAuB;EAC9C,IAAIC,cAAM,CAACC,MAAM,CAACH,OAAO,CAAC,EAAE;IAC1B,OAAO;MAAET,KAAK;MAAEa,eAAe,EAAEJ,OAAO,CAACK;IAAK,CAAE;EAClD;EAEA;EACA,OAAO;IACLd,KAAK;IACLa,eAAe,EAAE;MACfE,iBAAiB,EAAE,IAAAxB,wBAAkB,EACnCR,WAA4C,CAC7C,CAACY,KAAK;MACPqB,KAAK,EAAEnB;;GAEV;AACH,CAAC,CAAC;AAAAU,OAAA,CAAAC,kBAAA,GAAAA,kBAAA","ignoreList":[]}
+{"version":3,"file":"decisionModel.js","names":["_core","require","_effect","_decode","_readLedger","modelAtHead","projections","Effect","gen","store","DcbEventStore","decode","decodeSlices","composite","composeProjections","assertServableAddition","closeHop","recordQuery","query","events","head","read","decoded","state","Stream","runFold","initialState","acc","event","evolve","exports","buildDecisionModel","ambient","ambientLayeredCondition","Option","isSome","appendCondition","value","failIfEventsMatch","after"],"sources":["../../src/decisionModel.ts"],"sourcesContent":[null],"mappings":";;;;;;AAiCA,IAAAA,KAAA,GAAAC,OAAA;AAQA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAGA,IAAAG,WAAA,GAAAH,OAAA;AA7CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDO,MAAMI,WAAW,GACtBC,WAAc,IAMdC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,KAAK,GAAG,OAAOC,mBAAa;EAElC;EACA;EACA;EACA,MAAMC,MAAM,GAAG,IAAAC,oBAAY,EAACN,WAAW,CAAC;EAExC;EACA,MAAMO,SAAS,GAAG,IAAAC,wBAAkB,EAClCR,WAA4C,CAC7C;EAED;EACA;EACA;EACA;EACA;EACA;EACA;EACA,OAAO,IAAAS,kCAAsB,EAACT,WAA4C,CAAC;EAE3E;EACA;EACA;EACA,MAAMU,QAAQ,GAAG,OAAO,IAAAC,uBAAW,EAACJ,SAAS,CAACK,KAAK,CAAC;EAEpD,MAAM;IAAEC,MAAM;IAAEC;EAAI,CAAE,GAAG,OAAOX,KAAK,CAACY,IAAI,CAACR,SAAS,CAACK,KAAK,CAAC;EAE3D,MAAMI,OAAO,GAAGX,MAAM,CAACQ,MAAM,CAAC;EAE9B,MAAMI,KAAK,GAAI,OAAOC,cAAM,CAACC,OAAO,CAClCH,OAAO,EACP,MAAMT,SAAS,CAACa,YAAY,EAC5B,CAACC,GAAG,EAAEC,KAAK,KAAKf,SAAS,CAACgB,MAAM,CAACF,GAAG,EAAEC,KAAK,CAAC,CACvB;EAEvB;EACA;EACA;EACA,OAAOZ,QAAQ,CAACI,IAAI,CAAC;EAErB,OAAO;IAAEG,KAAK;IAAEH;EAAI,CAAE;AACxB,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAU,OAAA,CAAAzB,WAAA,GAAAA,WAAA;AA0CO,MAAM0B,kBAAkB,GAC7BzB,WAAc,IASdC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAM;IAAEe,KAAK;IAAEH;EAAI,CAAE,GAAG,OAAOf,WAAW,CAACC,WAAW,CAAC;EAEvD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAM0B,OAAO,GAAG,OAAOC,mCAAuB;EAC9C,IAAIC,cAAM,CAACC,MAAM,CAACH,OAAO,CAAC,EAAE;IAC1B,OAAO;MAAET,KAAK;MAAEa,eAAe,EAAEJ,OAAO,CAACK;IAAK,CAAE;EAClD;EAEA;EACA,OAAO;IACLd,KAAK;IACLa,eAAe,EAAE;MACfE,iBAAiB,EAAE,IAAAxB,wBAAkB,EACnCR,WAA4C,CAC7C,CAACY,KAAK;MACPqB,KAAK,EAAEnB;;GAEV;AACH,CAAC,CAAC;AAAAU,OAAA,CAAAC,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/dist/cjs/decode.js

@@ -35,9 +35,9 @@ var _Serializer = require("./Serializer.js");
  * 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.**
@@ -51,8 +51,8 @@ var _Serializer = require("./Serializer.js");
  * 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

package/dist/cjs/decode.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode.js","names":["_effect","require","_deserialiseThenDecode","_errors","_Serializer","mergeSliceSchemas","projections","schemas","Map","contributedBy","key","Object","keys","slice","type","schema","owner","get","undefined","Error","set","decodeEvents","events","Stream","unwrap","Effect","map","Serializer","serializer","pipe","mapEffect","sequenced","event","fail","CodecError","reason","deserialiseThenDecode","data","payload","decodeSlices","slices","exports"],"sources":["../../src/decode.ts"],"sourcesContent":[null],"mappings":";;;;;;AAiDA,IAAAA,OAAA,GAAAC,OAAA;AAKA,IAAAC,sBAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAEA,IAAAG,WAAA,GAAAH,OAAA;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAMI,iBAAiB,GACrBC,WAAc,IAC4D;EAC1E,MAAMC,OAAO,GAAG,IAAIC,GAAG,EAGpB;EACH;EACA;EACA;EACA;EACA,MAAMC,aAAa,GAAG,IAAID,GAAG,EAAkB;EAC/C,KAAK,MAAME,GAAG,IAAIC,MAAM,CAACC,IAAI,CAACN,WAAW,CAAC,EAAE;IAC1C,MAAMO,KAAK,GAAGP,WAAW,CAACI,GAAG,CAAC;IAC9B,KAAK,MAAM,CAACI,IAAI,EAAEC,MAAM,CAAC,IAAIF,KAAK,CAACN,OAAO,EAAE;MAC1C,MAAMS,KAAK,GAAGP,aAAa,CAACQ,GAAG,CAACH,IAAI,CAAC;MACrC,IAAIE,KAAK,KAAKE,SAAS,IAAIX,OAAO,CAACU,GAAG,CAACH,IAAI,CAAC,KAAKC,MAAM,EAAE;QACvD,MAAM,IAAII,KAAK,CACb,yBAAyBL,IAAI,gBAAgBE,KAAK,UAAUN,GAAG,KAAK,GAClE,gEAAgE,GAChE,kEAAkE,GAClE,+BAA+B,CAClC;MACH;MACAH,OAAO,CAACa,GAAG,CACTN,IAAI,EACJC,MAA2D,CAC5D;MACDN,aAAa,CAACW,GAAG,CAACN,IAAI,EAAEJ,GAAG,CAAC;IAC9B;EACF;EACA,OAAOH,OAAO;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAMc,YAAY,GACXd,OAAiE,IAEpEe,MAA2C,IAE3CC,cAAM,CAACC,MAAM,CACXC,cAAM,CAACC,GAAG,CAACC,sBAAU,EAAGC,UAAU,IAChCN,MAAM,CAACO,IAAI,CACTN,cAAM,CAACO,SAAS,CAAEC,SAAS,IAAI;EAC7B,MAAMhB,MAAM,GAAGR,OAAO,CAACU,GAAG,CAACc,SAAS,CAACC,KAAK,CAAClB,IAAI,CAAC;EAChD,IAAIC,MAAM,KAAKG,SAAS,EAAE;IACxB,OAAOO,cAAM,CAACQ,IAAI,CAChB,IAAIC,kBAAU,CAAC;MACbC,MAAM,EAAE,6BAA6BJ,SAAS,CAACC,KAAK,CAAClB,IAAI;KAC1D,CAAC,CACH;EACH;EACA,OAAO,IAAAsB,4CAAqB,EAC1BR,UAAU,EACVb,MAAM,EACNgB,SAAS,CAACC,KAAK,CAACK,IAAI,CACrB,CAACR,IAAI,CACJJ,cAAM,CAACC,GAAG,CAAEY,OAAO,KAAoB;IAAEP,SAAS;IAAEO;EAAO,CAAE,CAAC,CAAC,CAChE;AACH,CAAC,CAAC,CACH,CACF,CACF;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCO,MAAMC,YAAY,GACvBC,MAAS,IAOLnB,YAAY,CAAChB,iBAAiB,CAACmC,MAAM,CAAC,CAAC;AAAAC,OAAA,CAAAF,YAAA,GAAAA,YAAA","ignoreList":[]}
+{"version":3,"file":"decode.js","names":["_effect","require","_deserialiseThenDecode","_errors","_Serializer","mergeSliceSchemas","projections","schemas","Map","contributedBy","key","Object","keys","slice","type","schema","owner","get","undefined","Error","set","decodeEvents","events","Stream","unwrap","Effect","map","Serializer","serializer","pipe","mapEffect","sequenced","event","fail","CodecError","reason","deserialiseThenDecode","data","payload","decodeSlices","slices","exports"],"sources":["../../src/decode.ts"],"sourcesContent":[null],"mappings":";;;;;;AAiDA,IAAAA,OAAA,GAAAC,OAAA;AAKA,IAAAC,sBAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAEA,IAAAG,WAAA,GAAAH,OAAA;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAMI,iBAAiB,GACrBC,WAAc,IACoD;EAClE,MAAMC,OAAO,GAAG,IAAIC,GAAG,EAAqD;EAC5E;EACA;EACA;EACA;EACA,MAAMC,aAAa,GAAG,IAAID,GAAG,EAAkB;EAC/C,KAAK,MAAME,GAAG,IAAIC,MAAM,CAACC,IAAI,CAACN,WAAW,CAAC,EAAE;IAC1C,MAAMO,KAAK,GAAGP,WAAW,CAACI,GAAG,CAAC;IAC9B,KAAK,MAAM,CAACI,IAAI,EAAEC,MAAM,CAAC,IAAIF,KAAK,CAACN,OAAO,EAAE;MAC1C,MAAMS,KAAK,GAAGP,aAAa,CAACQ,GAAG,CAACH,IAAI,CAAC;MACrC,IAAIE,KAAK,KAAKE,SAAS,IAAIX,OAAO,CAACU,GAAG,CAACH,IAAI,CAAC,KAAKC,MAAM,EAAE;QACvD,MAAM,IAAII,KAAK,CACb,yBAAyBL,IAAI,gBAAgBE,KAAK,UAAUN,GAAG,KAAK,GAClE,gEAAgE,GAChE,kEAAkE,GAClE,+BAA+B,CAClC;MACH;MACAH,OAAO,CAACa,GAAG,CAACN,IAAI,EAAEC,MAAmD,CAAC;MACtEN,aAAa,CAACW,GAAG,CAACN,IAAI,EAAEJ,GAAG,CAAC;IAC9B;EACF;EACA,OAAOH,OAAO;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAMc,YAAY,GACXd,OAAyD,IAE5De,MAA2C,IAE3CC,cAAM,CAACC,MAAM,CACXC,cAAM,CAACC,GAAG,CAACC,sBAAU,EAAGC,UAAU,IAChCN,MAAM,CAACO,IAAI,CACTN,cAAM,CAACO,SAAS,CAAEC,SAAS,IAAI;EAC7B,MAAMhB,MAAM,GAAGR,OAAO,CAACU,GAAG,CAACc,SAAS,CAACC,KAAK,CAAClB,IAAI,CAAC;EAChD,IAAIC,MAAM,KAAKG,SAAS,EAAE;IACxB,OAAOO,cAAM,CAACQ,IAAI,CAChB,IAAIC,kBAAU,CAAC;MACbC,MAAM,EAAE,6BAA6BJ,SAAS,CAACC,KAAK,CAAClB,IAAI;KAC1D,CAAC,CACH;EACH;EACA,OAAO,IAAAsB,4CAAqB,EAC1BR,UAAU,EACVb,MAAM,EACNgB,SAAS,CAACC,KAAK,CAACK,IAAI,CACrB,CAACR,IAAI,CACJJ,cAAM,CAACC,GAAG,CAAEY,OAAO,KAAoB;IAAEP,SAAS;IAAEO;EAAO,CAAE,CAAC,CAAC,CAChE;AACH,CAAC,CAAC,CACH,CACF,CACF;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCO,MAAMC,YAAY,GACvBC,MAAS,IAOLnB,YAAY,CAAChB,iBAAiB,CAACmC,MAAM,CAAC,CAAC;AAAAC,OAAA,CAAAF,YAAA,GAAAA,YAAA","ignoreList":[]}

package/dist/cjs/deserialiseThenDecode.js

@@ -12,7 +12,7 @@ const deserialiseThenDecode = (serializer, schema, bytes) => _effect.Effect.try(
     reason: 'deserialise',
     cause
   })
-}).pipe(_effect.Effect.flatMap(raw => _effect.Schema.decodeUnknown(schema)(raw).pipe(_effect.Effect.mapError(cause => new _errors.CodecError({
+}).pipe(_effect.Effect.flatMap(raw => _effect.Schema.decodeUnknownEffect(schema)(raw).pipe(_effect.Effect.mapError(cause => new _errors.CodecError({
   reason: 'decode',
   cause
 })))));

package/dist/cjs/deserialiseThenDecode.js.map

@@ -1 +1 @@
-{"version":3,"file":"deserialiseThenDecode.js","names":["_effect","require","_errors","deserialiseThenDecode","serializer","schema","bytes","Effect","try","deserialise","catch","cause","CodecError","reason","pipe","flatMap","raw","Schema","decodeUnknown","mapError","exports"],"sources":["../../src/deserialiseThenDecode.ts"],"sourcesContent":[null],"mappings":";;;;;;AAyDA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAGO,MAAME,qBAAqB,GAAGA,CACnCC,UAA2C,EAC3CC,MAA0C,EAC1CC,KAAiB,KAEjBC,cAAM,CAACC,GAAG,CAAC;EACTA,GAAG,EAAEA,CAAA,KAAMJ,UAAU,CAACK,WAAW,CAACH,KAAK,CAAC;EACxCI,KAAK,EAAGC,KAAK,IAAK,IAAIC,kBAAU,CAAC;IAAEC,MAAM,EAAE,aAAa;IAAEF;EAAK,CAAE;CAClE,CAAC,CAACG,IAAI,CACLP,cAAM,CAACQ,OAAO,CAAEC,GAAG,IACjBC,cAAM,CAACC,aAAa,CAACb,MAAM,CAAC,CAACW,GAAG,CAAC,CAACF,IAAI,CACpCP,cAAM,CAACY,QAAQ,CAAER,KAAK,IAAK,IAAIC,kBAAU,CAAC;EAAEC,MAAM,EAAE,QAAQ;EAAEF;AAAK,CAAE,CAAC,CAAC,CACxE,CACF,CACF;AAAAS,OAAA,CAAAjB,qBAAA,GAAAA,qBAAA","ignoreList":[]}
+{"version":3,"file":"deserialiseThenDecode.js","names":["_effect","require","_errors","deserialiseThenDecode","serializer","schema","bytes","Effect","try","deserialise","catch","cause","CodecError","reason","pipe","flatMap","raw","Schema","decodeUnknownEffect","mapError","exports"],"sources":["../../src/deserialiseThenDecode.ts"],"sourcesContent":[null],"mappings":";;;;;;AAyDA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAGO,MAAME,qBAAqB,GAAGA,CACnCC,UAAoD,EACpDC,MAAkC,EAClCC,KAAiB,KAEjBC,cAAM,CAACC,GAAG,CAAC;EACTA,GAAG,EAAEA,CAAA,KAAMJ,UAAU,CAACK,WAAW,CAACH,KAAK,CAAC;EACxCI,KAAK,EAAGC,KAAK,IAAK,IAAIC,kBAAU,CAAC;IAAEC,MAAM,EAAE,aAAa;IAAEF;EAAK,CAAE;CAClE,CAAC,CAACG,IAAI,CACLP,cAAM,CAACQ,OAAO,CAAEC,GAAG,IACjBC,cAAM,CAACC,mBAAmB,CAACb,MAAM,CAAC,CAACW,GAAG,CAAC,CAACF,IAAI,CAC1CP,cAAM,CAACY,QAAQ,CAAER,KAAK,IAAK,IAAIC,kBAAU,CAAC;EAAEC,MAAM,EAAE,QAAQ;EAAEF;AAAK,CAAE,CAAC,CAAC,CACxE,CACF,CACF;AAAAS,OAAA,CAAAjB,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/dist/cjs/errors.js

@@ -10,7 +10,8 @@ var _effect = require("effect");
  * 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).
@@ -45,9 +46,10 @@ class CodecError extends /*#__PURE__*/_effect.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.
    */
   get message() {
     return this.reason;

package/dist/cjs/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","names":["_effect","require","CodecError","Data","TaggedError","message","reason","exports","UnknownEventType","type"],"sources":["../../src/errors.ts"],"sourcesContent":[null],"mappings":";;;;;;AAaA,IAAAA,OAAA,GAAAC,OAAA;AAbA;;;;;;;;;;;;;;AAeA;AACM,MAAOC,UAAW,sBAAQC,YAAI,CAACC,WAAW,CAAC,YAAY,CAG3D;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BA,IAAaC,OAAOA,CAAA;IAClB,OAAO,IAAI,CAACC,MAAM;EACpB;;AAGF;AAAAC,OAAA,CAAAL,UAAA,GAAAA,UAAA;AACM,MAAOM,gBAAiB,sBAAQL,YAAI,CAACC,WAAW,CAAC,kBAAkB,CAEvE;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BA,IAAaC,OAAOA,CAAA;IAClB,OAAO,eAAe,IAAI,CAACI,IAAI,0BAA0B;EAC3D","ignoreList":[]}
+{"version":3,"file":"errors.js","names":["_effect","require","CodecError","Data","TaggedError","message","reason","exports","UnknownEventType","type"],"sources":["../../src/errors.ts"],"sourcesContent":[null],"mappings":";;;;;;AAcA,IAAAA,OAAA,GAAAC,OAAA;AAdA;;;;;;;;;;;;;;;AAgBA;AACM,MAAOC,UAAW,sBAAQC,YAAI,CAACC,WAAW,CAAC,YAAY,CAG3D;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BA,IAAaC,OAAOA,CAAA;IAClB,OAAO,IAAI,CAACC,MAAM;EACpB;;AAGF;AAAAC,OAAA,CAAAL,UAAA,GAAAA,UAAA;AACM,MAAOM,gBAAiB,sBAAQL,YAAI,CAACC,WAAW,CAAC,kBAAkB,CAEvE;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BA,IAAaC,OAAOA,CAAA;IAClB,OAAO,eAAe,IAAI,CAACI,IAAI,0BAA0B;EAC3D","ignoreList":[]}

package/dist/cjs/event.js.map

@@ -1 +1 @@
-{"version":3,"file":"event.js","names":["_effect","require","event","type","fields","tagsFor","schema","Schema","Struct","exports"],"sources":["../../src/event.ts"],"sourcesContent":[null],"mappings":";;;;;;AA+BA,IAAAA,OAAA,GAAAC,OAAA;AA+BA;;;;;;;;AAQO,MAAMC,KAAK,GAAGA,CAInBC,IAAU,EACVC,MAAc,EACdC,OAA4C,KAK1C;EACF,MAAMC,MAAM,GAAGC,cAAM,CAACC,MAAM,CAACJ,MAAM,CAAC;EACpC,OAAO;IACL;IACAD,IAAI,EAAEA,IAAwB;IAC9BG,MAAM;IACND;GACD;AACH,CAAC;AAAAI,OAAA,CAAAP,KAAA,GAAAA,KAAA","ignoreList":[]}
+{"version":3,"file":"event.js","names":["_effect","require","event","type","fields","tagsFor","schema","Schema","Struct","exports"],"sources":["../../src/event.ts"],"sourcesContent":[null],"mappings":";;;;;;AA+BA,IAAAA,OAAA,GAAAC,OAAA;AAyCA;;;;;;;;AAQO,MAAMC,KAAK,GAAGA,CAInBC,IAAU,EACVC,MAAc,EACdC,OAA4C,KAK1C;EACF,MAAMC,MAAM,GAAGC,cAAM,CAACC,MAAM,CAACJ,MAAM,CAAC;EACpC,OAAO;IACL;IACAD,IAAI,EAAEA,IAAwB;IAC9BG,MAAM;IACND;GACD;AACH,CAAC;AAAAI,OAAA,CAAAP,KAAA,GAAAA,KAAA","ignoreList":[]}

package/dist/cjs/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "Decision", {
     return _decision.Decision;
   }
 });
+Object.defineProperty(exports, "MetadataSource", {
+  enumerable: true,
+  get: function () {
+    return _MetadataSource.MetadataSource;
+  }
+});
 Object.defineProperty(exports, "NoReadsRecorded", {
   enumerable: true,
   get: function () {
@@ -165,6 +171,7 @@ var _decisionModel = require("./decisionModel.js");
 var _decode = require("./decode.js");
 var _errors = require("./errors.js");
 var _event = require("./event.js");
+var _MetadataSource = require("./MetadataSource.js");
 var _precondition = require("./precondition.js");
 var _projection = require("./projection.js");
 var _readLedger = require("./readLedger.js");

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_decider","require","_decision","_decisionModel","_decode","_errors","_event","_precondition","_projection","_readLedger","_registry","_Serializer","_toEvent","_Uuid"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuHA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAQA,IAAAE,cAAA,GAAAF,OAAA;AAKA,IAAAG,OAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,MAAA,GAAAL,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AAMA,IAAAO,WAAA,GAAAP,OAAA;AAKA,IAAAQ,WAAA,GAAAR,OAAA;AAOA,IAAAS,SAAA,GAAAT,OAAA;AACA,IAAAU,WAAA,GAAAV,OAAA;AACA,IAAAW,QAAA,GAAAX,OAAA;AACA,IAAAY,KAAA,GAAAZ,OAAA","ignoreList":[]}
+{"version":3,"file":"index.js","names":["_decider","require","_decision","_decisionModel","_decode","_errors","_event","_MetadataSource","_precondition","_projection","_readLedger","_registry","_Serializer","_toEvent","_Uuid"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwHA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAQA,IAAAE,cAAA,GAAAF,OAAA;AAKA,IAAAG,OAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,MAAA,GAAAL,OAAA;AACA,IAAAM,eAAA,GAAAN,OAAA;AACA,IAAAO,aAAA,GAAAP,OAAA;AAMA,IAAAQ,WAAA,GAAAR,OAAA;AAKA,IAAAS,WAAA,GAAAT,OAAA;AAOA,IAAAU,SAAA,GAAAV,OAAA;AACA,IAAAW,WAAA,GAAAX,OAAA;AACA,IAAAY,QAAA,GAAAZ,OAAA;AACA,IAAAa,KAAA,GAAAb,OAAA","ignoreList":[]}

package/dist/cjs/precondition.js

@@ -86,7 +86,7 @@ const decideOnly = (decider, command) => _effect.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.
@@ -116,7 +116,7 @@ reason) => _effect.Effect.flatMap(_core.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.Effect.mapInputContext(store.append(events), context => _effect.Context.omit(_core.AppendIsOwned)(context)));
+_effect.Effect.updateContext(store.append(events), context => _effect.Context.omit(_core.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/cjs/precondition.js.map

@@ -1 +1 @@
-{"version":3,"file":"precondition.js","names":["_core","require","_effect","_decision","_decisionModel","_readLedger","decideOnly","decider","command","Effect","gen","ReadLedger","state","modelAtHead","projections","decide","exports","unsafeAppend","events","reason","flatMap","DcbEventStore","store","mapInputContext","append","context","Context","omit","AppendIsOwned","transact","precondition","body","ledger","makeReadLedger","output","proof","evaluate","pipe","provideService","tag","provide","Layer","merge","layer","succeed","by","isUnchanged","condition","deriveLayeredCondition","hops","undefined","NoReadsRecorded"],"sources":["../../src/precondition.ts"],"sourcesContent":[null],"mappings":";;;;;;AAwGA,IAAAA,KAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,SAAA,GAAAF,OAAA;AAKA,IAAAG,cAAA,GAAAH,OAAA;AAGA,IAAAI,WAAA,GAAAJ,OAAA;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDO,MAAMK,UAAU,GAAGA,CAOxBC,OAAqC,EACrCC,OAAgB,KAMhBC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,OAAOC,sBAAU;EAEjB,MAAM;IAAEC;EAAK,CAAE,GAAG,OAAO,IAAAC,0BAAW,EAACN,OAAO,CAACO,WAAW,CAACN,OAAO,CAAC,CAAC;EAClE,OAAO,OAAOD,OAAO,CAACQ,MAAM,CAACH,KAAK,EAAEJ,OAAO,CAAC;AAC9C,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;AAAAQ,OAAA,CAAAV,UAAA,GAAAA,UAAA;AAsBO,MAAMW,YAAY,GAAGA,CAC1BC,MAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAC,MAAc,KAEdV,cAAM,CAACW,OAAO,CAACC,mBAAa,EAAGC,KAAK;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAb,cAAM,CAACc,eAAe,CACpBD,KAAK,CAACE,MAAM,CAACN,MAAM,CAAC,EACnBO,OAA+B,IAAKC,eAAO,CAACC,IAAI,CAACC,mBAAa,CAAC,CAACH,OAAO,CAAC,CAC1E,CACF;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAAAT,OAAA,CAAAC,YAAA,GAAAA,YAAA;AAuBO,MAAMY,QAAQ,GACGC,YAA+C,IAEnEC,IAA4B,IAQ5BtB,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMY,KAAK,GAAG,OAAOD,mBAAa;EAClC,MAAMW,MAAM,GAAG,OAAOC,0BAAc;EAEpC,MAAMC,MAAM,GAAmB,OAAOzB,cAAM,CAACC,GAAG,CAAC,aAAS;IACxD;IACA;IACA;IACA,MAAMyB,KAAK,GAAG,OAAOL,YAAY,CAACM,QAAQ;IAC1C,OAAO,OAAOL,IAAI,CAACM,IAAI,CAAC5B,cAAM,CAAC6B,cAAc,CAACR,YAAY,CAACS,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;EACA5B,cAAM,CAAC+B,OAAO,CACZC,aAAK,CAACC,KAAK,CACTV,MAAM,CAACW,KAAK,EACZF,aAAK,CAACG,OAAO,CAAChB,mBAAa,EAAE;IAAEiB,EAAE,EAAE;EAAU,CAAE,CAAC,CACjD,CACF,CACF;EAED;EACA;EACA;EACA;EACA;EACA;EACA,IAAI,IAAAC,qBAAW,EAACZ,MAAM,CAAC,EAAE;IACvB,OAAOA,MAA2B;EACpC;EAEA,MAAMa,SAAS,GAAG,IAAAC,kCAAsB,EAAC,OAAOhB,MAAM,CAACiB,IAAI,CAAC;EAC5D,IAAIF,SAAS,KAAKG,SAAS,EAAE;IAC3B,OAAO,OAAO,IAAIC,2BAAe,EAAE;EACrC;EAEA,OAAQ,OAAO7B,KAAK,CAACE,MAAM,CAACU,MAAM,EAAEa,SAAS,CAAC;AAChD,CAAC,CAAC;AAAA/B,OAAA,CAAAa,QAAA,GAAAA,QAAA","ignoreList":[]}
+{"version":3,"file":"precondition.js","names":["_core","require","_effect","_decision","_decisionModel","_readLedger","decideOnly","decider","command","Effect","gen","ReadLedger","state","modelAtHead","projections","decide","exports","unsafeAppend","events","reason","flatMap","DcbEventStore","store","updateContext","append","context","Context","omit","AppendIsOwned","transact","precondition","body","ledger","makeReadLedger","output","proof","evaluate","pipe","provideService","tag","provide","Layer","merge","layer","succeed","by","isUnchanged","condition","deriveLayeredCondition","hops","undefined","NoReadsRecorded"],"sources":["../../src/precondition.ts"],"sourcesContent":[null],"mappings":";;;;;;AAwGA,IAAAA,KAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,SAAA,GAAAF,OAAA;AAKA,IAAAG,cAAA,GAAAH,OAAA;AAGA,IAAAI,WAAA,GAAAJ,OAAA;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDO,MAAMK,UAAU,GAAGA,CAOxBC,OAAqC,EACrCC,OAAgB,KAMhBC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,OAAOC,sBAAU;EAEjB,MAAM;IAAEC;EAAK,CAAE,GAAG,OAAO,IAAAC,0BAAW,EAACN,OAAO,CAACO,WAAW,CAACN,OAAO,CAAC,CAAC;EAClE,OAAO,OAAOD,OAAO,CAACQ,MAAM,CAACH,KAAK,EAAEJ,OAAO,CAAC;AAC9C,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;AAAAQ,OAAA,CAAAV,UAAA,GAAAA,UAAA;AAsBO,MAAMW,YAAY,GAAGA,CAC1BC,MAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAC,MAAc,KAEdV,cAAM,CAACW,OAAO,CAACC,mBAAa,EAAGC,KAAK;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAb,cAAM,CAACc,aAAa,CAClBD,KAAK,CAACE,MAAM,CAACN,MAAM,CAAC,EACnBO,OAA+B,IAAKC,eAAO,CAACC,IAAI,CAACC,mBAAa,CAAC,CAACH,OAAO,CAAC,CAC1E,CACF;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAAAT,OAAA,CAAAC,YAAA,GAAAA,YAAA;AAuBO,MAAMY,QAAQ,GACGC,YAA+C,IAEnEC,IAA4B,IAQ5BtB,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMY,KAAK,GAAG,OAAOD,mBAAa;EAClC,MAAMW,MAAM,GAAG,OAAOC,0BAAc;EAEpC,MAAMC,MAAM,GAAmB,OAAOzB,cAAM,CAACC,GAAG,CAAC,aAAS;IACxD;IACA;IACA;IACA,MAAMyB,KAAK,GAAG,OAAOL,YAAY,CAACM,QAAQ;IAC1C,OAAO,OAAOL,IAAI,CAACM,IAAI,CAAC5B,cAAM,CAAC6B,cAAc,CAACR,YAAY,CAACS,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;EACA5B,cAAM,CAAC+B,OAAO,CACZC,aAAK,CAACC,KAAK,CACTV,MAAM,CAACW,KAAK,EACZF,aAAK,CAACG,OAAO,CAAChB,mBAAa,EAAE;IAAEiB,EAAE,EAAE;EAAU,CAAE,CAAC,CACjD,CACF,CACF;EAED;EACA;EACA;EACA;EACA;EACA;EACA,IAAI,IAAAC,qBAAW,EAACZ,MAAM,CAAC,EAAE;IACvB,OAAOA,MAA2B;EACpC;EAEA,MAAMa,SAAS,GAAG,IAAAC,kCAAsB,EAAC,OAAOhB,MAAM,CAACiB,IAAI,CAAC;EAC5D,IAAIF,SAAS,KAAKG,SAAS,EAAE;IAC3B,OAAO,OAAO,IAAIC,2BAAe,EAAE;EACrC;EAEA,OAAQ,OAAO7B,KAAK,CAACE,MAAM,CAACU,MAAM,EAAEa,SAAS,CAAC;AAChD,CAAC,CAAC;AAAA/B,OAAA,CAAAa,QAAA,GAAAA,QAAA","ignoreList":[]}

package/dist/cjs/projection.js

@@ -12,7 +12,7 @@ var _core = require("@kairos-es/core");
  * 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.
@@ -57,18 +57,17 @@ 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/cjs/projection.js.map

@@ -1 +1 @@
-{"version":3,"file":"projection.js","names":["_core","require","projection","initialState","make","schemas","folds","on","def","fold","has","type","Error","nextSchemas","Map","set","schema","nextFolds","build","options","types","keys","map","t","EventType","query","items","tags","evolve","state","decoded","get","sequenced","event","undefined","payload","exports"],"sources":["../../src/projection.ts"],"sourcesContent":[null],"mappings":";;;;;;AAmBA,IAAAA,KAAA,GAAAC,OAAA;AAnBA;;;;;;;;;;;;;;;;;;;;AA6DA;;;;AAIO,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,IAAKC,eAAS,CAACpB,IAAI,CAACmB,CAAC,CAAC,CAAC;MAC/D,MAAME,KAAK,GAAU;QACnBC,KAAK,EAAE,CAAC;UAAEN,KAAK;UAAEO,IAAI,EAAER,OAAO,EAAEQ,IAAI,IAAI;QAAE,CAAE;OAC7C;MACD,OAAO;QACLxB,YAAY;QACZsB,KAAK;QACL;QACA;QACA;QACA;QACA;QACA;QACApB,OAAO,EAAE,IAAIS,GAAG,CAACT,OAAO,CAAC;QACzB;QACA;QACA;QACA;QACA;QACA;QACAuB,MAAM,EAAEA,CAACC,KAAK,EAAEC,OAAqB,KAAI;UACvC,MAAMrB,IAAI,GAAGH,KAAK,CAACyB,GAAG,CAACD,OAAO,CAACE,SAAS,CAACC,KAAK,CAACtB,IAAI,CAAC;UACpD,OAAOF,IAAI,KAAKyB,SAAS,GAAGL,KAAK,GAAGpB,IAAI,CAACoB,KAAU,EAAEC,OAAO,CAACK,OAAO,CAAC;QACvE;OACD;IACH;GACD,CAAC;EACF;EACA;EACA,OAAO/B,IAAI,CAAQ,IAAIU,GAAG,EAAE,EAAE,IAAIA,GAAG,EAAE,CAAC;AAC1C,CAAC;AAAAsB,OAAA,CAAAlC,UAAA,GAAAA,UAAA","ignoreList":[]}
+{"version":3,"file":"projection.js","names":["_core","require","projection","initialState","make","schemas","folds","on","def","fold","has","type","Error","nextSchemas","Map","set","schema","nextFolds","build","options","types","keys","map","t","EventType","query","items","tags","evolve","state","decoded","get","sequenced","event","undefined","payload","exports"],"sources":["../../src/projection.ts"],"sourcesContent":[null],"mappings":";;;;;;AAmBA,IAAAA,KAAA,GAAAC,OAAA;AAnBA;;;;;;;;;;;;;;;;;;;;AA6DA;;;;AAIO,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,IAAKC,eAAS,CAACpB,IAAI,CAACmB,CAAC,CAAC,CAAC;MAC/D,MAAME,KAAK,GAAU;QACnBC,KAAK,EAAE,CAAC;UAAEN,KAAK;UAAEO,IAAI,EAAER,OAAO,EAAEQ,IAAI,IAAI;QAAE,CAAE;OAC7C;MACD,OAAO;QACLxB,YAAY;QACZsB,KAAK;QACL;QACA;QACA;QACA;QACA;QACA;QACApB,OAAO,EAAE,IAAIS,GAAG,CAACT,OAAO,CAAC;QACzB;QACA;QACA;QACA;QACA;QACA;QACAuB,MAAM,EAAEA,CAACC,KAAK,EAAEC,OAAqB,KAAI;UACvC,MAAMrB,IAAI,GAAGH,KAAK,CAACyB,GAAG,CAACD,OAAO,CAACE,SAAS,CAACC,KAAK,CAACtB,IAAI,CAAC;UACpD,OAAOF,IAAI,KAAKyB,SAAS,GAAGL,KAAK,GAAGpB,IAAI,CAACoB,KAAU,EAAEC,OAAO,CAACK,OAAO,CAAC;QACvE;OACD;IACH;GACD,CAAC;EACF;EACA;EACA,OAAO/B,IAAI,CAAQ,IAAIU,GAAG,EAAE,EAAE,IAAIA,GAAG,EAAE,CAAC;AAC1C,CAAC;AAAAsB,OAAA,CAAAlC,UAAA,GAAAA,UAAA","ignoreList":[]}

package/dist/cjs/readLedger.js

@@ -14,7 +14,7 @@ var _effect = require("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
@@ -24,7 +24,7 @@ var _effect = require("effect");
  * Recording is two-phase, and `record`'s own doc below owns why and what shape the
  * second phase takes.
  */
-class ReadLedger extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/codec/ReadLedger')() {}
+class ReadLedger extends /*#__PURE__*/_effect.Context.Service()('@kairos-es/codec/ReadLedger') {}
 /**
  * Raised when a bracket closes having recorded no read at all.
  *
@@ -174,8 +174,23 @@ const recordQuery = query => withLedger(NO_CLOSE, ledger => ledger.record(query)
 /** The tagless slice keys in a record, in declaration order. */
 exports.recordQuery = recordQuery;
 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) => (0, _core.servableQueryFault)((0, _core.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 = (0, _core.unionQueries)([...existing.map(h => h.query), incoming]);
+  return (0, _core.unknownQueryKeyFault)(union) === undefined && (0, _core.servableQueryFault)(union) !== undefined;
+};
 /**
  * Refuse a read that would leave the bracket's accumulated union unservable,
  * BEFORE the read is paid for.
@@ -220,5 +235,5 @@ const assertServableAddition = projections => withLedger(undefined, ledger => _e
  * than from its own single read.
  */
 exports.assertServableAddition = assertServableAddition;
-const ambientLayeredCondition = exports.ambientLayeredCondition = /*#__PURE__*/withLedger(/*#__PURE__*/_effect.Option.none(), ledger => _effect.Effect.map(ledger.hops, hops => _effect.Option.fromNullable(deriveLayeredCondition(hops))));
+const ambientLayeredCondition = exports.ambientLayeredCondition = /*#__PURE__*/withLedger(/*#__PURE__*/_effect.Option.none(), ledger => _effect.Effect.map(ledger.hops, hops => _effect.Option.fromNullishOr(deriveLayeredCondition(hops))));
 //# sourceMappingURL=readLedger.js.map

package/dist/cjs/readLedger.js.map

@@ -1 +1 @@
-{"version":3,"file":"readLedger.js","names":["_core","require","_effect","ReadLedger","Context","Tag","exports","NoReadsRecorded","Data","TaggedError","message","TaglessSliceInLedger","sliceKey","deriveLayeredCondition","hops","length","undefined","merged","unionQueries","map","hop","query","arrived","flatMap","head","after","reduce","a","b","ORIGIN","failIfEventsMatch","makeReadLedger","Effect","gen","ref","Ref","make","layer","Layer","succeed","record","modify","update","current","index","get","withLedger","absent","f","serviceOption","ledger","Option","isNone","value","NO_CLOSE","void","recordQuery","taglessKeys","projections","Object","entries","filter","projection","items","some","item","tags","key","unionWouldBeUnservable","existing","incoming","servableQueryFault","h","assertServableAddition","composeProjections","offending","ambientLayeredCondition","none","fromNullable"],"sources":["../../src/readLedger.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"readLedger.js","names":["_core","require","_effect","ReadLedger","Context","Service","exports","NoReadsRecorded","Data","TaggedError","message","TaglessSliceInLedger","sliceKey","deriveLayeredCondition","hops","length","undefined","merged","unionQueries","map","hop","query","arrived","flatMap","head","after","reduce","a","b","ORIGIN","failIfEventsMatch","makeReadLedger","Effect","gen","ref","Ref","make","layer","Layer","succeed","record","modify","update","current","index","get","withLedger","absent","f","serviceOption","ledger","Option","isNone","value","NO_CLOSE","void","recordQuery","taglessKeys","projections","Object","entries","filter","projection","items","some","item","tags","key","unionWouldBeUnservable","existing","incoming","union","h","unknownQueryKeyFault","servableQueryFault","assertServableAddition","composeProjections","offending","ambientLayeredCondition","none","fromNullishOr"],"sources":["../../src/readLedger.ts"],"sourcesContent":[null],"mappings":";;;;;;AAsEA,IAAAA,KAAA,GAAAC,OAAA;AAOA,IAAAC,OAAA,GAAAD,OAAA;AAeA;;;;;;;;;;;;;;;;;;AAkBM,MAAOE,UAAW,sBAAQC,eAAO,CAACC,OAAO,EAmB5C,CAAC,6BAA6B,CAAC;AAYlC;;;;;;;;;;;;;;;;;;;AAAAC,OAAA,CAAAH,UAAA,GAAAA,UAAA;AAmBM,MAAOI,eAAgB,sBAAQC,YAAI,CAACC,WAAW,CAAC,iBAAiB,CAEtE;EACC;;;;;;;;EAQA,IAAaC,OAAOA,CAAA;IAClB,OACE,8EAA8E,GAC9E,8EAA8E,GAC9E,uEAAuE;EAE3E;;AAGF;;;;;;;;;;;;;;;;;AAAAJ,OAAA,CAAAC,eAAA,GAAAA,eAAA;AAiBM,MAAOI,oBAAqB,sBAAQH,YAAI,CAACC,WAAW,CACxD,sBAAsB,CACQ;EAC9B;EACA,IAAaC,OAAOA,CAAA;IAClB,OACE,UAAU,IAAI,CAACE,QAAQ,uDAAuD,GAC9E,wEAAwE,GACxE,6EAA6E,GAC7E,+CAA+C;EAEnD;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAN,OAAA,CAAAK,oBAAA,GAAAA,oBAAA;AA2BO,MAAME,sBAAsB,GACjCC,IAAwB,IACO;EAC/B,IAAIA,IAAI,CAACC,MAAM,KAAK,CAAC,EAAE;IACrB,OAAOC,SAAS;EAClB;EACA,MAAMC,MAAM,GAAG,IAAAC,kBAAY,EAACJ,IAAI,CAACK,GAAG,CAAEC,GAAG,IAAKA,GAAG,CAACC,KAAK,CAAC,CAAC;EAEzD,MAAMC,OAAO,GAAGR,IAAI,CAACS,OAAO,CAAEH,GAAG,IAC/BA,GAAG,CAACI,IAAI,KAAKR,SAAS,GAAG,EAAE,GAAG,CAACI,GAAG,CAACI,IAAI,CAAC,CACzC;EACD;EACA;EACA,MAAMC,KAAK,GACTH,OAAO,CAACP,MAAM,KAAKD,IAAI,CAACC,MAAM,GAC1BO,OAAO,CAACI,MAAM,CAAC,CAACC,CAAC,EAAEC,CAAC,KAAMA,CAAC,GAAGD,CAAC,GAAGC,CAAC,GAAGD,CAAE,CAAC,GACzCE,YAAM;EAEZ,OAAO;IAAEC,iBAAiB,EAAEb,MAAM;IAAEQ;EAAK,CAAE;AAC7C,CAAC;AAED;;;;;;;;AAAAnB,OAAA,CAAAO,sBAAA,GAAAA,sBAAA;AAQO,MAAMkB,cAAc,GAAAzB,OAAA,CAAAyB,cAAA,gBAGtBC,cAAM,CAACC,GAAG,CAAC,aAAS;EACvB,MAAMC,GAAG,GAAG,OAAOC,WAAG,CAACC,IAAI,CAAqB,EAAE,CAAC;EACnD,OAAO;IACLC,KAAK,EAAEC,aAAK,CAACC,OAAO,CAACpC,UAAU,EAAE;MAC/BqC,MAAM,EAAGnB,KAAY,IACnBc,WAAG,CAACM,MAAM,CAACP,GAAG,EAAGpB,IAAI,IAAK;MACxB;MACA;MACCU,IAAc,IACbW,WAAG,CAACO,MAAM,CAACR,GAAG,EAAGS,OAAO,IACtBA,OAAO,CAACxB,GAAG,CAAC,CAACC,GAAG,EAAEwB,KAAK,KACrBA,KAAK,KAAK9B,IAAI,CAACC,MAAM,GAAG;QAAEM,KAAK,EAAED,GAAG,CAACC,KAAK;QAAEG;MAAI,CAAE,GAAGJ,GAAG,CACzD,CACF,EACH,CAAC,GAAGN,IAAI,EAAE;QAAEO;MAAK,CAAE,CAAC,CACrB,CAAC;MACJP,IAAI,EAAEqB,WAAG,CAACU,GAAG,CAACX,GAAG;KAClB,CAAC;IACF;IACA;IACApB,IAAI,EAAEqB,WAAG,CAACU,GAAG,CAACX,GAAG;GAClB;AACH,CAAC,CAAC;AAEF;;;;;;;;;AASA,MAAMY,UAAU,GAAGA,CACjBC,MAAS,EACTC,CAA4E,KAE5EhB,cAAM,CAACT,OAAO,CAACS,cAAM,CAACiB,aAAa,CAAC9C,UAAU,CAAC,EAAG+C,MAAM,IACtDC,cAAM,CAACC,MAAM,CAACF,MAAM,CAAC,GAAGlB,cAAM,CAACO,OAAO,CAACQ,MAAM,CAAC,GAAGC,CAAC,CAACE,MAAM,CAACG,KAAK,CAAC,CACjE;AAEH;AACA,MAAMC,QAAQ,GAAaA,CAAA,KAAMtB,cAAM,CAACuB,IAAI;AAE5C;;;;;AAKO,MAAMC,WAAW,GAAInC,KAAY,IACtCyB,UAAU,CAACQ,QAAQ,EAAGJ,MAAM,IAAKA,MAAM,CAACV,MAAM,CAACnB,KAAK,CAAC,CAAC;AAExD;AAAAf,OAAA,CAAAkD,WAAA,GAAAA,WAAA;AACA,MAAMC,WAAW,GACfC,WAA0C,IAE1CC,MAAM,CAACC,OAAO,CAACF,WAAW,CAAC,CACxBG,MAAM,CAAC,CAAC,GAAGC,UAAU,CAAC,KACrBA,UAAU,CAACzC,KAAK,CAAC0C,KAAK,CAACC,IAAI,CAAEC,IAAI,IAAKA,IAAI,CAACC,IAAI,CAACnD,MAAM,KAAK,CAAC,CAAC,CAC9D,CACAI,GAAG,CAAC,CAAC,CAACgD,GAAG,CAAC,KAAKA,GAAG,CAAC;AAExB;;;;;;;;;;;;;AAaA,MAAMC,sBAAsB,GAAGA,CAC7BC,QAA4B,EAC5BC,QAAe,KACJ;EACX,MAAMC,KAAK,GAAG,IAAArD,kBAAY,EAAC,CAAC,GAAGmD,QAAQ,CAAClD,GAAG,CAAEqD,CAAC,IAAKA,CAAC,CAACnD,KAAK,CAAC,EAAEiD,QAAQ,CAAC,CAAC;EACvE,OACE,IAAAG,0BAAoB,EAACF,KAAK,CAAC,KAAKvD,SAAS,IACzC,IAAA0D,wBAAkB,EAACH,KAAK,CAAC,KAAKvD,SAAS;AAE3C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;AAuBO,MAAM2D,sBAAsB,GACjCjB,WAA0C,IAE1CZ,UAAU,CAA6B9B,SAAS,EAAGkC,MAAM,IACvDlB,cAAM,CAACT,OAAO,CAAC2B,MAAM,CAACpC,IAAI,EAAGuD,QAAQ,IAAI;EACvC,MAAMC,QAAQ,GAAG,IAAAM,wBAAkB,EAAClB,WAAW,CAAC,CAACrC,KAAK;EACtD,IAAI,CAAC+C,sBAAsB,CAACC,QAAQ,EAAEC,QAAQ,CAAC,EAAE;IAC/C,OAAOtC,cAAM,CAACuB,IAAI;EACpB;EACA;EACA;EACA;EACA,MAAMsB,SAAS,GAAGpB,WAAW,CAACC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,kBAAkB;EACnE,OAAO,IAAI/C,oBAAoB,CAAC;IAAEC,QAAQ,EAAEiE;EAAS,CAAE,CAAC;AAC1D,CAAC,CAAC,CACH;AAEH;;;;;;;AAAAvE,OAAA,CAAAqE,sBAAA,GAAAA,sBAAA;AAOO,MAAMG,uBAAuB,GAAAxE,OAAA,CAAAwE,uBAAA,gBAEhChC,UAAU,cAACK,cAAM,CAAC4B,IAAI,EAAmB,EAAG7B,MAAM,IACpDlB,cAAM,CAACb,GAAG,CAAC+B,MAAM,CAACpC,IAAI,EAAGA,IAAI,IAC3BqC,cAAM,CAAC6B,aAAa,CAACnE,sBAAsB,CAACC,IAAI,CAAC,CAAC,CACnD,CACF","ignoreList":[]}

package/dist/cjs/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","names":["_effect","require","_deserialiseThenDecode","_errors","_Serializer","makeRegistry","defs","map","Map","def","has","type","Error","set","schema","decode","event","Effect","gen","get","undefined","fail","UnknownEventType","serializer","Serializer","payload","deserialiseThenDecode","data","exports"],"sources":["../../src/registry.ts"],"sourcesContent":[null],"mappings":";;;;;;AA2BA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAEA,IAAAG,WAAA,GAAAH,OAAA;AAqBO,MAAMI,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,IACZC,cAAM,CAACC,GAAG,CAAC,aAAS;MAClB,MAAMJ,MAAM,GAAGP,GAAG,CAACY,GAAG,CAACH,KAAK,CAACL,IAAI,CAAC;MAClC,IAAIG,MAAM,KAAKM,SAAS,EAAE;QACxB,OAAO,OAAOH,cAAM,CAACI,IAAI,CAAC,IAAIC,wBAAgB,CAAC;UAAEX,IAAI,EAAEK,KAAK,CAACL;QAAI,CAAE,CAAC,CAAC;MACvE;MACA,MAAMY,UAAU,GAAG,OAAOC,sBAAU;MACpC,MAAMC,OAAO,GAAG,OAAO,IAAAC,4CAAqB,EAC1CH,UAAU,EACVT,MAAM,EACNE,KAAK,CAACW,IAAI,CACX;MACD,OAAO;QAAEhB,IAAI,EAAEK,KAAK,CAACL,IAAI;QAAEc;MAAO,CAAE;MACpC;MACA;MACA;MACA;IACF,CAAC;GAKJ;AACH,CAAC;AAAAG,OAAA,CAAAvB,YAAA,GAAAA,YAAA","ignoreList":[]}
+{"version":3,"file":"registry.js","names":["_effect","require","_deserialiseThenDecode","_errors","_Serializer","makeRegistry","defs","map","Map","def","has","type","Error","set","schema","decode","event","Effect","gen","get","undefined","fail","UnknownEventType","serializer","Serializer","payload","deserialiseThenDecode","data","exports"],"sources":["../../src/registry.ts"],"sourcesContent":[null],"mappings":";;;;;;AA2BA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAEA,IAAAG,WAAA,GAAAH,OAAA;AAqBO,MAAMI,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,IACZC,cAAM,CAACC,GAAG,CAAC,aAAS;MAClB,MAAMJ,MAAM,GAAGP,GAAG,CAACY,GAAG,CAACH,KAAK,CAACL,IAAI,CAAC;MAClC,IAAIG,MAAM,KAAKM,SAAS,EAAE;QACxB,OAAO,OAAOH,cAAM,CAACI,IAAI,CAAC,IAAIC,wBAAgB,CAAC;UAAEX,IAAI,EAAEK,KAAK,CAACL;QAAI,CAAE,CAAC,CAAC;MACvE;MACA,MAAMY,UAAU,GAAG,OAAOC,sBAAU;MACpC,MAAMC,OAAO,GAAG,OAAO,IAAAC,4CAAqB,EAC1CH,UAAU,EACVT,MAAM,EACNE,KAAK,CAACW,IAAI,CACX;MACD,OAAO;QAAEhB,IAAI,EAAEK,KAAK,CAACL,IAAI;QAAEc;MAAO,CAAE;MACpC;MACA;MACA;MACA;IACF,CAAC;GAKJ;AACH,CAAC;AAAAG,OAAA,CAAAvB,YAAA,GAAAA,YAAA","ignoreList":[]}

package/dist/cjs/toEvent.js

@@ -4,10 +4,33 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.toEvent = void 0;
+var _core = require("@kairos-es/core");
 var _effect = require("effect");
 var _errors = require("./errors.js");
+var _MetadataSource = require("./MetadataSource.js");
 var _Serializer = require("./Serializer.js");
 var _Uuid = require("./Uuid.js");
+/**
+ * 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.
+ */
+
 /**
  * Encode `payload` under `def` and stamp it into a wire `DcbEvent`, deriving its
  * `tags` from `def.tagsFor(payload)` (a throwing mapper surfaces as a
@@ -16,10 +39,40 @@ var _Uuid = require("./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'`.
  */
 const toEvent = (def, payload, options) => _effect.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 ? _effect.Option.getOrElse(yield* _effect.Effect.serviceOption(_MetadataSource.MetadataSource), () => ({})) : options.metadata;
+  const metadata = {
+    ...(yield* _effect.Schema.decodeUnknownEffect(_core.Metadata)(given).pipe(_effect.Effect.mapError(cause => new _errors.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
@@ -32,7 +85,7 @@ const toEvent = (def, payload, options) => _effect.Effect.gen(function* () {
     })
   });
   const serializer = yield* _Serializer.Serializer;
-  const encoded = yield* _effect.Schema.encode(def.schema)(payload).pipe(_effect.Effect.mapError(cause => new _errors.CodecError({
+  const encoded = yield* _effect.Schema.encodeEffect(def.schema)(payload).pipe(_effect.Effect.mapError(cause => new _errors.CodecError({
     reason: 'encode',
     cause
   })));
@@ -44,7 +97,8 @@ const toEvent = (def, payload, options) => _effect.Effect.gen(function* () {
     data,
     tags,
     uuid,
-    occurredAt
+    occurredAt,
+    metadata
   };
 });
 exports.toEvent = toEvent;

package/dist/cjs/toEvent.js.map

@@ -1 +1 @@
-{"version":3,"file":"toEvent.js","names":["_effect","require","_errors","_Serializer","_Uuid","toEvent","def","payload","options","Effect","gen","tags","try","tagsFor","catch","cause","CodecError","reason","serializer","Serializer","encoded","Schema","encode","schema","pipe","mapError","data","serialise","uuid","Uuid","generate","occurredAt","DateTime","now","type","exports"],"sources":["../../src/toEvent.ts"],"sourcesContent":[null],"mappings":";;;;;;AAcA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,WAAA,GAAAF,OAAA;AACA,IAAAG,KAAA,GAAAH,OAAA;AAEA;;;;;;;;;;AAUO,MAAMI,OAAO,GAAGA,CACrBC,GAAsB,EACtBC,OAAU,EACVC,OAGC,KAEDC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB;EACA;EACA;EACA;EACA;EACA,MAAMC,IAAI,GAAG,OAAOF,cAAM,CAACG,GAAG,CAAC;IAC7BA,GAAG,EAAEA,CAAA,KAAMN,GAAG,CAACO,OAAO,CAACN,OAAO,CAAC;IAC/BO,KAAK,EAAGC,KAAK,IAAK,IAAIC,kBAAU,CAAC;MAAEC,MAAM,EAAE,MAAM;MAAEF;IAAK,CAAE;GAC3D,CAAC;EACF,MAAMG,UAAU,GAAG,OAAOC,sBAAU;EACpC,MAAMC,OAAO,GAAG,OAAOC,cAAM,CAACC,MAAM,CAAChB,GAAG,CAACiB,MAAM,CAAC,CAAChB,OAAO,CAAC,CAACiB,IAAI,CAC5Df,cAAM,CAACgB,QAAQ,CAAEV,KAAK,IAAK,IAAIC,kBAAU,CAAC;IAAEC,MAAM,EAAE,QAAQ;IAAEF;EAAK,CAAE,CAAC,CAAC,CACxE;EACD,MAAMW,IAAI,GAAGR,UAAU,CAACS,SAAS,CAACP,OAAO,CAAC;EAC1C,MAAMQ,IAAI,GAAGpB,OAAO,EAAEoB,IAAI,KAAK,OAAO,CAAC,OAAOC,UAAI,EAAEC,QAAQ,CAAC;EAC7D,MAAMC,UAAU,GAAGvB,OAAO,EAAEuB,UAAU,KAAK,OAAOC,gBAAQ,CAACC,GAAG,CAAC;EAC/D,OAAO;IACLC,IAAI,EAAE5B,GAAG,CAAC4B,IAAI;IACdR,IAAI;IACJf,IAAI;IACJiB,IAAI;IACJG;GACD;AACH,CAAC,CAAC;AAAAI,OAAA,CAAA9B,OAAA,GAAAA,OAAA","ignoreList":[]}
+{"version":3,"file":"toEvent.js","names":["_core","require","_effect","_errors","_MetadataSource","_Serializer","_Uuid","toEvent","def","payload","options","Effect","gen","given","metadata","undefined","Option","getOrElse","serviceOption","MetadataSource","Schema","decodeUnknownEffect","Metadata","pipe","mapError","cause","CodecError","reason","tags","try","tagsFor","catch","serializer","Serializer","encoded","encodeEffect","schema","data","serialise","uuid","Uuid","generate","occurredAt","DateTime","now","type","exports"],"sources":["../../src/toEvent.ts"],"sourcesContent":[null],"mappings":";;;;;;AAoBA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAEA,IAAAG,eAAA,GAAAH,OAAA;AACA,IAAAI,WAAA,GAAAJ,OAAA;AACA,IAAAK,KAAA,GAAAL,OAAA;AA1BA;;;;;;;;;;;;;;;;;;;;;AA4BA;;;;;;;;;;;;;AAaO,MAAMM,OAAO,GAAGA,CACrBC,GAAsB,EACtBC,OAAU,EACVC,OAIC,KAEDC,cAAM,CAACC,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,GACTH,OAAO,EAAEI,QAAQ,KAAKC,SAAS,GAC3BC,cAAM,CAACC,SAAS,CACd,OAAON,cAAM,CAACO,aAAa,CAACC,8BAAc,CAAC,EAC3C,OAAiB,EAAE,CAAC,CACrB,GACDT,OAAO,CAACI,QAAQ;EACtB,MAAMA,QAAQ,GAAa;IACzB,IAAI,OAAOM,cAAM,CAACC,mBAAmB,CAACC,cAAQ,CAAC,CAACT,KAAK,CAAC,CAACU,IAAI,CACzDZ,cAAM,CAACa,QAAQ,CACZC,KAAK,IAAK,IAAIC,kBAAU,CAAC;MAAEC,MAAM,EAAE,UAAU;MAAEF;IAAK,CAAE,CAAC,CACzD,CACF;GACF;EACD;EACA;EACA;EACA;EACA;EACA,MAAMG,IAAI,GAAG,OAAOjB,cAAM,CAACkB,GAAG,CAAC;IAC7BA,GAAG,EAAEA,CAAA,KAAMrB,GAAG,CAACsB,OAAO,CAACrB,OAAO,CAAC;IAC/BsB,KAAK,EAAGN,KAAK,IAAK,IAAIC,kBAAU,CAAC;MAAEC,MAAM,EAAE,MAAM;MAAEF;IAAK,CAAE;GAC3D,CAAC;EACF,MAAMO,UAAU,GAAG,OAAOC,sBAAU;EACpC,MAAMC,OAAO,GAAG,OAAOd,cAAM,CAACe,YAAY,CAAC3B,GAAG,CAAC4B,MAAM,CAAC,CAAC3B,OAAO,CAAC,CAACc,IAAI,CAClEZ,cAAM,CAACa,QAAQ,CAAEC,KAAK,IAAK,IAAIC,kBAAU,CAAC;IAAEC,MAAM,EAAE,QAAQ;IAAEF;EAAK,CAAE,CAAC,CAAC,CACxE;EACD,MAAMY,IAAI,GAAGL,UAAU,CAACM,SAAS,CAACJ,OAAO,CAAC;EAC1C,MAAMK,IAAI,GAAG7B,OAAO,EAAE6B,IAAI,KAAK,OAAO,CAAC,OAAOC,UAAI,EAAEC,QAAQ,CAAC;EAC7D,MAAMC,UAAU,GAAGhC,OAAO,EAAEgC,UAAU,KAAK,OAAOC,gBAAQ,CAACC,GAAG,CAAC;EAC/D,OAAO;IACLC,IAAI,EAAErC,GAAG,CAACqC,IAAI;IACdR,IAAI;IACJT,IAAI;IACJW,IAAI;IACJG,UAAU;IACV5B;GACD;AACH,CAAC,CAAC;AAAAgC,OAAA,CAAAvC,OAAA,GAAAA,OAAA","ignoreList":[]}

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

@@ -0,0 +1,8 @@
+import { Context } from 'effect';
+declare const MetadataSource_base: Context.ServiceClass<MetadataSource, "@kairos-es/codec/MetadataSource", {
+    readonly [x: string]: string;
+}>;
+export declare class MetadataSource extends MetadataSource_base {
+}
+export {};
+//# sourceMappingURL=MetadataSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataSource.d.ts","sourceRoot":"","sources":["../../src/MetadataSource.ts"],"names":[],"mappings":"AAsCA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;;;;AAEhC,qBAAa,cAAe,SAAQ,mBAEnC;CAAG"}