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

package/src/deserialiseThenDecode.ts

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

package/src/errors.ts

@@ -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).
@@ -42,9 +43,10 @@ export class CodecError extends 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.
    */
   override get message(): string {
     return this.reason

package/src/event.ts

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

package/src/index.ts

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

package/src/precondition.ts

@@ -148,7 +148,7 @@ import type { Uuid } from './Uuid'
  * path meant to deny the input cheaply. Wrap such work in `Effect.suspend`.
  */
 export interface Precondition<Id, Service, E, R> {
-  readonly tag: Context.Tag<Id, Service>
+  readonly tag: Context.Key<Id, Service>
   readonly evaluate: Effect.Effect<Service, E, R>
 }
 
@@ -243,7 +243,7 @@ export const decideOnly = <
  * condition here. If that turns up in practice, a composing override is the
  * additive answer and this hatch is not it.
  *
- * `Effect.mapInputContext` over
+ * `Effect.updateContext` over
  * `Context.omit(AppendIsOwned)` is what lets it through the store's ownership
  * refusal — the one route, and `AppendIsOwned.ts` owns why removing the marker is
  * the shape rather than a second tag or a sanctioning flag.
@@ -275,7 +275,7 @@ export const unsafeAppend = (
     // channel), so nothing here will fail to compile if this is deleted — what
     // catches it is `test/appendOwnership.test.ts` in the source repository, not the
     // type checker.
-    Effect.mapInputContext(
+    Effect.updateContext(
       store.append(events),
       (context: Context.Context<never>) => Context.omit(AppendIsOwned)(context),
     ),

package/src/projection.ts

@@ -5,7 +5,7 @@
  * A `SliceProjection<S, R>` is a core `AnyProjection<S>` (directly composable —
  * its `evolve` folds a `DecodedEvent`) enriched with the `type -> Schema` map
  * `decodeSlices` merges and decodes through. That map's value type carries `R`
- * covariantly (`Schema<unknown, unknown, R>`), so the union of the defs'
+ * covariantly (`Schema.Decoder<unknown, R>`), so the union of the defs'
  * requirements flows to the decision model with no cast (and no phantom marker).
  * Because `evolve` is already erased, a built slice drops straight into
  * `composeProjections` — no `AnyProjection.of` ceremony.
@@ -35,7 +35,7 @@ import type { EventDef } from './event'
  */
 export interface SliceProjection<out S = unknown, out R = unknown>
   extends AnyProjection<S> {
-  readonly schemas: ReadonlyMap<string, Schema.Schema<unknown, unknown, R>>
+  readonly schemas: ReadonlyMap<string, Schema.Decoder<unknown, R>>
 }
 
 /** The fluent builder: accumulate `.on(def, fold)` steps, then `.build()`. */
@@ -75,7 +75,7 @@ export const projection = <S>(initialState: S): ProjectionBuilder<S, never> => {
   // threading `R` means the implementation states the same widening the
   // `ProjectionBuilder` interface promises, and `on` returns without a cast.
   const make = <R>(
-    schemas: ReadonlyMap<string, Schema.Schema<unknown, unknown, R>>,
+    schemas: ReadonlyMap<string, Schema.Decoder<unknown, R>>,
     folds: ReadonlyMap<string, (state: S, payload: unknown) => S>,
   ): ProjectionBuilder<S, R> => ({
     on: <A, I, R2>(
@@ -101,25 +101,20 @@ export const projection = <S>(initialState: S): ProjectionBuilder<S, never> => {
       // The entry type is annotated `R | R2` rather than inferred, and that
       // annotation is what carries the requirement forward — `build` reads `R`
       // straight off this map, so `RequirementOf` ultimately reads it from here.
-      // Widening the copied `R` entries into it costs nothing: `Schema` is
-      // declared `<in out A, in out I, out R>` upstream, hence covariant in its
+      // Widening the copied `R` entries into it costs nothing: `Schema.Decoder`
+      // is declared `<out T, out RD>` upstream, hence covariant in its
       // requirement.
-      const nextSchemas = new Map<
-        string,
-        Schema.Schema<unknown, unknown, R | R2>
-      >(schemas)
-      // Erasing `A`/`I` is the one unavoidable cast, and `as unknown as` is what
-      // it takes: `Schema` is INVARIANT in both, so `Schema<A, I, R2>` and
-      // `Schema<unknown, unknown, R2>` are unrelated in either direction. It is
-      // sound because the payload is only ever read back through `evolve`, which
-      // re-narrows by event type via the matching `fold`. The target names `R2`
-      // and not `never` because `R2` is what the def actually requires — an
-      // `Encrypted` field's `CipherKey` is not nothing — so the cast erases only
-      // what it has to and states the rest truthfully.
-      nextSchemas.set(
-        def.type,
-        def.schema as unknown as Schema.Schema<unknown, unknown, R2>,
+      const nextSchemas = new Map<string, Schema.Decoder<unknown, R | R2>>(
+        schemas,
       )
+      // Erasing `A`/`I` needs no cast: a `Schema.Codec` is covariant in both, so
+      // `Codec<A, I, R2, R2>` is already a `Decoder<unknown, R2>`. The erasure is
+      // sound because the payload is only ever read back through `evolve`, which
+      // re-narrows by event type via the matching `fold`. What survives it is
+      // `R2`, the def's DECODING requirement — an `Encrypted` field's `CipherKey`
+      // is not nothing — and that is the half a slice ever spends, since a slice
+      // decodes and never encodes.
+      nextSchemas.set(def.type, def.schema)
       const nextFolds = new Map(folds)
       // Contravariance in the payload parameter, so this one is a cast too: the
       // map holds folds over `unknown`, and `evolve` supplies the payload the

package/src/readLedger.ts

@@ -73,6 +73,7 @@ import {
   ORIGIN,
   servableQueryFault,
   unionQueries,
+  unknownQueryKeyFault,
 } from '@kairos-es/core'
 import { Context, Data, Effect, Layer, Option, Ref } from 'effect'
 
@@ -97,7 +98,7 @@ export interface Hop {
  * requirement channel nothing is exactly what makes this change additive.
  * `modelAtHead` is that path and is why the rule exists.
  *
- * A BRACKET-ONLY function is the opposite case and yields the tag deliberately.
+ * A BRACKET-ONLY function is the opposite case and yields the service deliberately.
  * `decideOnly` does, and naming the requirement is what turns *"call me inside a
  * bracket"* from a runtime defect into a compile error — presence being the one
  * direction the type system can decide here. So the test is what the function
@@ -107,7 +108,7 @@ export interface Hop {
  * Recording is two-phase, and `record`'s own doc below owns why and what shape the
  * second phase takes.
  */
-export class ReadLedger extends Context.Tag('@kairos-es/codec/ReadLedger')<
+export class ReadLedger extends Context.Service<
   ReadLedger,
   {
     /**
@@ -126,14 +127,14 @@ export class ReadLedger extends Context.Tag('@kairos-es/codec/ReadLedger')<
     readonly record: (query: Query) => Effect.Effect<CloseHop>
     readonly hops: Effect.Effect<ReadonlyArray<Hop>>
   }
->() {}
+>()('@kairos-es/codec/ReadLedger') {}
 
 /**
  * Fill in a recorded hop's head. Never called if the read does not complete.
  *
  * On the package's public surface because it is already ON it: `record` returns
- * one, `ReadLedger` is exported, so a consumer holding the tag holds this type and
- * could not name it. `Hop` was exported and this was not — the same interface, two
+ * one, `ReadLedger` is exported, so a consumer holding the service holds this
+ * type and could not name it. `Hop` was exported and this was not — the same interface, two
  * treatments.
  */
 export type CloseHop = (head: Position) => Effect.Effect<void>
@@ -302,7 +303,7 @@ export const makeReadLedger: Effect.Effect<{
  */
 const withLedger = <A, E = never>(
   absent: A,
-  f: (ledger: Context.Tag.Service<ReadLedger>) => Effect.Effect<A, E>,
+  f: (ledger: Context.Service.Shape<typeof ReadLedger>) => Effect.Effect<A, E>,
 ): Effect.Effect<A, E> =>
   Effect.flatMap(Effect.serviceOption(ReadLedger), (ledger) =>
     Option.isNone(ledger) ? Effect.succeed(absent) : f(ledger.value),
@@ -329,14 +330,29 @@ const taglessKeys = (
     )
     .map(([key]) => key)
 
-/** Would recording this record's query leave the accumulated union unservable? */
+/**
+ * Would recording this record's query leave the accumulated union unservable in
+ * its SHAPE — the one fault a slice's tags can fix, and so the one this ledger
+ * reports?
+ *
+ * An unknown key anywhere in the union answers no. It is not a tagless slice and no
+ * slice's tags would fix it, and the store refuses it as a defect naming the key at
+ * the read of the hop that carries it, so an earlier hop's key has already been
+ * refused once by the time a later record is judged. Judged here it would surface
+ * as this ledger's error, on the error channel, naming a slice with nothing wrong
+ * with it — and a hop is recorded before its read runs, so an earlier hop's key
+ * would go on doing that to every clean read after it.
+ */
 const unionWouldBeUnservable = (
   existing: ReadonlyArray<Hop>,
   incoming: Query,
-): boolean =>
-  servableQueryFault(
-    unionQueries([...existing.map((h) => h.query), incoming]),
-  ) !== undefined
+): boolean => {
+  const union = unionQueries([...existing.map((h) => h.query), incoming])
+  return (
+    unknownQueryKeyFault(union) === undefined &&
+    servableQueryFault(union) !== undefined
+  )
+}
 
 /**
  * Refuse a read that would leave the bracket's accumulated union unservable,
@@ -389,6 +405,6 @@ export const ambientLayeredCondition: Effect.Effect<
   Option.Option<AppendCondition>
 > = withLedger(Option.none<AppendCondition>(), (ledger) =>
   Effect.map(ledger.hops, (hops) =>
-    Option.fromNullable(deriveLayeredCondition(hops)),
+    Option.fromNullishOr(deriveLayeredCondition(hops)),
   ),
 )

package/src/registry.ts

@@ -53,7 +53,7 @@ type RequirementOfDefs<Defs extends ReadonlyArray<EventDefAny>> =
 export const makeRegistry = <Defs extends ReadonlyArray<EventDefAny>>(
   defs: Defs,
 ): Registry<RequirementOfDefs<Defs>> => {
-  const map = new Map<string, Schema.Schema<unknown, unknown, unknown>>()
+  const map = new Map<string, Schema.Decoder<unknown, unknown>>()
   for (const def of defs) {
     if (map.has(def.type)) {
       throw new Error(`duplicate event type '${def.type}' in registry`)

package/src/toEvent.ts

@@ -1,7 +1,7 @@
 /**
  * Event production (codec edge-helper): turn a typed payload into a wire
- * `DcbEvent`. Encode is `Schema.encode(def.schema)` (a `ParseError` becomes a
- * `CodecError`; any encryption transform runs here, *before* serialisation)
+ * `DcbEvent`. Encode is `Schema.encodeEffect(def.schema)` (a `SchemaError`
+ * becomes a `CodecError`; any encryption transform runs here, *before* serialisation)
  * then `serialiser.serialise`. The wire `tags` are derived from the def's
  * required `tagsFor` mapper (ADR-0006) — they are never hand-passed, so two
  * command sites emitting the same event type cannot tag it differently. A mapper
@@ -10,11 +10,19 @@
  * comes from `options.uuid` or the `Uuid` service; `occurredAt` from
  * `options.occurredAt` or the Effect clock (`DateTime.now`), keeping `core`
  * clock- and RNG-free while staying overridable for backdated imports.
+ * `metadata` comes from `options.metadata` or the OPTIONAL ambient
+ * `MetadataSource` service, and is `{}` when neither supplies it (ADR-0017). A
+ * bag core's `Metadata` schema refuses, such as one holding a value that is not a
+ * string, fails on the `CodecError` channel (`reason: 'metadata'`), whichever of
+ * the two supplied it. It never reaches `tagsFor`, the
+ * event's schema or the serialiser, so it can enter neither the tag junction
+ * table nor the encryption seam.
  */
-import type { DcbEvent } from '@kairos-es/core'
-import { DateTime, Effect, Schema } from 'effect'
+import { type DcbEvent, Metadata } from '@kairos-es/core'
+import { DateTime, Effect, Option, Schema } from 'effect'
 import { CodecError } from './errors'
 import type { EventDef } from './event'
+import { MetadataSource } from './MetadataSource'
 import { Serializer } from './Serializer'
 import { Uuid } from './Uuid'
 
@@ -26,7 +34,10 @@ import { Uuid } from './Uuid'
  * wire-envelope fields (the query surface), so a `tagsFor` mapper may only key
  * off cleartext payload fields (ADR-0006). `uuid` / `occurredAt` are
  * exact-optional overrides; absent, they come from the `Uuid` service and the
- * Effect clock.
+ * Effect clock. `metadata` is an exact-optional override too; absent, it comes
+ * from the ambient `MetadataSource` if one is provided and is `{}` otherwise.
+ * The ambient read adds nothing to the requirement channel. A bag core's
+ * `Metadata` schema refuses fails as a `CodecError` with `reason: 'metadata'`.
  */
 export const toEvent = <A, I, R>(
   def: EventDef<A, I, R>,
@@ -34,10 +45,45 @@ export const toEvent = <A, I, R>(
   options?: {
     readonly uuid?: string
     readonly occurredAt?: DateTime.Utc
+    readonly metadata?: Metadata
   },
 ): Effect.Effect<DcbEvent, CodecError, Serializer | Uuid | R> =>
   Effect.gen(function* () {
-    // Derive tags first. A mapper is app code that can throw (e.g. `Tag.make`
+    // Resolve metadata before anything else. Per-call wins, ambient fills,
+    // absent yields `{}`. `serviceOption` keeps `MetadataSource` out of the
+    // requirement channel.
+    //
+    // The bag is then CHECKED against core's `Metadata` schema, whichever arm
+    // supplied it. The type holds a typed caller to a bag of strings, but an
+    // `any` or untyped JavaScript gets past it, and the engines then disagree
+    // about what they stored: the cross-engine parity of this field rests on its
+    // values being strings, and this is the one place a value is refused. It is
+    // refused HERE, at write, and never on read: a read-side check would make an
+    // event the store had accepted unreadable for ever. A bad bag is the
+    // caller's mistake, so it fails on the `CodecError` channel exactly as a
+    // throwing `tagsFor` does, never as a defect. Checking consumes no sequence,
+    // so placing it above the tag derivation leaves the property below intact.
+    //
+    // The bag is COPIED, never stamped by reference: an ambient bag would
+    // otherwise be ONE object shared by every event of a request, and the
+    // caller's own object would be shared with the event it built, so a mutation
+    // of either before the append would rewrite the other. (After the append no
+    // store shares anything with its caller; that is each store's guarantee.)
+    const given: unknown =
+      options?.metadata === undefined
+        ? Option.getOrElse(
+            yield* Effect.serviceOption(MetadataSource),
+            (): Metadata => ({}),
+          )
+        : options.metadata
+    const metadata: Metadata = {
+      ...(yield* Schema.decodeUnknownEffect(Metadata)(given).pipe(
+        Effect.mapError(
+          (cause) => new CodecError({ reason: 'metadata', cause }),
+        ),
+      )),
+    }
+    // Derive tags next. A mapper is app code that can throw (e.g. `Tag.make`
     // rejects an ill-formed `key:value`), and the codec's contract is that such
     // failures are values on the `CodecError` channel, never defects (errors.ts).
     // Deriving before the uuid/clock effects also means a bad tag fails without
@@ -47,7 +93,7 @@ export const toEvent = <A, I, R>(
       catch: (cause) => new CodecError({ reason: 'tags', cause }),
     })
     const serializer = yield* Serializer
-    const encoded = yield* Schema.encode(def.schema)(payload).pipe(
+    const encoded = yield* Schema.encodeEffect(def.schema)(payload).pipe(
       Effect.mapError((cause) => new CodecError({ reason: 'encode', cause })),
     )
     const data = serializer.serialise(encoded)
@@ -59,5 +105,6 @@ export const toEvent = <A, I, R>(
       tags,
       uuid,
       occurredAt,
+      metadata,
     }
   })

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

@@ -1 +0,0 @@
-{"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.map

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

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

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

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

@@ -1 +0,0 @@
-{"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,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAA;CAC1E;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,CAiGzE,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"toEvent.d.ts","sourceRoot":"","sources":["../../src/toEvent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B;;;;;;;;;GASG;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;CACnC,KACA,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,GAAG,CAAC,CAyBxD,CAAA"}