@kairos-es/codec 0.0.0

package/dist/cjs/decode.js.map

@@ -0,0 +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":[]}

package/dist/cjs/deserialiseThenDecode.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deserialiseThenDecode = void 0;
+var _effect = require("effect");
+var _errors = require("./errors.js");
+const deserialiseThenDecode = (serializer, schema, bytes) => _effect.Effect.try({
+  try: () => serializer.deserialise(bytes),
+  catch: cause => new _errors.CodecError({
+    reason: 'deserialise',
+    cause
+  })
+}).pipe(_effect.Effect.flatMap(raw => _effect.Schema.decodeUnknown(schema)(raw).pipe(_effect.Effect.mapError(cause => new _errors.CodecError({
+  reason: 'decode',
+  cause
+})))));
+exports.deserialiseThenDecode = deserialiseThenDecode;
+//# sourceMappingURL=deserialiseThenDecode.js.map

package/dist/cjs/deserialiseThenDecode.js.map

@@ -0,0 +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":[]}

package/dist/cjs/errors.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnknownEventType = exports.CodecError = void 0;
+var _effect = require("effect");
+/**
+ * Tagged errors for the codec. Decode failures are values on the error channel,
+ * never defects.
+ *
+ * `CodecError` covers every serialisation/`Schema` failure on the codec path
+ * (deserialise threw, `Schema.decode`/`encode` produced a `ParseError`, 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).
+ * `UnknownEventType` is raised only on the general (registry) path, when a wire
+ * event's runtime type string is outside the registered set — the home of
+ * ADR-0005 decode-totality.
+ */
+
+/** A serialisation or `Schema` decode/encode failure on the codec path. */
+class CodecError extends /*#__PURE__*/_effect.Data.TaggedError('CodecError') {
+  /**
+   * `reason` again, as the `Error` field that says why — so the fault renders
+   * ITSELF.
+   *
+   * `Data.TaggedError` sets `name` to the tag and leaves `message` empty, so
+   * without this a `CodecError` stringifies to `'CodecError'`, and the sentence
+   * naming the schema, the event type or the missing key that failed reaches a log
+   * line only where the code doing the logging knows to reach in for `reason`.
+   * Filled, `Error.prototype.toString` yields `'CodecError: <reason>'`, which is
+   * what `Cause.pretty` (it reads `message` off anything `instanceof Error`) and the
+   * read side's projection supervisor both report — neither of them holding a table
+   * of this class's fields to keep in step with it.
+   *
+   * This class is on the package's PUBLISHED surface, so be exact about what the
+   * field moves. Everything that renders the error for a HUMAN: `String(err)`,
+   * `Cause.pretty` and therefore a failed fibre's `cause` annotation on every
+   * shipped logger, and an unhandled failure's report. Nothing that renders it for
+   * a MACHINE: `Data.Error` overrides `YieldableError`'s `toJSON` with
+   * `{ ...plainArgs, ...this }` — own enumerables plus the constructor args, and a
+   * prototype accessor is neither — so `JSON.stringify(err)` still emits the same
+   * `reason`/`_tag` and a structured log of a raw `CodecError` keeps its shape.
+   *
+   * 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.
+   */
+  get message() {
+    return this.reason;
+  }
+}
+/** A wire event whose runtime type string is outside the registry's known set. */
+exports.CodecError = CodecError;
+class UnknownEventType extends /*#__PURE__*/_effect.Data.TaggedError('UnknownEventType') {
+  /**
+   * The offending type, in a sentence saying what the registry did with it — so the
+   * fault renders ITSELF, exactly as `CodecError` above does.
+   *
+   * `Data.TaggedError` sets `name` to the tag and leaves `message` empty, so without
+   * this a decode that met an unregistered type stringifies to `'UnknownEventType'`
+   * — the one datum that makes the failure actionable, the type string itself,
+   * reaching a log line only where the logging code knows to reach in for `type`.
+   * Filled, `Error.prototype.toString` yields the tag followed by
+   * `event type 'nope.v1' is not in the registry`, which is what `Cause.pretty`
+   * prints and what an operator greps for. It matters here in particular because
+   * this class is the home of ADR-0005 decode-totality: a wire event outside the
+   * registered set is the expected consequence of a deployment reading a log a newer
+   * writer has extended, and the first question is always WHICH type — which the tag
+   * alone cannot answer.
+   *
+   * The wording deliberately differs from `CodecError`'s. That one says there is no
+   * schema for a type, and is raised on the TYPED path, where a caller named the
+   * type and the schema map it supplied has no entry for it. This one is the general
+   * (registry) path, where the type arrived off the WIRE and the registry is what
+   * does not know it. Distinct sentences keep the two greppable apart, which a
+   * shared phrasing would cost for nothing.
+   *
+   * A GETTER rather than a second field, so `type` stays the single declaration.
+   * What filling this field reaches, what it deliberately leaves untouched, and why
+   * a prototype accessor is visible at all are argued once on `CodecError` above and
+   * not restated here — it is the same package, the same published surface and the
+   * same mechanism, and two copies of that paragraph would be two things to keep in
+   * step. The read side's four getters point at one home for the identical reason.
+   */
+  get message() {
+    return `event type '${this.type}' is not in the registry`;
+  }
+}
+exports.UnknownEventType = UnknownEventType;
+//# sourceMappingURL=errors.js.map

package/dist/cjs/errors.js.map

@@ -0,0 +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":[]}

package/dist/cjs/event.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.event = void 0;
+var _effect = require("effect");
+/**
+ * Define an event from a versioned `type` literal, its payload `fields`, and its
+ * required `tagsFor` mapper. Builds `Schema.Struct(fields)` and brands the type
+ * literal *once* (the single sanctioned cast). The returned def is typed so
+ * `def.type` is a branded literal assignable to core's `EventType` with no
+ * consumer cast, `A`/`I`/`R` are inferred from the struct, and `tagsFor`
+ * receives the def's decoded payload type.
+ */
+const event = (type, fields, tagsFor) => {
+  const schema = _effect.Schema.Struct(fields);
+  return {
+    // The single EventType brand, applied once inside event(); no consumer casts.
+    type: type,
+    schema,
+    tagsFor
+  };
+};
+exports.event = event;
+//# sourceMappingURL=event.js.map

package/dist/cjs/event.js.map

@@ -0,0 +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":[]}

package/dist/cjs/index.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CodecError", {
+  enumerable: true,
+  get: function () {
+    return _errors.CodecError;
+  }
+});
+Object.defineProperty(exports, "Serializer", {
+  enumerable: true,
+  get: function () {
+    return _Serializer.Serializer;
+  }
+});
+Object.defineProperty(exports, "SerializerDefault", {
+  enumerable: true,
+  get: function () {
+    return _Serializer.SerializerDefault;
+  }
+});
+Object.defineProperty(exports, "UnknownEventType", {
+  enumerable: true,
+  get: function () {
+    return _errors.UnknownEventType;
+  }
+});
+Object.defineProperty(exports, "Uuid", {
+  enumerable: true,
+  get: function () {
+    return _Uuid.Uuid;
+  }
+});
+Object.defineProperty(exports, "UuidLive", {
+  enumerable: true,
+  get: function () {
+    return _Uuid.UuidLive;
+  }
+});
+Object.defineProperty(exports, "UuidTest", {
+  enumerable: true,
+  get: function () {
+    return _Uuid.UuidTest;
+  }
+});
+Object.defineProperty(exports, "buildDecisionModel", {
+  enumerable: true,
+  get: function () {
+    return _decisionModel.buildDecisionModel;
+  }
+});
+Object.defineProperty(exports, "decider", {
+  enumerable: true,
+  get: function () {
+    return _decider.decider;
+  }
+});
+Object.defineProperty(exports, "decodeSlices", {
+  enumerable: true,
+  get: function () {
+    return _decode.decodeSlices;
+  }
+});
+Object.defineProperty(exports, "event", {
+  enumerable: true,
+  get: function () {
+    return _event.event;
+  }
+});
+Object.defineProperty(exports, "makeRegistry", {
+  enumerable: true,
+  get: function () {
+    return _registry.makeRegistry;
+  }
+});
+Object.defineProperty(exports, "modelAtHead", {
+  enumerable: true,
+  get: function () {
+    return _decisionModel.modelAtHead;
+  }
+});
+Object.defineProperty(exports, "projection", {
+  enumerable: true,
+  get: function () {
+    return _projection.projection;
+  }
+});
+Object.defineProperty(exports, "runDecider", {
+  enumerable: true,
+  get: function () {
+    return _decider.runDecider;
+  }
+});
+Object.defineProperty(exports, "toEvent", {
+  enumerable: true,
+  get: function () {
+    return _toEvent.toEvent;
+  }
+});
+var _decider = require("./decider.js");
+var _decisionModel = require("./decisionModel.js");
+var _decode = require("./decode.js");
+var _errors = require("./errors.js");
+var _event = require("./event.js");
+var _projection = require("./projection.js");
+var _registry = require("./registry.js");
+var _Serializer = require("./Serializer.js");
+var _toEvent = require("./toEvent.js");
+var _Uuid = require("./Uuid.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_decider","require","_decisionModel","_decode","_errors","_event","_projection","_registry","_Serializer","_toEvent","_Uuid"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAD,OAAA;AAKA,IAAAE,OAAA,GAAAF,OAAA;AACA,IAAAG,OAAA,GAAAH,OAAA;AACA,IAAAI,MAAA,GAAAJ,OAAA;AACA,IAAAK,WAAA,GAAAL,OAAA;AAKA,IAAAM,SAAA,GAAAN,OAAA;AACA,IAAAO,WAAA,GAAAP,OAAA;AACA,IAAAQ,QAAA,GAAAR,OAAA;AACA,IAAAS,KAAA,GAAAT,OAAA","ignoreList":[]}

package/dist/cjs/projection.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.projection = void 0;
+var _core = require("@kairos-es/core");
+/**
+ * The typed slice path (primary): a schema-backed projection and the fluent
+ * builder that produces it.
+ *
+ * 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'
+ * 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.
+ *
+ * `projection(initialState).on(def, fold)...build()` infers the state `S` and
+ * the union `R` of the `.on`-ed defs' requirements, derives the read `Query`'s
+ * event-types from the defs' branded type literals (no `as EventType`), and
+ * hands each `fold` its decoded, typed payload. A handler for an un-imported
+ * event is therefore a compile error, and a mistyped type cannot silently match
+ * nothing.
+ */
+
+/**
+ * Start a slice for `initialState`. Returns a builder with no defs yet
+ * (`R = never`); each `.on(def, fold)` widens `R` by the def's requirement.
+ */
+const projection = initialState => {
+  // Persistent builder: `make` closes over the accumulated maps, and each
+  // `.on` copies them into a fresh builder rather than mutating in place, so
+  // no two derived builders ever share mutable state (reusing an intermediate
+  // builder can't cross-contaminate slices).
+  //
+  // `make` is generic in the accumulated requirement `R` — the parameter the
+  // builder is *about*. Pinning it to `never` and casting the result back would
+  // make the recursion typecheck by discarding the very thing each `.on` adds;
+  // threading `R` means the implementation states the same widening the
+  // `ProjectionBuilder` interface promises, and `on` returns without a cast.
+  const make = (schemas, folds) => ({
+    on: (def, fold) => {
+      // A repeated type WITHIN one chain is unambiguously a mistake, so this is
+      // a plain `has` rather than the reference-equality rule `mergeSliceSchemas`
+      // applies ACROSS slices. There, two entries for one type are the intended
+      // way to feed one event into two views, and the schemas being one object is
+      // what makes the collision harmless. Here there is only ever one fold per
+      // type — `evolve` dispatches by type into a single map — so a second `.on`
+      // cannot mean "as well as", only "instead of", and it silently discards
+      // the author's first fold along with its schema. The asymmetry is the
+      // point: the same `has` up there would outlaw the legitimate case.
+      if (schemas.has(def.type)) {
+        throw new Error(`duplicate event type '${def.type}' in slice: .on was called twice ` + 'for it, and the second fold would silently replace the first. ' + 'Handle both cases in one fold.');
+      }
+      // 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
+      // 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
+      // 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);
+      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
+      // matching def decoded, which is the `A` this fold was written against.
+      nextFolds.set(def.type, fold);
+      return make(nextSchemas, nextFolds);
+    },
+    build: options => {
+      // Internal-layer Query assembly from plain data (see core's Projection.ts
+      // note): a type-only-plus-optional-tags item the public surface withholds.
+      const types = [...schemas.keys()].map(t => _core.EventType.make(t));
+      const query = {
+        items: [{
+          types,
+          tags: options?.tags ?? []
+        }]
+      };
+      return {
+        initialState,
+        query,
+        // Defensive copy: hand out a fresh Map, not the builder's own. `schemas`
+        // is typed `ReadonlyMap`, but that is a compile-time guard only — a
+        // caller who casts it back to `Map` could otherwise mutate the slice's
+        // live decode table after `build`, desyncing it from `query` (whose
+        // event-types were snapshotted from these keys just above). The copy is
+        // cheap (a handful of keys) and makes the slice genuinely immutable.
+        schemas: new Map(schemas),
+        // Erased evolve: dispatch by the sequenced event's type to the matching
+        // fold over the decoded payload. Per the `AnyProjection.evolve` contract
+        // (core), a projection is only ever handed events matching its `query` —
+        // `composeProjections` gates each sub before dispatch — so this needs no
+        // second `matchesSequenced` check; the `fold === undefined` fallback is
+        // the honest total-function guard (evolve is typed over any DecodedEvent).
+        evolve: (state, decoded) => {
+          const fold = folds.get(decoded.sequenced.event.type);
+          return fold === undefined ? state : fold(state, decoded.payload);
+        }
+      };
+    }
+  });
+  // Explicit `never`: an empty `Map` literal gives inference nothing to read the
+  // requirement off, and "no defs yet" is exactly `never`, not `unknown`.
+  return make(new Map(), new Map());
+};
+exports.projection = projection;
+//# sourceMappingURL=projection.js.map

package/dist/cjs/projection.js.map

@@ -0,0 +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":[]}

package/dist/cjs/registry.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeRegistry = void 0;
+var _effect = require("effect");
+var _deserialiseThenDecode = require("./deserialiseThenDecode.js");
+var _errors = require("./errors.js");
+var _Serializer = require("./Serializer.js");
+const makeRegistry = defs => {
+  const map = new Map();
+  for (const def of defs) {
+    if (map.has(def.type)) {
+      throw new Error(`duplicate event type '${def.type}' in registry`);
+    }
+    map.set(def.type, def.schema);
+  }
+  return {
+    decode: event => _effect.Effect.gen(function* () {
+      const schema = map.get(event.type);
+      if (schema === undefined) {
+        return yield* _effect.Effect.fail(new _errors.UnknownEventType({
+          type: event.type
+        }));
+      }
+      const serializer = yield* _Serializer.Serializer;
+      const payload = yield* (0, _deserialiseThenDecode.deserialiseThenDecode)(serializer, schema, event.data);
+      return {
+        type: event.type,
+        payload
+      };
+      // The schema map erases `R` to `unknown`; the declared `R` is recovered
+      // from `Defs` at the type level, so the gen block's inferred requirement
+      // (`unknown`) is re-stated as `Serializer | R` here, which is this
+      // module's only cast.
+    })
+  };
+};
+exports.makeRegistry = makeRegistry;
+//# sourceMappingURL=registry.js.map

package/dist/cjs/registry.js.map

@@ -0,0 +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":[]}

package/dist/cjs/toEvent.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toEvent = void 0;
+var _effect = require("effect");
+var _errors = require("./errors.js");
+var _Serializer = require("./Serializer.js");
+var _Uuid = require("./Uuid.js");
+/**
+ * Encode `payload` under `def` and stamp it into a wire `DcbEvent`, deriving its
+ * `tags` from `def.tagsFor(payload)` (a throwing mapper surfaces as a
+ * `CodecError`, not a defect). The tags are stamped exactly as the mapper
+ * returns them — no dedup or reordering. `type` and `tags` are cleartext
+ * 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.
+ */
+const toEvent = (def, payload, options) => _effect.Effect.gen(function* () {
+  // Derive tags first. 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
+  // consuming the `Uuid` sequence.
+  const tags = yield* _effect.Effect.try({
+    try: () => def.tagsFor(payload),
+    catch: cause => new _errors.CodecError({
+      reason: 'tags',
+      cause
+    })
+  });
+  const serializer = yield* _Serializer.Serializer;
+  const encoded = yield* _effect.Schema.encode(def.schema)(payload).pipe(_effect.Effect.mapError(cause => new _errors.CodecError({
+    reason: 'encode',
+    cause
+  })));
+  const data = serializer.serialise(encoded);
+  const uuid = options?.uuid ?? (yield* (yield* _Uuid.Uuid).generate);
+  const occurredAt = options?.occurredAt ?? (yield* _effect.DateTime.now);
+  return {
+    type: def.type,
+    data,
+    tags,
+    uuid,
+    occurredAt
+  };
+});
+exports.toEvent = toEvent;
+//# sourceMappingURL=toEvent.js.map

package/dist/cjs/toEvent.js.map

@@ -0,0 +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":[]}

package/dist/dts/Serializer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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
+ * `Serializer` from context, so encode and decode cannot mismatch; swapping
+ * JSON for msgpack is a different layer with no schema or call-site changes.
+ *
+ * `deserialise` may throw synchronously (corrupt bytes): wrapping it as a
+ * `CodecError` is the *caller's* concern — every decode site wraps it in
+ * `Effect.try`. Keeping the service interface plain (no Effect) lets a layer be
+ * a trivial `Layer.succeed`.
+ */
+import { Context, Layer } from 'effect';
+declare const Serializer_base: Context.TagClass<Serializer, "@kairos-es/codec/Serializer", {
+    readonly serialise: (v: unknown) => Uint8Array;
+    readonly deserialise: (b: Uint8Array) => unknown;
+}>;
+export declare class Serializer extends Serializer_base {
+}
+/**
+ * The shipped default: JSON over UTF-8. `serialise` = `JSON.stringify` then
+ * `TextEncoder`; `deserialise` = `TextDecoder` then `JSON.parse` (which throws
+ * synchronously on corrupt bytes, wrapped to `CodecError` at the call site).
+ */
+export declare const SerializerDefault: Layer.Layer<Serializer>;
+export {};
+//# sourceMappingURL=Serializer.d.ts.map

package/dist/dts/Serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serializer.d.ts","sourceRoot":"","sources":["../../src/Serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;;wBAKf,CAAC,CAAC,EAAE,OAAO,KAAK,UAAU;0BACxB,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO;;AAJpD,qBAAa,UAAW,SAAQ,eAM7B;CAAG;AAKN;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAMrD,CAAA"}

package/dist/dts/Uuid.d.ts

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer } from 'effect';
+declare const Uuid_base: Context.TagClass<Uuid, "@kairos-es/codec/Uuid", {
+    readonly generate: Effect.Effect<string>;
+}>;
+export declare class Uuid extends Uuid_base {
+}
+/** Live uuid generation via WebCrypto (no `node:crypto`). */
+export declare const UuidLive: Layer.Layer<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
+ * yields a stable v4-shaped sequence `00000000-0000-4000-8000-<12 hex>` starting
+ * at `...000000000000`. Generation is wrapped in `Effect.sync` because the
+ * generator advances its counter (a side effect on each call).
+ */
+export declare const UuidTest: Layer.Layer<Uuid>;
+export {};
+//# sourceMappingURL=Uuid.d.ts.map

package/dist/dts/Uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uuid.d.ts","sourceRoot":"","sources":["../../src/Uuid.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;;uBAIxB,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;;AAF5C,qBAAa,IAAK,SAAQ,SAGvB;CAAG;AAEN,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAErC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAGrC,CAAA"}