diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2dc8f83..4bea6e1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,62 +15,51 @@ on:
     tags: [v*]
 
 env:
-  PGP_PASSPHRASE: ${{ secrets.PGP_PASSPHRASE }}
-  SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
-  SONATYPE_CREDENTIAL_HOST: ${{ secrets.SONATYPE_CREDENTIAL_HOST }}
-  SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
-  PGP_SECRET: ${{ secrets.PGP_SECRET }}
   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+
+concurrency:
+  group: ${{ github.workflow }} @ ${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
-    name: Build and Test
+    name: Test
     strategy:
       matrix:
-        os: [ubuntu-latest]
-        scala: [3.2.2, 2.12.17, 2.13.10]
+        os: [ubuntu-22.04]
+        scala: [3, 2.12, 2.13]
         java: [temurin@8]
         project: [rootJS, rootJVM, rootNative]
     runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
     steps:
       - name: Checkout current branch (full)
-        uses: actions/checkout@v3
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 
-      - name: Download Java (temurin@8)
-        id: download-java-temurin-8
-        if: matrix.java == 'temurin@8'
-        uses: typelevel/download-java@v2
-        with:
-          distribution: temurin
-          java-version: 8
+      - name: Setup sbt
+        uses: sbt/setup-sbt@v1
 
       - name: Setup Java (temurin@8)
+        id: setup-java-temurin-8
         if: matrix.java == 'temurin@8'
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v5
         with:
-          distribution: jdkfile
+          distribution: temurin
           java-version: 8
-          jdkFile: ${{ steps.download-java-temurin-8.outputs.jdkFile }}
+          cache: sbt
 
-      - name: Cache sbt
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.sbt
-            ~/.ivy2/cache
-            ~/.coursier/cache/v1
-            ~/.cache/coursier/v1
-            ~/AppData/Local/Coursier/Cache/v1
-            ~/Library/Caches/Coursier/v1
-          key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }}
+      - name: sbt update
+        if: matrix.java == 'temurin@8' && steps.setup-java-temurin-8.outputs.cache-hit == 'false'
+        run: sbt +update
 
       - name: Check that workflows are up to date
         run: sbt githubWorkflowCheck
 
       - name: Check headers and formatting
-        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-latest'
+        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-22.04'
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' headerCheckAll scalafmtCheckAll 'project /' scalafmtSbtCheck
 
       - name: scalaJSLink
@@ -85,24 +74,24 @@ jobs:
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' test
 
       - name: Check binary compatibility
-        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-latest'
+        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-22.04'
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' mimaReportBinaryIssues
 
       - name: Generate API documentation
-        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-latest'
+        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-22.04'
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' doc
 
       - name: Make target directories
         if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main')
-        run: mkdir -p target .js/target core/native/target core/js/target core/jvm/target .jvm/target .native/target project/target
+        run: mkdir -p core/native/target core/js/target core/jvm/target project/target
 
       - name: Compress target directories
         if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main')
-        run: tar cf targets.tar target .js/target core/native/target core/js/target core/jvm/target .jvm/target .native/target project/target
+        run: tar cf targets.tar core/native/target core/js/target core/jvm/target project/target
 
       - name: Upload target directories
         if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main')
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v5
         with:
           name: target-${{ matrix.os }}-${{ matrix.java }}-${{ matrix.scala }}-${{ matrix.project }}
           path: targets.tar
@@ -113,144 +102,177 @@ jobs:
     if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main')
     strategy:
       matrix:
-        os: [ubuntu-latest]
-        scala: [3.2.2]
+        os: [ubuntu-22.04]
         java: [temurin@8]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout current branch (full)
-        uses: actions/checkout@v3
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 
-      - name: Download Java (temurin@8)
-        id: download-java-temurin-8
-        if: matrix.java == 'temurin@8'
-        uses: typelevel/download-java@v2
-        with:
-          distribution: temurin
-          java-version: 8
+      - name: Setup sbt
+        uses: sbt/setup-sbt@v1
 
       - name: Setup Java (temurin@8)
+        id: setup-java-temurin-8
         if: matrix.java == 'temurin@8'
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v5
         with:
-          distribution: jdkfile
+          distribution: temurin
           java-version: 8
-          jdkFile: ${{ steps.download-java-temurin-8.outputs.jdkFile }}
+          cache: sbt
 
-      - name: Cache sbt
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.sbt
-            ~/.ivy2/cache
-            ~/.coursier/cache/v1
-            ~/.cache/coursier/v1
-            ~/AppData/Local/Coursier/Cache/v1
-            ~/Library/Caches/Coursier/v1
-          key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }}
-
-      - name: Download target directories (3.2.2, rootJS)
-        uses: actions/download-artifact@v3
+      - name: sbt update
+        if: matrix.java == 'temurin@8' && steps.setup-java-temurin-8.outputs.cache-hit == 'false'
+        run: sbt +update
+
+      - name: Download target directories (3, rootJS)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-3.2.2-rootJS
+          name: target-${{ matrix.os }}-${{ matrix.java }}-3-rootJS
 
-      - name: Inflate target directories (3.2.2, rootJS)
+      - name: Inflate target directories (3, rootJS)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (3.2.2, rootJVM)
-        uses: actions/download-artifact@v3
+      - name: Download target directories (3, rootJVM)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-3.2.2-rootJVM
+          name: target-${{ matrix.os }}-${{ matrix.java }}-3-rootJVM
 
-      - name: Inflate target directories (3.2.2, rootJVM)
+      - name: Inflate target directories (3, rootJVM)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (3.2.2, rootNative)
-        uses: actions/download-artifact@v3
+      - name: Download target directories (3, rootNative)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-3.2.2-rootNative
+          name: target-${{ matrix.os }}-${{ matrix.java }}-3-rootNative
 
-      - name: Inflate target directories (3.2.2, rootNative)
+      - name: Inflate target directories (3, rootNative)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.12.17, rootJS)
-        uses: actions/download-artifact@v3
+      - name: Download target directories (2.12, rootJS)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-2.12.17-rootJS
+          name: target-${{ matrix.os }}-${{ matrix.java }}-2.12-rootJS
 
-      - name: Inflate target directories (2.12.17, rootJS)
+      - name: Inflate target directories (2.12, rootJS)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.12.17, rootJVM)
-        uses: actions/download-artifact@v3
+      - name: Download target directories (2.12, rootJVM)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-2.12.17-rootJVM
+          name: target-${{ matrix.os }}-${{ matrix.java }}-2.12-rootJVM
 
-      - name: Inflate target directories (2.12.17, rootJVM)
+      - name: Inflate target directories (2.12, rootJVM)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.12.17, rootNative)
-        uses: actions/download-artifact@v3
+      - name: Download target directories (2.12, rootNative)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-2.12.17-rootNative
+          name: target-${{ matrix.os }}-${{ matrix.java }}-2.12-rootNative
 
-      - name: Inflate target directories (2.12.17, rootNative)
+      - name: Inflate target directories (2.12, rootNative)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.13.10, rootJS)
-        uses: actions/download-artifact@v3
+      - name: Download target directories (2.13, rootJS)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-2.13.10-rootJS
+          name: target-${{ matrix.os }}-${{ matrix.java }}-2.13-rootJS
 
-      - name: Inflate target directories (2.13.10, rootJS)
+      - name: Inflate target directories (2.13, rootJS)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.13.10, rootJVM)
-        uses: actions/download-artifact@v3
+      - name: Download target directories (2.13, rootJVM)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-2.13.10-rootJVM
+          name: target-${{ matrix.os }}-${{ matrix.java }}-2.13-rootJVM
 
-      - name: Inflate target directories (2.13.10, rootJVM)
+      - name: Inflate target directories (2.13, rootJVM)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.13.10, rootNative)
-        uses: actions/download-artifact@v3
+      - name: Download target directories (2.13, rootNative)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-${{ matrix.java }}-2.13.10-rootNative
+          name: target-${{ matrix.os }}-${{ matrix.java }}-2.13-rootNative
 
-      - name: Inflate target directories (2.13.10, rootNative)
+      - name: Inflate target directories (2.13, rootNative)
         run: |
           tar xf targets.tar
           rm targets.tar
 
       - name: Import signing key
         if: env.PGP_SECRET != '' && env.PGP_PASSPHRASE == ''
-        run: echo $PGP_SECRET | base64 -di | gpg --import
+        env:
+          PGP_SECRET: ${{ secrets.PGP_SECRET }}
+          PGP_PASSPHRASE: ${{ secrets.PGP_PASSPHRASE }}
+        run: echo $PGP_SECRET | base64 -d -i - | gpg --import
 
       - name: Import signing key and strip passphrase
         if: env.PGP_SECRET != '' && env.PGP_PASSPHRASE != ''
+        env:
+          PGP_SECRET: ${{ secrets.PGP_SECRET }}
+          PGP_PASSPHRASE: ${{ secrets.PGP_PASSPHRASE }}
         run: |
-          echo "$PGP_SECRET" | base64 -di > /tmp/signing-key.gpg
+          echo "$PGP_SECRET" | base64 -d -i - > /tmp/signing-key.gpg
           echo "$PGP_PASSPHRASE" | gpg --pinentry-mode loopback --passphrase-fd 0 --import /tmp/signing-key.gpg
           (echo "$PGP_PASSPHRASE"; echo; echo) | gpg --command-fd 0 --pinentry-mode loopback --change-passphrase $(gpg --list-secret-keys --with-colons 2> /dev/null | grep '^sec:' | cut --delimiter ':' --fields 5 | tail -n 1)
 
       - name: Publish
-        run: sbt '++ ${{ matrix.scala }}' tlCiRelease
+        env:
+          SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+          SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+          SONATYPE_CREDENTIAL_HOST: ${{ secrets.SONATYPE_CREDENTIAL_HOST }}
+        run: sbt tlCiRelease
+
+  dependency-submission:
+    name: Submit Dependencies
+    if: github.event.repository.fork == false && github.event_name != 'pull_request'
+    strategy:
+      matrix:
+        os: [ubuntu-22.04]
+        java: [temurin@8]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout current branch (full)
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Setup sbt
+        uses: sbt/setup-sbt@v1
+
+      - name: Setup Java (temurin@8)
+        id: setup-java-temurin-8
+        if: matrix.java == 'temurin@8'
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 8
+          cache: sbt
+
+      - name: sbt update
+        if: matrix.java == 'temurin@8' && steps.setup-java-temurin-8.outputs.cache-hit == 'false'
+        run: sbt +update
+
+      - name: Submit Dependencies
+        uses: scalacenter/sbt-dependency-submission@v2
+        with:
+          modules-ignore: rootjs_3 rootjs_2.12 rootjs_2.13 rootjvm_3 rootjvm_2.12 rootjvm_2.13 rootnative_3 rootnative_2.12 rootnative_2.13
+          configs-ignore: test scala-tool scala-doc-tool test-internal
diff --git a/build.sbt b/build.sbt
index 25a47b1..c57f2ca 100644
--- a/build.sbt
+++ b/build.sbt
@@ -8,7 +8,7 @@ ThisBuild / organization := "org.typelevel"
 ThisBuild / organizationName := "Typelevel"
 ThisBuild / startYear := Some(2023)
 
-ThisBuild / crossScalaVersions := Seq("3.2.2", "2.12.17", "2.13.10")
+ThisBuild / crossScalaVersions := Seq("3.3.7", "2.12.20", "2.13.18")
 ThisBuild / scalaVersion := (ThisBuild / crossScalaVersions).value.head
 
 ThisBuild / doctestTestFramework := DoctestTestFramework.ScalaCheck
@@ -36,7 +36,7 @@ lazy val core = crossProject(JVMPlatform, JSPlatform, NativePlatform)
   .settings(
     name := "twiddles-core",
     libraryDependencies ++= Seq(
-      "org.typelevel" %%% "cats-core" % "2.9.0",
+      "org.typelevel" %%% "cats-core" % "2.10.0",
       "org.typelevel" %%% "munit-cats-effect" % "2.0.0-M3" % Test,
       "org.typelevel" %%% "scalacheck-effect-munit" % "2.0.0-M2" % Test
     ) ++ (if (scalaVersion.value.startsWith("2.")) Seq("com.chuusai" %%% "shapeless" % "2.3.10")
diff --git a/core/shared/src/main/scala-2/org/typelevel/twiddles/TwiddleCompat.scala b/core/shared/src/main/scala-2/org/typelevel/twiddles/TwiddleCompat.scala
index 83bc23b..db20544 100644
--- a/core/shared/src/main/scala-2/org/typelevel/twiddles/TwiddleCompat.scala
+++ b/core/shared/src/main/scala-2/org/typelevel/twiddles/TwiddleCompat.scala
@@ -45,145 +45,101 @@ trait TwiddleCompat {
   type *:[+A, +B <: Tuple] = ::[A, B]
   @inline val *: = ::
 
-  implicit def toTupleOps[T <: Tuple](t: T): TupleOps[T] =
+  implicit def orgTypelevelTwiddleCompatToTupleOps[T <: Tuple](t: T): TupleOps[T] =
     new TupleOps[T](t)
 
   import shapeless.syntax.std.tuple._
 
-  implicit def tuple2ToHList[A, B](t: (A, B)): A *: B *: EmptyTuple = t.productElements
-  implicit def tuple3ToHList[A, B, C](t: (A, B, C)): A *: B *: C *: EmptyTuple = t.productElements
-  implicit def tuple4ToHList[A, B, C, D](t: (A, B, C, D)): A *: B *: C *: D *: EmptyTuple =
-    t.productElements
-  implicit def tuple5ToHList[A, B, C, D, E](t: (A, B, C, D, E)): A *: B *: C *: D *: E *:
-    EmptyTuple = t.productElements
-  implicit def tuple6ToHList[A, B, C, D, E, F](t: (A, B, C, D, E, F)): A *: B *: C *: D *: E *: F *:
-    EmptyTuple = t.productElements
-  implicit def tuple7ToHList[A, B, C, D, E, F, G](
-      t: (A, B, C, D, E, F, G)
-  ): A *: B *: C *: D *: E *: F *: G *: EmptyTuple = t.productElements
-  implicit def tuple8ToHList[A, B, C, D, E, F, G, H](
-      t: (A, B, C, D, E, F, G, H)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: EmptyTuple = t.productElements
-  implicit def tuple9ToHList[A, B, C, D, E, F, G, H, I](
-      t: (A, B, C, D, E, F, G, H, I)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: EmptyTuple = t.productElements
-  implicit def tuple10ToHList[A, B, C, D, E, F, G, H, I, J](
-      t: (A, B, C, D, E, F, G, H, I, J)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: EmptyTuple = t.productElements
-  implicit def tuple11ToHList[A, B, C, D, E, F, G, H, I, J, K](
-      t: (A, B, C, D, E, F, G, H, I, J, K)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: EmptyTuple = t.productElements
-  implicit def tuple12ToHList[A, B, C, D, E, F, G, H, I, J, K, L](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: EmptyTuple = t.productElements
-  implicit def tuple13ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: EmptyTuple = t.productElements
-  implicit def tuple14ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: EmptyTuple =
-    t.productElements
-  implicit def tuple15ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: EmptyTuple =
-    t.productElements
-  implicit def tuple16ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: EmptyTuple =
-    t.productElements
-  implicit def tuple17ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *:
-    EmptyTuple = t.productElements
-  implicit def tuple18ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *:
-    EmptyTuple = t.productElements
-  implicit def tuple19ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *:
-    EmptyTuple = t.productElements
-  implicit def tuple20ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *:
-    T *: EmptyTuple = t.productElements
-  implicit def tuple21ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *:
-    T *: U *: EmptyTuple = t.productElements
-  implicit def tuple22ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](
-      t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
-  ): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *:
-    T *: U *: V *: EmptyTuple = t.productElements
-
   // format: off
-  implicit def hlistToTuple0[Z <: Tuple](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatTuple2ToHList[A, B](t: (A, B)): A *: B *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple3ToHList[A, B, C](t: (A, B, C)): A *: B *: C *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple4ToHList[A, B, C, D](t: (A, B, C, D)): A *: B *: C *: D *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple5ToHList[A, B, C, D, E](t: (A, B, C, D, E)): A *: B *: C *: D *: E *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple6ToHList[A, B, C, D, E, F](t: (A, B, C, D, E, F)): A *: B *: C *: D *: E *: F *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple7ToHList[A, B, C, D, E, F, G](t: (A, B, C, D, E, F, G)): A *: B *: C *: D *: E *: F *: G *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple8ToHList[A, B, C, D, E, F, G, H](t: (A, B, C, D, E, F, G, H)): A *: B *: C *: D *: E *: F *: G *: H *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple9ToHList[A, B, C, D, E, F, G, H, I](t: (A, B, C, D, E, F, G, H, I)): A *: B *: C *: D *: E *: F *: G *: H *: I *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple10ToHList[A, B, C, D, E, F, G, H, I, J](t: (A, B, C, D, E, F, G, H, I, J)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple11ToHList[A, B, C, D, E, F, G, H, I, J, K](t: (A, B, C, D, E, F, G, H, I, J, K)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple12ToHList[A, B, C, D, E, F, G, H, I, J, K, L](t: (A, B, C, D, E, F, G, H, I, J, K, L)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple13ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M](t: (A, B, C, D, E, F, G, H, I, J, K, L, M)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple14ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple15ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple16ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple17ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple18ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple19ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple20ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple21ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: U *: EmptyTuple = t.productElements
+  implicit def orgTypelevelTwiddleCompatTuple22ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: U *: V *: EmptyTuple = t.productElements
+
+  implicit def orgTypelevelTwiddleCompatHlistToTuple0[Z <: Tuple](z: Z)(implicit
       tupler: shapeless.ops.hlist.Tupler.Aux[Z, Unit]
   ): Unit = tupler(z)
-  implicit def hlistToTuple1[Z <: Tuple, A](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple1[Z <: Tuple, A](z: Z)(implicit
       tupler: shapeless.ops.hlist.Tupler.Aux[Z, Tuple1[A]]
   ): Tuple1[A] = tupler(z)
-  implicit def hlistToTuple2[Z <: Tuple, A, B](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple2[Z <: Tuple, A, B](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B)]
   ): (A, B) = tupler(z)
-  implicit def hlistToTuple3[Z <: Tuple, A, B, C](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple3[Z <: Tuple, A, B, C](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C)]
   ): (A, B, C) = tupler(z)
-  implicit def hlistToTuple4[Z <: Tuple, A, B, C, D](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple4[Z <: Tuple, A, B, C, D](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D)]
   ): (A, B, C, D) = tupler(z)
-  implicit def hlistToTuple5[Z <: Tuple, A, B, C, D, E](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple5[Z <: Tuple, A, B, C, D, E](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E)]
   ): (A, B, C, D, E) = tupler(z)
-  implicit def hlistToTuple6[Z <: Tuple, A, B, C, D, E, F](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple6[Z <: Tuple, A, B, C, D, E, F](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F)]
   ): (A, B, C, D, E, F) = tupler(z)
-  implicit def hlistToTuple7[Z <: Tuple, A, B, C, D, E, F, G](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple7[Z <: Tuple, A, B, C, D, E, F, G](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G)]
   ): (A, B, C, D, E, F, G) = tupler(z)
-  implicit def hlistToTuple8[Z <: Tuple, A, B, C, D, E, F, G, H](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple8[Z <: Tuple, A, B, C, D, E, F, G, H](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H)]
   ): (A, B, C, D, E, F, G, H) = tupler(z)
-  implicit def hlistToTuple9[Z <: Tuple, A, B, C, D, E, F, G, H, I](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple9[Z <: Tuple, A, B, C, D, E, F, G, H, I](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I)]
   ): (A, B, C, D, E, F, G, H, I) = tupler(z)
-  implicit def hlistToTuple10[Z <: Tuple, A, B, C, D, E, F, G, H, I, J](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple10[Z <: Tuple, A, B, C, D, E, F, G, H, I, J](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J)]
   ): (A, B, C, D, E, F, G, H, I, J) = tupler(z)
-  implicit def hlistToTuple11[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple11[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K)]
   ): (A, B, C, D, E, F, G, H, I, J, K) = tupler(z)
-  implicit def hlistToTuple12[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple12[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L) = tupler(z)
-  implicit def hlistToTuple13[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple13[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M) = tupler(z)
-  implicit def hlistToTuple14[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple14[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N) = tupler(z)
-  implicit def hlistToTuple15[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple15[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) = tupler(z)
-  implicit def hlistToTuple16[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple16[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) = tupler(z)
-  implicit def hlistToTuple17[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple17[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) = tupler(z)
-  implicit def hlistToTuple18[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple18[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) = tupler(z)
-  implicit def hlistToTuple19[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple19[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) = tupler(z)
-  implicit def hlistToTuple20[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple20[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) = tupler(z)
-  implicit def hlistToTuple21[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple21[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) = tupler(z)
-  implicit def hlistToTuple22[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](z: Z)(implicit
+  implicit def orgTypelevelTwiddleCompatHlistToTuple22[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](z: Z)(implicit
       tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]
   ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) = tupler(z)
   // format: on
@@ -192,4 +148,57 @@ trait TwiddleCompat {
   def hlistToTuple[L <: Tuple, T](l: L)(implicit
       tupler: shapeless.ops.hlist.Tupler.Aux[L, T]
   ): T = l.tupled
+
+  @deprecated("use orgTypelevelTwiddleCompatToTupleOps", "0.6.3") def toTupleOps[T <: Tuple](
+      t: T
+  ): TupleOps[T] = orgTypelevelTwiddleCompatToTupleOps(t)
+
+  // format: off
+  @deprecated("use orgTypelevelTwiddleCompatTuple2ToHList", "0.6.3") def tuple2ToHList[A, B](t: (A, B)): A *: B *: EmptyTuple = orgTypelevelTwiddleCompatTuple2ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple3ToHList", "0.6.3") def tuple3ToHList[A, B, C](t: (A, B, C)): A *: B *: C *: EmptyTuple = orgTypelevelTwiddleCompatTuple3ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple4ToHList", "0.6.3") def tuple4ToHList[A, B, C, D](t: (A, B, C, D)): A *: B *: C *: D *: EmptyTuple = orgTypelevelTwiddleCompatTuple4ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple5ToHList", "0.6.3") def tuple5ToHList[A, B, C, D, E](t: (A, B, C, D, E)): A *: B *: C *: D *: E *: EmptyTuple = orgTypelevelTwiddleCompatTuple5ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple6ToHList", "0.6.3") def tuple6ToHList[A, B, C, D, E, F](t: (A, B, C, D, E, F)): A *: B *: C *: D *: E *: F *: EmptyTuple = orgTypelevelTwiddleCompatTuple6ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple7ToHList", "0.6.3") def tuple7ToHList[A, B, C, D, E, F, G](t: (A, B, C, D, E, F, G)): A *: B *: C *: D *: E *: F *: G *: EmptyTuple = orgTypelevelTwiddleCompatTuple7ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple8ToHList", "0.6.3") def tuple8ToHList[A, B, C, D, E, F, G, H](t: (A, B, C, D, E, F, G, H)): A *: B *: C *: D *: E *: F *: G *: H *: EmptyTuple = orgTypelevelTwiddleCompatTuple8ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple9ToHList", "0.6.3") def tuple9ToHList[A, B, C, D, E, F, G, H, I](t: (A, B, C, D, E, F, G, H, I)): A *: B *: C *: D *: E *: F *: G *: H *: I *: EmptyTuple = orgTypelevelTwiddleCompatTuple9ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple10ToHList", "0.6.3") def tuple10ToHList[A, B, C, D, E, F, G, H, I, J](t: (A, B, C, D, E, F, G, H, I, J)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: EmptyTuple = orgTypelevelTwiddleCompatTuple10ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple11ToHList", "0.6.3") def tuple11ToHList[A, B, C, D, E, F, G, H, I, J, K](t: (A, B, C, D, E, F, G, H, I, J, K)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: EmptyTuple = orgTypelevelTwiddleCompatTuple11ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple12ToHList", "0.6.3") def tuple12ToHList[A, B, C, D, E, F, G, H, I, J, K, L](t: (A, B, C, D, E, F, G, H, I, J, K, L)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: EmptyTuple = orgTypelevelTwiddleCompatTuple12ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple13ToHList", "0.6.3") def tuple13ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M](t: (A, B, C, D, E, F, G, H, I, J, K, L, M)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: EmptyTuple = orgTypelevelTwiddleCompatTuple13ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple14ToHList", "0.6.3") def tuple14ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: EmptyTuple = orgTypelevelTwiddleCompatTuple14ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple15ToHList", "0.6.3") def tuple15ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: EmptyTuple = orgTypelevelTwiddleCompatTuple15ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple16ToHList", "0.6.3") def tuple16ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: EmptyTuple = orgTypelevelTwiddleCompatTuple16ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple17ToHList", "0.6.3") def tuple17ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: EmptyTuple = orgTypelevelTwiddleCompatTuple17ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple18ToHList", "0.6.3") def tuple18ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: EmptyTuple = orgTypelevelTwiddleCompatTuple18ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple19ToHList", "0.6.3") def tuple19ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: EmptyTuple = orgTypelevelTwiddleCompatTuple19ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple20ToHList", "0.6.3") def tuple20ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: EmptyTuple = orgTypelevelTwiddleCompatTuple20ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple21ToHList", "0.6.3") def tuple21ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: U *: EmptyTuple = orgTypelevelTwiddleCompatTuple21ToHList(t)
+  @deprecated("use orgTypelevelTwiddleCompatTuple22ToHList", "0.6.3") def tuple22ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: U *: V *: EmptyTuple = orgTypelevelTwiddleCompatTuple22ToHList(t)
+
+  // format: off
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple0", "0.6.3") def hlistToTuple0[Z <: Tuple](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, Unit]): Unit = orgTypelevelTwiddleCompatHlistToTuple0(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple1", "0.6.3") def hlistToTuple1[Z <: Tuple, A](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, Tuple1[A]]): Tuple1[A] = orgTypelevelTwiddleCompatHlistToTuple1(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple2", "0.6.3") def hlistToTuple2[Z <: Tuple, A, B](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B)]): (A, B) = orgTypelevelTwiddleCompatHlistToTuple2(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple3", "0.6.3") def hlistToTuple3[Z <: Tuple, A, B, C](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C)]): (A, B, C) = orgTypelevelTwiddleCompatHlistToTuple3(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple4", "0.6.3") def hlistToTuple4[Z <: Tuple, A, B, C, D](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D)]): (A, B, C, D) = orgTypelevelTwiddleCompatHlistToTuple4(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple5", "0.6.3") def hlistToTuple5[Z <: Tuple, A, B, C, D, E](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E)]): (A, B, C, D, E) = orgTypelevelTwiddleCompatHlistToTuple5(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple6", "0.6.3") def hlistToTuple6[Z <: Tuple, A, B, C, D, E, F](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F)]): (A, B, C, D, E, F) = orgTypelevelTwiddleCompatHlistToTuple6(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple7", "0.6.3") def hlistToTuple7[Z <: Tuple, A, B, C, D, E, F, G](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G)]): (A, B, C, D, E, F, G) = orgTypelevelTwiddleCompatHlistToTuple7(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple8", "0.6.3") def hlistToTuple8[Z <: Tuple, A, B, C, D, E, F, G, H](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H)]): (A, B, C, D, E, F, G, H) = orgTypelevelTwiddleCompatHlistToTuple8(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple9", "0.6.3") def hlistToTuple9[Z <: Tuple, A, B, C, D, E, F, G, H, I](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I)]): (A, B, C, D, E, F, G, H, I) = orgTypelevelTwiddleCompatHlistToTuple9(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple10", "0.6.3") def hlistToTuple10[Z <: Tuple, A, B, C, D, E, F, G, H, I, J](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J)]): (A, B, C, D, E, F, G, H, I, J) = orgTypelevelTwiddleCompatHlistToTuple10(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple11", "0.6.3") def hlistToTuple11[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K)]): (A, B, C, D, E, F, G, H, I, J, K) = orgTypelevelTwiddleCompatHlistToTuple11(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple12", "0.6.3") def hlistToTuple12[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L)]): (A, B, C, D, E, F, G, H, I, J, K, L) = orgTypelevelTwiddleCompatHlistToTuple12(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple13", "0.6.3") def hlistToTuple13[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M)]): (A, B, C, D, E, F, G, H, I, J, K, L, M) = orgTypelevelTwiddleCompatHlistToTuple13(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple14", "0.6.3") def hlistToTuple14[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N) = orgTypelevelTwiddleCompatHlistToTuple14(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple15", "0.6.3") def hlistToTuple15[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) = orgTypelevelTwiddleCompatHlistToTuple15(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple16", "0.6.3") def hlistToTuple16[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) = orgTypelevelTwiddleCompatHlistToTuple16(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple17", "0.6.3") def hlistToTuple17[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) = orgTypelevelTwiddleCompatHlistToTuple17(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple18", "0.6.3") def hlistToTuple18[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) = orgTypelevelTwiddleCompatHlistToTuple18(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple19", "0.6.3") def hlistToTuple19[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) = orgTypelevelTwiddleCompatHlistToTuple19(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple19", "0.6.3") def hlistToTuple20[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) = orgTypelevelTwiddleCompatHlistToTuple20(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple19", "0.6.3") def hlistToTuple21[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) = orgTypelevelTwiddleCompatHlistToTuple21(z)
+  @deprecated("use orgTypelevelTwiddleCompatHlistToTuple19", "0.6.3") def hlistToTuple22[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) = orgTypelevelTwiddleCompatHlistToTuple22(z)
+  // format: on
 }
diff --git a/project/build.properties b/project/build.properties
index 46e43a9..01a16ed 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=1.8.2
+sbt.version=1.11.7
diff --git a/project/plugins.sbt b/project/plugins.sbt
index c41c506..14feb68 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,8 +1,8 @@
-val sbtTypelevelVersion = "0.4.19"
+val sbtTypelevelVersion = "0.8.3"
 addSbtPlugin("org.typelevel" % "sbt-typelevel" % sbtTypelevelVersion)
-addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.13.0")
-addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.4.12")
-addSbtPlugin("org.portable-scala" % "sbt-scala-native-crossproject" % "1.3.0")
-addSbtPlugin("com.armanbilge" % "sbt-scala-native-config-brew-github-actions" % "0.1.3")
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.20.1")
+addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.4.17")
+addSbtPlugin("org.portable-scala" % "sbt-scala-native-crossproject" % "1.3.2")
+addSbtPlugin("com.armanbilge" % "sbt-scala-native-config-brew-github-actions" % "0.4.0")
 addSbtPlugin("com.github.tkawachi" % "sbt-doctest" % "0.10.0")
 addSbtPlugin("org.scalameta" % "sbt-mdoc" % "2.3.7")