chore: update TSTyche to v5.0.0

package.json

@@ -69,7 +69,7 @@
     "playwright": "^1.52.0",
     "prettier": "^3.5.3",
     "rimraf": "^6.0.1",
-    "tstyche": "^4.1.0",
+    "tstyche": "^5.0.0-beta.1",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "vite": "^6.1.1",

packages/effect/dtslint/Either.tst.ts

@@ -220,10 +220,11 @@ describe("Either", () => {
       )
     ).type.toBe<Either.Either<readonly [string, ...Array<string>], "b" | Error>>()
 
-    // TODO: this doesn't work but it should
-    expect.fail(
+    // @tstyche fixme -- This doesn't work but it should
+    expect(
       Either.filterOrLeft(literal$Error, Predicate.isString, (a) => {
-        expect.fail(a).type.toBe<"a">()
+        // @tstyche fixme -- This doesn't work but it should
+        expect(a).type.toBe<"a">()
         return "b" as const
       })
     ).type.toBe<Either.Either<"a", "b" | Error>>()
@@ -237,8 +238,8 @@ describe("Either", () => {
       )
     ).type.toBe<Either.Either<"a", "b" | Error>>()
 
-    // TODO: this doesn't work but it should
-    expect.fail(
+    // @tstyche fixme -- This doesn't work but it should
+    expect(
       Either.filterOrLeft(literal$Error, Predicate.isString, (_s: string) => "b" as const)
     ).type.toBe<Either.Either<"a", "b" | Error>>()
     expect(

packages/effect/dtslint/Exit.tst.ts

@@ -11,10 +11,10 @@ describe("Exit", () => {
     if (Exit.exists(stringOrNumber$string, Predicate.isString)) {
       expect(stringOrNumber$string).type.toBe<Exit.Exit<string, never>>()
     }
-    // TODO
-    // if (pipe(stringOrNumber$string, Exit.exists(Predicate.isString))) {
-    //   expect(stringOrNumber$string).type.toBe<Exit.Exit<string, never>>()
-    // }
+    if (pipe(stringOrNumber$string, Exit.exists(Predicate.isString))) {
+      // @tstyche fixme -- This doesn't work but it should
+      expect(stringOrNumber$string).type.toBe<Exit.Exit<string, never>>()
+    }
     if (Exit.exists(Predicate.isString)(stringOrNumber$string)) {
       expect(stringOrNumber$string).type.toBe<Exit.Exit<string, never>>()
     }

packages/effect/dtslint/HashSet.tst.ts

@@ -11,10 +11,10 @@ describe("HashSet", () => {
     if (HashSet.every(numberOrString, Predicate.isString)) {
       expect(numberOrString).type.toBe<HashSet.HashSet<string>>()
     }
-    // TODO
-    // if (pipe(numberOrString, HashSet.every(Predicate.isString))) {
-    //   expect(numberOrString).type.toBe<HashSet.HashSet<string>>()
-    // }
+    if (pipe(numberOrString, HashSet.every(Predicate.isString))) {
+      // @tstyche fixme -- This doesn't work but it should
+      expect(numberOrString).type.toBe<HashSet.HashSet<string>>()
+    }
     if (HashSet.every(Predicate.isString)(numberOrString)) {
       expect(numberOrString).type.toBe<HashSet.HashSet<string>>()
     }

packages/effect/dtslint/List.tst.ts

@@ -14,10 +14,10 @@ describe("List", () => {
     if (List.every(numberOrString, Predicate.isString)) {
       expect(numberOrString).type.toBe<List.List<string>>()
     }
-    // TODO
-    // if (pipe(numberOrString, List.every(Predicate.isString))) {
-    //   expect(numberOrString).type.toBe<List.List<string>>()
-    // }
+    if (pipe(numberOrString, List.every(Predicate.isString))) {
+      // @tstyche fixme -- This doesn't work but it should
+      expect(numberOrString).type.toBe<List.List<string>>()
+    }
     if (List.every(Predicate.isString)(numberOrString)) {
       expect(numberOrString).type.toBe<List.List<string>>()
     }
@@ -41,10 +41,10 @@ describe("List", () => {
     if (List.some(numberOrString, Predicate.isString)) {
       expect(numberOrString).type.toBe<List.Cons<string | number>>()
     }
-    // TODO
-    // if (pipe(numberOrString, List.some(Predicate.isString))) {
-    //   expect(numberOrString).type.toBe<List.Cons<string | number>>()
-    // }
+    if (pipe(numberOrString, List.some(Predicate.isString))) {
+      // @tstyche fixme -- This doesn't work but it should
+      expect(numberOrString).type.toBe<List.Cons<string | number>>()
+    }
     if (List.some(Predicate.isString)(numberOrString)) {
       expect(numberOrString).type.toBe<List.Cons<string | number>>()
     }

packages/effect/dtslint/Match.tst.ts

@@ -237,23 +237,23 @@ describe("Match", () => {
       const match = pipe(
         Match.type<Uint8Array | Uint16Array>(),
         Match.when(Match.instanceOf(Uint8Array), (v) => {
-          // @tstyche if { target: [">=5.7"] } -- Before TypeScript 5.7, 'Uint8Array' was not generic
+          // @tstyche if { target: ">=5.7" } -- Before TypeScript 5.7, 'Uint8Array' was not generic
           expect(v).type.toBe<Uint8Array<ArrayBuffer>>()
-          // @tstyche if { target: ["<5.7"] }
+          // @tstyche if { target: "<5.7" }
           expect(v).type.toBe<Uint8Array>()
           return "uint8"
         }),
         Match.when(Match.instanceOf(Uint16Array), (v) => {
-          // @tstyche if { target: [">=5.7"] } -- Before TypeScript 5.7, 'Uint16Array' was not generic
+          // @tstyche if { target: ">=5.7" } -- Before TypeScript 5.7, 'Uint16Array' was not generic
           expect(v).type.toBe<Uint16Array<ArrayBuffer>>()
-          // @tstyche if { target: ["<5.7"] }
+          // @tstyche if { target: "<5.7" }
           expect(v).type.toBe<Uint16Array>()
           return "uint16"
         }),
         Match.orElse((v) => {
-          // @tstyche if { target: [">=5.7"] } -- Before TypeScript 5.7, 'Uint8Array' and 'Uint16Array' were not generic
+          // @tstyche if { target: ">=5.7" } -- Before TypeScript 5.7, 'Uint8Array' and 'Uint16Array' were not generic
           expect(v).type.toBe<Uint8Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike>>()
-          // @tstyche if { target: ["<5.7"] }
+          // @tstyche if { target: "<5.7" }
           expect(v).type.toBe<Uint8Array | Uint16Array>()
           return "a"
         })

packages/effect/dtslint/Number.tst.ts

@@ -19,7 +19,7 @@ describe("Number", () => {
     const numOrString: number | string = 123
     if (Number.isNumber(numOrString)) {
       expect(numOrString).type.toBe<number>()
-      expect(numOrString).type.not.toBeAssignableWith<string>()
+      expect(numOrString).type.not.toBeAssignableFrom<string>()
     }
   })
 
@@ -29,8 +29,8 @@ describe("Number", () => {
     type DataFirst = typeof Number.sum
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.sum(a, b)).type.toBe<number>()
@@ -43,8 +43,8 @@ describe("Number", () => {
     type DataFirst = typeof Number.subtract
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.subtract(a, b)).type.toBe<number>()
@@ -57,9 +57,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.multiply
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.multiply(a, b)).type.toBe<number>()
@@ -72,9 +72,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.divide
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.divide(a, b)).type.toBe<Option.Option<number>>()
@@ -87,9 +87,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.unsafeDivide
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.unsafeDivide(a, b)).type.toBe<number>()
@@ -100,7 +100,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.increment
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.increment(a)).type.toBe<number>()
@@ -111,7 +111,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.decrement
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.decrement(a)).type.toBe<number>()
@@ -122,7 +122,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.Equivalence
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
     // test the output type
     expect(Number.Equivalence(a, b)).type.toBe<boolean>()
@@ -132,7 +132,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.Order
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
     // test the output type
     expect(Number.Order(a, b)).type.toBe<-1 | 0 | 1>()
@@ -144,8 +144,8 @@ describe("Number", () => {
     type DataFirst = typeof Number.lessThan
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.lessThan(a, b)).type.toBe<boolean>()
@@ -158,9 +158,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.lessThanOrEqualTo
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.lessThanOrEqualTo(a, b)).type.toBe<boolean>()
@@ -173,9 +173,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.greaterThan
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.greaterThan(a, b)).type.toBe<boolean>()
@@ -188,9 +188,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.greaterThanOrEqualTo
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.greaterThanOrEqualTo(a, b)).type.toBe<boolean>()
@@ -205,11 +205,11 @@ describe("Number", () => {
     type DataFirst = typeof Number.between
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<
       [number, { minimum: number; maximum: number }]
     >()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.between(a, options)).type.toBe<boolean>()
@@ -224,11 +224,11 @@ describe("Number", () => {
     type DataFirst = typeof Number.clamp
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<
       [number, { minimum: number; maximum: number }]
     >()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.clamp(a, options)).type.toBe<number>()
@@ -241,9 +241,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.min
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.min(a, b)).type.toBe<number>()
@@ -256,9 +256,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.max
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.max(a, b)).type.toBe<number>()
@@ -269,7 +269,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.sign
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.sign(a)).type.toBe<-1 | 0 | 1>()
@@ -279,7 +279,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.sumAll
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<
       [Iterable<number>]
     >()
 
@@ -292,7 +292,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.multiplyAll
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<
       [Iterable<number>]
     >()
 
@@ -309,9 +309,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.remainder
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.remainder(a, b)).type.toBe<number>()
@@ -322,7 +322,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.nextPow2
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.nextPow2(a)).type.toBe<number>()
@@ -332,7 +332,7 @@ describe("Number", () => {
     type DataFirst = typeof Number.parse
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[string]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[string]>()
 
     // test the output type
     expect(Number.parse("123")).type.toBe<Option.Option<number>>()
@@ -344,9 +344,9 @@ describe("Number", () => {
     type DataFirst = typeof Number.round
 
     // test the input type
-    expect<Parameters<DataFirst>>().type.toBeAssignableWith<[number, number]>()
+    expect<Parameters<DataFirst>>().type.toBeAssignableFrom<[number, number]>()
 
-    expect<Parameters<DataLast>>().type.toBeAssignableWith<[number]>()
+    expect<Parameters<DataLast>>().type.toBeAssignableFrom<[number]>()
 
     // test the output type
     expect(Number.round(a, 2)).type.toBe<number>()