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

package/src/DcbEventStore.ts

@@ -1,5 +1,5 @@
 /**
- * The `DcbEventStore` contract: a `Context.Tag` with no bundled implementation.
+ * The `DcbEventStore` contract: a `Context.Service` with no bundled implementation.
  * Consumers supply a `Layer` (the in-memory one lives in this package; each SQL
  * engine is a package of its own — `@kairos-es/store-postgres` and
  * `@kairos-es/store-sqlite`).
@@ -42,7 +42,7 @@ export interface ReadResponse {
   readonly head: Position
 }
 
-export class DcbEventStore extends Context.Tag('@kairos-es/core/DcbEventStore')<
+export class DcbEventStore extends Context.Service<
   DcbEventStore,
   {
     /**
@@ -74,4 +74,4 @@ export class DcbEventStore extends Context.Tag('@kairos-es/core/DcbEventStore')<
       after?: Position,
     ) => Stream.Stream<SequencedEvent, never, Scope.Scope>
   }
->() {}
+>()('@kairos-es/core/DcbEventStore') {}

package/src/Event.ts

@@ -6,19 +6,55 @@
  * payloads into these bytes. Ordering is by `position` alone; `occurredAt` is
  * producer-supplied domain time and is informational only.
  */
-import { Schema } from 'effect'
+import {
+  BigInt as BigInt_,
+  Effect,
+  Option,
+  Schema,
+  SchemaIssue,
+  SchemaTransformation,
+} 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
+ * Encoded, a position is a decimal string (JSON-safe, `String(b)`); decoded, a
  * `bigint`. `0n` is the "before the first event" sentinel used by `after` and by
  * an empty store's head.
+ *
+ * The string-to-`bigint` step is hand-built rather than Effect 4's
+ * `Schema.BigIntFromString`, because that schema accepts only `^-?\d+$` and so
+ * refuses inputs the encoded side has always admitted — `" 5"`, `"+5"`,
+ * `"0x10"`. The decode here is the global `BigInt(s)` behind a blank-string
+ * refusal, which is `BigInt.fromString` and is exactly what Effect 3's
+ * `Schema.BigInt` ran, so a position string any earlier release decoded still
+ * decodes to the same value. The non-negative check then runs on the `bigint`,
+ * as it always did.
  */
-export const Position = Schema.BigInt.pipe(
-  Schema.nonNegativeBigInt(),
+export const Position = Schema.String.pipe(
+  Schema.decodeTo(
+    Schema.BigInt,
+    SchemaTransformation.transformEffect<bigint, string>({
+      decode: (s, options) =>
+        Option.match(BigInt_.fromString(s), {
+          onNone: () =>
+            Effect.fail(
+              new SchemaIssue.InvalidValue(
+                {
+                  message: `Unable to decode ${JSON.stringify(s)} into a bigint`,
+                },
+                s,
+                options,
+              ),
+            ),
+          onSome: Effect.succeed,
+        }),
+      encode: (b) => Effect.succeed(String(b)),
+    }),
+  ),
+  Schema.check(Schema.isGreaterThanOrEqualToBigInt(0n)),
   Schema.brand('Position'),
 )
 export type Position = typeof Position.Type
@@ -33,7 +69,7 @@ export const ORIGIN: Position = Position.make(0n)
  * item's tags (superset test).
  */
 export const Tag = Schema.String.pipe(
-  Schema.pattern(/^[^:]+:.+/, { identifier: 'Tag' }),
+  Schema.check(Schema.isPattern(/^[^:]+:.+/, { identifier: 'Tag' })),
   Schema.brand('Tag'),
 )
 export type Tag = typeof Tag.Type
@@ -95,7 +131,7 @@ export const tagIdentity = (key: string): TagIdentity => {
  * `ReadLimit.make(n)`.
  */
 export const ReadLimit = Schema.Int.pipe(
-  Schema.greaterThanOrEqualTo(0),
+  Schema.check(Schema.isGreaterThanOrEqualTo(0)),
   Schema.brand('ReadLimit'),
 )
 export type ReadLimit = typeof ReadLimit.Type
@@ -105,7 +141,7 @@ export type ReadLimit = typeof ReadLimit.Type
  * in the name (e.g. `course-registered.v2`); only non-emptiness is enforced.
  */
 export const EventType = Schema.String.pipe(
-  Schema.nonEmptyString(),
+  Schema.check(Schema.isNonEmpty()),
   Schema.brand('EventType'),
 )
 export type EventType = typeof EventType.Type
@@ -159,10 +195,7 @@ export type EventType = typeof EventType.Type
  * alone: it would make an event the store accepted unreadable for ever, so a
  * value check belongs at write or nowhere.
  */
-export const Metadata = Schema.Record({
-  key: Schema.String,
-  value: Schema.String,
-})
+export const Metadata = Schema.Record(Schema.String, Schema.String)
 export type Metadata = typeof Metadata.Type
 
 /**
@@ -172,6 +205,8 @@ export type Metadata = typeof Metadata.Type
  *
  * `data` is `Uint8Array` (opaque bytes); the store does not interpret it.
  * `uuid` is producer-supplied to keep `core` deterministic (no RNG in core).
+ * It is checked for UUID SHAPE only (`isGUID`), not for a version nibble: a
+ * stricter check would refuse ids an existing log already holds.
  * `occurredAt` is informational only; ordering is by position alone.
  * `metadata` mirrors `tags` rather than `data`: REQUIRED, with an empty bag
  * legal. Required because an absent-versus-empty divergence between engines is
@@ -181,10 +216,10 @@ export type Metadata = typeof Metadata.Type
  */
 export const DcbEvent = Schema.Struct({
   type: EventType,
-  data: Schema.Uint8ArrayFromSelf,
+  data: Schema.Uint8Array,
   tags: Schema.Array(Tag),
-  uuid: Schema.UUID,
-  occurredAt: Schema.DateTimeUtc,
+  uuid: Schema.String.check(Schema.isGUID()),
+  occurredAt: Schema.DateTimeUtcFromString,
   metadata: Metadata,
 })
 export type DcbEvent = typeof DcbEvent.Type

package/src/Query.ts

@@ -273,7 +273,7 @@ export const classifyServableQuery = (query: Query): ServableQueryShape => {
   }
   const only = query.items.length === 1 ? query.items[0] : undefined
   if (only !== undefined && only.tags.length === 0) {
-    return Arr.isNonEmptyReadonlyArray(only.types)
+    return Arr.isReadonlyArrayNonEmpty(only.types)
       ? { kind: 'typeOnly', types: only.types }
       : { kind: 'wildcard' }
   }

package/src/SubscribeMachine.ts

@@ -69,7 +69,6 @@
  * where an ephemeral view re-catches-up the entire log on every boot.
  */
 import {
-  Chunk,
   Effect,
   Option,
   Queue,
@@ -120,12 +119,12 @@ export const DEFAULT_POLL_INTERVAL_MILLIS = 1000
  * the key NAME, the VALIDATION and the DEFAULT from one place, so a caller who has
  * tuned one engine's subscribe reads another's without translating, and the two
  * cannot drift in what they ACCEPT any more than in what they assume. Two engines
- * hand-authoring the identical `Schema.optionalWith(…)` twice were identical only
+ * hand-authoring the identical `Schema.optionalKey(…)` twice were identical only
  * by inspection.
  *
  * The bounds differ between the two because the quantities do. `pollInterval` is a
- * duration, so a fraction of a millisecond is meaningful and only `positive` and
- * `finite` matter: at zero or below the loop would spin without ever waiting for a
+ * duration, so a fraction of a millisecond is meaningful and only `isGreaterThan(0)`
+ * and `isFinite` matter: at zero or below the loop would spin without ever waiting for a
  * wake, and at `Infinity` the periodic re-read — the half that carries delivery —
  * would never come, which silently converts the wake source from an optimisation
  * into the guarantee. `catchUpPageSize` is a COUNT, so it must be an integer
@@ -133,18 +132,17 @@ export const DEFAULT_POLL_INTERVAL_MILLIS = 1000
  * length against it to decide the tail is drained, and a page of zero would report
  * "drained" forever without reading anything.
  *
- * `exact: true` on both keeps the decoded type at `key?: T` rather than
+ * `optionalKey` on both keeps the decoded type at `key?: T` rather than
  * `T | undefined`, matching the repo's `exactOptionalPropertyTypes` discipline — an
  * absent key, never an explicit `undefined`.
  */
 export const subscriptionTuningFields = {
-  pollInterval: Schema.optionalWith(
-    Schema.Number.pipe(Schema.positive(), Schema.finite()),
-    { exact: true },
+  pollInterval: Schema.optionalKey(
+    Schema.Number.check(Schema.isGreaterThan(0), Schema.isFinite()),
+  ),
+  catchUpPageSize: Schema.optionalKey(
+    Schema.Int.check(Schema.isGreaterThan(0)),
   ),
-  catchUpPageSize: Schema.optionalWith(Schema.Int.pipe(Schema.positive()), {
-    exact: true,
-  }),
 } as const
 
 /**
@@ -154,10 +152,13 @@ export const subscriptionTuningFields = {
  * past the cap propagates (the decorator dies it) — infrastructure stays off the
  * contract channel while the stream survives ordinary transients.
  */
-const POLL_RETRY_SCHEDULE = Schedule.exponential('100 millis', 2).pipe(
-  Schedule.union(Schedule.spaced('2 seconds')),
-  Schedule.intersect(Schedule.recurs(20)),
-)
+const POLL_RETRY_SCHEDULE = Schedule.max([
+  Schedule.min([
+    Schedule.exponential('100 millis', 2),
+    Schedule.spaced('2 seconds'),
+  ]),
+  Schedule.recurs(20),
+])
 
 /**
  * The two seams the subscribe machine runs over, plus the two tuning knobs. `E` is
@@ -166,7 +167,7 @@ const POLL_RETRY_SCHEDULE = Schedule.exponential('100 millis', 2).pipe(
  *
  * ONE type parameter and not two, deliberately: a wake source with an error type of
  * its own is `Stream.orDie`d by the caller, yielding a `Stream<unknown, never>`
- * that is assignable here under Effect v3's covariant error channel. A second
+ * that is assignable here under Effect's covariant error channel. A second
  * parameter would buy nothing and would have to be spelled at every call site. Nor
  * is there an `R`: neither seam contributes a requirement, and unused generality is
  * not free.
@@ -199,17 +200,17 @@ export interface SubscriptionDeps<E> {
 
 /**
  * Build the subscription `Stream`: catch up from `after`, then track the live tail.
- * The cursor threads through the `unfoldChunkEffect` unfold state, starting at
- * `after` and advancing to the last delivered position each batch; the stream never
- * completes on its own (always `Option.some`), so the enclosing scope interrupts it
- * on close. An `E` mid-stream stays on the channel; `makeContractStore` dies it
+ * The cursor threads through the `Stream.paginate` state, starting at `after` and
+ * advancing to the last delivered position each batch; the stream never completes
+ * on its own (the next state is always `Option.some`), so the enclosing scope
+ * interrupts it on close. An `E` mid-stream stays on the channel; `makeContractStore` dies it
  * (subscribe is `E = never` on the contract).
  */
 export const subscribeStream = <E>(
   deps: SubscriptionDeps<E>,
   after: Position | undefined,
 ): Stream.Stream<SequencedEvent, E, Scope.Scope> =>
-  Stream.unwrapScoped(
+  Stream.unwrap(
     Effect.gen(function* () {
       // The wake primitive: a sliding(1) queue holding at most one pending
       // signal. The wake source `offer`s an opaque wake on every notification;
@@ -230,9 +231,10 @@ export const subscribeStream = <E>(
       const listener = (deps.listen ?? Stream.never).pipe(
         Stream.tap(() => Queue.offer(wake, undefined)),
         Stream.retry(
-          Schedule.exponential('50 millis').pipe(
-            Schedule.union(Schedule.spaced('1 seconds')),
-          ),
+          Schedule.min([
+            Schedule.exponential('50 millis'),
+            Schedule.spaced('1 seconds'),
+          ]),
         ),
       )
       // Drain the wake source into the wake queue on a background fibre; the
@@ -280,7 +282,7 @@ export const subscribeStream = <E>(
 
       /**
        * Produce the NEXT non-empty batch from a cursor position, together with
-       * the advanced cursor — a pure `Position → Effect<[Chunk, next]>`. The
+       * the advanced cursor — a pure `Position → Effect<[events, next]>`. The
        * `> boundary` de-dup is enforced by `fetch`'s exclusive lower bound, so a
        * live re-read after a wake never re-emits an already-delivered position.
        *
@@ -288,18 +290,20 @@ export const subscribeStream = <E>(
        * the cursor. If a drain yields nothing, wait for a wake but only up to the
        * poll interval, then loop and re-read ANYWAY — the periodic position-based
        * poll that makes delivery correct independently of any wake. This effect
-       * only completes by returning a non-empty chunk; the scope interrupts it on
+       * only completes by returning a non-empty batch; the scope interrupts it on
        * close.
        */
       const nextBatch = (
         from: Position,
-      ): Effect.Effect<readonly [Chunk.Chunk<SequencedEvent>, Position], E> =>
+      ): Effect.Effect<readonly [ReadonlyArray<SequencedEvent>, Position], E> =>
         Effect.gen(function* () {
           while (true) {
-            yield* Queue.takeAll(wake)
+            // `Queue.clear` and not `Queue.takeAll`: the drain must NOT wait, and
+            // `takeAll` suspends until at least one signal is present.
+            yield* Queue.clear(wake)
             const { events, last } = yield* drainFrom(from)
             if (events.length > 0) {
-              return [Chunk.fromIterable(events), last] as const
+              return [events, last] as const
             }
             // Nothing new: block on a wake, but only up to the poll interval — on
             // timeout we fall through and the loop re-reads regardless.
@@ -309,8 +313,11 @@ export const subscribeStream = <E>(
           }
         })
 
-      return Stream.unfoldChunkEffect(after ?? ORIGIN, (from) =>
-        Effect.map(nextBatch(from), Option.some),
+      return Stream.paginate(after ?? ORIGIN, (from) =>
+        Effect.map(
+          nextBatch(from),
+          ([events, last]) => [events, Option.some(last)] as const,
+        ),
       )
     }),
   )

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 { DateTime, 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'
@@ -73,7 +73,7 @@ const copyEvent = (event: DcbEvent): DcbEvent => ({
   data: new Uint8Array(event.data),
   tags: [...event.tags],
   uuid: event.uuid,
-  occurredAt: DateTime.unsafeMake(DateTime.toEpochMillis(event.occurredAt)),
+  occurredAt: DateTime.makeUnsafe(DateTime.toEpochMillis(event.occurredAt)),
   metadata: { ...event.metadata },
 })
 
@@ -288,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)
 
@@ -381,7 +381,7 @@ 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`).
@@ -393,7 +393,7 @@ const make = (
                 Effect.map(Ref.get(log), (snapshot) =>
                   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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;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,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD,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,CAoGrB,CAAA"}

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,QAAQ,4DAGnB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ;;;;;;;EAOnB,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/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"}