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

package/dist/{dts → dts-cjs}/Serializer.d.ts

@@ -1,7 +1,7 @@
 /**
  * The pluggable serialiser: the `Uint8Array` <-> value boundary applied
- * *outside* `Schema`. Encode is `Schema.encode` then `serialise`; decode is
- * `deserialise` then `Schema.decodeUnknown`. Both codec paths read the same
+ * *outside* `Schema`. Encode is `Schema.encodeEffect` then `serialise`; decode is
+ * `deserialise` then `Schema.decodeUnknownEffect`. Both codec paths read the same
  * `Serializer` from context, so encode and decode cannot mismatch; swapping
  * JSON for msgpack is a different layer with no schema or call-site changes.
  *
@@ -11,7 +11,7 @@
  * a trivial `Layer.succeed`.
  */
 import { Context, Layer } from 'effect';
-declare const Serializer_base: Context.TagClass<Serializer, "@kairos-es/codec/Serializer", {
+declare const Serializer_base: Context.ServiceClass<Serializer, "@kairos-es/codec/Serializer", {
     readonly serialise: (v: unknown) => Uint8Array;
     readonly deserialise: (b: Uint8Array) => unknown;
 }>;

package/dist/{dts → dts-cjs}/Serializer.d.ts.map

@@ -1 +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"}
+{"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,eAME;CAAG;AAKrC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAMrD,CAAA"}

package/dist/{dts → dts-cjs}/Uuid.d.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer } from 'effect';
-declare const Uuid_base: Context.TagClass<Uuid, "@kairos-es/codec/Uuid", {
+declare const Uuid_base: Context.ServiceClass<Uuid, "@kairos-es/codec/Uuid", {
     readonly generate: Effect.Effect<string>;
 }>;
 export declare class Uuid extends Uuid_base {
@@ -9,9 +9,12 @@ 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
+ * Each BUILD of the layer makes a fresh generator, so it owns its own counter and
  * yields a stable v4-shaped sequence `00000000-0000-4000-8000-<12 hex>` starting
- * at `...000000000000`. Generation is wrapped in `Effect.sync` because the
+ * at `...000000000000`. A build is not one per `Effect.provide`: Effect memoises
+ * a layer across the provisions that share a memo map, so a nested second
+ * provision of this layer continues the counter rather than restarting it, and
+ * `Layer.fresh` is the way to ask for a restart. Generation is wrapped in `Effect.sync` because the
  * generator advances its counter (a side effect on each call).
  */
 export declare const UuidTest: Layer.Layer<Uuid>;

package/dist/{dts → dts-cjs}/Uuid.d.ts.map

@@ -1 +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"}
+{"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,SAGE;CAAG;AAE/B,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAErC,CAAA;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAGrC,CAAA"}

package/dist/{dts → dts-cjs}/decider.d.ts

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

package/dist/{dts → dts-cjs}/decider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decider.d.ts","sourceRoot":"","sources":["../../src/decider.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"decider.d.ts","sourceRoot":"","sources":["../../src/decider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACd,QAAQ,EACT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,QAAQ,CAAA;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,OAAO,CACtB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK,EACT,CAAC,SAAS,cAAc,GAAG,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC;IAE9D,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,CAAC,CAAA;IAC7C,QAAQ,CAAC,MAAM,EAAE,CACf,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EACxB,OAAO,EAAE,OAAO,KACb,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,CAAA;CAChD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAgB,OAAO,CACrB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,GAAG,SAAS,MAAM,CAAC,MAAM,CACvB,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EACnC,OAAO,EACP,OAAO,CACR,EAED,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,CAAC,EACpC,MAAM,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,KAAK,GAAG,GAC1D,OAAO,CACR,CAAC,EACD,OAAO,EACP,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC,CACjD,CAAA;AACD,wBAAgB,OAAO,CACrB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,GAAG,SAAS,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,EAAE,OAAO,CAAC,EAE3D,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,CAAC,EACpC,MAAM,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,KAAK,GAAG,GAC1D,OAAO,CACR,CAAC,EACD,OAAO,EACP,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC,EAChD,cAAc,CACf,CAAA;AAiBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,UAAU,GACrB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,CAAC,EACD,CAAC,EACD,CAAC,SAAS,cAAc,GAAG,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAE9D,SAAS,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACrC,SAAS,OAAO,KACf,MAAM,CAAC,MAAM,CACd,cAAc,CAAC,CAAC,CAAC,EACjB,CAAC,GAAG,UAAU,GAAG,qBAAqB,GAAG,oBAAoB,EAC7D,aAAa,GAAG,UAAU,GAAG,IAAI,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAgBtD,CAAA"}

package/dist/{dts → dts-cjs}/decision.d.ts

@@ -66,7 +66,7 @@
  *   channels; an overloaded step would lose both to `unknown`.
  *
  * `decider(…)` cannot be served by a conditional at all. Its `O` is derived from
- * the SUCCESS of an effect type variable, and `Effect.Effect.Success` of a type
+ * the SUCCESS of an effect type variable, and `Effect.Success` of a type
  * variable is itself deferred, so a wrapper that copies `decider`'s own generics
  * would get a `Decider` whose `O` nothing can resolve, and a runner result that
  * is not `Position`. So `decider` is declared TWICE, which asks the question by
@@ -100,7 +100,7 @@ export declare const UnchangedTypeId: unique symbol;
 export type UnchangedTypeId = typeof UnchangedTypeId;
 declare const Unchanged_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
     readonly _tag: "Unchanged";
-};
+} & import("effect/Pipeable").Pipeable;
 /**
  * "Nothing to do: this work is already done." A runner that receives it appends
  * nothing and returns it in place of a `Position`.

package/dist/{dts → dts-cjs}/decode.d.ts

@@ -20,10 +20,10 @@
  * than memory.
  *
  * Be precise about what adding `concurrency` here would and would not cost,
- * because the obvious reason is the wrong one. Effect v3's `mapEffect` is
+ * because the obvious reason is the wrong one. Effect's `mapEffect` is
  * order-PRESERVING even when concurrent — reordering needs the separate
- * `unordered: true` option (verified against the installed
- * `effect@3.22`'s `Stream.d.ts`, and probed at runtime) — so a bare
+ * `unordered: true` option (verified against `effect@4`'s `Channel.mapEffect`,
+ * which takes the ordered path unless that option is set) — so a bare
  * `concurrency` would NOT hand the fold its events out of position order. What
  * it would actually cost is the back-pressure above, and it would run
  * application-authored `Schema` transforms (an ADR-0004 decryption hook, say)

package/dist/{dts → dts-cjs}/decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/decode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACnE,OAAO,EAAuB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAIpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AA0JzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACpE,QAAQ,CAAC,KACR,CAAC,CAAC,CAAC,EAAE,CAAC,EACP,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC,KACxC,MAAM,CAAC,MAAM,CAChB,YAAY,EACZ,CAAC,GAAG,UAAU,EACd,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,UAAU,CAClC,CAA4C,CAAA"}
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/decode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACnE,OAAO,EAAuB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAIpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAoJzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACpE,QAAQ,CAAC,KACR,CAAC,CAAC,CAAC,EAAE,CAAC,EACP,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC,KACxC,MAAM,CAAC,MAAM,CAChB,YAAY,EACZ,CAAC,GAAG,UAAU,EACd,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,UAAU,CAClC,CAA4C,CAAA"}

package/dist/{dts → dts-cjs}/deserialiseThenDecode.d.ts

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

package/dist/{dts → dts-cjs}/deserialiseThenDecode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deserialiseThenDecode.d.ts","sourceRoot":"","sources":["../../src/deserialiseThenDecode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C,eAAO,MAAM,qBAAqB,GAAI,CAAC,EACrC,YAAY,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,EAC3C,QAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,EAC1C,OAAO,UAAU,KAChB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,CAUpC,CAAA"}
+{"version":3,"file":"deserialiseThenDecode.d.ts","sourceRoot":"","sources":["../../src/deserialiseThenDecode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C,eAAO,MAAM,qBAAqB,GAAI,CAAC,EACrC,YAAY,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,EACpD,QAAQ,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAClC,OAAO,UAAU,KAChB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,CAUpC,CAAA"}

package/dist/{dts → dts-cjs}/errors.d.ts

@@ -30,9 +30,10 @@ export declare class CodecError extends CodecError_base<{
      *
      * 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(): string;
 }

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":";;;AAgBA,2EAA2E;AAC3E,qBAAa,UAAW,SAAQ,gBAA+B;IAC7D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC;IACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,kFAAkF;AAClF,qBAAa,gBAAiB,SAAQ,sBAAqC;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAC;IACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/{dts → dts-cjs}/event.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/event.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,QAAQ,CAAA;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,GAAG,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAA;AAEvE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,KAAK;IAC3D,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CAC7B;AAED;;;;;GAKG;AAEH,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,CAAA;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,GAChB,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,MAAM,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EAEnC,MAAM,IAAI,EACV,QAAQ,MAAM,EACd,SAAS,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAC3C;IACD,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAA;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACtC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;CAStD,CAAA"}

package/dist/{dts → dts-cjs}/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsHG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC7D,OAAO,EACL,QAAQ,EACR,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,WAAW,EACX,SAAS,EACT,eAAe,GAChB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,KAAK,aAAa,GACnB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,KAAK,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EACL,UAAU,EACV,KAAK,YAAY,EACjB,QAAQ,EACR,YAAY,GACb,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,KAAK,iBAAiB,EACtB,UAAU,EACV,KAAK,eAAe,GACrB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,GAAG,EACR,eAAe,EACf,UAAU,EACV,oBAAoB,GACrB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,YAAY,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAA;AACxD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA"}

package/dist/dts-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/{dts → dts-cjs}/precondition.d.ts

@@ -137,7 +137,7 @@ import type { Uuid } from './Uuid.js';
  * path meant to deny the input cheaply. Wrap such work in `Effect.suspend`.
  */
 export interface Precondition<Id, Service, E, R> {
-    readonly tag: Context.Tag<Id, Service>;
+    readonly tag: Context.Key<Id, Service>;
     readonly evaluate: Effect.Effect<Service, E, R>;
 }
 /**
@@ -211,7 +211,7 @@ export declare const decideOnly: <P extends Record<string, SliceProjection>, Com
  * 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.

package/dist/{dts → dts-cjs}/projection.d.ts

@@ -5,7 +5,7 @@
  * A `SliceProjection<S, R>` is a core `AnyProjection<S>` (directly composable —
  * its `evolve` folds a `DecodedEvent`) enriched with the `type -> Schema` map
  * `decodeSlices` merges and decodes through. That map's value type carries `R`
- * covariantly (`Schema<unknown, unknown, R>`), so the union of the defs'
+ * covariantly (`Schema.Decoder<unknown, R>`), so the union of the defs'
  * requirements flows to the decision model with no cast (and no phantom marker).
  * Because `evolve` is already erased, a built slice drops straight into
  * `composeProjections` — no `AnyProjection.of` ceremony.
@@ -27,7 +27,7 @@ import type { EventDef } from './event.js';
  * (and the `out R` annotation keeps union-widening sound) with no phantom marker.
  */
 export interface SliceProjection<out S = unknown, out R = unknown> extends AnyProjection<S> {
-    readonly schemas: ReadonlyMap<string, Schema.Schema<unknown, unknown, R>>;
+    readonly schemas: ReadonlyMap<string, Schema.Decoder<unknown, R>>;
 }
 /** The fluent builder: accumulate `.on(def, fold)` steps, then `.build()`. */
 export interface ProjectionBuilder<S, R = never> {

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

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../src/projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EACL,KAAK,aAAa,EAIlB,KAAK,GAAG,EACT,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;;GAKG;AACH,MAAM,WAAW,eAAe,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,CAAC,CAAC,GAAG,OAAO,CAC/D,SAAQ,aAAa,CAAC,CAAC,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAA;CAClE;AAED,8EAA8E;AAC9E,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK;IAC7C;;;;;;;OAOG;IACH,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EACT,GAAG,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EACvB,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,GAChC,iBAAiB,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IAC/B;;;OAGG;IACH,KAAK,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAA;KAAE,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CAC/E;AAED;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,cAAc,CAAC,KAAG,iBAAiB,CAAC,CAAC,EAAE,KAAK,CA4FzE,CAAA"}

package/dist/{dts → dts-cjs}/readLedger.d.ts

@@ -76,7 +76,7 @@ export interface Hop {
     readonly query: Query;
     readonly head?: Position;
 }
-declare const ReadLedger_base: Context.TagClass<ReadLedger, "@kairos-es/codec/ReadLedger", {
+declare const ReadLedger_base: Context.ServiceClass<ReadLedger, "@kairos-es/codec/ReadLedger", {
     /**
      * File a query, and hand back the effect that will fill in its head.
      *
@@ -101,7 +101,7 @@ declare const ReadLedger_base: Context.TagClass<ReadLedger, "@kairos-es/codec/Re
  * 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
@@ -117,8 +117,8 @@ export declare class ReadLedger extends ReadLedger_base {
  * Fill in a recorded hop's head. Never called if the read does not complete.
  *
  * On the package's public surface because it is already ON it: `record` returns
- * one, `ReadLedger` is exported, so a consumer holding the tag holds this type and
- * could not name it. `Hop` was exported and this was not — the same interface, two
+ * one, `ReadLedger` is exported, so a consumer holding the service holds this
+ * type and could not name it. `Hop` was exported and this was not — the same interface, two
  * treatments.
  */
 export type CloseHop = (head: Position) => Effect.Effect<void>;

package/dist/{dts → dts-cjs}/readLedger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readLedger.d.ts","sourceRoot":"","sources":["../../src/readLedger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,QAAQ,EACR,KAAK,EACN,MAAM,iBAAiB,CAAA;AAOxB,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAO,MAAM,QAAQ,CAAA;AAElE;;;;;;;GAOG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CACzB;;IAuBG;;;;;;;;;;;;OAYG;qBACc,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;mBAC3C,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;;AAnCpD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,UAAW,SAAQ,eAmB7B;CAAG;AAEN;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;;;;AAE9D;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,eAAgB,SAAQ,qBACnC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CACrB;IACC;;;;;;;OAOG;IACH,IAAa,OAAO,IAAI,MAAM,CAM7B;CACF;;;;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,oBAAqB,SAAQ,0BAExC;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;IAC9B,2DAA2D;IAC3D,IAAa,OAAO,IAAI,MAAM,CAO7B;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,aAAa,CAAC,GAAG,CAAC,KACvB,eAAe,GAAG,SAiBpB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAA;CACjD,CAsBC,CAAA;AAsBF;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,KAAK,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CACT,CAAA;AAqBxD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,sBAAsB,GACjC,aAAa,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KACzC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,oBAAoB,CAaxC,CAAA;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,CACjD,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAK/B,CAAA"}
+{"version":3,"file":"readLedger.d.ts","sourceRoot":"","sources":["../../src/readLedger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,QAAQ,EACR,KAAK,EACN,MAAM,iBAAiB,CAAA;AAQxB,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAO,MAAM,QAAQ,CAAA;AAElE;;;;;;;GAOG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CACzB;;IAuBG;;;;;;;;;;;;OAYG;qBACc,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;mBAC3C,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;;AAnCpD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,UAAW,SAAQ,eAmBE;CAAG;AAErC;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;;;;AAE9D;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,eAAgB,SAAQ,qBACnC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CACrB;IACC;;;;;;;OAOG;IACH,IAAa,OAAO,IAAI,MAAM,CAM7B;CACF;;;;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,oBAAqB,SAAQ,0BAExC;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;IAC9B,2DAA2D;IAC3D,IAAa,OAAO,IAAI,MAAM,CAO7B;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,aAAa,CAAC,GAAG,CAAC,KACvB,eAAe,GAAG,SAiBpB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAA;CACjD,CAsBC,CAAA;AAsBF;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,KAAK,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CACT,CAAA;AAoCxD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,sBAAsB,GACjC,aAAa,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KACzC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,oBAAoB,CAaxC,CAAA;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,CACjD,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAK/B,CAAA"}

package/dist/{dts → dts-cjs}/toEvent.d.ts

@@ -1,7 +1,7 @@
 /**
  * Event production (codec edge-helper): turn a typed payload into a wire
- * `DcbEvent`. Encode is `Schema.encode(def.schema)` (a `ParseError` becomes a
- * `CodecError`; any encryption transform runs here, *before* serialisation)
+ * `DcbEvent`. Encode is `Schema.encodeEffect(def.schema)` (a `SchemaError`
+ * becomes a `CodecError`; any encryption transform runs here, *before* serialisation)
  * then `serialiser.serialise`. The wire `tags` are derived from the def's
  * required `tagsFor` mapper (ADR-0006) — they are never hand-passed, so two
  * command sites emitting the same event type cannot tag it differently. A mapper
@@ -10,8 +10,15 @@
  * comes from `options.uuid` or the `Uuid` service; `occurredAt` from
  * `options.occurredAt` or the Effect clock (`DateTime.now`), keeping `core`
  * clock- and RNG-free while staying overridable for backdated imports.
+ * `metadata` comes from `options.metadata` or the OPTIONAL ambient
+ * `MetadataSource` service, and is `{}` when neither supplies it (ADR-0017). A
+ * bag core's `Metadata` schema refuses, such as one holding a value that is not a
+ * string, fails on the `CodecError` channel (`reason: 'metadata'`), whichever of
+ * the two supplied it. It never reaches `tagsFor`, the
+ * event's schema or the serialiser, so it can enter neither the tag junction
+ * table nor the encryption seam.
  */
-import type { DcbEvent } from '@kairos-es/core';
+import { type DcbEvent, Metadata } from '@kairos-es/core';
 import { DateTime, Effect } from 'effect';
 import { CodecError } from './errors.js';
 import type { EventDef } from './event.js';
@@ -25,10 +32,14 @@ import { Uuid } from './Uuid.js';
  * wire-envelope fields (the query surface), so a `tagsFor` mapper may only key
  * off cleartext payload fields (ADR-0006). `uuid` / `occurredAt` are
  * exact-optional overrides; absent, they come from the `Uuid` service and the
- * Effect clock.
+ * Effect clock. `metadata` is an exact-optional override too; absent, it comes
+ * from the ambient `MetadataSource` if one is provided and is `{}` otherwise.
+ * The ambient read adds nothing to the requirement channel. A bag core's
+ * `Metadata` schema refuses fails as a `CodecError` with `reason: 'metadata'`.
  */
 export declare const toEvent: <A, I, R>(def: EventDef<A, I, R>, payload: A, options?: {
     readonly uuid?: string;
     readonly occurredAt?: DateTime.Utc;
+    readonly metadata?: Metadata;
 }) => Effect.Effect<DcbEvent, CodecError, Serializer | Uuid | R>;
 //# sourceMappingURL=toEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toEvent.d.ts","sourceRoot":"","sources":["../../src/toEvent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,KAAK,QAAQ,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAkB,MAAM,QAAQ,CAAA;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACtB,SAAS,CAAC,EACV,UAAU;IACR,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAA;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAC7B,KACA,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,GAAG,CAAC,CA4DxD,CAAA"}

package/dist/dts-esm/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-esm/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"}

package/dist/dts-esm/Serializer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The pluggable serialiser: the `Uint8Array` <-> value boundary applied
+ * *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.
+ *
+ * `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.ServiceClass<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-esm/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,eAME;CAAG;AAKrC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAMrD,CAAA"}

package/dist/dts-esm/Uuid.d.ts

@@ -0,0 +1,22 @@
+import { Context, Effect, Layer } from 'effect';
+declare const Uuid_base: Context.ServiceClass<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 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`. A build is not one per `Effect.provide`: Effect memoises
+ * a layer across the provisions that share a memo map, so a nested second
+ * provision of this layer continues the counter rather than restarting it, and
+ * `Layer.fresh` is the way to ask for a restart. Generation is wrapped in `Effect.sync` because the
+ * generator advances its counter (a side effect on each call).
+ */
+export declare const UuidTest: Layer.Layer<Uuid>;
+export {};
+//# sourceMappingURL=Uuid.d.ts.map

package/dist/dts-esm/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,SAGE;CAAG;AAE/B,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAErC,CAAA;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAGrC,CAAA"}