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

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

@@ -0,0 +1,56 @@
+/**
+ * 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.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.
+ *
+ * `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.
+ */
+import { type AnyProjection, type Tag } from '@kairos-es/core';
+import type { Schema } from 'effect';
+import type { EventDef } from './event.js';
+/**
+ * A schema-backed, directly-composable projection: an `AnyProjection<S>` plus
+ * the `type -> Schema` map for decode. The map's value type carries the union
+ * `R` of its defs' requirements covariantly, so `RequirementOf` recovers `R`
+ * (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.Decoder<unknown, R>>;
+}
+/** The fluent builder: accumulate `.on(def, fold)` steps, then `.build()`. */
+export interface ProjectionBuilder<S, R = never> {
+    /**
+     * Fold events of `def`'s type: `fold` receives the decoded, typed `payload`.
+     * Adds `def`'s requirement `R2` to the accumulated `R`.
+     *
+     * Throws if this chain has already `.on`-ed that event type — see the guard in
+     * `projection` for why a repeat is always a mistake here, where across two
+     * slices it need not be.
+     */
+    on<A, I, R2>(def: EventDef<A, I, R2>, fold: (state: S, payload: A) => S): ProjectionBuilder<S, R | R2>;
+    /**
+     * Materialise the slice. The query is a single item over the `.on`-ed defs'
+     * types (branded via `EventType.make`) and `options.tags` (default none).
+     */
+    build(options?: {
+        readonly tags?: ReadonlyArray<Tag>;
+    }): SliceProjection<S, R>;
+}
+/**
+ * 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.
+ */
+export declare const projection: <S>(initialState: S) => ProjectionBuilder<S, never>;
+//# sourceMappingURL=projection.d.ts.map

package/dist/dts-esm/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-esm/readLedger.d.ts

@@ -0,0 +1,263 @@
+/**
+ * The ambient read ledger: the hops a bracket walked, and the single derivation
+ * that turns them into one `AppendCondition`.
+ *
+ * ## The gap this closes, and why the fix has to be ambient
+ *
+ * A decision model whose second query cannot be written until an earlier read has
+ * been folded — the identifier it needs is data that fold produced — guards its
+ * append on only the LAST read if it reaches for `buildDecisionModel` there. The
+ * append then succeeds on a premise that is no longer true, and nothing warns: it
+ * compiles, it runs, and it is silent. Two things must both change for the
+ * condition to be sound, and fixing either alone still lets the stale write
+ * through. Keeping the union of queries but taking the last head misses, because
+ * the invalidating event lands in the window between the two heads. Keeping the
+ * earliest head but taking the last query misses, because the invalidating event
+ * fails that query's TYPE arm before its tag arm is reached — which is why adding
+ * a tag to the last query cannot recover it.
+ *
+ * The ledger is an OPTIONAL AMBIENT SERVICE rather than a scope object a caller
+ * threads, and that is the whole design. A scope object's guarantee is "every read
+ * through this object", which is not "every read": `modelAtHead` stays exported
+ * and stays in scope inside the bracket, so a read that reached for the familiar
+ * name — or that happened inside a helper the body merely called — drops a hop
+ * silently. Here `modelAtHead` ITSELF records, so a read is recorded whatever
+ * symbol performed it and at whatever call depth. `Effect.serviceOption` is what
+ * makes that additive: it reads the service if present and adds NOTHING to the
+ * requirement channel, so `modelAtHead`'s published signature is untouched and no
+ * existing caller provides anything.
+ *
+ * ## Why the query is recorded eagerly and the head only on completion
+ *
+ * A `Hop` is `{ query, head? }` and the two halves are recorded at different
+ * moments: the query before a single event is streamed, the head once the fold has
+ * run to completion. So a read that opened and never finished widens the guard
+ * without contributing a floor, and both halves fail safe.
+ *
+ * The laziness is deliberate protection rather than an accident of where the line
+ * sits. Recording the head at read-return is available and MUST NOT be done: a
+ * read that failed part-way folded only a PREFIX, and a head recorded for it is a
+ * claim the hop did not earn — the floor would sit above events that read never
+ * folded, and nothing would refuse an append those events invalidate.
+ *
+ * ## An invalidated ledger must REFUSE to derive, never derive narrowly
+ *
+ * Nothing here evicts a hop, so there is no eviction policy to specify — but the
+ * rule is stated now because the moment a bound is added, and an unbounded walk on
+ * a large log will want one, the tempting implementation is to drop the oldest hop
+ * and carry on. A ledger that has lost hops must become a poison value and refuse
+ * to produce a condition at all. Deriving from a PARTIAL set is worse than
+ * refusing, because it looks like it worked: an emptied ledger produces a NARROWER
+ * condition and a silent success, which is the original hazard wearing a fix's
+ * name. The valve is coarsen, then poison. Never forget.
+ *
+ * ## What is deliberately NOT exported from the package
+ *
+ * `deriveLayeredCondition` is PACKAGE-internal and reaches no entry point. Two
+ * traps stay reachable for a caller who assembles a condition by hand, both
+ * demonstrated: concatenating query items drops a wildcard hop, an empty item list
+ * being absorbing under OR while an empty concatenation contributes nothing; and a
+ * MAXIMUM over heads reads as naturally as a minimum, two reducers of identical
+ * signature where "the position I read at" argues just as fluently for the later
+ * one. Offering the derivation as a public step would put both back within reach
+ * of the callers the bracket exists to protect.
+ */
+import type { AnyProjection, AppendCondition, Position, Query } from '@kairos-es/core';
+import { Context, Effect, Layer, Option } from 'effect';
+/**
+ * One recorded read: the query it rode, and the head it observed.
+ *
+ * `head` is a genuinely OPTIONAL key and not `Position | undefined`, because
+ * `exactOptionalPropertyTypes` is on and the absent case must be an absent key.
+ * Absent means the read did not complete, which the derivation below treats as
+ * the widest possible floor.
+ */
+export interface Hop {
+    readonly query: Query;
+    readonly head?: Position;
+}
+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.
+     *
+     * Two phases and not one `record(hop)`, which is what the eager/lazy split
+     * above needs: a one-shot recorder cannot express a hop whose head never
+     * arrives, and that is the case the whole fail-safe direction turns on.
+     *
+     * The second phase comes back as a CLOSURE rather than as a slot number the
+     * caller carries to a second method. The closure holds its own slot, so
+     * nothing threads an index through the reader, nothing looks the service up a
+     * second time to spend it, and there is no slot value for a caller to hold
+     * wrongly.
+     */
+    readonly record: (query: Query) => Effect.Effect<CloseHop>;
+    readonly hops: Effect.Effect<ReadonlyArray<Hop>>;
+}>;
+/**
+ * The ambient ledger, present only inside a bracket.
+ *
+ * ⚠ A RECORDING path reads it with `Effect.serviceOption` and never
+ * `yield* ReadLedger`: its absence is the normal case there, and costing the
+ * 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 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
+ * means outside a bracket: nothing (record ambiently), or nothing sensible
+ * (require it).
+ *
+ * Recording is two-phase, and `record`'s own doc below owns why and what shape the
+ * second phase takes.
+ */
+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 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>;
+declare const NoReadsRecorded_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]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NoReadsRecorded";
+} & Readonly<A>;
+/**
+ * Raised when a bracket closes having recorded no read at all.
+ *
+ * On the ERROR channel and deliberately split from the nested-append DEFECT,
+ * because the two are different mistakes. An empty bracket can arise from a
+ * data-dependent branch that produces events without reading — a genuinely
+ * unconditional creation, written inside a bracket by mistake — where a nested
+ * append is always a wiring fault. An error-channel value lets a caller decide
+ * which it is.
+ *
+ * Its job is narrower than it looks, and the narrowing is worth stating because
+ * the wider reading is the tempting one. Once a bracket's guard is itself a fold,
+ * a body that reads nothing still has a hop, so this cannot fire — it is the guard
+ * against an unguarded UNCONDITIONAL bracket, not against an unguarded bracket. A
+ * bracket that looks guarded and is not is NOT what this catches and never was,
+ * and nothing else catches it either — `precondition.ts` owns that gap and the
+ * rule a reader has to keep in its place. A refusal taken BEFORE reading is not
+ * this case either: it short-circuits and surfaces as the refusal.
+ */
+export declare class NoReadsRecorded extends NoReadsRecorded_base<Record<never, never>> {
+    /**
+     * The sentence, as the `Error` field that says why — so the fault renders
+     * ITSELF, exactly as this package's other two errors do (`errors.ts` owns the
+     * argument for the mechanism and it is not restated here).
+     *
+     * A getter over a constant rather than a constructor field, because there is no
+     * datum to vary: every raise of this error means one thing.
+     */
+    get message(): string;
+}
+declare const TaglessSliceInLedger_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]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TaglessSliceInLedger";
+} & Readonly<A>;
+/**
+ * Raised when recording a hop would leave the bracket's accumulated union
+ * unservable.
+ *
+ * The store refuses a multi-item query in which any item is tagless, and it
+ * refuses it by THROWING inside the append decorator, which becomes a defect:
+ * uncatchable, one call and one layer away from the `build()` that chose no tags.
+ * A slice built without tags defaults to none, so it is perfectly servable alone
+ * and kills the append the moment it is unioned. This moves that failure onto the
+ * error channel, to the read that caused it, naming the record entry to fix.
+ *
+ * It refuses an unservable UNION and not every tagless hop, which is the easy
+ * mistake to make in the other direction: one tagless slice read on its own is
+ * servable and must keep working. Two cases reach it — a tagless hop unioned with
+ * another, and a single hop whose own RECORD holds two tagless slices, which
+ * composes to a multi-item query with no second hop needed.
+ */
+export declare class TaglessSliceInLedger extends TaglessSliceInLedger_base<{
+    readonly sliceKey: string;
+}> {
+    /** The offending slice and the remedy, in one sentence. */
+    get message(): string;
+}
+/**
+ * The ONE derivation: the union of every query walked, at the earliest head
+ * observed. Package-internal, for the reason the module doc gives.
+ *
+ * The union goes through core's own `unionQueries` — the merge
+ * `composeProjections` folds a record through, reached without one — and never a
+ * spread of `items`, because a wildcard hop (`items: []`) is ABSORBING under OR
+ * while a spread of an empty list contributes nothing, so hand-rolling the union
+ * narrows a match-everything hop to its sibling, silently and in the unsafe
+ * direction. A
+ * repeated or overlapping hop is harmless because this derives ONCE from a merged
+ * set and matching is idempotent over an OR; that property belongs to deriving
+ * once and would be lost by a refactor to per-hop evaluation.
+ *
+ * ## When any hop is headless the floor is `ORIGIN`, and the alternative is unsound
+ *
+ * The earliest head that actually ARRIVED is refused, and is named here as refused
+ * rather than merely not chosen, because it is what a reader writes by accident
+ * when told to take the earliest head. With one headless hop among completed hops
+ * the union looks right and the floor betrays it, sitting already above the
+ * invalidating event.
+ *
+ * `ORIGIN`'s cost is measured rather than described: it refuses every append to
+ * any identity that already has history, so it is not a conservative default but a
+ * hard stop. It is affordable only because conflict retry wraps the bracket from
+ * OUTSIDE and re-reads, which is the rule the whole shape depends on.
+ */
+export declare const deriveLayeredCondition: (hops: ReadonlyArray<Hop>) => AppendCondition | undefined;
+/**
+ * A fresh ledger and the `Layer` providing it: a `Ref` of hops behind the two-phase
+ * `record` the service declares.
+ *
+ * The hops effect is handed back beside the layer because the bracket reads them
+ * AFTER the body has run and the layer is out of scope, which is the same moment it
+ * stops being able to reach the service.
+ */
+export declare const makeReadLedger: Effect.Effect<{
+    readonly layer: Layer.Layer<ReadLedger>;
+    readonly hops: Effect.Effect<ReadonlyArray<Hop>>;
+}>;
+/**
+ * File a query into the ambient ledger if there is one, and hand back the effect
+ * that completes it. Outside a bracket the whole thing is a no-op, and the caller
+ * still writes one line rather than a conditional.
+ */
+export declare const recordQuery: (query: Query) => Effect.Effect<CloseHop>;
+/**
+ * Refuse a read that would leave the bracket's accumulated union unservable,
+ * BEFORE the read is paid for.
+ *
+ * Servability is answerable from the queries alone, so the check runs when a hop is
+ * recorded rather than at append time — the eager half of the eager/lazy split doing
+ * one more job. Outside a bracket nothing is unioned and nothing is unservable, so
+ * the ordinary single-hop caller is untaxed.
+ *
+ * It judges the PROSPECTIVE UNION and asks core for the verdict, which is what makes
+ * both failing shapes one case rather than two. An earlier version tested each
+ * recorded query separately and treated a FIRST hop as unconditionally fine — but a
+ * hop is a RECORD, and a record of two tagless slices composes to a multi-item query
+ * that is unservable on its own. That read died at the store, uncatchably, on the
+ * exact path this error exists to keep off the defect channel. A grammar with two
+ * homes drifts at the shapes neither author had in mind, so there is one home and it
+ * is `servableQueryFault`'s.
+ *
+ * Where the OFFENDING slice is THIS record's the ledger can name its key; where it
+ * belongs to an earlier hop it can only say so, a recorded hop keeping its query
+ * rather than the key it was composed from. That asymmetry is diagnostic-only and is
+ * why the message is built from a key that may be a placeholder.
+ */
+export declare const assertServableAddition: (projections: Record<string, AnyProjection>) => Effect.Effect<void, TaglessSliceInLedger>;
+/**
+ * The condition the ambient ledger derives right now, or `None` outside a bracket.
+ *
+ * This is what makes `buildDecisionModel` correct inside a bracket: the call whose
+ * current behaviour is the hazard derives from every hop the bracket walked rather
+ * than from its own single read.
+ */
+export declare const ambientLayeredCondition: Effect.Effect<Option.Option<AppendCondition>>;
+export {};
+//# sourceMappingURL=readLedger.d.ts.map

package/dist/dts-esm/readLedger.d.ts.map

@@ -0,0 +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;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-esm/registry.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The general (registry) path (minimal): decode an arbitrary wire event by its
+ * runtime type string. This is the one place a type outside the known set
+ * surfaces as a typed `UnknownEventType` — the home of ADR-0005 decode-totality.
+ *
+ * `makeRegistry(defs)` builds a `type -> Schema` map with a construction-time
+ * uniqueness guard (a duplicate type throws at wiring, not at runtime). Its
+ * requirement `R` is the union of the defs' requirements. `decode` looks the
+ * type up, then runs `deserialiseThenDecode` over the bytes, yielding
+ * `{ type, payload: unknown }`. That `unknown` is the point of the path rather
+ * than a gap in it: the type is discovered at RUNTIME off the wire event, so the
+ * caller has named no def and the return is deliberately NOT a discriminated
+ * union over `Defs`. What this path owes its caller is decode TOTALITY — every
+ * known type decodes, an unknown one fails as `UnknownEventType` — and not typed
+ * access. A caller who wants a typed payload names the def it expects and takes
+ * the typed slice path (`projection(init).on(def, fold)`), where each fold
+ * receives its payload already decoded and narrowed.
+ *
+ * What is this path's OWN and what it merely shares. The lookup is its own: a
+ * miss here is `UnknownEventType`, where the same miss on the typed path is a
+ * `CodecError` about a schema the caller did not supply — the asymmetry ADR-0005
+ * exists for. Everything after the lookup is the two-step both paths perform, so
+ * it is `deserialiseThenDecode` that owns it and fixes the `deserialise` /
+ * `decode` `reason` strings; this module holding a second copy is exactly how one
+ * of them would come to be reworded on one path only.
+ */
+import type { DcbEvent } from '@kairos-es/core';
+import { Effect } from 'effect';
+import { type CodecError, UnknownEventType } from './errors.js';
+import type { EventDef, EventDefAny } from './event.js';
+import { Serializer } from './Serializer.js';
+/** A registry decoding arbitrary wire events; `R` is the union of def requirements. */
+export interface Registry<R> {
+    readonly decode: (event: DcbEvent) => Effect.Effect<{
+        readonly type: string;
+        readonly payload: unknown;
+    }, UnknownEventType | CodecError, Serializer | R>;
+}
+/**
+ * Build a `Registry` from a def barrel. Throws at construction on a duplicate
+ * type; `R` is the union of the defs' requirements.
+ */
+type RequirementOfDefs<Defs extends ReadonlyArray<EventDefAny>> = Defs[number] extends EventDef<any, any, infer R> ? R : never;
+export declare const makeRegistry: <Defs extends ReadonlyArray<EventDefAny>>(defs: Defs) => Registry<RequirementOfDefs<Defs>>;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/dts-esm/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAe,MAAM,QAAQ,CAAA;AAE5C,OAAO,EAAE,KAAK,UAAU,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC,uFAAuF;AACvF,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,CACf,KAAK,EAAE,QAAQ,KACZ,MAAM,CAAC,MAAM,CAChB;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,EACpD,gBAAgB,GAAG,UAAU,EAC7B,UAAU,GAAG,CAAC,CACf,CAAA;CACF;AAED;;;GAGG;AACH,KAAK,iBAAiB,CAAC,IAAI,SAAS,aAAa,CAAC,WAAW,CAAC,IAE5D,IAAI,CAAC,MAAM,CAAC,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE9D,eAAO,MAAM,YAAY,GAAI,IAAI,SAAS,aAAa,CAAC,WAAW,CAAC,EAClE,MAAM,IAAI,KACT,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAgClC,CAAA"}

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

@@ -0,0 +1,45 @@
+/**
+ * Event production (codec edge-helper): turn a typed payload into a wire
+ * `DcbEvent`. Encode is `Schema.encodeEffect(def.schema)` (a `SchemaError`
+ * becomes a `CodecError`; any encryption transform runs here, *before* serialisation)
+ * then `serialiser.serialise`. The wire `tags` are derived from the def's
+ * required `tagsFor` mapper (ADR-0006) — they are never hand-passed, so two
+ * command sites emitting the same event type cannot tag it differently. A mapper
+ * that throws (e.g. an ill-formed `key:value` rejected by `Tag.make`) is
+ * surfaced on the `CodecError` channel, not as a defect. `uuid`
+ * comes from `options.uuid` or the `Uuid` service; `occurredAt` from
+ * `options.occurredAt` or the Effect clock (`DateTime.now`), keeping `core`
+ * clock- and RNG-free while staying overridable for backdated imports.
+ * `metadata` comes from `options.metadata` or the OPTIONAL ambient
+ * `MetadataSource` service, and is `{}` when neither supplies it (ADR-0017). A
+ * bag core's `Metadata` schema refuses, such as one holding a value that is not a
+ * string, fails on the `CodecError` channel (`reason: 'metadata'`), whichever of
+ * the two supplied it. It never reaches `tagsFor`, the
+ * event's schema or the serialiser, so it can enter neither the tag junction
+ * table nor the encryption seam.
+ */
+import { type DcbEvent, Metadata } from '@kairos-es/core';
+import { DateTime, Effect } from 'effect';
+import { CodecError } from './errors.js';
+import type { EventDef } from './event.js';
+import { Serializer } from './Serializer.js';
+import { Uuid } from './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. `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-esm/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/esm/MetadataSource.js

@@ -0,0 +1,3 @@
+import { Context } from 'effect';
+export class MetadataSource extends /*#__PURE__*/Context.Service()('@kairos-es/codec/MetadataSource') {}
+//# sourceMappingURL=MetadataSource.js.map

package/dist/esm/MetadataSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataSource.js","names":["Context","MetadataSource","Service"],"sources":["../../src/MetadataSource.ts"],"sourcesContent":[null],"mappings":"AAsCA,SAASA,OAAO,QAAQ,QAAQ;AAEhC,OAAM,MAAOC,cAAe,sBAAQD,OAAO,CAACE,OAAO,EAA4B,CAC7E,iCAAiC,CAClC","ignoreList":[]}

package/dist/esm/Serializer.js

@@ -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';
-export class Serializer extends /*#__PURE__*/Context.Tag('@kairos-es/codec/Serializer')() {}
+export class Serializer extends /*#__PURE__*/Context.Service()('@kairos-es/codec/Serializer') {}
 const encoder = /*#__PURE__*/new TextEncoder();
 const decoder = /*#__PURE__*/new TextDecoder();
 /**

package/dist/esm/Serializer.js.map

@@ -1 +1 @@
-{"version":3,"file":"Serializer.js","names":["Context","Layer","Serializer","Tag","encoder","TextEncoder","decoder","TextDecoder","SerializerDefault","succeed","serialise","v","encode","JSON","stringify","deserialise","b","parse","decode"],"sources":["../../src/Serializer.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;AAYA,SAASA,OAAO,EAAEC,KAAK,QAAQ,QAAQ;AAEvC,OAAM,MAAOC,UAAW,sBAAQF,OAAO,CAACG,GAAG,CAAC,6BAA6B,CAAC,EAMvE;AAEH,MAAMC,OAAO,gBAAG,IAAIC,WAAW,EAAE;AACjC,MAAMC,OAAO,gBAAG,IAAIC,WAAW,EAAE;AAEjC;;;;;AAKA,OAAO,MAAMC,iBAAiB,gBAA4BP,KAAK,CAACQ,OAAO,CACrEP,UAAU,EACV;EACEQ,SAAS,EAAGC,CAAC,IAAKP,OAAO,CAACQ,MAAM,CAACC,IAAI,CAACC,SAAS,CAACH,CAAC,CAAC,CAAC;EACnDI,WAAW,EAAGC,CAAC,IAAKH,IAAI,CAACI,KAAK,CAACX,OAAO,CAACY,MAAM,CAACF,CAAC,CAAC;CACjD,CACF","ignoreList":[]}
+{"version":3,"file":"Serializer.js","names":["Context","Layer","Serializer","Service","encoder","TextEncoder","decoder","TextDecoder","SerializerDefault","succeed","serialise","v","encode","JSON","stringify","deserialise","b","parse","decode"],"sources":["../../src/Serializer.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;AAYA,SAASA,OAAO,EAAEC,KAAK,QAAQ,QAAQ;AAEvC,OAAM,MAAOC,UAAW,sBAAQF,OAAO,CAACG,OAAO,EAM5C,CAAC,6BAA6B,CAAC;AAElC,MAAMC,OAAO,gBAAG,IAAIC,WAAW,EAAE;AACjC,MAAMC,OAAO,gBAAG,IAAIC,WAAW,EAAE;AAEjC;;;;;AAKA,OAAO,MAAMC,iBAAiB,gBAA4BP,KAAK,CAACQ,OAAO,CACrEP,UAAU,EACV;EACEQ,SAAS,EAAGC,CAAC,IAAKP,OAAO,CAACQ,MAAM,CAACC,IAAI,CAACC,SAAS,CAACH,CAAC,CAAC,CAAC;EACnDI,WAAW,EAAGC,CAAC,IAAKH,IAAI,CAACI,KAAK,CAACX,OAAO,CAACY,MAAM,CAACF,CAAC,CAAC;CACjD,CACF","ignoreList":[]}

package/dist/esm/Uuid.js

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

package/dist/esm/Uuid.js.map

@@ -1 +1 @@
-{"version":3,"file":"Uuid.js","names":["makeSequentialUuid","Context","Effect","Layer","Uuid","Tag","UuidLive","succeed","generate","sync","globalThis","crypto","randomUUID","UuidTest","next"],"sources":["../../src/Uuid.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;AAWA,SAASA,kBAAkB,QAAQ,yBAAyB;AAC5D,SAASC,OAAO,EAAEC,MAAM,EAAEC,KAAK,QAAQ,QAAQ;AAE/C,OAAM,MAAOC,IAAK,sBAAQH,OAAO,CAACI,GAAG,CAAC,uBAAuB,CAAC,EAG3D;AAEH;AACA,OAAO,MAAMC,QAAQ,gBAAsBH,KAAK,CAACI,OAAO,CAACH,IAAI,EAAE;EAC7DI,QAAQ,eAAEN,MAAM,CAACO,IAAI,CAAC,MAAMC,UAAU,CAACC,MAAM,CAACC,UAAU,EAAE;CAC3D,CAAC;AAEF;;;;;;;;AAQA,OAAO,MAAMC,QAAQ,gBAAsBV,KAAK,CAACM,IAAI,CAACL,IAAI,EAAE,MAAK;EAC/D,MAAMU,IAAI,GAAGd,kBAAkB,EAAE;EACjC,OAAO;IAAEQ,QAAQ,EAAEN,MAAM,CAACO,IAAI,CAACK,IAAI;EAAC,CAAE;AACxC,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"Uuid.js","names":["makeSequentialUuid","Context","Effect","Layer","Uuid","Service","UuidLive","succeed","generate","sync","globalThis","crypto","randomUUID","UuidTest","next"],"sources":["../../src/Uuid.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;AAWA,SAASA,kBAAkB,QAAQ,yBAAyB;AAC5D,SAASC,OAAO,EAAEC,MAAM,EAAEC,KAAK,QAAQ,QAAQ;AAE/C,OAAM,MAAOC,IAAK,sBAAQH,OAAO,CAACI,OAAO,EAGtC,CAAC,uBAAuB,CAAC;AAE5B;AACA,OAAO,MAAMC,QAAQ,gBAAsBH,KAAK,CAACI,OAAO,CAACH,IAAI,EAAE;EAC7DI,QAAQ,eAAEN,MAAM,CAACO,IAAI,CAAC,MAAMC,UAAU,CAACC,MAAM,CAACC,UAAU,EAAE;CAC3D,CAAC;AAEF;;;;;;;;;;;AAWA,OAAO,MAAMC,QAAQ,gBAAsBV,KAAK,CAACM,IAAI,CAACL,IAAI,EAAE,MAAK;EAC/D,MAAMU,IAAI,GAAGd,kBAAkB,EAAE;EACjC,OAAO;IAAEQ,QAAQ,EAAEN,MAAM,CAACO,IAAI,CAACK,IAAI;EAAC,CAAE;AACxC,CAAC,CAAC","ignoreList":[]}

package/dist/esm/decider.js

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

package/dist/esm/decisionModel.js

@@ -117,7 +117,7 @@ export const modelAtHead = projections => Effect.gen(function* () {
     head
   } = yield* store.read(composite.query);
   const decoded = decode(events);
-  const state = yield* Stream.runFold(decoded, composite.initialState, (acc, event) => composite.evolve(acc, event));
+  const state = yield* 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/esm/decisionModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"decisionModel.js","names":["composeProjections","DcbEventStore","Effect","Option","Stream","decodeSlices","ambientLayeredCondition","assertServableAddition","recordQuery","modelAtHead","projections","gen","store","decode","composite","closeHop","query","events","head","read","decoded","state","runFold","initialState","acc","event","evolve","buildDecisionModel","ambient","isSome","appendCondition","value","failIfEventsMatch","after"],"sources":["../../src/decisionModel.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAIEA,kBAAkB,EAClBC,aAAa,QAER,iBAAiB;AACxB,SAASC,MAAM,EAAEC,MAAM,EAAEC,MAAM,QAAQ,QAAQ;AAC/C,SAASC,YAAY,QAAQ,aAAU;AAGvC,SACEC,uBAAuB,EACvBC,sBAAsB,EACtBC,WAAW,QAEN,iBAAc;AAOrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,OAAO,MAAMC,WAAW,GACtBC,WAAc,IAMdR,MAAM,CAACS,GAAG,CAAC,aAAS;EAClB,MAAMC,KAAK,GAAG,OAAOX,aAAa;EAElC;EACA;EACA;EACA,MAAMY,MAAM,GAAGR,YAAY,CAACK,WAAW,CAAC;EAExC;EACA,MAAMI,SAAS,GAAGd,kBAAkB,CAClCU,WAA4C,CAC7C;EAED;EACA;EACA;EACA;EACA;EACA;EACA;EACA,OAAOH,sBAAsB,CAACG,WAA4C,CAAC;EAE3E;EACA;EACA;EACA,MAAMK,QAAQ,GAAG,OAAOP,WAAW,CAACM,SAAS,CAACE,KAAK,CAAC;EAEpD,MAAM;IAAEC,MAAM;IAAEC;EAAI,CAAE,GAAG,OAAON,KAAK,CAACO,IAAI,CAACL,SAAS,CAACE,KAAK,CAAC;EAE3D,MAAMI,OAAO,GAAGP,MAAM,CAACI,MAAM,CAAC;EAE9B,MAAMI,KAAK,GAAI,OAAOjB,MAAM,CAACkB,OAAO,CAClCF,OAAO,EACPN,SAAS,CAACS,YAAY,EACtB,CAACC,GAAG,EAAEC,KAAK,KAAKX,SAAS,CAACY,MAAM,CAACF,GAAG,EAAEC,KAAK,CAAC,CACvB;EAEvB;EACA;EACA;EACA,OAAOV,QAAQ,CAACG,IAAI,CAAC;EAErB,OAAO;IAAEG,KAAK;IAAEH;EAAI,CAAE;AACxB,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,OAAO,MAAMS,kBAAkB,GAC7BjB,WAAc,IASdR,MAAM,CAACS,GAAG,CAAC,aAAS;EAClB,MAAM;IAAEU,KAAK;IAAEH;EAAI,CAAE,GAAG,OAAOT,WAAW,CAACC,WAAW,CAAC;EAEvD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMkB,OAAO,GAAG,OAAOtB,uBAAuB;EAC9C,IAAIH,MAAM,CAAC0B,MAAM,CAACD,OAAO,CAAC,EAAE;IAC1B,OAAO;MAAEP,KAAK;MAAES,eAAe,EAAEF,OAAO,CAACG;IAAK,CAAE;EAClD;EAEA;EACA,OAAO;IACLV,KAAK;IACLS,eAAe,EAAE;MACfE,iBAAiB,EAAEhC,kBAAkB,CACnCU,WAA4C,CAC7C,CAACM,KAAK;MACPiB,KAAK,EAAEf;;GAEV;AACH,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"decisionModel.js","names":["composeProjections","DcbEventStore","Effect","Option","Stream","decodeSlices","ambientLayeredCondition","assertServableAddition","recordQuery","modelAtHead","projections","gen","store","decode","composite","closeHop","query","events","head","read","decoded","state","runFold","initialState","acc","event","evolve","buildDecisionModel","ambient","isSome","appendCondition","value","failIfEventsMatch","after"],"sources":["../../src/decisionModel.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAIEA,kBAAkB,EAClBC,aAAa,QAER,iBAAiB;AACxB,SAASC,MAAM,EAAEC,MAAM,EAAEC,MAAM,QAAQ,QAAQ;AAC/C,SAASC,YAAY,QAAQ,aAAU;AAGvC,SACEC,uBAAuB,EACvBC,sBAAsB,EACtBC,WAAW,QAEN,iBAAc;AAOrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,OAAO,MAAMC,WAAW,GACtBC,WAAc,IAMdR,MAAM,CAACS,GAAG,CAAC,aAAS;EAClB,MAAMC,KAAK,GAAG,OAAOX,aAAa;EAElC;EACA;EACA;EACA,MAAMY,MAAM,GAAGR,YAAY,CAACK,WAAW,CAAC;EAExC;EACA,MAAMI,SAAS,GAAGd,kBAAkB,CAClCU,WAA4C,CAC7C;EAED;EACA;EACA;EACA;EACA;EACA;EACA;EACA,OAAOH,sBAAsB,CAACG,WAA4C,CAAC;EAE3E;EACA;EACA;EACA,MAAMK,QAAQ,GAAG,OAAOP,WAAW,CAACM,SAAS,CAACE,KAAK,CAAC;EAEpD,MAAM;IAAEC,MAAM;IAAEC;EAAI,CAAE,GAAG,OAAON,KAAK,CAACO,IAAI,CAACL,SAAS,CAACE,KAAK,CAAC;EAE3D,MAAMI,OAAO,GAAGP,MAAM,CAACI,MAAM,CAAC;EAE9B,MAAMI,KAAK,GAAI,OAAOjB,MAAM,CAACkB,OAAO,CAClCF,OAAO,EACP,MAAMN,SAAS,CAACS,YAAY,EAC5B,CAACC,GAAG,EAAEC,KAAK,KAAKX,SAAS,CAACY,MAAM,CAACF,GAAG,EAAEC,KAAK,CAAC,CACvB;EAEvB;EACA;EACA;EACA,OAAOV,QAAQ,CAACG,IAAI,CAAC;EAErB,OAAO;IAAEG,KAAK;IAAEH;EAAI,CAAE;AACxB,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,OAAO,MAAMS,kBAAkB,GAC7BjB,WAAc,IASdR,MAAM,CAACS,GAAG,CAAC,aAAS;EAClB,MAAM;IAAEU,KAAK;IAAEH;EAAI,CAAE,GAAG,OAAOT,WAAW,CAACC,WAAW,CAAC;EAEvD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMkB,OAAO,GAAG,OAAOtB,uBAAuB;EAC9C,IAAIH,MAAM,CAAC0B,MAAM,CAACD,OAAO,CAAC,EAAE;IAC1B,OAAO;MAAEP,KAAK;MAAES,eAAe,EAAEF,OAAO,CAACG;IAAK,CAAE;EAClD;EAEA;EACA,OAAO;IACLV,KAAK;IACLS,eAAe,EAAE;MACfE,iBAAiB,EAAEhC,kBAAkB,CACnCU,WAA4C,CAC7C,CAACM,KAAK;MACPiB,KAAK,EAAEf;;GAEV;AACH,CAAC,CAAC","ignoreList":[]}

package/dist/esm/decode.js

@@ -29,9 +29,9 @@ import { Serializer } from "./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.**
@@ -45,8 +45,8 @@ import { Serializer } from "./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/esm/decode.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode.js","names":["Effect","Stream","deserialiseThenDecode","CodecError","Serializer","mergeSliceSchemas","projections","schemas","Map","contributedBy","key","Object","keys","slice","type","schema","owner","get","undefined","Error","set","decodeEvents","events","unwrap","map","serializer","pipe","mapEffect","sequenced","event","fail","reason","data","payload","decodeSlices","slices"],"sources":["../../src/decode.ts"],"sourcesContent":[null],"mappings":"AAiDA,SAASA,MAAM,EAAeC,MAAM,QAAQ,QAAQ;AAKpD,SAASC,qBAAqB,QAAQ,4BAAyB;AAC/D,SAASC,UAAU,QAAQ,aAAU;AAErC,SAASC,UAAU,QAAQ,iBAAc;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAMC,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,IAE3CrB,MAAM,CAACsB,MAAM,CACXvB,MAAM,CAACwB,GAAG,CAACpB,UAAU,EAAGqB,UAAU,IAChCH,MAAM,CAACI,IAAI,CACTzB,MAAM,CAAC0B,SAAS,CAAEC,SAAS,IAAI;EAC7B,MAAMb,MAAM,GAAGR,OAAO,CAACU,GAAG,CAACW,SAAS,CAACC,KAAK,CAACf,IAAI,CAAC;EAChD,IAAIC,MAAM,KAAKG,SAAS,EAAE;IACxB,OAAOlB,MAAM,CAAC8B,IAAI,CAChB,IAAI3B,UAAU,CAAC;MACb4B,MAAM,EAAE,6BAA6BH,SAAS,CAACC,KAAK,CAACf,IAAI;KAC1D,CAAC,CACH;EACH;EACA,OAAOZ,qBAAqB,CAC1BuB,UAAU,EACVV,MAAM,EACNa,SAAS,CAACC,KAAK,CAACG,IAAI,CACrB,CAACN,IAAI,CACJ1B,MAAM,CAACwB,GAAG,CAAES,OAAO,KAAoB;IAAEL,SAAS;IAAEK;EAAO,CAAE,CAAC,CAAC,CAChE;AACH,CAAC,CAAC,CACH,CACF,CACF;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,OAAO,MAAMC,YAAY,GACvBC,MAAS,IAOLd,YAAY,CAAChB,iBAAiB,CAAC8B,MAAM,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"decode.js","names":["Effect","Stream","deserialiseThenDecode","CodecError","Serializer","mergeSliceSchemas","projections","schemas","Map","contributedBy","key","Object","keys","slice","type","schema","owner","get","undefined","Error","set","decodeEvents","events","unwrap","map","serializer","pipe","mapEffect","sequenced","event","fail","reason","data","payload","decodeSlices","slices"],"sources":["../../src/decode.ts"],"sourcesContent":[null],"mappings":"AAiDA,SAASA,MAAM,EAAeC,MAAM,QAAQ,QAAQ;AAKpD,SAASC,qBAAqB,QAAQ,4BAAyB;AAC/D,SAASC,UAAU,QAAQ,aAAU;AAErC,SAASC,UAAU,QAAQ,iBAAc;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAMC,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,IAE3CrB,MAAM,CAACsB,MAAM,CACXvB,MAAM,CAACwB,GAAG,CAACpB,UAAU,EAAGqB,UAAU,IAChCH,MAAM,CAACI,IAAI,CACTzB,MAAM,CAAC0B,SAAS,CAAEC,SAAS,IAAI;EAC7B,MAAMb,MAAM,GAAGR,OAAO,CAACU,GAAG,CAACW,SAAS,CAACC,KAAK,CAACf,IAAI,CAAC;EAChD,IAAIC,MAAM,KAAKG,SAAS,EAAE;IACxB,OAAOlB,MAAM,CAAC8B,IAAI,CAChB,IAAI3B,UAAU,CAAC;MACb4B,MAAM,EAAE,6BAA6BH,SAAS,CAACC,KAAK,CAACf,IAAI;KAC1D,CAAC,CACH;EACH;EACA,OAAOZ,qBAAqB,CAC1BuB,UAAU,EACVV,MAAM,EACNa,SAAS,CAACC,KAAK,CAACG,IAAI,CACrB,CAACN,IAAI,CACJ1B,MAAM,CAACwB,GAAG,CAAES,OAAO,KAAoB;IAAEL,SAAS;IAAEK;EAAO,CAAE,CAAC,CAAC,CAChE;AACH,CAAC,CAAC,CACH,CACF,CACF;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,OAAO,MAAMC,YAAY,GACvBC,MAAS,IAOLd,YAAY,CAAChB,iBAAiB,CAAC8B,MAAM,CAAC,CAAC","ignoreList":[]}

package/dist/esm/deserialiseThenDecode.js

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

package/dist/esm/deserialiseThenDecode.js.map

@@ -1 +1 @@
-{"version":3,"file":"deserialiseThenDecode.js","names":["Effect","Schema","CodecError","deserialiseThenDecode","serializer","schema","bytes","try","deserialise","catch","cause","reason","pipe","flatMap","raw","decodeUnknown","mapError"],"sources":["../../src/deserialiseThenDecode.ts"],"sourcesContent":[null],"mappings":"AAyDA,SAASA,MAAM,EAAEC,MAAM,QAAQ,QAAQ;AACvC,SAASC,UAAU,QAAQ,aAAU;AAGrC,OAAO,MAAMC,qBAAqB,GAAGA,CACnCC,UAA2C,EAC3CC,MAA0C,EAC1CC,KAAiB,KAEjBN,MAAM,CAACO,GAAG,CAAC;EACTA,GAAG,EAAEA,CAAA,KAAMH,UAAU,CAACI,WAAW,CAACF,KAAK,CAAC;EACxCG,KAAK,EAAGC,KAAK,IAAK,IAAIR,UAAU,CAAC;IAAES,MAAM,EAAE,aAAa;IAAED;EAAK,CAAE;CAClE,CAAC,CAACE,IAAI,CACLZ,MAAM,CAACa,OAAO,CAAEC,GAAG,IACjBb,MAAM,CAACc,aAAa,CAACV,MAAM,CAAC,CAACS,GAAG,CAAC,CAACF,IAAI,CACpCZ,MAAM,CAACgB,QAAQ,CAAEN,KAAK,IAAK,IAAIR,UAAU,CAAC;EAAES,MAAM,EAAE,QAAQ;EAAED;AAAK,CAAE,CAAC,CAAC,CACxE,CACF,CACF","ignoreList":[]}
+{"version":3,"file":"deserialiseThenDecode.js","names":["Effect","Schema","CodecError","deserialiseThenDecode","serializer","schema","bytes","try","deserialise","catch","cause","reason","pipe","flatMap","raw","decodeUnknownEffect","mapError"],"sources":["../../src/deserialiseThenDecode.ts"],"sourcesContent":[null],"mappings":"AAyDA,SAASA,MAAM,EAAEC,MAAM,QAAQ,QAAQ;AACvC,SAASC,UAAU,QAAQ,aAAU;AAGrC,OAAO,MAAMC,qBAAqB,GAAGA,CACnCC,UAAoD,EACpDC,MAAkC,EAClCC,KAAiB,KAEjBN,MAAM,CAACO,GAAG,CAAC;EACTA,GAAG,EAAEA,CAAA,KAAMH,UAAU,CAACI,WAAW,CAACF,KAAK,CAAC;EACxCG,KAAK,EAAGC,KAAK,IAAK,IAAIR,UAAU,CAAC;IAAES,MAAM,EAAE,aAAa;IAAED;EAAK,CAAE;CAClE,CAAC,CAACE,IAAI,CACLZ,MAAM,CAACa,OAAO,CAAEC,GAAG,IACjBb,MAAM,CAACc,mBAAmB,CAACV,MAAM,CAAC,CAACS,GAAG,CAAC,CAACF,IAAI,CAC1CZ,MAAM,CAACgB,QAAQ,CAAEN,KAAK,IAAK,IAAIR,UAAU,CAAC;EAAES,MAAM,EAAE,QAAQ;EAAED;AAAK,CAAE,CAAC,CAAC,CACxE,CACF,CACF","ignoreList":[]}

package/dist/esm/errors.js

@@ -3,7 +3,8 @@
  * never defects.
  *
  * `CodecError` covers every serialisation/`Schema` failure on the codec path
- * (deserialise threw, `Schema.decode`/`encode` produced a `ParseError`, a
+ * (deserialise threw, `Schema.decodeUnknownEffect`/`encodeEffect` produced a
+ * `SchemaError`, a
  * wrong/absent encryption key surfaced through a `Schema` transform, or a
  * `tagsFor` mapper threw while deriving an event's tags). It carries a
  * human-readable `reason` and the underlying `cause` (exact-optional).
@@ -38,9 +39,10 @@ export class CodecError extends /*#__PURE__*/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/esm/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","names":["Data","CodecError","TaggedError","message","reason","UnknownEventType","type"],"sources":["../../src/errors.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;AAaA,SAASA,IAAI,QAAQ,QAAQ;AAE7B;AACA,OAAM,MAAOC,UAAW,sBAAQD,IAAI,CAACE,WAAW,CAAC,YAAY,CAG3D;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BA,IAAaC,OAAOA,CAAA;IAClB,OAAO,IAAI,CAACC,MAAM;EACpB;;AAGF;AACA,OAAM,MAAOC,gBAAiB,sBAAQL,IAAI,CAACE,WAAW,CAAC,kBAAkB,CAEvE;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BA,IAAaC,OAAOA,CAAA;IAClB,OAAO,eAAe,IAAI,CAACG,IAAI,0BAA0B;EAC3D","ignoreList":[]}
+{"version":3,"file":"errors.js","names":["Data","CodecError","TaggedError","message","reason","UnknownEventType","type"],"sources":["../../src/errors.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;AAcA,SAASA,IAAI,QAAQ,QAAQ;AAE7B;AACA,OAAM,MAAOC,UAAW,sBAAQD,IAAI,CAACE,WAAW,CAAC,YAAY,CAG3D;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BA,IAAaC,OAAOA,CAAA;IAClB,OAAO,IAAI,CAACC,MAAM;EACpB;;AAGF;AACA,OAAM,MAAOC,gBAAiB,sBAAQL,IAAI,CAACE,WAAW,CAAC,kBAAkB,CAEvE;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BA,IAAaC,OAAOA,CAAA;IAClB,OAAO,eAAe,IAAI,CAACG,IAAI,0BAA0B;EAC3D","ignoreList":[]}