diff --git a/site/index.html b/site/index.html
index d8c96a3..cf8975d 100644
--- a/site/index.html
+++ b/site/index.html
@@ -1,26 +1,26 @@
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-  <meta name="keywords" content="wink, jsr311, jaxrs, rest, restful, apache, open source, jsr-311, java, MartinSnitkovskyEliBaramElmanMichaelNadavFischer">
-   <title>Apache Wink</title>
- </head>
-<body>
-<table border="0" width="100%" cellspacing="0">
-<tr>
-    <td align="left" valign="top">
-		<a href="http://www.apache.org/"><img src="apache-incubator-wink-white.PNG" alt="The Apache Software Foundation" border="0"/></a>
-    </td>
-<td align="right">
-<a href="http://incubator.apache.org/"><img src="http://incubator.apache.org/images/apache-incubator-logo.png" alt="Apache Incubator" border="0"/></a>
-</td>
-</tr>
-  </table>
-<h3><p align="center">
-Apache Wink site is currently under construction. 
-For information regarding Wink project, see the 
-<a href="http://cwiki.apache.org/confluence/display/WINK/Index" title="ASF Wink Confluence Wiki" rel="nofollow">Wink Wiki</a>
-<br><br><br><img border="0" src="Construction.gif">
-</p>
-</h3>
-</body>
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+  <meta name="keywords" content="wink, jsr311, jaxrs, rest, restful, apache, open source, jsr-311, java, MartinSnitkovskyEliBaramElmanMichaelNadavFischer">
+   <title>Apache Wink</title>
+ </head>
+<body>
+<table border="0" width="100%" cellspacing="0">
+<tr>
+    <td align="left" valign="top">
+		<a href="http://www.apache.org/"><img src="apache-incubator-wink-white.PNG" alt="The Apache Software Foundation" border="0"/></a>
+    </td>
+<td align="right">
+<a href="http://incubator.apache.org/"><img src="http://incubator.apache.org/images/apache-incubator-logo.png" alt="Apache Incubator" border="0"/></a>
+</td>
+</tr>
+  </table>
+<h3><p align="center">
+Apache Wink site is currently under construction. 
+For information regarding Wink project, see the 
+<a href="http://cwiki.apache.org/confluence/display/WINK/Index" title="ASF Wink Confluence Wiki" rel="nofollow">Wink Wiki</a>
+<br><br><br><img border="0" src="Construction.gif">
+</p>
+</h3>
+</body>
 </html>
\ No newline at end of file
diff --git a/site/pom.xml b/site/pom.xml
index 9a180e5..814a231 100644
--- a/site/pom.xml
+++ b/site/pom.xml
@@ -1,212 +1,216 @@
-<?xml version="1.0" encoding="UTF-8"?>
-	<!--
-		Licensed to the Apache Software Foundation (ASF) under one or more
-		contributor license agreements. See the NOTICE file distributed with
-		this work for additional information regarding copyright ownership.
-		The ASF licenses this file to you under the Apache License, Version
-		2.0 (the "License"); you may not use this file except in compliance
-		with the License. You may obtain a copy of the License at
-		http://www.apache.org/licenses/LICENSE-2.0 Unless required by
-		applicable law or agreed to in writing, software distributed under the
-		License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-		CONDITIONS OF ANY KIND, either express or implied. See the License for
-		the specific language governing permissions and limitations under the
-		License.
-	-->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<groupId>org.apache.wink</groupId>
-	<artifactId>wink</artifactId>
-	<version>0.1-SNAPSHOT</version>
-	<packaging>pom</packaging>
-	<name>Wink</name>
-	<parent>
-		<groupId>org.apache</groupId>
-		<artifactId>apache</artifactId>
-		<version>6</version>
-	</parent>
-	<properties>
-		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<javadoc.aggregate>true</javadoc.aggregate>
-		<javadoc.exclude.patterns>*internal:org.apache.wink.example</javadoc.exclude.patterns>
-		<site.deploy.dir>C:/wink/buildsReports</site.deploy.dir>
-		<file.system.site.deploy.dir>C:/wink/reports</file.system.site.deploy.dir>
-	</properties>
-	<scm>
-		<connection>scm:svn:http://svn.apache.org/repos/asf/incubator/wink/trunk</connection>
-		<developerConnection>scm:svn:https://svn.apache.org/repos/asf/incubator/wink/trunk</developerConnection>
-		<url>http://svn.apache.org/viewvc/incubator/wink/trunk</url>
-	</scm>
-	<reporting>
-		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-project-info-reports-plugin</artifactId>
-				<reportSets>
-					<reportSet>
-						<reports>
-							<!-- >report>index</report -->
-							<!-- <report>dependencies</report> -->
-							<!-- report>dependency-convergence</report -->
-							<report>project-team</report>
-							<report>license</report>
-							<report>scm</report>
-							<report>mailing-list</report>
-							<!-- report>cim</report-->
-							<report>issue-tracking</report>
-							<!-- report>summary</report-->
-						</reports>
-					</reportSet>
-				</reportSets>
-			</plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-jxr-plugin</artifactId>
-			</plugin>
-		</plugins>
-	</reporting>
-	<issueManagement>
-		<system>Jira Issue Tracker</system>
-		<url>http://issues.apache.org/jira/browse/WINK</url>
-	</issueManagement>
-	<mailingLists>
-		<mailingList>
-			<name>Development</name>
-			<post>wink-dev@incubator.apache.org</post>
-			<subscribe>wink-dev-subsribe@incubator.apache.org</subscribe>
-			<unsubscribe>wink-dev-unsubsribe@incubator.apache.org</unsubscribe>
-			<archive>http://mail-archives.apache.org/mod_mbox/incubator-wink-dev/</archive>
-		</mailingList>
-		<mailingList>
-			<name>Commits</name>
-			<post>wink-commits@incubator.apache.org</post>
-			<subscribe>wink-commits-subsribe@incubator.apache.org</subscribe>
-			<unsubscribe>wink-commits-unsubsribe@incubator.apache.org</unsubscribe>
-			<archive>http://mail-archives.apache.org/mod_mbox/incubator-wink-commits/</archive>
-		</mailingList>
-	</mailingLists>
-	<developers>
-		<developer>
-			<id>dims</id>
-			<name>Davanum Srinivas</name>
-			<roles>
-				<role>mentor</role>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>kevan</id>
-			<name>Kevan Miller</name>
-			<roles>
-				<role>mentor</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>stevel</id>
-			<name>Steve Loughran</name>
-			<roles>
-				<role>mentor</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>bluk</id>
-			<name>Bryant Luk</name>
-			<organization>IBM</organization>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>cjblythe</id>
-			<name>Christopher James Blythe</name>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>damrhei</id>
-			<name>Dustin Amrhein</name>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>elib</id>
-			<name>Eli Baram</name>
-			<organization>HP</organization>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>elman</id>
-			<name>Elman Michael</name>
-			<organization>HP</organization>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>jdillon</id>
-			<name>Jason Dillon</name>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>jramos</id>
-			<name>Jesse A. Ramos</name>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>martins</id>
-			<name>Martin Snitkovsky</name>
-			<organization>HP</organization>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>nfischer</id>
-			<name>Nadav Fischer</name>
-			<organization>HP</organization>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>ngallardo</id>
-			<name>Nicholas L. Gallardo</name>
-			<organization>IBM</organization>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>tomershadi</id>
-			<name>Tomer Shadi</name>
-			<organization>HP</organization>
-			<roles>
-				<role>committer</role>
-			</roles>
-		</developer>
-	</developers>
-	<licenses>
-		<license>
-			<name>The Apache Software License, Version 2.0</name>
-			<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
-			<distribution>repo</distribution>
-		</license>
-	</licenses>
-	<distributionManagement>
-		<site>
-			<id>people-apache</id>
-			<url>tbd</url>
-		</site>
-	</distributionManagement>
-	<inceptionYear>2009</inceptionYear>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>org.apache.wink</groupId>
+	<artifactId>wink</artifactId>
+	<version>0.1-SNAPSHOT</version>
+	<packaging>pom</packaging>
+	<name>Wink</name>
+	<parent>
+		<groupId>org.apache</groupId>
+		<artifactId>apache</artifactId>
+		<version>6</version>
+	</parent>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<javadoc.aggregate>true</javadoc.aggregate>
+		<javadoc.exclude.patterns>*internal:org.apache.wink.example</javadoc.exclude.patterns>
+		<site.deploy.dir>C:/wink/buildsReports</site.deploy.dir>
+		<file.system.site.deploy.dir>C:/wink/reports</file.system.site.deploy.dir>
+	</properties>
+	<scm>
+		<connection>scm:svn:http://svn.apache.org/repos/asf/incubator/wink/trunk</connection>
+		<developerConnection>scm:svn:https://svn.apache.org/repos/asf/incubator/wink/trunk</developerConnection>
+		<url>http://svn.apache.org/viewvc/incubator/wink/trunk</url>
+	</scm>
+	<reporting>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-project-info-reports-plugin</artifactId>
+				<reportSets>
+					<reportSet>
+						<reports>
+							<!-- >report>index</report -->
+							<!-- <report>dependencies</report> -->
+							<!-- report>dependency-convergence</report -->
+							<report>project-team</report>
+							<report>license</report>
+							<report>scm</report>
+							<report>mailing-list</report>
+							<!-- report>cim</report-->
+							<report>issue-tracking</report>
+							<!-- report>summary</report-->
+						</reports>
+					</reportSet>
+				</reportSets>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-jxr-plugin</artifactId>
+			</plugin>
+		</plugins>
+	</reporting>
+	<issueManagement>
+		<system>Jira Issue Tracker</system>
+		<url>http://issues.apache.org/jira/browse/WINK</url>
+	</issueManagement>
+	<mailingLists>
+		<mailingList>
+			<name>Development</name>
+			<post>wink-dev@incubator.apache.org</post>
+			<subscribe>wink-dev-subsribe@incubator.apache.org</subscribe>
+			<unsubscribe>wink-dev-unsubsribe@incubator.apache.org</unsubscribe>
+			<archive>http://mail-archives.apache.org/mod_mbox/incubator-wink-dev/</archive>
+		</mailingList>
+		<mailingList>
+			<name>Commits</name>
+			<post>wink-commits@incubator.apache.org</post>
+			<subscribe>wink-commits-subsribe@incubator.apache.org</subscribe>
+			<unsubscribe>wink-commits-unsubsribe@incubator.apache.org</unsubscribe>
+			<archive>http://mail-archives.apache.org/mod_mbox/incubator-wink-commits/</archive>
+		</mailingList>
+	</mailingLists>
+	<developers>
+		<developer>
+			<id>dims</id>
+			<name>Davanum Srinivas</name>
+			<roles>
+				<role>mentor</role>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>kevan</id>
+			<name>Kevan Miller</name>
+			<roles>
+				<role>mentor</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>stevel</id>
+			<name>Steve Loughran</name>
+			<roles>
+				<role>mentor</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>bluk</id>
+			<name>Bryant Luk</name>
+			<organization>IBM</organization>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>cjblythe</id>
+			<name>Christopher James Blythe</name>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>damrhei</id>
+			<name>Dustin Amrhein</name>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>elib</id>
+			<name>Eli Baram</name>
+			<organization>HP</organization>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>elman</id>
+			<name>Elman Michael</name>
+			<organization>HP</organization>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>jdillon</id>
+			<name>Jason Dillon</name>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>jramos</id>
+			<name>Jesse A. Ramos</name>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>martins</id>
+			<name>Martin Snitkovsky</name>
+			<organization>HP</organization>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>nfischer</id>
+			<name>Nadav Fischer</name>
+			<organization>HP</organization>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>ngallardo</id>
+			<name>Nicholas L. Gallardo</name>
+			<organization>IBM</organization>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+		<developer>
+			<id>tomershadi</id>
+			<name>Tomer Shadi</name>
+			<organization>HP</organization>
+			<roles>
+				<role>committer</role>
+			</roles>
+		</developer>
+	</developers>
+	<licenses>
+		<license>
+			<name>The Apache Software License, Version 2.0</name>
+			<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+			<distribution>repo</distribution>
+		</license>
+	</licenses>
+	<distributionManagement>
+		<site>
+			<id>people-apache</id>
+			<url>tbd</url>
+		</site>
+	</distributionManagement>
+	<inceptionYear>2009</inceptionYear>
+
+</project>
diff --git a/site/src/site/apt/community.apt b/site/src/site/apt/community.apt
index 347aa44..c68c010 100644
--- a/site/src/site/apt/community.apt
+++ b/site/src/site/apt/community.apt
@@ -23,7 +23,7 @@
 ~~ under the License.
 ~~
 
-Community
+Apache Community
 
  Every volunteer project obtains its strength from the people involved in it. 
  We invite you to participate as much or as little as you choose.
diff --git a/site/src/site/apt/documentation.apt b/site/src/site/apt/documentation.apt
index d2f4222..ece9c59 100644
--- a/site/src/site/apt/documentation.apt
+++ b/site/src/site/apt/documentation.apt
@@ -1,32 +1,32 @@
- -----
- Wink 0.1 Documentation
- -----
- -----
- June 2008
-
-~~
-~~ Licensed to the Apache Software Foundation (ASF) under one
-~~ or more contributor license agreements.  See the NOTICE file
-~~ distributed with this work for additional information
-~~ regarding copyright ownership.  The ASF licenses this file
-~~ to you under the Apache License, Version 2.0 (the
-~~ "License"); you may not use this file except in compliance
-~~ with the License.  You may obtain a copy of the License at
-~~ 
-~~ http://www.apache.org/licenses/LICENSE-2.0
-~~ 
-~~ Unless required by applicable law or agreed to in writing,
-~~ software distributed under the License is distributed on an
-~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-~~ KIND, either express or implied.  See the License for the
-~~ specific language governing permissions and limitations
-~~ under the License.
-~~
-
-Wink Documentation
-
-* Wink 0.1 
-
-  * User Guide {{{http://incubator.apache.org/wink/docs/Apache_Wink_User_Guide.htm}HTML}} / {{{http://incubator.apache.org/wink/docs/Apache_Wink_User_Guide.pdf}PDF}} 
-  * {{{http://hudson.zones.apache.org/hudson/view/Wink/job/Wink-Trunk-JDK1.5/javadoc}API}} (Javadoc)
-  
\ No newline at end of file
+ -----
+ Wink 0.1 Documentation
+ -----
+ -----
+ June 2008
+
+~~
+~~ Licensed to the Apache Software Foundation (ASF) under one
+~~ or more contributor license agreements.  See the NOTICE file
+~~ distributed with this work for additional information
+~~ regarding copyright ownership.  The ASF licenses this file
+~~ to you under the Apache License, Version 2.0 (the
+~~ "License"); you may not use this file except in compliance
+~~ with the License.  You may obtain a copy of the License at
+~~ 
+~~ http://www.apache.org/licenses/LICENSE-2.0
+~~ 
+~~ Unless required by applicable law or agreed to in writing,
+~~ software distributed under the License is distributed on an
+~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+~~ KIND, either express or implied.  See the License for the
+~~ specific language governing permissions and limitations
+~~ under the License.
+~~
+
+Apache Wink Documentation
+
+* Wink 0.1 
+
+  * User Guide {{{http://incubator.apache.org/wink/docs/Apache_Wink_User_Guide.htm}HTML}} / {{{http://incubator.apache.org/wink/docs/Apache_Wink_User_Guide.pdf}PDF}} 
+  * {{{http://hudson.zones.apache.org/hudson/view/Wink/job/Wink-Trunk-JDK1.5/javadoc}API}} (Javadoc)
+  
diff --git a/site/src/site/apt/downloads.apt b/site/src/site/apt/downloads.apt
index 7d25bd9..05c2548 100644
--- a/site/src/site/apt/downloads.apt
+++ b/site/src/site/apt/downloads.apt
@@ -23,18 +23,20 @@
 ~~ under the License.
 ~~
 
-Wink Downloads
+Apache Wink Downloads
 
  Wink is distributed in several formats for your convenience.
 		
 * Distribution Archive
 
-  {{{https://repository.apache.org/content/repositories/snapshots/org/apache/wink/wink-dist/0.1-incubating-SNAPSHOT/wink-dist-0.1-incubating-SNAPSHOT.zip}wink-dist-0.1.zip}} - contains Wink server module, client module, extensions, all 3-rd party dependencies, server and client examples, documentation.
+  {{{https://repository.apache.org/content/repositories/snapshots/org/apache/wink/wink-dist/0.1-incubating-SNAPSHOT/wink-dist-0.1-incubating-SNAPSHOT.zip}wink-dist-0.1-incubating-SNAPSHOT.zip}} - contains the Wink server module, client module, extensions, all 3-rd party dependencies, server and client examples, documentation.
 
 * Maven
 
 ** Dependencies
 
+ You can add the following dependencies to your Maven pom.xml to include the Apache Wink Client module and the Server module.
+
 *** Client
 
 ---------------------------------------
diff --git a/site/src/site/apt/index.apt b/site/src/site/apt/index.apt
index 855562c..d115632 100644
--- a/site/src/site/apt/index.apt
+++ b/site/src/site/apt/index.apt
@@ -1,5 +1,5 @@
  -----
- Wink
+ Apache Wink
  -----
  -----
  May 2009
@@ -23,12 +23,12 @@
 ~~ under the License.
 ~~
 
-Wink
+Apache Wink
 
-  Wink is simple yet solid framework for building RESTful Web services. It is comprised of a Server module and a Client module
+  Wink is a simple yet solid framework for building RESTful Web services. It is comprised of a Server module and a Client module
   for developing and consuming RESTful Web services.
 
-  The <<Wink Server>> module is a complete implementation of the JAX-RS v1.0 specification. On top this implementation, 
+  The <<Wink Server>> module is a complete implementation of the JAX-RS v1.0 specification. On top of this implementation, 
   the Wink Server module provides a set of additional features that were designed to facilitate
    the development of RESTful Web services.
   
diff --git a/site/src/site/resources/css/site.css b/site/src/site/resources/css/site.css
index c6ccf1d..43b7278 100644
--- a/site/src/site/resources/css/site.css
+++ b/site/src/site/resources/css/site.css
@@ -1,40 +1,40 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- * 
- *   http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-a:link {
-  color:#1111ee;
-}
-a:visited  {
-  color:#111188;
-}
-#navcolumn h5 {
-  color: #336666;
-}
-.xright a:link, .xright a:visited {
-  color: #000099;
-}
-.xright a:hover, .xright a:active {
-  color: #990000;
-}
-#banner {
-  height: 70px;
-  background: none;
-  background-color: #FFFFFF
-}
-
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+a:link {
+  color:#1111ee;
+}
+a:visited  {
+  color:#111188;
+}
+#navcolumn h5 {
+  color: #336666;
+}
+.xright a:link, .xright a:visited {
+  color: #000099;
+}
+.xright a:hover, .xright a:active {
+  color: #990000;
+}
+#banner {
+  height: 70px;
+  background: none;
+  background-color: #FFFFFF
+}
+
diff --git a/site/src/site/site.xml b/site/src/site/site.xml
index 448e57a..3307440 100644
--- a/site/src/site/site.xml
+++ b/site/src/site/site.xml
@@ -1,79 +1,82 @@
-<?xml version="1.0" encoding="UTF-8"?>
-	<!--
-		Licensed to the Apache Software Foundation (ASF) under one or more
-		contributor license agreements. See the NOTICE file distributed with
-		this work for additional information regarding copyright ownership.
-		The ASF licenses this file to you under the Apache License, Version
-		2.0 (the "License"); you may not use this file except in compliance
-		with the License. You may obtain a copy of the License at
-
-		http://www.apache.org/licenses/LICENSE-2.0 Unless required by
-		applicable law or agreed to in writing, software distributed under the
-		License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-		CONDITIONS OF ANY KIND, either express or implied. See the License for
-		the specific language governing permissions and limitations under the
-		License.
-	-->
-
-<project xmlns="http://maven.apache.org/DECORATION/1.0.0"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
-	<publishDate format="dd-MM-yy kk:mm" />
-	<version position="left" />
-	<bannerRight>
-		<name>Apache Incubator</name>
-		<src>http://incubator.apache.org/images/apache-incubator-logo.png</src>
-		<href>http://incubator.apache.org</href>
-	</bannerRight>
-	<bannerLeft>
-		<name>Wink</name>
-		<src>images/apache-incubator-wink-white.PNG</src>
-		<href>http://incubator.apache.org/wink/</href>
-	</bannerLeft>
-	<poweredBy>
-		<logo name="" img="images/white.jpg" />
-	</poweredBy>
-	<body>
-		<head>
-			<link rel="shortcut icon" href="images/favicon.ico" />
-			<!--
-				this style is needed to enable child modules to use the main
-				site.css
-			-->
-			<style type="text/css" media="all">
-				@import
-				url(css/site.css);
-            </style>
-		</head>
-		<links>
-			<item name="Repository" href="" />
-			<item name="SVN" href="http://svn.apache.org/viewvc/incubator/wink/" />
-			<item name="Wiki"
-				href="http://cwiki.apache.org/confluence/display/WINK/Index" />
-			<item name="Jira" href="https://issues.apache.org/jira/browse/WINK" />
-		</links>
-		<breadcrumbs>
-			<item name="${project.artifactId}" href="/" />
-		</breadcrumbs>
-		<menu name="Main">
-			<item name="Introduction" href="index.html" />
-			<item name="Downloads" href="downloads.html" />
-			<item name="Documentation" href="documentation.html" />
-			<item name="Community" href="community.html" />
-			<item name="FAQ" href="faqs.html" />
-		</menu>
-
-
-		<!--
-			menu name="Contribute"> <item name="Introduction" href=""/> <item
-			name="Contribution Policies" href="how-to/setup-how.html"/> <item
-			name="Project Setup" href="how-to/setup-how.html"/> </menu
-		-->
-		<menu ref="reports"  />
-	</body>
-	<skin>
-		<groupId>org.apache.maven.skins</groupId>
-		<artifactId>maven-stylus-skin</artifactId>
-		<version>1.0.1</version>
-	</skin>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+    
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+
+<project xmlns="http://maven.apache.org/DECORATION/1.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
+	<publishDate format="dd-MM-yy kk:mm" />
+	<version position="left" />
+	<bannerRight>
+		<name>Apache Incubator</name>
+		<src>http://incubator.apache.org/images/apache-incubator-logo.png</src>
+		<href>http://incubator.apache.org</href>
+	</bannerRight>
+	<bannerLeft>
+		<name>Wink</name>
+		<src>images/apache-incubator-wink-white.PNG</src>
+		<href>http://incubator.apache.org/wink/</href>
+	</bannerLeft>
+	<poweredBy>
+		<logo name="" img="images/white.jpg" />
+	</poweredBy>
+	<body>
+		<head>
+			<link rel="shortcut icon" href="images/favicon.ico" />
+			<!--
+				this style is needed to enable child modules to use the main
+				site.css
+			-->
+			<style type="text/css" media="all">
+				@import
+				url(css/site.css);
+            </style>
+		</head>
+		<links>
+			<item name="Repository" href="" />
+			<item name="SVN" href="http://svn.apache.org/viewvc/incubator/wink/" />
+			<item name="Wiki"
+				href="http://cwiki.apache.org/confluence/display/WINK/Index" />
+			<item name="Jira" href="https://issues.apache.org/jira/browse/WINK" />
+		</links>
+		<breadcrumbs>
+			<item name="${project.artifactId}" href="/" />
+		</breadcrumbs>
+		<menu name="Main">
+			<item name="Introduction" href="index.html" />
+			<item name="Downloads" href="downloads.html" />
+			<item name="Documentation" href="documentation.html" />
+			<item name="Community" href="community.html" />
+			<item name="FAQ" href="faqs.html" />
+		</menu>
+
+
+		<!--
+			menu name="Contribute"> <item name="Introduction" href=""/> <item
+			name="Contribution Policies" href="how-to/setup-how.html"/> <item
+			name="Project Setup" href="how-to/setup-how.html"/> </menu
+		-->
+		<menu ref="reports"  />
+	</body>
+	<skin>
+		<groupId>org.apache.maven.skins</groupId>
+		<artifactId>maven-stylus-skin</artifactId>
+		<version>1.0.1</version>
+	</skin>
+</project>
diff --git a/site/target/site/community.html b/site/target/site/community.html
index e24422a..5d115e2 100644
--- a/site/target/site/community.html
+++ b/site/target/site/community.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -147,39 +147,39 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>Community</h2>
-<p>Every volunteer project obtains its strength from the people involved in it. We invite you to participate as much or as little as you choose.</p>
-<p>You can:</p>
-<ul><li>Use our project and provide a feedback.</li>
-<li>Provide us with the use-cases.</li>
-<li>Report bugs and submit patches.</li>
-<li>Contribute code, javadocs, documentation.<p>Visit the <a href="http://cwiki.apache.org/confluence/display/WINK/Project+Guidelines" class="externalLink">Project Guidelines</a> for more information.</p>
-</li>
-</ul>
-<div class="section"><h3>Communication</h3>
-<p>The Apache Wink project uses <a href="mail-lists.html">mailing lists</a> primarily to communicate with its members.<br />
-IRC is also used for a real-time discussions. </p>
-<div class="section"><h4>IRC</h4>
-<p>Log into #apache-wink on Freenode or use a <a href="http://webchat.freenode.net/?channels=apache-wink" class="externalLink">Web Client</a></p>
-</div>
-</div>
-<div class="section"><h3>Issue Tracker</h3>
-<div class="section"><h4>Bug Reports</h4>
-<p>Found bug? Enter an issue in the <a href="issue-tracking.html">Issue Tracker</a>.</p>
-<p>Before submitting an issue, please:</p>
-<ul><li>Verify that the bug does in fact exist.</li>
-<li>Search the issue tracker to verify there is no existing issue reporting the bug you've found.</li>
-<li>Consider tracking down the bug yourself in the Wink's source and submitting a patch along with your bug report. This is a great time saver for the Wink developers and helps ensure the bug will be fixed quickly. </li>
-</ul>
-</div>
-<div class="section"><h4>Feature Request</h4>
-<p>Enhancement requests for new features are also welcome. The more concrete and rationale the request is, the greater the chance it will incorporated into future releases.</p>
-</div>
-</div>
-<div class="section"><h3>Source Code</h3>
-<p>The project sources are accessible via the <a href="source-repository.html">SVN</a>. </p>
-</div>
-</div>
+        <div class="section"><h2>Apache Community</h2>
+<p>Every volunteer project obtains its strength from the people involved in it. We invite you to participate as much or as little as you choose.</p>
+<p>You can:</p>
+<ul><li>Use our project and provide a feedback.</li>
+<li>Provide us with the use-cases.</li>
+<li>Report bugs and submit patches.</li>
+<li>Contribute code, javadocs, documentation.<p>Visit the <a href="http://cwiki.apache.org/confluence/display/WINK/Project+Guidelines" class="externalLink">Project Guidelines</a> for more information.</p>
+</li>
+</ul>
+<div class="section"><h3>Communication</h3>
+<p>The Apache Wink project uses <a href="mail-lists.html">mailing lists</a> primarily to communicate with its members.<br />
+IRC is also used for a real-time discussions. </p>
+<div class="section"><h4>IRC</h4>
+<p>Log into #apache-wink on Freenode or use a <a href="http://webchat.freenode.net/?channels=apache-wink" class="externalLink">Web Client</a></p>
+</div>
+</div>
+<div class="section"><h3>Issue Tracker</h3>
+<div class="section"><h4>Bug Reports</h4>
+<p>Found bug? Enter an issue in the <a href="issue-tracking.html">Issue Tracker</a>.</p>
+<p>Before submitting an issue, please:</p>
+<ul><li>Verify that the bug does in fact exist.</li>
+<li>Search the issue tracker to verify there is no existing issue reporting the bug you've found.</li>
+<li>Consider tracking down the bug yourself in the Wink's source and submitting a patch along with your bug report. This is a great time saver for the Wink developers and helps ensure the bug will be fixed quickly. </li>
+</ul>
+</div>
+<div class="section"><h4>Feature Request</h4>
+<p>Enhancement requests for new features are also welcome. The more concrete and rationale the request is, the greater the chance it will incorporated into future releases.</p>
+</div>
+</div>
+<div class="section"><h3>Source Code</h3>
+<p>The project sources are accessible via the <a href="source-repository.html">SVN</a>. </p>
+</div>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/css/site.css b/site/target/site/css/site.css
index c6ccf1d..43b7278 100644
--- a/site/target/site/css/site.css
+++ b/site/target/site/css/site.css
@@ -1,40 +1,40 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- * 
- *   http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-a:link {
-  color:#1111ee;
-}
-a:visited  {
-  color:#111188;
-}
-#navcolumn h5 {
-  color: #336666;
-}
-.xright a:link, .xright a:visited {
-  color: #000099;
-}
-.xright a:hover, .xright a:active {
-  color: #990000;
-}
-#banner {
-  height: 70px;
-  background: none;
-  background-color: #FFFFFF
-}
-
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+a:link {
+  color:#1111ee;
+}
+a:visited  {
+  color:#111188;
+}
+#navcolumn h5 {
+  color: #336666;
+}
+.xright a:link, .xright a:visited {
+  color: #000099;
+}
+.xright a:hover, .xright a:active {
+  color: #990000;
+}
+#banner {
+  height: 70px;
+  background: none;
+  background-color: #FFFFFF
+}
+
diff --git a/site/target/site/documentation.html b/site/target/site/documentation.html
index 18245e4..a1b37df 100644
--- a/site/target/site/documentation.html
+++ b/site/target/site/documentation.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -147,12 +147,12 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>Wink Documentation</h2>
-<div class="section"><h3>Wink 0.1 </h3>
-<ul><li>User Guide <a href="http://incubator.apache.org/wink/docs/Apache_Wink_User_Guide.htm" class="externalLink">HTML</a> / <a href="http://incubator.apache.org/wink/docs/Apache_Wink_User_Guide.pdf" class="externalLink">PDF</a> * <a href="http://hudson.zones.apache.org/hudson/view/Wink/job/Wink-Trunk-JDK1.5/javadoc" class="externalLink">API</a> (Javadoc)</li>
-</ul>
-</div>
-</div>
+        <div class="section"><h2>Apache Wink Documentation</h2>
+<div class="section"><h3>Wink 0.1 </h3>
+<ul><li>User Guide <a href="http://incubator.apache.org/wink/docs/Apache_Wink_User_Guide.htm" class="externalLink">HTML</a> / <a href="http://incubator.apache.org/wink/docs/Apache_Wink_User_Guide.pdf" class="externalLink">PDF</a> * <a href="http://hudson.zones.apache.org/hudson/view/Wink/job/Wink-Trunk-JDK1.5/javadoc" class="externalLink">API</a> (Javadoc)</li>
+</ul>
+</div>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/downloads.html b/site/target/site/downloads.html
index dcf5629..309fa7f 100644
--- a/site/target/site/downloads.html
+++ b/site/target/site/downloads.html
Binary files differ
diff --git a/site/target/site/faqs.html b/site/target/site/faqs.html
index 0564a0c..65f5f4a 100644
--- a/site/target/site/faqs.html
+++ b/site/target/site/faqs.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -147,94 +147,94 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2><a name="top">Frequently Asked Questions</a></h2>
-<p><b>Wink 0.1</b></p>
-<ol type="1"><li><a href="#sdk-examples">Where can I find examples for using Wink?</a></li>
-<li><a href="#sdk-spring">Does Wink have an integration with spring? Can I expose my REST services using Spring Remoting?</a></li>
-<li><a href="#sdk-struts">Is there an integration with Struts?</a></li>
-<li><a href="#sdk-struts-usage">Can Wink be used in the same WAR with Struts?</a></li>
-<li><a href="#sdk-tested-with-other-clients">Have you tested consuming REST resources developed using Wink from a REST client developed using other tools?</a></li>
-<li><a href="#sdk-query-parameters">Does Wink query parameters?</a></li>
-<li><a href="#sdk-ide-plugin">Are there any plans for developing an IDE plugin wrapper for Wink?</a></li>
-</ol>
-<p><b>Building the Apache Wink</b></p>
-<ol type="1"><li><a href="#maven-version">What version of Maven is used to build Wink?</a></li>
-<li><a href="#maven-sources">Where can I read about Maven?</a></li>
-<li><a href="#null">I am getting an OutOfMemoryException when performing a full build</a></li>
-<li><a href="#null">Can I build the sources if I am not connected to the network?</a></li>
-<li><a href="#null">Some tests fail during the build. Where can I see what happened?</a></li>
-</ol>
-</div>
-<div class="section"><h2>Wink 0.1</h2>
-<dl><dt><a name="sdk-examples">Where can I find examples for using Wink?</a></dt>
+        <div class="section"><h2><a name="top">Frequently Asked Questions</a></h2>
+<p><b>Wink 0.1</b></p>
+<ol type="1"><li><a href="#sdk-examples">Where can I find examples for using Wink?</a></li>
+<li><a href="#sdk-spring">Does Wink have an integration with spring? Can I expose my REST services using Spring Remoting?</a></li>
+<li><a href="#sdk-struts">Is there an integration with Struts?</a></li>
+<li><a href="#sdk-struts-usage">Can Wink be used in the same WAR with Struts?</a></li>
+<li><a href="#sdk-tested-with-other-clients">Have you tested consuming REST resources developed using Wink from a REST client developed using other tools?</a></li>
+<li><a href="#sdk-query-parameters">Does Wink query parameters?</a></li>
+<li><a href="#sdk-ide-plugin">Are there any plans for developing an IDE plugin wrapper for Wink?</a></li>
+</ol>
+<p><b>Building the Apache Wink</b></p>
+<ol type="1"><li><a href="#maven-version">What version of Maven is used to build Wink?</a></li>
+<li><a href="#maven-sources">Where can I read about Maven?</a></li>
+<li><a href="#null">I am getting an OutOfMemoryException when performing a full build</a></li>
+<li><a href="#null">Can I build the sources if I am not connected to the network?</a></li>
+<li><a href="#null">Some tests fail during the build. Where can I see what happened?</a></li>
+</ol>
+</div>
+<div class="section"><h2>Wink 0.1</h2>
+<dl><dt><a name="sdk-examples">Where can I find examples for using Wink?</a></dt>
 <dd> 
 				<p> 
 					Wink distributions comes bundled with several examples ilustarting how to use the server and client. <br></br>
 					All the examples are located in the <code>Wink/examples</code> directory of the distribution zip.
 				</p> 
-			<hr />
-</dd>
-<dt><a name="sdk-spring">Does Wink have an integration with spring? Can I expose my REST services using Spring Remoting?</a></dt>
+			<hr />
+</dd>
+<dt><a name="sdk-spring">Does Wink have an integration with spring? Can I expose my REST services using Spring Remoting?</a></dt>
 <dd> 
 				<p> 
 					Yes, it provides an extension module with the Spring integration. 
 					However, Wink doesn't use Spring Remoting.
 				</p> 
-			<hr />
-</dd>
-<dt><a name="sdk-struts">Is there an integration with Struts?</a></dt>
+			<hr />
+</dd>
+<dt><a name="sdk-struts">Is there an integration with Struts?</a></dt>
 <dd> 
 				<p> 
 					Wink does not have an integration with struts.
 				</p> 
-			<hr />
-</dd>
-<dt><a name="sdk-struts-usage">Can Wink be used in the same WAR with Struts?</a></dt>
+			<hr />
+</dd>
+<dt><a name="sdk-struts-usage">Can Wink be used in the same WAR with Struts?</a></dt>
 <dd> 
 				<p> 
 					Yes, Wink and the code you develop over it can be used inside any WAR.
 				</p> 
-			<hr />
-</dd>
-<dt><a name="sdk-tested-with-other-clients">Have you tested consuming REST resources developed using Wink from a REST client developed using other tools?</a></dt>
+			<hr />
+</dd>
+<dt><a name="sdk-tested-with-other-clients">Have you tested consuming REST resources developed using Wink from a REST client developed using other tools?</a></dt>
 <dd> 
 				<p> 
 					Sure. We have tested it from variety of clients including IE, Firefox, Outlook, Apache Abdera, Sun Rome, etc.
 				</p> 
-			<hr />
-</dd>
-<dt><a name="sdk-query-parameters">Does Wink query parameters?</a></dt>
+			<hr />
+</dd>
+<dt><a name="sdk-query-parameters">Does Wink query parameters?</a></dt>
 <dd> 
 				<p> 
 					Absolutely.
 				</p> 
-			<hr />
-</dd>
-<dt><a name="sdk-ide-plugin">Are there any plans for developing an IDE plugin wrapper for Wink?</a></dt>
+			<hr />
+</dd>
+<dt><a name="sdk-ide-plugin">Are there any plans for developing an IDE plugin wrapper for Wink?</a></dt>
 <dd> 
 				<p> 
 					We are considering this option for the Eclipse IDE.
 				</p> 
-			</dd>
-</dl>
-</div>
-<div class="section"><h2>Building the Apache Wink</h2>
-<dl><dt><a name="maven-version">What version of Maven is used to build Wink?</a></dt>
+			</dd>
+</dl>
+</div>
+<div class="section"><h2>Building the Apache Wink</h2>
+<dl><dt><a name="maven-version">What version of Maven is used to build Wink?</a></dt>
 <dd> 
 				<p> 
 					Wink is built using Maven 2, version 2.0.9.
 				</p> 
-			<hr />
-</dd>
-<dt><a name="maven-sources">Where can I read about Maven?</a></dt>
+			<hr />
+</dd>
+<dt><a name="maven-sources">Where can I read about Maven?</a></dt>
 <dd> 
 				<p> 
 					Maven site: <a href="http://maven.apache.org">http://maven.apache.org</a><br></br>
 					Maven FAQ: <a href="http://docs.codehaus.org/display/MAVENUSER/FAQs-1">http://docs.codehaus.org/display/MAVENUSER/FAQs-1</a>
 				</p> 
-			<hr />
-</dd>
-<dt><a>I am getting an OutOfMemoryException when performing a full build</a></dt>
+			<hr />
+</dd>
+<dt><a>I am getting an OutOfMemoryException when performing a full build</a></dt>
 <dd> 
 				<p> 
 					If you are getting OutOfMemoryException when attempting a full
@@ -243,18 +243,18 @@
 					<br></br>
 					<pre>MAVEN_OPTS=-Xmx512m -XX:MaxPermSize=256m</pre>
 				</p> 
-			<hr />
-</dd>
-<dt><a>Can I build the sources if I am not connected to the network?</a></dt>
+			<hr />
+</dd>
+<dt><a>Can I build the sources if I am not connected to the network?</a></dt>
 <dd> 
 				<p> 
 					If you know your downloads are up-to-date, you can use the offline option 
 					which may speed up your build considerably depending on network latency:
 					<pre>mvn -o</pre>
 				</p> 
-			<hr />
-</dd>
-<dt><a>Some tests fail during the build. Where can I see what happened?</a></dt>
+			<hr />
+</dd>
+<dt><a>Some tests fail during the build. Where can I see what happened?</a></dt>
 <dd> 
 				<p> 
 					Surefire, which is the default Maven test runner, outputs all tests reports
@@ -263,9 +263,9 @@
 					The output can be temporarily redirected to the console by adding the following option:
 					<pre>mvn -Dsurefire.useFile=false</pre>
 				</p> 
-			</dd>
-</dl>
-</div>
+			</dd>
+</dl>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/index.html b/site/target/site/index.html
index 94a6fc9..cacb68e 100644
--- a/site/target/site/index.html
+++ b/site/target/site/index.html
@@ -13,16 +13,16 @@
 <html xmlns="http://www.w3.org/1999/xhtml">
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <title>Wink - Wink</title>
+    <title>Wink - Apache Wink</title>
     <style type="text/css" media="all">
       @import url("./css/maven-base.css");
       @import url("./css/maven-theme.css");
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -147,11 +147,11 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>Wink</h2>
-<p>Wink is simple yet solid framework for building RESTful Web services. It is comprised of a Server module and a Client module for developing and consuming RESTful Web services.</p>
-<p>The <b>Wink Server</b> module is a complete implementation of the JAX-RS v1.0 specification. On top this implementation, the Wink Server module provides a set of additional features that were designed to facilitate the development of RESTful Web services.</p>
-<p>The <b>Wink Client</b> module is a Java based framework that provides functionality for communicating with RESTful Web services. The framework is built on top of the JDK HttpURLConnection and adds essential features that facilitate the development of such client applications.</p>
-</div>
+        <div class="section"><h2>Apache Wink</h2>
+<p>Wink is a simple yet solid framework for building RESTful Web services. It is comprised of a Server module and a Client module for developing and consuming RESTful Web services.</p>
+<p>The <b>Wink Server</b> module is a complete implementation of the JAX-RS v1.0 specification. On top of this implementation, the Wink Server module provides a set of additional features that were designed to facilitate the development of RESTful Web services.</p>
+<p>The <b>Wink Client</b> module is a Java based framework that provides functionality for communicating with RESTful Web services. The framework is built on top of the JDK HttpURLConnection and adds essential features that facilitate the development of such client applications.</p>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/issue-tracking.html b/site/target/site/issue-tracking.html
index 9765f6e..9e0af32 100644
--- a/site/target/site/issue-tracking.html
+++ b/site/target/site/issue-tracking.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -169,13 +169,13 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>Overview</h2>
-This project uses <a href="http://www.atlassian.com/software/jira" class="externalLink">JIRA</a> a J2EE-based, issue tracking and project management application.</div>
-<div class="section"><h2>Issue Tracking</h2>
-<p>Issues, bugs, and feature requests should be submitted to the following issue tracking system for this project.</p>
-<div class="source"><pre><a href="http://issues.apache.org/jira/browse/WINK" class="externalLink">http://issues.apache.org/jira/browse/WINK</a></pre>
-</div>
-</div>
+        <div class="section"><h2>Overview</h2>
+This project uses <a href="http://www.atlassian.com/software/jira" class="externalLink">JIRA</a> a J2EE-based, issue tracking and project management application.</div>
+<div class="section"><h2>Issue Tracking</h2>
+<p>Issues, bugs, and feature requests should be submitted to the following issue tracking system for this project.</p>
+<div class="source"><pre><a href="http://issues.apache.org/jira/browse/WINK" class="externalLink">http://issues.apache.org/jira/browse/WINK</a></pre>
+</div>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/license.html b/site/target/site/license.html
index 0513bbc..546ad6a 100644
--- a/site/target/site/license.html
+++ b/site/target/site/license.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -169,11 +169,11 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>Overview</h2>
-<p>Typically the licenses listed for the project are that of the project itself, and not of dependencies.</p>
-</div>
-<div class="section"><h2>Project License</h2>
-<div class="section"><h3>The Apache Software License, Version 2.0</h3>
+        <div class="section"><h2>Overview</h2>
+<p>Typically the licenses listed for the project are that of the project itself, and not of dependencies.</p>
+</div>
+<div class="section"><h2>Project License</h2>
+<div class="section"><h3>The Apache Software License, Version 2.0</h3>
 <div class="source"><pre>
                                  Apache License
                            Version 2.0, January 2004
@@ -376,10 +376,10 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-</pre>
-</div>
-</div>
-</div>
+</pre>
+</div>
+</div>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/mail-lists.html b/site/target/site/mail-lists.html
index c2e311a..b8742d1 100644
--- a/site/target/site/mail-lists.html
+++ b/site/target/site/mail-lists.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -169,28 +169,28 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>Project Mailing Lists</h2>
-<p>These are the mailing lists that have been established for this project. For each list, there is a subscribe, unsubscribe, and an archive link.</p>
-<table class="bodyTable"><tr class="a"><th>Name</th>
-<th>Subscribe</th>
-<th>Unsubscribe</th>
-<th>Post</th>
-<th>Archive</th>
-</tr>
-<tr class="b"><td>Development</td>
-<td><a href="mailto:wink-dev-subsribe@incubator.apache.org" class="externalLink">Subscribe</a></td>
-<td><a href="mailto:wink-dev-unsubsribe@incubator.apache.org" class="externalLink">Unsubscribe</a></td>
-<td><a href="mailto:wink-dev@incubator.apache.org" class="externalLink">Post</a></td>
-<td><a href="http://mail-archives.apache.org/mod_mbox/incubator-wink-dev/" class="externalLink">mail-archives.apache.org</a></td>
-</tr>
-<tr class="a"><td>Commits</td>
-<td><a href="mailto:wink-commits-subsribe@incubator.apache.org" class="externalLink">Subscribe</a></td>
-<td><a href="mailto:wink-commits-unsubsribe@incubator.apache.org" class="externalLink">Unsubscribe</a></td>
-<td><a href="mailto:wink-commits@incubator.apache.org" class="externalLink">Post</a></td>
-<td><a href="http://mail-archives.apache.org/mod_mbox/incubator-wink-commits/" class="externalLink">mail-archives.apache.org</a></td>
-</tr>
-</table>
-</div>
+        <div class="section"><h2>Project Mailing Lists</h2>
+<p>These are the mailing lists that have been established for this project. For each list, there is a subscribe, unsubscribe, and an archive link.</p>
+<table class="bodyTable"><tr class="a"><th>Name</th>
+<th>Subscribe</th>
+<th>Unsubscribe</th>
+<th>Post</th>
+<th>Archive</th>
+</tr>
+<tr class="b"><td>Development</td>
+<td><a href="mailto:wink-dev-subsribe@incubator.apache.org" class="externalLink">Subscribe</a></td>
+<td><a href="mailto:wink-dev-unsubsribe@incubator.apache.org" class="externalLink">Unsubscribe</a></td>
+<td><a href="mailto:wink-dev@incubator.apache.org" class="externalLink">Post</a></td>
+<td><a href="http://mail-archives.apache.org/mod_mbox/incubator-wink-dev/" class="externalLink">mail-archives.apache.org</a></td>
+</tr>
+<tr class="a"><td>Commits</td>
+<td><a href="mailto:wink-commits-subsribe@incubator.apache.org" class="externalLink">Subscribe</a></td>
+<td><a href="mailto:wink-commits-unsubsribe@incubator.apache.org" class="externalLink">Unsubscribe</a></td>
+<td><a href="mailto:wink-commits@incubator.apache.org" class="externalLink">Post</a></td>
+<td><a href="http://mail-archives.apache.org/mod_mbox/incubator-wink-commits/" class="externalLink">mail-archives.apache.org</a></td>
+</tr>
+</table>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/project-info.html b/site/target/site/project-info.html
index 975c468..a24a664 100644
--- a/site/target/site/project-info.html
+++ b/site/target/site/project-info.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -169,30 +169,30 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>Project Information</h2>
-<p>This document provides an overview of the various documents and links that are part of this project's general information. All of this content is automatically generated by <a href="http://maven.apache.org" class="externalLink">Maven</a> on behalf of the project.</p>
-<div class="section"><h3>Overview</h3>
-<table class="bodyTable"><tr class="a"><th>Document</th>
-<th>Description</th>
-</tr>
-<tr class="b"><td><a href="issue-tracking.html">Issue Tracking</a></td>
-<td>This is a link to the issue management system for this project. Issues (bugs, features, change requests) can be created and queried using this link.</td>
-</tr>
-<tr class="a"><td><a href="mail-lists.html">Mailing Lists</a></td>
-<td>This document provides subscription and archive information for this project's mailing lists.</td>
-</tr>
-<tr class="b"><td><a href="license.html">Project License</a></td>
-<td>This is a link to the definitions of project licenses.</td>
-</tr>
-<tr class="a"><td><a href="team-list.html">Project Team</a></td>
-<td>This document provides information on the members of this project. These are the individuals who have contributed to the project in one form or another.</td>
-</tr>
-<tr class="b"><td><a href="source-repository.html">Source Repository</a></td>
-<td>This is a link to the online source repository that can be viewed via a web browser.</td>
-</tr>
-</table>
-</div>
-</div>
+        <div class="section"><h2>Project Information</h2>
+<p>This document provides an overview of the various documents and links that are part of this project's general information. All of this content is automatically generated by <a href="http://maven.apache.org" class="externalLink">Maven</a> on behalf of the project.</p>
+<div class="section"><h3>Overview</h3>
+<table class="bodyTable"><tr class="a"><th>Document</th>
+<th>Description</th>
+</tr>
+<tr class="b"><td><a href="issue-tracking.html">Issue Tracking</a></td>
+<td>This is a link to the issue management system for this project. Issues (bugs, features, change requests) can be created and queried using this link.</td>
+</tr>
+<tr class="a"><td><a href="mail-lists.html">Mailing Lists</a></td>
+<td>This document provides subscription and archive information for this project's mailing lists.</td>
+</tr>
+<tr class="b"><td><a href="license.html">Project License</a></td>
+<td>This is a link to the definitions of project licenses.</td>
+</tr>
+<tr class="a"><td><a href="team-list.html">Project Team</a></td>
+<td>This document provides information on the members of this project. These are the individuals who have contributed to the project in one form or another.</td>
+</tr>
+<tr class="b"><td><a href="source-repository.html">Source Repository</a></td>
+<td>This is a link to the online source repository that can be viewed via a web browser.</td>
+</tr>
+</table>
+</div>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/source-repository.html b/site/target/site/source-repository.html
index 55135a5..69f5ace 100644
--- a/site/target/site/source-repository.html
+++ b/site/target/site/source-repository.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -169,41 +169,41 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>Overview</h2>
-This project uses <a href="http://subversion.tigris.org/" class="externalLink">Subversion</a> to manage its source code. Instructions on Subversion use can be found at <a href="http://svnbook.red-bean.com/" class="externalLink">http://svnbook.red-bean.com/</a>.</div>
-<div class="section"><h2>Web Access</h2>
-<p>The following is a link to the online source repository.</p>
-<div class="source"><pre><a href="http://svn.apache.org/viewvc/incubator/wink/trunk" class="externalLink">http://svn.apache.org/viewvc/incubator/wink/trunk</a></pre>
-</div>
-</div>
-<div class="section"><h2>Anonymous access</h2>
-<p>The source can be checked out anonymously from SVN with this command:</p>
-<div class="source"><pre>$ svn checkout http://svn.apache.org/repos/asf/incubator/wink/trunk wink</pre>
-</div>
-</div>
-<div class="section"><h2>Developer access</h2>
-<p>Everyone can access the Subversion repository via HTTP, but Committers must checkout the Subversion repository via HTTPS.</p>
-<div class="source"><pre>$ svn checkout https://svn.apache.org/repos/asf/incubator/wink/trunk wink</pre>
-</div>
-<p>To commit changes to the repository, execute the following command to commit your changes (svn will prompt you for your password)</p>
-<div class="source"><pre>$ svn commit --username your-username -m &quot;A message&quot;</pre>
-</div>
-</div>
-<div class="section"><h2>Access from behind a firewall</h2>
-<p>For those users who are stuck behind a corporate firewall which is blocking HTTP access to the Subversion repository, you can try to access it via the developer connection:</p>
-<div class="source"><pre>$ svn checkout https://svn.apache.org/repos/asf/incubator/wink/trunk wink</pre>
-</div>
-</div>
-<div class="section"><h2>Access through a proxy</h2>
-<p>The Subversion client can go through a proxy, if you configure it to do so. First, edit your &quot;servers&quot; configuration file to indicate which proxy to use. The file's location depends on your operating system. On Linux or Unix it is located in the directory &quot;~/.subversion&quot;. On Windows it is in &quot;%APPDATA%\Subversion&quot;. (Try &quot;echo %APPDATA%&quot;, note this is a hidden directory.)</p>
-<p>There are comments in the file explaining what to do. If you don't have that file, get the latest Subversion client and run any command; this will cause the configuration directory and template files to be created.</p>
-<p>Example: Edit the 'servers' file and add something like:</p>
+        <div class="section"><h2>Overview</h2>
+This project uses <a href="http://subversion.tigris.org/" class="externalLink">Subversion</a> to manage its source code. Instructions on Subversion use can be found at <a href="http://svnbook.red-bean.com/" class="externalLink">http://svnbook.red-bean.com/</a>.</div>
+<div class="section"><h2>Web Access</h2>
+<p>The following is a link to the online source repository.</p>
+<div class="source"><pre><a href="http://svn.apache.org/viewvc/incubator/wink/trunk" class="externalLink">http://svn.apache.org/viewvc/incubator/wink/trunk</a></pre>
+</div>
+</div>
+<div class="section"><h2>Anonymous access</h2>
+<p>The source can be checked out anonymously from SVN with this command:</p>
+<div class="source"><pre>$ svn checkout http://svn.apache.org/repos/asf/incubator/wink/trunk wink</pre>
+</div>
+</div>
+<div class="section"><h2>Developer access</h2>
+<p>Everyone can access the Subversion repository via HTTP, but Committers must checkout the Subversion repository via HTTPS.</p>
+<div class="source"><pre>$ svn checkout https://svn.apache.org/repos/asf/incubator/wink/trunk wink</pre>
+</div>
+<p>To commit changes to the repository, execute the following command to commit your changes (svn will prompt you for your password)</p>
+<div class="source"><pre>$ svn commit --username your-username -m &quot;A message&quot;</pre>
+</div>
+</div>
+<div class="section"><h2>Access from behind a firewall</h2>
+<p>For those users who are stuck behind a corporate firewall which is blocking HTTP access to the Subversion repository, you can try to access it via the developer connection:</p>
+<div class="source"><pre>$ svn checkout https://svn.apache.org/repos/asf/incubator/wink/trunk wink</pre>
+</div>
+</div>
+<div class="section"><h2>Access through a proxy</h2>
+<p>The Subversion client can go through a proxy, if you configure it to do so. First, edit your &quot;servers&quot; configuration file to indicate which proxy to use. The file's location depends on your operating system. On Linux or Unix it is located in the directory &quot;~/.subversion&quot;. On Windows it is in &quot;%APPDATA%\Subversion&quot;. (Try &quot;echo %APPDATA%&quot;, note this is a hidden directory.)</p>
+<p>There are comments in the file explaining what to do. If you don't have that file, get the latest Subversion client and run any command; this will cause the configuration directory and template files to be created.</p>
+<p>Example: Edit the 'servers' file and add something like:</p>
 <div class="source"><pre>[global]
 http-proxy-host = your.proxy.name
 http-proxy-port = 3128
-</pre>
-</div>
-</div>
+</pre>
+</div>
+</div>
 
       </div>
     </div>
diff --git a/site/target/site/team-list.html b/site/target/site/team-list.html
index 1a13044..96b50d1 100644
--- a/site/target/site/team-list.html
+++ b/site/target/site/team-list.html
@@ -20,9 +20,9 @@
       @import url("./css/site.css");
     </style>
     <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
-                                                        
-<link rel="shortcut icon" href="images/favicon.ico"/>
-                                                        
+                                                        
+<link href="images/favicon.ico" rel="shortcut icon"/>
+                                                        
 <style type="text/css" media="all">@import
 				url(css/site.css);</style>
                     </head>
@@ -52,7 +52,7 @@
   
     
             <div class="xleft">
-        Last Published: 22-07-09 16:51
+        Last Published: 22-07-09 22:40
                   &nbsp;| Version: 0.1-SNAPSHOT
                           |   
           wink
@@ -169,92 +169,92 @@
     </div>
     <div id="bodyColumn">
       <div id="contentBox">
-        <div class="section"><h2>The Team</h2>
-<p>A successful project requires many people to play many roles. Some members write code or documentation, while others are valuable as testers, submitting patches and suggestions.</p>
-<p>The team is comprised of Members and Contributors. Members have direct access to the source of a project and actively evolve the code-base. Contributors improve the project through submission of patches and suggestions to the Members. The number of Contributors to the project is unbounded. Get involved today. All contributions to the project are greatly appreciated.</p>
-<div class="section"><h3>Members</h3>
-<p>The following is a list of developers with commit privileges that have directly contributed to the project in one way or another.</p>
-<table class="bodyTable"><tr class="a"><th>Id</th>
-<th>Name</th>
-<th>Organization</th>
-<th>Roles</th>
-</tr>
-<tr class="b"><td><a name="dims"></a>dims</td>
-<td>Davanum Srinivas</td>
-<td>-</td>
-<td>mentor, committer</td>
-</tr>
-<tr class="a"><td><a name="kevan"></a>kevan</td>
-<td>Kevan Miller</td>
-<td>-</td>
-<td>mentor</td>
-</tr>
-<tr class="b"><td><a name="stevel"></a>stevel</td>
-<td>Steve Loughran</td>
-<td>-</td>
-<td>mentor</td>
-</tr>
-<tr class="a"><td><a name="bluk"></a>bluk</td>
-<td>Bryant Luk</td>
-<td>IBM</td>
-<td>committer</td>
-</tr>
-<tr class="b"><td><a name="cjblythe"></a>cjblythe</td>
-<td>Christopher James Blythe</td>
-<td>-</td>
-<td>committer</td>
-</tr>
-<tr class="a"><td><a name="damrhei"></a>damrhei</td>
-<td>Dustin Amrhein</td>
-<td>-</td>
-<td>committer</td>
-</tr>
-<tr class="b"><td><a name="elib"></a>elib</td>
-<td>Eli Baram</td>
-<td>HP</td>
-<td>committer</td>
-</tr>
-<tr class="a"><td><a name="elman"></a>elman</td>
-<td>Elman Michael</td>
-<td>HP</td>
-<td>committer</td>
-</tr>
-<tr class="b"><td><a name="jdillon"></a>jdillon</td>
-<td>Jason Dillon</td>
-<td>-</td>
-<td>committer</td>
-</tr>
-<tr class="a"><td><a name="jramos"></a>jramos</td>
-<td>Jesse A. Ramos</td>
-<td>-</td>
-<td>committer</td>
-</tr>
-<tr class="b"><td><a name="martins"></a>martins</td>
-<td>Martin Snitkovsky</td>
-<td>HP</td>
-<td>committer</td>
-</tr>
-<tr class="a"><td><a name="nfischer"></a>nfischer</td>
-<td>Nadav Fischer</td>
-<td>HP</td>
-<td>committer</td>
-</tr>
-<tr class="b"><td><a name="ngallardo"></a>ngallardo</td>
-<td>Nicholas L. Gallardo</td>
-<td>IBM</td>
-<td>committer</td>
-</tr>
-<tr class="a"><td><a name="tomershadi"></a>tomershadi</td>
-<td>Tomer Shadi</td>
-<td>HP</td>
-<td>committer</td>
-</tr>
-</table>
-</div>
-<div class="section"><h3>Contributors</h3>
-<p>There are no contributors listed for this project. Please check back again later.</p>
-</div>
-</div>
+        <div class="section"><h2>The Team</h2>
+<p>A successful project requires many people to play many roles. Some members write code or documentation, while others are valuable as testers, submitting patches and suggestions.</p>
+<p>The team is comprised of Members and Contributors. Members have direct access to the source of a project and actively evolve the code-base. Contributors improve the project through submission of patches and suggestions to the Members. The number of Contributors to the project is unbounded. Get involved today. All contributions to the project are greatly appreciated.</p>
+<div class="section"><h3>Members</h3>
+<p>The following is a list of developers with commit privileges that have directly contributed to the project in one way or another.</p>
+<table class="bodyTable"><tr class="a"><th>Id</th>
+<th>Name</th>
+<th>Organization</th>
+<th>Roles</th>
+</tr>
+<tr class="b"><td><a name="dims"></a>dims</td>
+<td>Davanum Srinivas</td>
+<td>-</td>
+<td>mentor, committer</td>
+</tr>
+<tr class="a"><td><a name="kevan"></a>kevan</td>
+<td>Kevan Miller</td>
+<td>-</td>
+<td>mentor</td>
+</tr>
+<tr class="b"><td><a name="stevel"></a>stevel</td>
+<td>Steve Loughran</td>
+<td>-</td>
+<td>mentor</td>
+</tr>
+<tr class="a"><td><a name="bluk"></a>bluk</td>
+<td>Bryant Luk</td>
+<td>IBM</td>
+<td>committer</td>
+</tr>
+<tr class="b"><td><a name="cjblythe"></a>cjblythe</td>
+<td>Christopher James Blythe</td>
+<td>-</td>
+<td>committer</td>
+</tr>
+<tr class="a"><td><a name="damrhei"></a>damrhei</td>
+<td>Dustin Amrhein</td>
+<td>-</td>
+<td>committer</td>
+</tr>
+<tr class="b"><td><a name="elib"></a>elib</td>
+<td>Eli Baram</td>
+<td>HP</td>
+<td>committer</td>
+</tr>
+<tr class="a"><td><a name="elman"></a>elman</td>
+<td>Elman Michael</td>
+<td>HP</td>
+<td>committer</td>
+</tr>
+<tr class="b"><td><a name="jdillon"></a>jdillon</td>
+<td>Jason Dillon</td>
+<td>-</td>
+<td>committer</td>
+</tr>
+<tr class="a"><td><a name="jramos"></a>jramos</td>
+<td>Jesse A. Ramos</td>
+<td>-</td>
+<td>committer</td>
+</tr>
+<tr class="b"><td><a name="martins"></a>martins</td>
+<td>Martin Snitkovsky</td>
+<td>HP</td>
+<td>committer</td>
+</tr>
+<tr class="a"><td><a name="nfischer"></a>nfischer</td>
+<td>Nadav Fischer</td>
+<td>HP</td>
+<td>committer</td>
+</tr>
+<tr class="b"><td><a name="ngallardo"></a>ngallardo</td>
+<td>Nicholas L. Gallardo</td>
+<td>IBM</td>
+<td>committer</td>
+</tr>
+<tr class="a"><td><a name="tomershadi"></a>tomershadi</td>
+<td>Tomer Shadi</td>
+<td>HP</td>
+<td>committer</td>
+</tr>
+</table>
+</div>
+<div class="section"><h3>Contributors</h3>
+<p>There are no contributors listed for this project. Please check back again later.</p>
+</div>
+</div>
 <script type="text/javascript">
 function offsetDate(id, offset) {
     var now = new Date();
