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

package/src/inMemory.ts

@@ -4,7 +4,7 @@
  *
  * The log is a `Ref<ReadonlyArray<SequencedEvent>>` in ascending position
  * order. The whole check-then-append is run inside a single
- * `Effect.makeSemaphore(1)`+`withPermits(1)` critical section: the conditional
+ * `Semaphore.make(1)`+`withPermits(1)` critical section: the conditional
  * read and the commit must not be separable, and that atomicity is the entire
  * concurrency guarantee (exactly-one-wins under a race). Positions come from a
  * monotonic counter starting at 1n (contiguous here; the contract only promises
@@ -25,7 +25,7 @@
  * discharges the ascending-commit-order precondition `SubscribeMachine.ts` states.
  */
 import type { Array as Arr, Scope } from 'effect'
-import { Effect, Layer, PubSub, Ref, Stream } from 'effect'
+import { DateTime, Effect, Layer, PubSub, Ref, Semaphore, Stream } from 'effect'
 import type { AppendCondition } from './AppendCondition'
 import { makeContractStore, type RawDcbEventStore } from './ContractStore'
 import type { ReadOptions, ReadResponse } from './DcbEventStore'
@@ -41,6 +41,68 @@ import {
   subscribeStream,
 } from './SubscribeMachine'
 
+/**
+ * A copy of `event` that shares no mutable structure with it: fresh `data` bytes, a
+ * fresh `tags` array, a fresh `metadata` bag and a fresh `occurredAt`. Only `type`
+ * and `uuid`, which are strings, are carried as they are.
+ *
+ * Each copy is chosen for what it does on EVERY input the type admits, not on the
+ * common one. `data` is copied through the `Uint8Array` constructor and not with
+ * `slice`, because `DcbEvent` admits any `Uint8Array` subclass and a subclass may
+ * answer `slice` with a VIEW of the same memory — Node's `Buffer` does. A
+ * `DateTime.Utc` is an ordinary object whose fields can be written past its
+ * `readonly` type, so `occurredAt` is rebuilt from its instant rather than shared.
+ *
+ * ## Why the oracle copies at BOTH edges
+ *
+ * This store is the reference the SQL engines are judged against, and a SQL engine
+ * shares nothing with its caller: it serialises on the way in and builds fresh objects
+ * on the way out. A store that kept the caller's objects instead would let a caller
+ * rewrite the log AFTER the append — mutate a `Uint8Array`, push to a `tags` array,
+ * assign into a `metadata` bag — and every later read would see the rewritten event
+ * with no append, no position and no wake behind it. A reference that can be edited
+ * after the fact judges nothing.
+ *
+ * So `append` stores a copy (the log never holds a caller's object) and every read
+ * path hands out a copy (a reader cannot reach the log through what it was given).
+ * Copying on the way in alone would close the first route and leave the second open:
+ * the same object would then be shared by every reader of the log.
+ */
+const copyEvent = (event: DcbEvent): DcbEvent => ({
+  type: event.type,
+  data: new Uint8Array(event.data),
+  tags: [...event.tags],
+  uuid: event.uuid,
+  occurredAt: DateTime.makeUnsafe(DateTime.toEpochMillis(event.occurredAt)),
+  metadata: { ...event.metadata },
+})
+
+/**
+ * A copy of `query` that shares no array with it, taking only the keys the grammar
+ * defines.
+ *
+ * `subscribe` is the one verb that holds a query beyond its own call: the fetch seam
+ * judges it again on every page for as long as the subscription runs. Each SQL engine
+ * compiles its plan once, when the subscription starts, so an edit the caller makes
+ * to its own object afterwards reaches nothing there. The oracle has to answer the
+ * same, for the reason it copies events (above): a reference that the caller can
+ * change mid-stream judges nothing. Only `types` and `tags` are carried because they
+ * are all `matchesQueryItem` reads, and a key the grammar does not define was
+ * already refused at the contract decorator before this runs.
+ */
+const copyQuery = (query: Query): Query => ({
+  items: query.items.map((item) => ({
+    types: [...item.types],
+    tags: [...item.tags],
+  })),
+})
+
+/** A `SequencedEvent` whose event is a `copyEvent` of the stored one. */
+const copySequenced = (sequenced: SequencedEvent): SequencedEvent => ({
+  event: copyEvent(sequenced.event),
+  position: sequenced.position,
+})
+
 /** Filter a snapshot by `query` and `after` (strict `position > after`). */
 const filterLog = (
   log: ReadonlyArray<SequencedEvent>,
@@ -80,7 +142,7 @@ const readSnapshot = (
       ? lastPosition(log)
       : lastPosition(limited)) ?? ORIGIN
 
-  return { events: Stream.fromIterable(limited), head }
+  return { events: Stream.fromIterable(limited.map(copySequenced)), head }
 }
 
 /**
@@ -144,7 +206,7 @@ const fetchPage = (
   ) {
     const sequenced = log[index]
     if (matchesSequenced(sequenced, query)) {
-      page.push(sequenced)
+      page.push(copySequenced(sequenced))
     }
   }
   return page
@@ -226,7 +288,7 @@ const make = (
       options?.catchUpPageSize ?? DEFAULT_CATCH_UP_PAGE_SIZE
     const pollInterval = options?.pollInterval ?? DEFAULT_POLL_INTERVAL_MILLIS
     const log = yield* Ref.make<ReadonlyArray<SequencedEvent>>([])
-    const mutex = yield* Effect.makeSemaphore(1)
+    const mutex = yield* Semaphore.make(1)
     const hub = yield* PubSub.unbounded<SequencedEvent>()
     const nextPosition = yield* Ref.make<bigint>(1n)
 
@@ -247,53 +309,60 @@ const make = (
       events: Arr.NonEmptyReadonlyArray<DcbEvent>,
       condition?: AppendCondition,
     ): Effect.Effect<Position, AppendConditionFailed> =>
-      // Critical section: check + commit are atomic (the exactly-one-wins guarantee).
-      mutex.withPermits(1)(
-        Effect.gen(function* () {
-          const snapshot = yield* Ref.get(log)
+      Effect.suspend(() => {
+        // The events are copied when the append STARTS, before it waits for the
+        // permit, as each SQL engine serialises them before its first suspension:
+        // an edit the caller makes while this append is queued must not reach the
+        // log here when it could not reach theirs.
+        const owned = events.map(copyEvent)
+        // Critical section: check + commit are atomic (the exactly-one-wins guarantee).
+        return mutex.withPermits(1)(
+          Effect.gen(function* () {
+            const snapshot = yield* Ref.get(log)
 
-          if (condition !== undefined) {
-            const conflicts = filterLog(
-              snapshot,
-              condition.failIfEventsMatch,
-              condition.after,
-            )
-            // Detect by presence: any matching event after `condition.after`
-            // fails the append. The error carries only the condition (see
-            // `AppendConditionFailed`); a correct retry re-reads to the new head.
-            if (conflicts.length > 0) {
-              return yield* new AppendConditionFailed({ condition })
+            if (condition !== undefined) {
+              const conflicts = filterLog(
+                snapshot,
+                condition.failIfEventsMatch,
+                condition.after,
+              )
+              // Detect by presence: any matching event after `condition.after`
+              // fails the append. The error carries only the condition (see
+              // `AppendConditionFailed`); a correct retry re-reads to the new head.
+              if (conflicts.length > 0) {
+                return yield* new AppendConditionFailed({ condition })
+              }
             }
-          }
 
-          // Optional test seam between the conflict-check and the commit (see
-          // `InMemoryStoreOptions.beforeCommit`). Defaults to `Effect.void`, a
-          // synchronous no-op, so the shipped critical section stays atomic by
-          // construction; the concurrency contract test injects `Effect.yieldNow()`
-          // here to make the exactly-one-wins guard genuinely depend on the mutex.
-          yield* beforeCommit
+            // Optional test seam between the conflict-check and the commit (see
+            // `InMemoryStoreOptions.beforeCommit`). Defaults to `Effect.void`, a
+            // synchronous no-op, so the shipped critical section stays atomic by
+            // construction; the concurrency contract test injects `Effect.yieldNow()`
+            // here to make the exactly-one-wins guard genuinely depend on the mutex.
+            yield* beforeCommit
 
-          const start = yield* Ref.get(nextPosition)
-          const appended: Array<SequencedEvent> = events.map(
-            (event, index) => ({
-              event,
-              position: (start + BigInt(index)) as Position,
-            }),
-          )
-          const end = start + BigInt(events.length)
-          yield* Ref.set(log, [...snapshot, ...appended])
-          yield* Ref.set(nextPosition, end)
-          // The hub is a WAKE SOURCE and nothing else: the subscribe machine never
-          // reads what it carries, and its poll delivers with or without one. That
-          // is why suppressing the publish is a legitimate test seam rather than a
-          // broken store (see `InMemoryStoreOptions.suppressWake`).
-          if (!suppressWake) {
-            yield* PubSub.publishAll(hub, appended)
-          }
-          // `events` is non-empty, so the last new position is `end - 1`.
-          return (end - 1n) as Position
-        }),
-      )
+            const start = yield* Ref.get(nextPosition)
+            const appended: Array<SequencedEvent> = owned.map(
+              (event, index) => ({
+                event,
+                position: (start + BigInt(index)) as Position,
+              }),
+            )
+            const end = start + BigInt(events.length)
+            yield* Ref.set(log, [...snapshot, ...appended])
+            yield* Ref.set(nextPosition, end)
+            // The hub is a WAKE SOURCE and nothing else: the subscribe machine never
+            // reads what it carries, and its poll delivers with or without one. That
+            // is why suppressing the publish is a legitimate test seam rather than a
+            // broken store (see `InMemoryStoreOptions.suppressWake`).
+            if (!suppressWake) {
+              yield* PubSub.publishAll(hub, appended)
+            }
+            // `events` is non-empty, so the last new position is `end - 1`.
+            return (end - 1n) as Position
+          }),
+        )
+      })
 
     const subscribe = (
       query: Query,
@@ -312,16 +381,19 @@ const make = (
       // exclusive cursor is what makes the catch-up/live seam exactly-once, so there
       // is nothing left here for a critical section to protect. `append` keeps its
       // permit, which is the whole exactly-one-wins guarantee.
-      Stream.unwrapScoped(
+      Stream.unwrap(
         Effect.gen(function* () {
+          // Taken when the subscription starts, as the SQL engines compile theirs
+          // (see `copyQuery`).
+          const judged = copyQuery(query)
           const wakes = yield* PubSub.subscribe(hub)
           return subscribeStream<never>(
             {
               fetch: (from, limit) =>
                 Effect.map(Ref.get(log), (snapshot) =>
-                  fetchPage(snapshot, query, from, limit),
+                  fetchPage(snapshot, judged, from, limit),
                 ),
-              listen: Stream.fromQueue(wakes),
+              listen: Stream.fromSubscription(wakes),
               pollInterval,
               catchUpPageSize,
             },

package/src/index.ts

@@ -1,6 +1,6 @@
 /**
  * @kairos-es/core: DCB-first event-sourcing contract and in-memory store for
- * Effect v3.
+ * Effect.
  *
  * Exposes the domain types (`DcbEvent`, `SequencedEvent`, `Position`, `Tag`,
  * `EventType`), the selection language (`Query`, `QueryItem`, the pure match

package/src/retryOnConflict.ts

@@ -35,12 +35,6 @@
  * jitter draws from `Random.next`, a default service on the same footing as the
  * clock rather than a host `Math.random`. No `node:*`, no wall-clock reading, no
  * ungoverned RNG.
- *
- * Effect v3 caveat: the `Schedule` API below is the THREE-type-parameter
- * `Schedule<Out, In, R>` that `effect@3` exports, with `Schedule.intersect`. The
- * currently-published docs show a newer four-type-parameter `Schedule` without
- * `intersect` — do not copy them; this file is written against the installed
- * `effect@3` type definitions.
  */
 import { Effect, Predicate, Schedule } from 'effect'
 import type { AppendConditionFailed } from './errors'
@@ -49,9 +43,9 @@ import type { AppendConditionFailed } from './errors'
  * The default conflict backoff: exponential from 20ms, jittered, capped at five
  * retries.
  *
- * `Schedule.intersect` continues only while BOTH schedules continue, so the
- * `recurs(5)` arm is what bounds the attempts and the exponential arm is what
- * spaces them. Jitter matters more here than in a typical backoff: contending
+ * `Schedule.max` continues only while BOTH schedules continue, waiting the longer
+ * of their two delays, so the `recurs(5)` arm is what bounds the attempts and the
+ * exponential arm is what spaces them. Jitter matters more here than in a typical backoff: contending
  * deciders conflict precisely because they read the same boundary at the same
  * time, so an unjittered backoff would re-synchronise them into the same conflict
  * on every round. The figures are the conventional starting point (Emmett,
@@ -59,10 +53,10 @@ import type { AppendConditionFailed } from './errors'
  * command with a tighter latency budget, or one contending harder, should pass its
  * own schedule.
  */
-const conflictBackoff = Schedule.intersect(
+const conflictBackoff = Schedule.max([
   Schedule.jittered(Schedule.exponential('20 millis', 2)),
   Schedule.recurs(5),
-)
+])
 
 /**
  * Retry `command` while — and only while — it fails `AppendConditionFailed`.
@@ -91,6 +85,7 @@ export const retryOnConflict = <A, E, R>(
   schedule: Schedule.Schedule<
     unknown,
     AppendConditionFailed | E,
+    never,
     R
   > = conflictBackoff,
 ): Effect.Effect<A, AppendConditionFailed | E, R> =>

package/src/testing.ts

@@ -21,10 +21,10 @@ import { DateTime } from 'effect'
  *
  * Ordering in the log is by `position` alone, so an event's `occurredAt` is
  * informational; pinning it to the epoch keeps serialised bytes and comparisons
- * stable across runs. Built via `DateTime.unsafeMake(0)` (the value is a
+ * stable across runs. Built via `DateTime.makeUnsafe(0)` (the value is a
  * compile-time constant, not read from the host clock).
  */
-export const EPOCH = DateTime.unsafeMake(0)
+export const EPOCH = DateTime.makeUnsafe(0)
 
 /**
  * Build a fresh, deterministic uuid generator: a zero-based counter producing

package/testing/package.json

@@ -2,5 +2,5 @@
   "sideEffects": [],
   "main": "../dist/cjs/testing.js",
   "module": "../dist/esm/testing.js",
-  "types": "../dist/dts/testing.d.ts"
+  "types": "../dist/dts-cjs/testing.d.ts"
 }

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

@@ -1 +0,0 @@
-{"version":3,"file":"ContractStore.d.ts","sourceRoot":"","sources":["../../src/ContractStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,EAAE,MAAM,EAAqB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAEjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACrD,OAAO,EAAuB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAA;AAKzD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,CACb,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,WAAW,KAClB,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAA;IACnC,QAAQ,CAAC,MAAM,EAAE,CACf,MAAM,EAAE,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAC3C,SAAS,CAAC,EAAE,eAAe,KACxB,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,qBAAqB,GAAG,CAAC,CAAC,CAAA;IACvD,QAAQ,CAAC,SAAS,EAAE,CAClB,KAAK,EAAE,KAAK,EACZ,KAAK,CAAC,EAAE,QAAQ,KACb,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;CACnD;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EACjC,KAAK,gBAAgB,CAAC,CAAC,CAAC,KACvB,aAAa,CAAC,MAAM,CAsFrB,CAAA"}

package/dist/dts/Event.d.ts

@@ -1,104 +0,0 @@
-/**
- * Core domain types for the DCB event log: branded scalars and the wire
- * `DcbEvent`/`SequencedEvent` shapes.
- *
- * `data` is opaque bytes at the store layer; the codec (`@kairos-es/codec`) turns typed
- * payloads into these bytes. Ordering is by `position` alone; `occurredAt` is
- * producer-supplied domain time and is informational only.
- */
-import { Schema } from 'effect';
-/**
- * A position in the single global event log: a branded, non-negative `bigint`.
- *
- * The log is 64-bit (`bigserial` in Postgres) and exceeds JS `number` safety at
- * 2^53, so positions are a `bigint`. They are compared, never arithmetic'd.
- * `Schema.BigInt` encodes to a decimal string (JSON-safe) and decodes to
- * `bigint`. `0n` is the "before the first event" sentinel used by `after` and by
- * an empty store's head.
- */
-export declare const Position: Schema.brand<Schema.filter<typeof Schema.BigInt>, "Position">;
-export type Position = typeof Position.Type;
-/** The sentinel position meaning "before the first event". */
-export declare const ORIGIN: Position;
-/**
- * A business identifier attached to an event, following the `key:value`
- * convention (e.g. `student:s1`). Tags replace the per-stream id of classic
- * event sourcing; a query matches an event when the event carries all of an
- * item's tags (superset test).
- */
-export declare const Tag: Schema.brand<Schema.filter<typeof Schema.String>, "Tag">;
-export type Tag = typeof Tag.Type;
-/**
- * A reusable tag identity: a `key` plus a `.make(value)` that composes the
- * branded `Tag` `` `${key}:${value}` `` through core's `Tag` schema. Define an
- * identity once (`const CourseId = tagIdentity('course')`) and reuse
- * `CourseId.make(id)` everywhere that entity is tagged. The `key` is exposed for
- * key-aware tooling (e.g. a tag-vocabulary index, a future retag pass).
- *
- * The same constructor authors an event's tags (in a codec `tagsFor` mapper,
- * ADR-0006) and a query's tags, so the `key:value` string a mapper writes and
- * the string a query matches are produced by one function and cannot drift. It
- * lives here beside `Tag` — pure (no clock, no RNG, no effect) — so it is
- * reachable from every tag-authoring site, including core's own query
- * constructors.
- *
- * `key` and `value` are each a single colon-free atom: the `key:value` grammar
- * splits on the first colon, so both are validated to be non-empty and contain
- * no `:` — `key` once at construction, `value` on each `make`. This keeps
- * composition unambiguous and catches the double-prefix footgun loudly:
- * `CourseId.make('course:123')` throws rather than silently yielding
- * `course:course:123`. Raw `Tag.make` remains the escape hatch for a value that
- * must itself contain a colon.
- */
-export interface TagIdentity {
-    readonly key: string;
-    readonly make: (value: string) => Tag;
-}
-export declare const tagIdentity: (key: string) => TagIdentity;
-/**
- * A read cap: a branded non-negative integer bounding how many events a `read`
- * returns. `0` returns none; an absent limit returns all matching events.
- *
- * The bound lives in the type, not merely in prose: a negative or non-integer
- * limit is a programming error, so it is a DEFECT at the store boundary — the
- * store validates through this schema and dies rather than surfacing it on the
- * error channel (`read` keeps `E = never`). Constructed at call sites with
- * `ReadLimit.make(n)`.
- */
-export declare const ReadLimit: Schema.brand<Schema.filter<typeof Schema.Int>, "ReadLimit">;
-export type ReadLimit = typeof ReadLimit.Type;
-/**
- * An event type name, a branded non-empty string. Versioning is by convention
- * in the name (e.g. `course-registered.v2`); only non-emptiness is enforced.
- */
-export declare const EventType: Schema.brand<Schema.filter<typeof Schema.String>, "EventType">;
-export type EventType = typeof EventType.Type;
-/**
- * An event as stored: an opaque payload plus its type, tags, a
- * producer-supplied `uuid`, and producer-supplied `occurredAt` domain time.
- *
- * `data` is `Uint8Array` (opaque bytes); the store does not interpret it.
- * `uuid` is producer-supplied to keep `core` deterministic (no RNG in core).
- * `occurredAt` is informational only; ordering is by position alone.
- */
-export declare const DcbEvent: Schema.Struct<{
-    type: Schema.brand<Schema.filter<typeof Schema.String>, "EventType">;
-    data: typeof Schema.Uint8ArrayFromSelf;
-    tags: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "Tag">>;
-    uuid: typeof Schema.UUID;
-    occurredAt: typeof Schema.DateTimeUtc;
-}>;
-export type DcbEvent = typeof DcbEvent.Type;
-/** A persisted event: the event together with the position it was written at. */
-export declare const SequencedEvent: Schema.Struct<{
-    event: Schema.Struct<{
-        type: Schema.brand<Schema.filter<typeof Schema.String>, "EventType">;
-        data: typeof Schema.Uint8ArrayFromSelf;
-        tags: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "Tag">>;
-        uuid: typeof Schema.UUID;
-        occurredAt: typeof Schema.DateTimeUtc;
-    }>;
-    position: Schema.brand<Schema.filter<typeof Schema.BigInt>, "Position">;
-}>;
-export type SequencedEvent = typeof SequencedEvent.Type;
-//# sourceMappingURL=Event.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Event.d.ts","sourceRoot":"","sources":["../../src/Event.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,+DAGpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,8DAA8D;AAC9D,eAAO,MAAM,MAAM,EAAE,QAA4B,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,GAAG,0DAGf,CAAA;AACD,MAAM,MAAM,GAAG,GAAG,OAAO,GAAG,CAAC,IAAI,CAAA;AAEjC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,GAAG,CAAA;CACtC;AAED,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,WAiBzC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,6DAGrB,CAAA;AACD,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,SAAS,gEAGrB,CAAA;AACD,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;EAMnB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,iFAAiF;AACjF,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Query.d.ts","sourceRoot":"","sources":["../../src/Query.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,GAAG,EAAE,MAAM,SAAS,CAAA;AAE5E;;;GAGG;AACH,eAAO,MAAM,SAAS;;;EAGpB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C,iEAAiE;AACjE,eAAO,MAAM,KAAK;;;;;EAEhB,CAAA;AACF,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,QAAQ,EAAE,MAAM,SAAS,KAAG,OAOnE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,QAAQ,EAAE,OAAO,KAAK,KAAG,OAK5D,CAAA;AAED,qDAAqD;AACrD,eAAO,MAAM,gBAAgB,GAC3B,WAAW,cAAc,EACzB,OAAO,KAAK,KACX,OAA+C,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,KAAK,KAAG,IAKlD,CAAA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,KAAK,KAAG,MAAM,GAAG,SAkB1D,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAC7B;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAA;CACrD,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,KAAK,KAAG,kBAWpD,CAAA;AAoDD,iDAAiD;AACjD,eAAO,MAAM,KAAK;wBAlCF,KAAK;4BATC;QACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAA;QACpD,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;KAC1C,KAAG,SAAS;yBAkCJ,SAAS,CAAC,SAAS,EAAE,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,KACvD,KAAK;0BAtBA,SAAS,CAAC,GAAG,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,UACnC,aAAa,CAAC,SAAS,CAAC,KAC/B,KAAK;4BAUC,SAAS,CAAC,SAAS,EAAE,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,KACvD,KAAK;CAoBE,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"SubscribeMachine.d.ts","sourceRoot":"","sources":["../../src/SubscribeMachine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,OAAO,EAEL,MAAM,EAIN,MAAM,EACN,KAAK,KAAK,EACV,MAAM,EACP,MAAM,QAAQ,CAAA;AACf,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACvD,OAAO,EAAU,SAAS,EAAE,MAAM,SAAS,CAAA;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,MAAM,CAAA;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,4BAA4B,OAAO,CAAA;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,wBAAwB;;;;;;;CAQ3B,CAAA;AAcV;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,KACb,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAA;IACpD;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IAC3C,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CACjC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAC/B,MAAM,gBAAgB,CAAC,CAAC,CAAC,EACzB,OAAO,QAAQ,GAAG,SAAS,KAC1B,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAyG5C,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"retryOnConflict.d.ts","sourceRoot":"","sources":["../../src/retryOnConflict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,EAAE,MAAM,EAAa,QAAQ,EAAE,MAAM,QAAQ,CAAA;AACpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAqBrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EACrC,SAAS,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,qBAAqB,GAAG,CAAC,EAAE,CAAC,CAAC,EACvD,WAAU,QAAQ,CAAC,QAAQ,CACzB,OAAO,EACP,qBAAqB,GAAG,CAAC,EACzB,CAAC,CACgB,KAClB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,qBAAqB,GAAG,CAAC,EAAE,CAAC,CAI5C,CAAA"}