@kairos-es/codec 0.0.0

package/dist/dts/decider.d.ts

@@ -0,0 +1,157 @@
+/**
+ * A `Decider`: the write side's unit of decision. It pairs the projections a
+ * command handler reads (its decision model) with an effectful `decide` step
+ * that turns the folded state plus a command into the events to append.
+ *
+ * This is PRODUCTION code and it lives beside the `buildDecisionModel` it
+ * drives. It began in `@kairos-es/testing` because the Given/When/Then surface
+ * was its first consumer, but nothing in it is test apparatus: every import
+ * resolves to this package or to `@kairos-es/core`, and a test framework is
+ * never one of them. That home was a real hazard rather than a tidiness
+ * complaint — `@kairos-es/testing` peers `@effect/vitest`, so a command handler
+ * typed against `Decider` (as this repo's own worked example is, in `src/` and
+ * not `test/`) named a package whose sibling module imports `expect` and `it` at
+ * top level, and a handler that actually RAN a command would have
+ * runtime-imported `runDecider` from it, loading a test framework into a
+ * production module graph. `@kairos-es/read/testing` documents that same hazard
+ * as the reason a subpath may add no peer; the difference here is that this is
+ * not a testing surface at all, so the fix is a home rather than a rule.
+ *
+ * `@kairos-es/testing` now imports these two symbols like any other consumer,
+ * and NO compatibility re-export is left behind there: nothing is published yet,
+ * so a re-export would be permanent clutter bought for no consumer, and it would
+ * preserve in that package's public surface exactly the coupling the move
+ * exists to remove. That is the argument ADR-0008 made when `retryOnConflict`
+ * moved to the package that owns the error it matches, and it holds here for the
+ * same reason — a write-side consumer depending on the wrong package is
+ * backwards, whichever direction the dependency points.
+ *
+ * `projections` is a *function of the command* because a DCB decision model is
+ * parametrised by the command's own identifiers (e.g. narrow to
+ * `course:{command.courseId}`), which keeps the consistency boundary — and the
+ * `failIfEventsMatch` guard the read produces — as tight as the decision
+ * actually needs. This mirrors dcb-events, where the command handler calls
+ * `buildDecisionModel(store, { ...projections built from command.data })`.
+ *
+ * `runDecider` runs the DCB command cycle against whatever `DcbEventStore` is in
+ * context: build the decision model for the command (a real `read` + decode +
+ * fold via `buildDecisionModel`), decide, then `append` the new events under the
+ * 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,
+ * 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
+ * re-derives the condition.
+ *
+ * The `decide` step produces its events effectfully (they are encoded via
+ * `toEvent`, so it requires `Serializer | Uuid | R`) and may fail on its own
+ * error channel (a domain rule violation, e.g. "course already exists"); the
+ * append may fail with `AppendConditionFailed` if a concurrent writer moved the
+ * boundary, and decode may fail with `CodecError`. All surface on the error
+ * channel, so a caller handles all three the same way — and
+ * `@kairos-es/testing`'s `.thenError(tag)` can assert any of them.
+ */
+import type { AppendConditionFailed, CompositeState, DcbEvent, Position } from '@kairos-es/core';
+import { DcbEventStore } from '@kairos-es/core';
+import type { Array as Arr } from 'effect';
+import { Effect } from 'effect';
+import { type RequirementOf } from './decisionModel.js';
+import type { CodecError } from './errors.js';
+import type { SliceProjection } from './projection.js';
+import type { Serializer } from './Serializer.js';
+import type { Uuid } from './Uuid.js';
+/**
+ * A decision unit: the projections whose folded state a command is decided
+ * against, and the `decide` step producing the events to append.
+ *
+ * `decide` may fail with a domain error `E` (a tagged error is idiomatic, so
+ * `@kairos-es/testing`'s `.thenError` can match its `_tag`). It receives the
+ * composed decision-model `state` and the `command`, and returns the non-empty
+ * batch of new events — effectfully, because each event is produced via
+ * `toEvent` (encode -> serialise), which requires `Serializer | Uuid | R`.
+ *
+ * The projection record is bounded by this package's `SliceProjection` (the
+ * schema-backed, state-erased bound for a heterogeneous record); the
+ * precise per-key state is recovered by core's shared `CompositeState`. The
+ * requirement `R` is the union carried by the record's slices' schemas.
+ */
+export interface Decider<P extends Record<string, SliceProjection>, Command, E = never, R = never> {
+    readonly projections: (command: Command) => P;
+    readonly decide: (state: CompositeState<P>, command: Command) => Effect.Effect<Arr.NonEmptyReadonlyArray<DcbEvent>, E, Serializer | Uuid | R>;
+}
+/**
+ * Build a `Decider` with all four of its type arguments INFERRED: the slice
+ * record `P` from what `projections` returns, the error union `E` and the extra
+ * requirement `R` from what `decide` returns. The command type is the one thing
+ * a caller still writes, once, as the annotation on the `projections` parameter
+ * — `Command` occurs only in parameter positions, so nothing else could supply
+ * it, and it is domain information (the command this decision is parametrised
+ * by) rather than plumbing.
+ *
+ * It adds no capability: the interface stays directly inhabitable and this
+ * returns exactly the object literal a caller would have written. What it
+ * changes is what an author must SPELL. An object literal annotated
+ * `Decider<P, Command, E>` has to state the whole slice record — a
+ * `ReturnType<typeof someProjection>` per key, a slice's state type being
+ * inferred by `projection().on().build()` and so having no name to write — plus
+ * the union of every error its decide branches can fail with. Dropping the
+ * annotation instead is not open to the author: without it `decide`'s `state`
+ * and `command` parameters have no contextual type and are implicitly `any`. So
+ * the cost landed hardest on the worked example, where some thirty lines of type
+ * plumbing sat between the reader and the three decisions that file exists to
+ * teach.
+ *
+ * `Eff` captures decide's WHOLE return type as one type parameter instead of
+ * inferring `E` and `R` from an `Effect<…, E, Serializer | Uuid | R>` shaped
+ * target, and that is the part that had to be got right rather than merely
+ * written down. A real `decide` returns a UNION of effects — one `Effect.fail`
+ * per rule it enforces, plus the produce path — and TypeScript infers a type
+ * parameter from a union source by choosing one constituent's candidate, not by
+ * 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
+ * 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
+ * `decide` that could produce an EMPTY batch, the one guarantee the shaped
+ * target used to give and the one `append` relies on. It is also what
+ * contextually types the produce path's `(event) => [event]` as a one-element
+ * TUPLE; unconstrained, that widens to `DcbEvent[]`, which is not a
+ * `NonEmptyReadonlyArray` and would fail at the call site.
+ *
+ * The single `as` is narrow and unavoidable: the declared return is a
+ * conditional over an unresolved `Eff`, so while `Eff` is still a type variable
+ * the checker cannot relate `(…) => Eff` to `(…) => Effect<…,
+ * Effect.Error<Eff>, …>`. The value is the two functions it was handed, so
+ * there is nothing for the cast to be wrong about.
+ *
+ * `R` excludes `Serializer | Uuid` because that is what `R` MEANS on `Decider`:
+ * the interface writes decide's requirement as `Serializer | Uuid | R`, so `R`
+ * is what the produce side needs BEYOND the codec's own two services. Leaving
+ * 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
+ * service, context being keyed by the same string at runtime.
+ */
+export declare const 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>>;
+/**
+ * Run the full DCB command cycle for a decider against the ambient
+ * `DcbEventStore`: build the decision model (real read + decode + fold), decide,
+ * and append under the read's append condition. Returns the last new position.
+ *
+ * The requirement is `DcbEventStore | Serializer | Uuid | R |
+ * RequirementOf<P>`: `Serializer` enters through both the decode
+ * (`buildDecisionModel`) and produce (`toEvent`) sides, `Uuid` through produce,
+ * the slices' `RequirementOf<P>` through decode, and `R` through produce. (For a
+ * def whose `Schema` carries a requirement, `RequirementOf<P>` and `R` are the
+ * same tag.) Any `decide` failure, a decode `CodecError`, or an
+ * `AppendConditionFailed` propagates on the error channel unchanged.
+ */
+export declare const runDecider: <P extends Record<string, SliceProjection>, Command, E, R>(decider: Decider<P, Command, E, R>, command: Command) => Effect.Effect<Position, E | CodecError | AppendConditionFailed, DcbEventStore | Serializer | Uuid | R | RequirementOf<P>>;
+//# sourceMappingURL=decider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decider.d.ts","sourceRoot":"","sources":["../../src/decider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACd,QAAQ,EACR,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,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,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,OAAO,CACtB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK;IAET,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,CAChB,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EACnC,CAAC,EACD,UAAU,GAAG,IAAI,GAAG,CAAC,CACtB,CAAA;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,OAAO,GAClB,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,aAAa,CAAC,OAAO,EAAE,OAAO,KAAK,CAAC,EACpC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,KAAK,GAAG,KAC1D,OAAO,CACR,CAAC,EACD,OAAO,EACP,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EACxB,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC,CAOrD,CAAA;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GACrB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,CAAC,EACD,CAAC,EAED,SAAS,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,EAClC,SAAS,OAAO,KACf,MAAM,CAAC,MAAM,CACd,QAAQ,EACR,CAAC,GAAG,UAAU,GAAG,qBAAqB,EACtC,aAAa,GAAG,UAAU,GAAG,IAAI,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAStD,CAAA"}

package/dist/dts/decisionModel.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Read-and-fold over a slice record: read the composed query, decode each event
+ * through the matching def's `Schema` in an effectful `Stream.mapEffect` stage,
+ * then fold *purely* through core's `composeProjections`.
+ *
+ * TWO exports sit over that ONE body, the second expressed over the first.
+ * `modelAtHead` stops where the fold does, at `{ state, head }` — a
+ * materialisation of the record with no table, no checkpoint and no runner.
+ * `buildDecisionModel` adds the only part that is genuinely decision-specific:
+ * the `AppendCondition` derived from the same query and that same head (the DCB
+ * optimistic-concurrency contract). It is core's old
+ * `buildDecisionModel(Record<string, AnyProjection>)` surface, moved here
+ * because decode needs `Schema` + the `Serializer`.
+ *
+ * The fold stays pure and in core; only the decode stage is effectful, and that
+ * stage lives in `decode.ts` — `decodeSlices` — so the read side folds a live
+ * `subscribe` stream through the *same* decode this module folds a bounded
+ * `read` stream through.
+ *
+ * The result requirement is exactly `DcbEventStore | Serializer | R`, where `R`
+ * is the union of the record's slices' requirements — inferred with no cast,
+ * `R` being carried covariantly by each slice's `schemas` map value type.
+ * `Serializer` is not yielded here: `decodeSlices` reads it from context itself,
+ * so the requirement arrives through the decode stage rather than through a
+ * binding this module owns (see `decode.ts` for why).
+ */
+import { type AppendCondition, type CompositeState, DcbEventStore, type Position } from '@kairos-es/core';
+import { Effect } from 'effect';
+import type { CodecError } from './errors.js';
+import type { SliceProjection } from './projection.js';
+import type { Serializer } from './Serializer.js';
+/** The union of requirements `R` carried by a record of `SliceProjection`s. */
+export type RequirementOf<T extends Record<string, SliceProjection>> = T[keyof T] extends SliceProjection<infer _S, infer R> ? R : never;
+/**
+ * Read the events for the composed slices' query, decode each through its def's
+ * `Schema`, fold into per-key state, and return `{ state, head }`: one slice
+ * record materialised at read time, with no table, no checkpoint and no runner.
+ *
+ * ## Why `head` comes back, and not bare `state`
+ *
+ * `head` is the consistency statement, and without it the state is a figure with
+ * no as-of — which is why the as-of is in the name. The fold stops at the
+ * position the read returned and is maintained no further, so `head` is the
+ * whole of what a caller can say about this state's currency: it is what lets
+ * the write path turn it into an `AppendCondition` (see `buildDecisionModel`),
+ * and what lets a read-time caller report, cache or compare a state against a
+ * position rather than against a wall clock.
+ *
+ * It is also the inversion worth naming out loud, because intuition runs the
+ * other way. A MAINTAINED view is consistent as of its CHECKPOINT, which trails
+ * the log's head by however far behind its runner is; this fold is consistent as
+ * of the head itself. So of two materialisations of one slice record, the one
+ * with no table, no checkpoint and no runner is the MOST current, and the table
+ * beside it is the stale one. Reach for a maintained view for the queries a
+ * single fold cannot serve — across many identities, ordered, joined, paginated
+ * — and never because it is fresher, because it is not.
+ *
+ * `head` is LOG-GLOBAL: it is the head the store's `read` returned, so it moves
+ * for an event no slice here selects. `test/decisionModel.test.ts` pins that
+ * behaviour EXPLICITLY, over four appended events one of which the composed query
+ * excludes by tag; `test/modelAtHead.test.ts` pins it incidentally, its own head
+ * assertion landing on that same excluded event's position. Two guards, one of them
+ * deliberate — reach for the explicit one when the property itself is what changes.
+ * Log-global neither tightens nor loosens the derived guard — there can be no
+ * event matching the query between the query's last match and the log head, so a
+ * query-filtered head would refuse exactly the same appends — which is precisely
+ * why the store's own figure is the one to carry: one fact about the log, not a
+ * per-query derivation, and the honest as-of for a state folded from everything
+ * the query selected up to it.
+ *
+ * ## Why this lives in the codec and not in `@kairos-es/read`
+ *
+ * In `@kairos-es/read` it would be the only export touching none of that
+ * package's machinery: no checkpoint, no `EventLogDurability` (R2 is vacuous
+ * where there is no checkpoint to outlive the log), no rung of that package's
+ * construction gate, and none of its test apparatus. The vocabulary is already
+ * this package's — ADR-0004 names the typed slice path's clients as "a decision
+ * model / materialisation / command" — and the body is `buildDecisionModel`'s,
+ * which is here for the reason the module doc gives.
+ */
+export declare const modelAtHead: <T extends Record<string, SliceProjection>>(projections: T) => Effect.Effect<{
+    readonly state: CompositeState<T>;
+    readonly head: Position;
+}, CodecError, DcbEventStore | Serializer | RequirementOf<T>>;
+/**
+ * The write side's decision model: `modelAtHead` plus the `AppendCondition` that
+ * reuses the read query as `failIfEventsMatch` and the read head as `after` (the
+ * DCB optimistic-concurrency contract).
+ *
+ * It is expressed OVER `modelAtHead` rather than beside it, and that is the point
+ * of the pair. Two functions reading, decoding and folding a slice record almost
+ * identically would need two sets of tests and would be free to drift on the
+ * decode stage, on the cast recovering `CompositeState<T>`, or on which record
+ * the query is composed from. Re-expressing makes this a decomposition instead
+ * of a near-duplicate: `modelAtHead` is the shared part, this function is the
+ * condition and nothing else, and each is shorter than the one function was.
+ *
+ * `composeProjections` therefore runs TWICE for one command — once inside
+ * `modelAtHead` for the read, once here for `failIfEventsMatch` — and that is
+ * deliberate rather than waste. It is a pure derivation of the record, so the two
+ * queries cannot disagree however either call site changes. The alternative,
+ * returning the query from `modelAtHead`, would put a third field on a READ-TIME
+ * API that no read-time caller wants, to save one pure merge over a handful of
+ * slices; a surface paying for a body's convenience is the worse trade.
+ *
+ * ## How to attribute the read, the decode and the fold — the rule, stated once
+ *
+ * Because this function is `Effect.map` over `modelAtHead`, prose about the codec
+ * splits into two kinds and only one of them may name this symbol:
+ *
+ * - Naming this function as the ENTRY POINT a caller invokes, or as the path
+ *   something is reached THROUGH, is correct — "the `buildDecisionModel` fold", "the
+ *   write path reaches decode through `buildDecisionModel`". Transitive reach is real
+ *   reach, and this is the symbol a command actually calls.
+ * - Naming it as the function that CONTAINS the read, the decode or the fold is
+ *   FALSE. All three are `modelAtHead`'s; this body adds an `AppendCondition` and
+ *   nothing else.
+ *
+ * Worth writing down because the distinction is invisible from a call site and the
+ * mistake is systematic rather than careless: every such claim was TRUE before
+ * `modelAtHead` was extracted from here, so a doc written against the older shape
+ * reads perfectly and is wrong. The correction is to name `modelAtHead`, never to
+ * soften the sentence.
+ */
+export declare const buildDecisionModel: <T extends Record<string, SliceProjection>>(projections: T) => Effect.Effect<{
+    readonly state: CompositeState<T>;
+    readonly appendCondition: AppendCondition;
+}, CodecError, DcbEventStore | Serializer | RequirementOf<T>>;
+//# sourceMappingURL=decisionModel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decisionModel.d.ts","sourceRoot":"","sources":["../../src/decisionModel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,cAAc,EAEnB,aAAa,EACb,KAAK,QAAQ,EACd,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAEvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C,+EAA+E;AAC/E,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,IACjE,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,eAAe,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACnE,aAAa,CAAC,KACb,MAAM,CAAC,MAAM,CACd;IAAE,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,EAC9D,UAAU,EACV,aAAa,GAAG,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,CAyB3C,CAAA;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1E,aAAa,CAAC,KACb,MAAM,CAAC,MAAM,CACd;IACE,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,CAAA;IACjC,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAA;CAC1C,EACD,UAAU,EACV,aAAa,GAAG,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,CAU1C,CAAA"}

package/dist/dts/decode.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The shared decode stage: the wire-bytes -> typed-payload half of the codec
+ * seam, lifted out of `buildDecisionModel` into a `Stream` combinator so every
+ * consumer of a slice record decodes through *one* implementation.
+ *
+ * Two consumers, one stage. `modelAtHead` folds a bounded `read` stream into
+ * decision state, which is how `buildDecisionModel` gets one; the read side folds
+ * an unbounded `subscribe` stream into a materialised view. They differ in
+ * everything *downstream* of decode (bounded vs live, a pure fold vs a
+ * transactional commit) and in nothing upstream of it — same slice record, same `type -> Schema` lookup, same
+ * `Serializer`, same failure taxonomy — so decode is exactly where the seam
+ * belongs. Duplicating it would let the two paths drift: a read side with its
+ * own copy could silently accept an event the decision path rejects, or reword
+ * a `CodecError` reason, and nothing would catch it.
+ *
+ * Why a `Stream` combinator rather than an `Effect` over a materialised array:
+ * decode must stay back-pressured. `Stream.mapEffect` with no `concurrency`
+ * option decodes one event at a time, pulling only as fast as the consumer
+ * folds, and that is what lets a projection catch up over a backlog far larger
+ * 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
+ * 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
+ * `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)
+ * concurrently, which their authors have no reason to expect. `unordered: true`
+ * is the option that would be an outright correctness bug against an
+ * order-sensitive fold. Sequential is the right default for both reasons; the
+ * order argument alone does not carry it.
+ *
+ * Why these failures are values and not defects: corrupt bytes, an absent
+ * schema and a `Schema` mismatch are *data* problems an application can
+ * legitimately handle (quarantine the event, fail the command, alert), so they
+ * belong on the error channel as `CodecError` — see `errors.ts`. The three
+ * `reason` strings are observable surface; treat them as fixed, not cosmetic.
+ *
+ * Two of those three are no longer this module's to reword. `deserialise` and
+ * `decode` are fixed in `deserialiseThenDecode`, the two-step this stage shares
+ * with the general (registry) path, precisely so that a claim about surface has
+ * ONE implementation behind it rather than a copy per path. The absent-schema
+ * reason stays here, because the two paths deliberately disagree about what a
+ * lookup miss means — `UnknownEventType` there, ADR-0005 — and that helper's doc
+ * carries the argument.
+ */
+import type { DecodedEvent, SequencedEvent } from '@kairos-es/core';
+import { Stream } from 'effect';
+import type { RequirementOf } from './decisionModel.js';
+import { CodecError } from './errors.js';
+import type { SliceProjection } from './projection.js';
+import { Serializer } from './Serializer.js';
+/**
+ * The public decode stage: give it the slice record, get back a `Stream`
+ * combinator that decodes every event those slices can handle.
+ *
+ * **Why one call rather than two.** The lookup and the stage were briefly two
+ * public symbols — merge the record, then hand the map to the stage — and every
+ * consumer in the repo composed them in exactly that order and did nothing else
+ * with the intermediate map. A two-step protocol with one legal composition is
+ * not flexibility, it is a way to get it wrong: a caller can merge the wrong
+ * record, or a record that is not the one its `Query` was composed from, and
+ * that second mistake is silent. In the read side it would decode a live
+ * subscription against schemas the subscription never selects — every event
+ * arriving would fail `no schema for event type`, framed as a data problem when
+ * it is a wiring one. Taking the slices directly removes the intermediate value
+ * a caller could substitute, so the schemas provably come from the same record
+ * the query does.
+ *
+ * **Still curried, deliberately.** The merge is a pure derivation of the slice
+ * record, so both consumers build the stage ONCE — per decision model, per read
+ * model — and reuse it across every stream they drive. Rebuilding the table per
+ * stream (let alone per restart) would only burn allocations, and the currying
+ * is what makes "built once" the natural way to call this rather than a
+ * discipline.
+ *
+ * **It can REFUSE the record**, and does so the moment it is called rather than
+ * once events are flowing: a type reachable from two slices under two DIFFERENT
+ * `Schema`s throws, in the same words `makeRegistry` uses. See
+ * `mergeSliceSchemas` for the rule, why reference equality is its discriminator
+ * and why a throw is the right mechanism. Both in-repo consumers call this
+ * before there is a stream to fail, so inside their `Effect.gen`s the refusal is
+ * a defect at construction.
+ *
+ * `RequirementOf<T>` surfaces in the result's `R`, so a slice whose `Schema`
+ * carries a requirement (an application-authored decryption transform, ADR-0004)
+ * propagates it to the caller with no cast at the call site.
+ */
+export declare const decodeSlices: <T extends Record<string, SliceProjection>>(slices: T) => (<E, R>(events: Stream.Stream<SequencedEvent, E, R>) => Stream.Stream<DecodedEvent, E | CodecError, R | RequirementOf<T> | Serializer>);
+//# sourceMappingURL=decode.d.ts.map

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

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

package/dist/dts/deserialiseThenDecode.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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
+ * `CodecError` whose `reason` says WHICH half failed.
+ *
+ * **What it is the single home of.** The two `reason` strings `'deserialise'`
+ * and `'decode'`, and their ORDER. Why those strings are observable surface —
+ * fixed rather than cosmetic, because an application quarantines an event,
+ * alerts or fails a command off them — is argued in `decode.ts`'s module doc and
+ * is not restated here. What this module adds is that the argument had TWO
+ * implementations standing behind it: the slice stage (`decodeEvents`) and the
+ * general/registry path (`makeRegistry`'s `decode`) each wrote the pair out, in
+ * one package, and only the slice copy was pinned by a test. A reworded `reason`
+ * on the registry path would have been caught by nothing. Sharing the step
+ * DELETES that drift channel rather than alarming it, which is why this exists
+ * 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
+ * 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
+ * would not break a decode; it would send every incident to the wrong team.
+ *
+ * **Why a `Serializer` VALUE rather than reading the tag here.** The two callers
+ * acquire it at deliberately different moments and this step must not flatten
+ * that. `decodeEvents` reads it ONCE when the stream starts (`Stream.unwrap`), so
+ * a backlog of a million events does not re-read context per event; the
+ * registry's `decode` is a per-event `Effect` and yields it inside its own
+ * `Effect.gen`. Taking the resolved service preserves both, and keeps
+ * `Serializer` off this signature's `R`, so the requirement stays declared where
+ * the acquisition actually happens — which is where a reader goes looking for it.
+ *
+ * **Why the LOOKUP is not folded in**, though both callers do one immediately
+ * before calling this: the two paths disagree about what a miss MEANS, and the
+ * disagreement is deliberate. The slice path fails `CodecError` with
+ * `no schema for event type '<type>'` — a caller named the type and the record it
+ * supplied has no entry for it, so the wiring is wrong. The registry path fails
+ * `UnknownEventType` — the type arrived off the WIRE and the registry does not
+ * know it, which is ADR-0005 decode-totality and the one fault a rolling
+ * deployment is EXPECTED to meet. `errors.ts` argues why those two sentences stay
+ * greppable apart. Folding the lookup in would mean a per-caller miss
+ * constructor: a second seam, bought to share the one thing the two paths
+ * genuinely do not have in common.
+ *
+ * `R` is the SCHEMA's requirement, propagated untouched — an ADR-0004 decryption
+ * transform reaches the caller's `R` through here with no cast. The three
+ * parameters are positional because their types are mutually unassignable, so a
+ * transposed call is a compile error rather than a silent inversion.
+ *
+ * PACKAGE-INTERNAL: exported to its two callers and no further, deliberately
+ * absent from `index.ts`. It is a shared step, not a capability on offer — a
+ * consumer holding bytes and a `Schema` wants `decodeSlices` or a `Registry`,
+ * both of which do the lookup this one refuses to.
+ */
+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>;
+//# sourceMappingURL=deserialiseThenDecode.d.ts.map

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

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

package/dist/dts/errors.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":";;;AAeA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;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/event.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Event definitions: a tagged `Schema` built through `event(type, fields,
+ * tagsFor)`. Each def is a `Schema<Payload, Wire, 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).
+ *
+ * The single `EventType` brand is applied once, here, so no consumer ever casts
+ * a type string: `def.type` is already assignable to core's `EventType`. The
+ * payload `A`, wire encoding `I`, and requirement `R` are inferred from the
+ * `Schema.Struct` of `fields` — including any requirement a field's `Schema`
+ * transform carries (e.g. an application `Encrypted(...)` field contributes its
+ * `CipherKey` to `R`).
+ *
+ * `tagsFor` is the only way to tag an event: `toEvent` derives the wire tags by
+ * calling it, and there is no `tags` option to override them. Its
+ * `NonEmptyReadonlyArray<Tag>` return makes "every event carries at least one
+ * tag" a compile-time guarantee (returning `[]` is a type error at the def
+ * site), and its input being only this event's payload guarantees `tag ⊆ event
+ * data` structurally. An event with no natural business identity returns an
+ * explicit app-defined `system:<name>` tag, never an empty array.
+ *
+ * A mapper must be a *pure* function of its payload and key off fields in their
+ * schema-canonical form (normalising in the mapper to match a field's schema),
+ * so the tag it derives is stable under the schema round-trip: a later retag
+ * re-derives tags from decoded history, and `tagsFor(decode(encode(p)))` must
+ * equal `tagsFor(p)` for that to be sound. Plain scalar fields satisfy this
+ * trivially; a field whose schema canonicalises on decode (trim, lowercase,
+ * normalise) needs the mapper to apply the same normalisation (ADR-0006).
+ */
+import type { EventType, Tag } from '@kairos-es/core';
+import type { Array as Arr } from 'effect';
+import { Schema } from 'effect';
+/**
+ * A tag mapper: derives an event's tags from its decoded payload, returning at
+ * least one `Tag`. Named so a standalone mapper can be typed and shared (e.g.
+ * across two versioned defs of one logical event) and so the signature is
+ * written once, not per use site.
+ */
+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`.
+ */
+export interface EventDef<A = unknown, I = unknown, R = never> {
+    readonly type: EventType;
+    readonly schema: Schema.Schema<A, I, 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).
+ */
+export type EventDefAny = EventDef<any, any, unknown>;
+/**
+ * Define an event from a versioned `type` literal, its payload `fields`, and its
+ * required `tagsFor` mapper. Builds `Schema.Struct(fields)` and brands the type
+ * literal *once* (the single sanctioned cast). The returned def is typed so
+ * `def.type` is a branded literal assignable to core's `EventType` with no
+ * consumer cast, `A`/`I`/`R` are inferred from the struct, and `tagsFor`
+ * receives the def's decoded payload type.
+ */
+export declare const event: <const Type extends string, Fields extends Schema.Struct.Fields>(type: Type, fields: Fields, tagsFor: TagsFor<Schema.Struct.Type<Fields>>) => {
+    readonly type: Type & EventType;
+    readonly schema: Schema.Struct<Fields>;
+    readonly tagsFor: TagsFor<Schema.Struct.Type<Fields>>;
+};
+//# sourceMappingURL=event.d.ts.map

package/dist/dts/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;;;;;GAKG;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,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IACvC,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"}