diff --git a/src/Trait.ts b/src/Trait.ts
index e8f5cfd..2a2cfbe 100644
--- a/src/Trait.ts
+++ b/src/Trait.ts
@@ -97,11 +97,15 @@ export namespace Trait {
 
 export namespace Traits {
     export type MapImplClass<T> = {
-        [K in keyof T]: Trait.OwnImplClass<T[K]>
+        [K in keyof T]: K extends keyof []
+            ? T[K]
+            : Trait.OwnImplClass<T[K]>
     }
 
     export type MapImplInstance<T> = {
-        [K in keyof T]: Trait.OwnImplInstance<T[K]>
+        [K in keyof T]: K extends keyof []
+            ? T[K]
+            : Trait.OwnImplInstance<T[K]>
     }
 
     export type MapImplStaticMembers<T> = {
diff --git a/src/TraitBuilder.ts b/src/TraitBuilder.ts
index 420202c..1a68621 100644
--- a/src/TraitBuilder.ts
+++ b/src/TraitBuilder.ts
@@ -5,18 +5,25 @@ import { ExtendPlain, StaticMembers } from "./util"
 
 
 type ImplSuper<
-    Supertraits     extends Trait<any, any, any, any>[],
+    SuperExpression extends TraitExpression<
+        typeof TraitExpression.NullSuperclass,
+        Trait<any, any, any, any>[]
+    >,
     Abstract        extends object,
     StaticAbstract  extends object,
 > = (
     AbstractClass<
         ExtendPlain<[
-            ...Traits.MapImplInstance<Supertraits>,
+            ...Traits.MapImplInstance<
+                TraitExpression.Traits<SuperExpression>
+            >,
             Abstract,
         ]>
     > &
     ExtendPlain<[
-        ...Traits.MapImplStaticMembers<Supertraits>,
+        ...Traits.MapImplStaticMembers<
+            TraitExpression.Traits<SuperExpression>
+        >,
         StaticAbstract,
     ]> &
     { readonly _tag: "@thilawyn/traitify-ts/Super" }  // TODO: replace with unique symbol?
@@ -63,17 +70,13 @@ export class TraitBuilder<
 
     implement<
         ImplClassWithAbstract extends ImplSuper<  // TODO: use This instead?
-            TraitExpression.Traits<SuperExpression>,
+            SuperExpression,
             Abstract,
             StaticAbstract
         >
     >(
         apply: (
-            Super: ImplSuper<
-                TraitExpression.Traits<SuperExpression>,
-                Abstract,
-                StaticAbstract
-            >
+            Super: ImplSuper<SuperExpression, Abstract, StaticAbstract>
         ) => ImplClassWithAbstract
     ) {
         return new TraitBuilder(