@livestore/common 0.4.0 → 0.5.0-dev.0

package/src/sync/syncstate.test.ts

@@ -1,66 +1,112 @@
+import { assert, expect } from 'vitest'
+
 import { Vitest } from '@livestore/utils-dev/node-vitest'
 import { Cause, Effect, Exit, Schema } from '@livestore/utils/effect'
-import { assert, expect } from 'vitest'
 
 import * as EventSequenceNumber from '../schema/EventSequenceNumber/mod.ts'
 import * as LiveStoreEvent from '../schema/LiveStoreEvent/mod.ts'
 import * as SyncState from './syncstate.ts'
 
-class TestEvent extends LiveStoreEvent.Client.EncodedWithMeta {
-  public payload = 'uninitialized'
-  public isClient = false
-
-  static new = (
-    seqNum: EventSequenceNumber.Client.CompositeInput,
-    parentSeqNum: EventSequenceNumber.Client.CompositeInput,
-    payload: string,
-    isClient: boolean,
-  ) => {
-    const event = new TestEvent({
-      seqNum: EventSequenceNumber.Client.Composite.make(seqNum),
-      parentSeqNum: EventSequenceNumber.Client.Composite.make(parentSeqNum),
-      name: 'a',
-      args: payload,
-      clientId: 'static-local-id',
-      sessionId: 'static-session-id',
-    })
-    event.payload = payload
-    event.isClient = isClient
-    return event
-  }
-
-  rebase_ = (parentSeqNum: EventSequenceNumber.Client.Composite, rebaseGeneration: number) => {
-    return this.rebase({ parentSeqNum, isClient: this.isClient, rebaseGeneration })
-  }
-
-  // Only used for Vitest printing
-  // toJSON = () => `(${this.seqNum.global},${this.seqNum.client},${this.payload})`
-  // toString = () => this.toJSON()
-}
+/** Module-scoped JSON codecs; keeping the sync codecs out of Effect generators avoids `schemaSyncInEffect`. */
+const jsonStringify = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown))
+const jsonParse = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown))
+
+const makeTestEvent = ({
+  seqNum,
+  parentSeqNum,
+  payload,
+  isClientOnly,
+}: {
+  seqNum: EventSequenceNumber.Client.CompositeInput
+  parentSeqNum: EventSequenceNumber.Client.CompositeInput
+  payload: string
+  isClientOnly: boolean
+}) =>
+  new LiveStoreEvent.Client.EncodedWithMeta({
+    seqNum: EventSequenceNumber.Client.Composite.make(seqNum),
+    parentSeqNum: EventSequenceNumber.Client.Composite.make(parentSeqNum),
+    name: 'a',
+    // Effect v4 normalizes nested Schema.Class values to their declared schema fields.
+    // Keep this test-only flag inside `args`, which is part of EncodedWithMeta,
+    // instead of relying on subclass fields that are stripped during parsing.
+    args: { payload, isClientOnly },
+    clientId: 'static-local-id',
+    sessionId: 'static-session-id',
+  })
 
-const e0_1 = TestEvent.new({ global: 0, client: 1 }, EventSequenceNumber.Client.ROOT, 'a', true)
-const e1_0 = TestEvent.new({ global: 1, client: 0 }, EventSequenceNumber.Client.ROOT, 'a', false)
-const e1_1 = TestEvent.new({ global: 1, client: 1 }, e1_0.seqNum, 'a', true)
-const e1_2 = TestEvent.new({ global: 1, client: 2 }, e1_1.seqNum, 'a', true)
-const e1_3 = TestEvent.new({ global: 1, client: 3 }, e1_2.seqNum, 'a', true)
-const e2_0 = TestEvent.new({ global: 2, client: 0 }, e1_0.seqNum, 'a', false)
-const e2_1 = TestEvent.new({ global: 2, client: 1 }, e2_0.seqNum, 'a', true)
+const e0_1 = makeTestEvent({
+  seqNum: { global: 0, client: 1 },
+  parentSeqNum: EventSequenceNumber.Client.ROOT,
+  payload: 'a',
+  isClientOnly: true,
+})
+const e1_0 = makeTestEvent({
+  seqNum: { global: 1, client: 0 },
+  parentSeqNum: EventSequenceNumber.Client.ROOT,
+  payload: 'a',
+  isClientOnly: false,
+})
+const e1_1 = makeTestEvent({
+  seqNum: { global: 1, client: 1 },
+  parentSeqNum: e1_0.seqNum,
+  payload: 'a',
+  isClientOnly: true,
+})
+const e1_2 = makeTestEvent({
+  seqNum: { global: 1, client: 2 },
+  parentSeqNum: e1_1.seqNum,
+  payload: 'a',
+  isClientOnly: true,
+})
+const e1_3 = makeTestEvent({
+  seqNum: { global: 1, client: 3 },
+  parentSeqNum: e1_2.seqNum,
+  payload: 'a',
+  isClientOnly: true,
+})
+const e2_0 = makeTestEvent({
+  seqNum: { global: 2, client: 0 },
+  parentSeqNum: e1_0.seqNum,
+  payload: 'a',
+  isClientOnly: false,
+})
+const e2_1 = makeTestEvent({
+  seqNum: { global: 2, client: 1 },
+  parentSeqNum: e2_0.seqNum,
+  payload: 'a',
+  isClientOnly: true,
+})
 
 const isEqualEvent = LiveStoreEvent.Client.isEqualEncoded
 
-const isClientEvent = (event: LiveStoreEvent.Client.EncodedWithMeta) => (event as TestEvent).isClient
-
+const isClientOnlyEvent = (event: LiveStoreEvent.Client.EncodedWithMeta) =>
+  typeof event.args === 'object' &&
+  event.args !== null &&
+  'isClientOnly' in event.args &&
+  event.args.isClientOnly === true
+
+const rebaseTestEvent = ({
+  event,
+  parentSeqNum,
+  rebaseGeneration,
+}: {
+  event: LiveStoreEvent.Client.EncodedWithMeta
+  parentSeqNum: EventSequenceNumber.Client.Composite
+  rebaseGeneration: number
+}) => event.rebase({ parentSeqNum, isClientOnly: isClientOnlyEvent(event), rebaseGeneration })
+
+/** Verifies: LS.SYS.SYNC.SS-R01, LS.SYS.SYNC.SS-R02, LS.SYS.SYNC.SS-R03, LS.SYS.SYNC.SS-R05, LS.SYS.SYNC.SS-R06 */
 Vitest.describe('syncstate', () => {
   Vitest.describe('merge', () => {
     const merge = ({
       syncState,
       payload,
-      ignoreClientEvents = false,
+      ignoreClientOnlyEvents = false,
     }: {
       syncState: SyncState.SyncState
       payload: typeof SyncState.Payload.Type
-      ignoreClientEvents?: boolean
-    }) => SyncState.merge({ syncState, payload, isClientEvent, isEqualEvent, ignoreClientEvents })
+      ignoreClientOnlyEvents?: boolean
+    }) => SyncState.merge({ syncState, payload, isClientOnlyEvent, isEqualEvent, ignoreClientOnlyEvents })
 
     Vitest.describe('upstream-rebase', () => {
       Vitest.it.effect('should rollback until start', () =>
@@ -70,8 +116,8 @@ Vitest.describe('syncstate', () => {
             upstreamHead: EventSequenceNumber.Client.ROOT,
             localHead: e2_0.seqNum,
           })
-          const e1_0_e2_0 = e1_0.rebase_(e2_0.seqNum, 0)
-          const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.seqNum, 0)
+          const e1_0_e2_0 = rebaseTestEvent({ event: e1_0, parentSeqNum: e2_0.seqNum, rebaseGeneration: 0 })
+          const e1_1_e2_1 = rebaseTestEvent({ event: e1_1, parentSeqNum: e1_0_e2_0.seqNum, rebaseGeneration: 0 })
           const result = yield* merge({
             syncState,
             payload: SyncState.PayloadUpstreamRebase.make({
@@ -79,7 +125,7 @@ Vitest.describe('syncstate', () => {
               newEvents: [e1_0_e2_0, e1_1_e2_1],
             }),
           })
-          const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.seqNum, 1)
+          const e2_0_e3_0 = rebaseTestEvent({ event: e2_0, parentSeqNum: e1_0_e2_0.seqNum, rebaseGeneration: 1 })
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
           expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_1.seqNum)
@@ -96,7 +142,7 @@ Vitest.describe('syncstate', () => {
             upstreamHead: EventSequenceNumber.Client.ROOT,
             localHead: e2_0.seqNum,
           })
-          const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum, 0)
+          const e1_1_e2_0 = rebaseTestEvent({ event: e1_1, parentSeqNum: e1_0.seqNum, rebaseGeneration: 0 })
           const result = yield* merge({
             syncState,
             payload: SyncState.PayloadUpstreamRebase.make({
@@ -104,7 +150,7 @@ Vitest.describe('syncstate', () => {
               rollbackEvents: [e1_1],
             }),
           })
-          const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.seqNum, 1)
+          const e2_0_e3_0 = rebaseTestEvent({ event: e2_0, parentSeqNum: e1_1_e2_0.seqNum, rebaseGeneration: 1 })
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
           expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_0.seqNum)
@@ -129,7 +175,7 @@ Vitest.describe('syncstate', () => {
           expectEventArraysEqual(result.newSyncState.pending, [])
           expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
           expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
-          expect(result.newEvents).toStrictEqual([e2_0])
+          expectEventArraysEqual(result.newEvents, [e2_0])
         }),
       )
     })
@@ -146,7 +192,7 @@ Vitest.describe('syncstate', () => {
             Effect.exit,
           )
           assert(Exit.isFailure(exit))
-          expect(Cause.isDie(exit.cause)).toBe(true)
+          expect(Cause.hasDies(exit.cause)).toBe(true)
         }),
       )
 
@@ -161,7 +207,7 @@ Vitest.describe('syncstate', () => {
             Effect.exit,
           )
           assert(Exit.isFailure(exit))
-          expect(Cause.isDie(exit.cause)).toBe(true)
+          expect(Cause.hasDies(exit.cause)).toBe(true)
         }),
       )
 
@@ -176,7 +222,7 @@ Vitest.describe('syncstate', () => {
             Effect.exit,
           )
           assert(Exit.isFailure(exit))
-          expect(Cause.isDie(exit.cause)).toBe(true)
+          expect(Cause.hasDies(exit.cause)).toBe(true)
         }),
       )
 
@@ -191,7 +237,7 @@ Vitest.describe('syncstate', () => {
             Effect.exit,
           )
           assert(Exit.isFailure(exit))
-          expect(Cause.isDie(exit.cause)).toBe(true)
+          expect(Cause.hasDies(exit.cause)).toBe(true)
         }),
       )
 
@@ -247,7 +293,7 @@ Vitest.describe('syncstate', () => {
           expectEventArraysEqual(result.newSyncState.pending, [])
           expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.seqNum)
           expect(result.newSyncState.localHead).toMatchObject(e1_1.seqNum)
-          expect(result.newEvents).toStrictEqual([e1_1])
+          expectEventArraysEqual(result.newEvents, [e1_1])
           expectEventArraysEqual(result.confirmedEvents, [e1_0])
         }),
       )
@@ -268,7 +314,7 @@ Vitest.describe('syncstate', () => {
           expectEventArraysEqual(result.newSyncState.pending, [])
           expect(result.newSyncState.upstreamHead).toMatchObject(e2_1.seqNum)
           expect(result.newSyncState.localHead).toMatchObject(e2_1.seqNum)
-          expect(result.newEvents).toStrictEqual([e1_2, e1_3, e2_0, e2_1])
+          expectEventArraysEqual(result.newEvents, [e1_2, e1_3, e2_0, e2_1])
           expectEventArraysEqual(result.confirmedEvents, [e1_1])
         }),
       )
@@ -304,7 +350,7 @@ Vitest.describe('syncstate', () => {
           const result = yield* merge({
             syncState,
             payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
-            ignoreClientEvents: true,
+            ignoreClientOnlyEvents: true,
           })
           expectAdvance(result)
           expectEventArraysEqual(result.newSyncState.pending, [])
@@ -325,7 +371,7 @@ Vitest.describe('syncstate', () => {
           const result = yield* merge({
             syncState,
             payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
-            ignoreClientEvents: true,
+            ignoreClientOnlyEvents: true,
           })
           expectAdvance(result)
           expectEventArraysEqual(result.newSyncState.pending, [e2_0])
@@ -346,14 +392,14 @@ Vitest.describe('syncstate', () => {
           const result = yield* merge({
             syncState,
             payload: { _tag: 'upstream-advance', newEvents: [e1_0, e2_0] },
-            ignoreClientEvents: true,
+            ignoreClientOnlyEvents: true,
           })
 
           expectAdvance(result)
           expectEventArraysEqual(result.newSyncState.pending, [])
           expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
           expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
-          expect(result.newEvents).toStrictEqual([e2_0])
+          expectEventArraysEqual(result.newEvents, [e2_0])
           expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_0, e1_1])
         }),
       )
@@ -369,50 +415,52 @@ Vitest.describe('syncstate', () => {
             Effect.exit,
           )
           assert(Exit.isFailure(exit))
-          expect(Cause.isDie(exit.cause)).toBe(true)
+          expect(Cause.hasDies(exit.cause)).toBe(true)
         }),
       )
 
-      Vitest.it.effect('should advance (not rebase) when pending event has undefined-valued key dropped by JSON wire round-trip', () =>
-        Effect.gen(function* () {
-          const argsSchema = Schema.Struct({
-            id: Schema.String,
-            flag: Schema.UndefinedOr(Schema.Boolean),
-          })
-          const localArgs = Schema.encodeUnknownSync(argsSchema)({ id: 'abc' } as any)
-          const wireArgs = JSON.parse(JSON.stringify(localArgs))
-
-          const localPending = new TestEvent({
-            seqNum: e1_0.seqNum,
-            parentSeqNum: e1_0.parentSeqNum,
-            name: e1_0.name,
-            args: localArgs,
-            clientId: e1_0.clientId,
-            sessionId: e1_0.sessionId,
-          })
-          const fromUpstream = new TestEvent({
-            seqNum: e1_0.seqNum,
-            parentSeqNum: e1_0.parentSeqNum,
-            name: e1_0.name,
-            args: wireArgs,
-            clientId: e1_0.clientId,
-            sessionId: e1_0.sessionId,
-          })
-
-          const syncState = new SyncState.SyncState({
-            pending: [localPending],
-            upstreamHead: EventSequenceNumber.Client.ROOT,
-            localHead: localPending.seqNum,
-          })
-          const result = yield* merge({
-            syncState,
-            payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [fromUpstream] }),
-          })
-
-          expectAdvance(result)
-          expect(result.confirmedEvents).toHaveLength(1)
-          expect(result.newSyncState.pending).toHaveLength(0)
-        }),
+      Vitest.it.effect(
+        'should advance (not rebase) when pending event has undefined-valued key dropped by JSON wire round-trip',
+        () =>
+          Effect.gen(function* () {
+            const argsSchema = Schema.Struct({
+              id: Schema.String,
+              flag: Schema.optional(Schema.Boolean),
+            })
+            const localArgs = yield* Schema.encodeUnknownEffect(argsSchema)({ id: 'abc' } as any).pipe(Effect.orDie)
+            const wireArgs = jsonParse(jsonStringify(localArgs))
+
+            const localPending = new LiveStoreEvent.Client.EncodedWithMeta({
+              seqNum: e1_0.seqNum,
+              parentSeqNum: e1_0.parentSeqNum,
+              name: e1_0.name,
+              args: localArgs,
+              clientId: e1_0.clientId,
+              sessionId: e1_0.sessionId,
+            })
+            const fromUpstream = new LiveStoreEvent.Client.EncodedWithMeta({
+              seqNum: e1_0.seqNum,
+              parentSeqNum: e1_0.parentSeqNum,
+              name: e1_0.name,
+              args: wireArgs,
+              clientId: e1_0.clientId,
+              sessionId: e1_0.sessionId,
+            })
+
+            const syncState = new SyncState.SyncState({
+              pending: [localPending],
+              upstreamHead: EventSequenceNumber.Client.ROOT,
+              localHead: localPending.seqNum,
+            })
+            const result = yield* merge({
+              syncState,
+              payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [fromUpstream] }),
+            })
+
+            expectAdvance(result)
+            expect(result.confirmedEvents).toHaveLength(1)
+            expect(result.newSyncState.pending).toHaveLength(0)
+          }),
       )
     })
 
@@ -429,7 +477,7 @@ Vitest.describe('syncstate', () => {
             payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1] }),
           })
 
-          const e1_0_e1_2 = e1_0.rebase_(e1_1.seqNum, 1)
+          const e1_0_e1_2 = rebaseTestEvent({ event: e1_0, parentSeqNum: e1_1.seqNum, rebaseGeneration: 1 })
 
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [e1_0_e1_2])
@@ -442,7 +490,12 @@ Vitest.describe('syncstate', () => {
 
       Vitest.it.effect('should rebase different event with same id', () =>
         Effect.gen(function* () {
-          const e2_0_b = TestEvent.new({ global: 1, client: 0 }, e1_0.seqNum, '1_0_b', false)
+          const e2_0_b = makeTestEvent({
+            seqNum: { global: 1, client: 0 },
+            parentSeqNum: e1_0.seqNum,
+            payload: '1_0_b',
+            isClientOnly: false,
+          })
           const syncState = new SyncState.SyncState({
             pending: [e2_0_b],
             upstreamHead: EventSequenceNumber.Client.ROOT,
@@ -452,7 +505,7 @@ Vitest.describe('syncstate', () => {
             syncState,
             payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e2_0] }),
           })
-          const e2_0_e3_0 = e2_0_b.rebase_(e2_0.seqNum, 1)
+          const e2_0_e3_0 = rebaseTestEvent({ event: e2_0_b, parentSeqNum: e2_0.seqNum, rebaseGeneration: 1 })
 
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
@@ -475,7 +528,7 @@ Vitest.describe('syncstate', () => {
             payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
           })
 
-          const e1_0_e3_0 = e1_0.rebase_(e2_0.seqNum, 1)
+          const e1_0_e3_0 = rebaseTestEvent({ event: e1_0, parentSeqNum: e2_0.seqNum, rebaseGeneration: 1 })
 
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [e1_0_e3_0])
@@ -496,7 +549,7 @@ Vitest.describe('syncstate', () => {
             payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_0, e1_2, e1_3, e2_0] }),
           })
 
-          const e1_1_e2_1 = e1_1.rebase_(e2_0.seqNum, 1)
+          const e1_1_e2_1 = rebaseTestEvent({ event: e1_1, parentSeqNum: e2_0.seqNum, rebaseGeneration: 1 })
 
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [e1_1_e2_1])
@@ -519,8 +572,8 @@ Vitest.describe('syncstate', () => {
             payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
           })
 
-          const e1_0_e2_1 = e1_0.rebase_(e2_0.seqNum, 1)
-          const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.seqNum, 1)
+          const e1_0_e2_1 = rebaseTestEvent({ event: e1_0, parentSeqNum: e2_0.seqNum, rebaseGeneration: 1 })
+          const e1_1_e2_2 = rebaseTestEvent({ event: e1_1, parentSeqNum: e1_0_e2_1.seqNum, rebaseGeneration: 1 })
 
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [e1_0_e2_1, e1_1_e2_2])
@@ -567,7 +620,7 @@ Vitest.describe('syncstate', () => {
               const result = yield* merge({
                 syncState,
                 payload: SyncState.PayloadLocalPush.make({ newEvents: [e0_1] }),
-                ignoreClientEvents: true,
+                ignoreClientOnlyEvents: true,
               })
 
               expectAdvance(result)
@@ -578,28 +631,26 @@ Vitest.describe('syncstate', () => {
             }),
           )
 
-          Vitest.it.effect(
-            'appends only upstream-bound events to pending when ignoring client-only pushes',
-            () =>
-              Effect.gen(function* () {
-                const syncState = new SyncState.SyncState({
-                  pending: [],
-                  upstreamHead: EventSequenceNumber.Client.ROOT,
-                  localHead: EventSequenceNumber.Client.ROOT,
-                })
-
-                const result = yield* merge({
-                  syncState,
-                  payload: SyncState.PayloadLocalPush.make({ newEvents: [e0_1, e1_0] }),
-                  ignoreClientEvents: true,
-                })
-
-                expectAdvance(result)
-                expectEventArraysEqual(result.newSyncState.pending, [e1_0])
-                expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.Client.ROOT)
-                expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
-                expectEventArraysEqual(result.newEvents, [e0_1, e1_0])
-              }),
+          Vitest.it.effect('appends only upstream-bound events to pending when ignoring client-only pushes', () =>
+            Effect.gen(function* () {
+              const syncState = new SyncState.SyncState({
+                pending: [],
+                upstreamHead: EventSequenceNumber.Client.ROOT,
+                localHead: EventSequenceNumber.Client.ROOT,
+              })
+
+              const result = yield* merge({
+                syncState,
+                payload: SyncState.PayloadLocalPush.make({ newEvents: [e0_1, e1_0] }),
+                ignoreClientOnlyEvents: true,
+              })
+
+              expectAdvance(result)
+              expectEventArraysEqual(result.newSyncState.pending, [e1_0])
+              expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.Client.ROOT)
+              expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
+              expectEventArraysEqual(result.newEvents, [e0_1, e1_0])
+            }),
           )
         })
 
@@ -639,20 +690,20 @@ const expectEventArraysEqual = (
   })
 }
 
-const expectAdvance: (
-  result: typeof SyncState.MergeResult.Type,
-) => asserts result is typeof SyncState.MergeResultAdvance.Type = (result) => {
+const expectAdvance: (result: typeof SyncState.MergeResult.Type) => asserts result is SyncState.MergeResultAdvance = (
+  result,
+) => {
   expect(result._tag).toBe('advance')
 }
 
-const expectRebase: (
-  result: typeof SyncState.MergeResult.Type,
-) => asserts result is typeof SyncState.MergeResultRebase.Type = (result) => {
+const expectRebase: (result: typeof SyncState.MergeResult.Type) => asserts result is SyncState.MergeResultRebase = (
+  result,
+) => {
   expect(result._tag, `Expected rebase, got ${result._tag}`).toBe('rebase')
 }
 
-const expectReject: (
-  result: typeof SyncState.MergeResult.Type,
-) => asserts result is typeof SyncState.MergeResultReject.Type = (result) => {
+const expectReject: (result: typeof SyncState.MergeResult.Type) => asserts result is SyncState.MergeResultReject = (
+  result,
+) => {
   expect(result._tag).toBe('reject')
 }