diff --git a/spring-js/src/main/resources/META-INF/spring/Spring-Dojo.js.uncompressed.js b/spring-js/src/main/resources/META-INF/spring/Spring-Dojo.js.uncompressed.js
new file mode 100644
index 00000000..df320994
--- /dev/null
+++ b/spring-js/src/main/resources/META-INF/spring/Spring-Dojo.js.uncompressed.js
@@ -0,0 +1,378 @@
+/*
+ * Copyright 2004-2008 the original author or authors.
+ *
+ * Licensed 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.
+ */
+dojo.declare("Spring.DefaultEquals", null, {
+	equals : function(/*Object*/other){
+		if (other.declaredClass && other.declaredClass == this.declaredClass) {
+			return true;
+		}else{
+			return false;
+		}
+	}			
+});
+
+dojo.declare("Spring.ElementDecoration", [Spring.AbstractElementDecoration, Spring.DefaultEquals], {
+	constructor : function(config) {
+		this.copyFields = new Array('name', 'value', 'type', 'checked', 'selected', 'readOnly', 'disabled', 'alt', 'maxLength', 'class', 'title');
+		dojo.mixin(this, config);
+		if(this.widgetModule == "") {
+			this.widgetModule = this.widgetType;
+		}
+	},
+	
+	apply : function(){
+		if (dijit.byId(this.elementId)) {
+			dijit.byId(this.elementId).destroyRecursive(false);
+		}
+		var element = dojo.byId(this.elementId);
+		if (!element) {
+			console.error("Could not apply " + this.widgetType + " decoration.  Element with id '" + this.elementId + "' not found in the DOM.");
+		}
+		else {
+			for (var copyField in this.copyFields) {
+				copyField = this.copyFields[copyField];
+				if (!this.widgetAttrs[copyField] && element[copyField] &&
+				(typeof element[copyField] != 'number' ||
+				(typeof element[copyField] == 'number' && element[copyField] >= 0))) {
+					this.widgetAttrs[copyField] = element[copyField];
+				}
+			}
+			if(element['style'] && element['style'].cssText){
+				this.widgetAttrs['style'] = element['style'].cssText;
+			}
+			dojo.require(this.widgetModule);
+			var widgetConstructor = dojo.eval(this.widgetType);
+			this.widget = new widgetConstructor(this.widgetAttrs, element);
+			this.widget.startup();
+		}
+   		//return this to support method chaining
+   		return this;
+	},
+	
+	validate : function(){
+		if (!this.widget.isValid) {
+			// some widgets cannot be validated
+			return true;
+		}
+		var isValid = this.widget.isValid(false);
+		if (!isValid) {
+			this.widget.state = "Error";
+			this.widget._setStateClass();
+		}
+		return isValid;
+	}
+});
+
+dojo.declare("Spring.ValidateAllDecoration", [Spring.AbstractValidateAllDecoration, Spring.DefaultEquals], {
+	constructor : function(config) {
+		this.originalHandler = null;
+		this.connection = null;
+		dojo.mixin(this, config);
+	},
+	
+	apply : function() {
+		var element = dojo.byId(this.elementId);
+		this.originalHandler = element[this.event];
+		var context = this;
+		element[this.event] = function(event){
+			context.handleEvent(event, context);
+		};
+		return this;
+	},
+	
+	cleanup : function(){
+		dojo.disconnect(this.connection);
+	},
+	
+	handleEvent : function(event, context){
+		if (!Spring.validateAll()) {
+			dojo.stopEvent(event);
+		} else if(dojo.isFunction(context.originalHandler)) {
+			var result = context.originalHandler(event);
+			if (result == false) {
+				dojo.stopEvent(event);
+			}
+		}
+	}
+});
+
+dojo.declare("Spring.AjaxEventDecoration", [Spring.AbstractAjaxEventDecoration, Spring.DefaultEquals], {
+	constructor : function(config){
+		this.connection = null;
+		dojo.mixin(this, config);
+	},
+	
+	apply : function() {
+		this.connection = dojo.connect(dojo.byId(this.elementId), this.event, this, "submit");
+		return this;	
+	},
+	
+	cleanup : function(){
+		dojo.disconnect(this.connection);
+	},
+	
+	submit : function(event){
+		if (this.sourceId == ""){
+			this.sourceId = this.elementId;
+		}
+		if(this.formId == ""){
+			Spring.remoting.getLinkedResource(this.sourceId, this.params, this.popup);
+		} else {
+			Spring.remoting.submitForm(this.sourceId, this.formId, this.params);
+		}
+		dojo.stopEvent(event);
+	}
+});
+
+dojo.declare("Spring.RemotingHandler", Spring.AbstractRemotingHandler, {
+	constructor : function(){},
+	
+	submitForm : function(/*String */ sourceId, /*String*/formId, /*Object*/ params) {
+		var content = new Object();
+		for (var key in params) {
+			content[key] = params[key];
+		}
+		
+		var sourceComponent = dojo.byId(sourceId);
+	
+	    if (sourceComponent != null){
+	    	if(sourceComponent.value != undefined && sourceComponent.type && ("button,submit,reset").indexOf(sourceComponent.type) < 0) {
+				content[sourceId] = sourceComponent.value;
+			}
+			else if(sourceComponent.name != undefined) {
+	    		content[sourceComponent.name] = sourceComponent.name;
+	    	} else {
+	    		content[sourceId] = sourceId;
+	    	}
+	    }
+	    
+		if (!content['ajaxSource']) {
+			content['ajaxSource'] = sourceId;
+		}
+	    
+		dojo.xhrPost({
+			
+			content: content,
+			
+			form: formId,
+			
+			handleAs: "text",
+			
+			headers: {"Accept" : "text/html;type=ajax"},
+			
+			// The LOAD function will be called on a successful response.
+	        load: this.handleResponse,
+	
+	        // The ERROR function will be called in an error case.
+	        error: this.handleError
+        });	
+
+	},
+	
+	getLinkedResource: function(/*String */ linkId, /*Object*/params, /*boolean*/ modal) {
+		this.getResource(dojo.byId(linkId).href, params, modal);
+	},
+	
+	getResource: function(/*String */ resourceUri, /*Object*/params, /*boolean*/ modal) {
+		
+		dojo.xhrGet({
+			
+			url: resourceUri,
+			
+			content: params,
+			
+			handleAs: "text",
+			
+			headers: {"Accept" : "text/html;type=ajax"},
+			
+			load: this.handleResponse,
+			
+			error: this.handleError,
+			
+			modal: modal
+		});
+	},
+	
+	handleResponse: function(response, ioArgs) {
+		
+		//First check if this response should redirect
+		var redirectURL = ioArgs.xhr.getResponseHeader('Spring-Redirect-URL');
+		var modalViewHeader = ioArgs.xhr.getResponseHeader('Spring-Modal-View');
+		var modalView = ((dojo.isString(modalViewHeader) && modalViewHeader.length > 0) || ioArgs.args.modal);
+		
+		if (dojo.isString(redirectURL) && redirectURL.length > 0) {
+			if (modalView) {
+				//render a popup with the new URL
+				Spring.remoting.renderURLToModalDialog(redirectURL, ioArgs);
+				return response;
+			}
+			else {
+				if (redirectURL.indexOf("/") >= 0) {
+					window.location = window.location.protocol + "//" + window.location.host + redirectURL;
+				} else {
+					var location = window.location.protocol + "//" + window.location.host + window.location.pathname;
+					var appendIndex = location.lastIndexOf("/");
+					location = location.substr(0,appendIndex+1) + redirectURL;
+					if (location == window.location) {
+						Spring.remoting.getResource(location, ioArgs.args.content, false);
+					}
+					else {
+						window.location = location;
+					}
+				}
+				return response;
+			}
+		}
+		
+		//Extract and store all <script> elements from the response
+		var scriptPattern = '(?:<script(.|[\n|\r])*?>)((\n|\r|.)*?)(?:<\/script>)';
+		var extractedScriptNodes = [];
+		var matchAll = new RegExp(scriptPattern, 'img');
+		var matchOne = new RegExp(scriptPattern, 'im');
+	
+		var scriptNodes = response.match(matchAll);
+		if (scriptNodes != null)
+		{
+			for (var i=0; i<scriptNodes.length; i++)
+			{
+				var script = (scriptNodes[i].match(matchOne) || ['','',''])[2];
+				script = script.replace(/<!--/mg,'').replace(/\/\/-->/mg,'').replace(/<!\[CDATA\[(\/\/>)*/mg,'').replace(/(<!)*\]\]>/mg,'');
+				extractedScriptNodes.push(script);
+			}
+		}
+		response = response.replace(matchAll, '');
+
+		//Extract the new DOM nodes from the response
+		var tempSpan = dojo.doc.createElement("span");
+		tempSpan.id="ajaxResponse";
+		tempSpan.style.visibility= "hidden";
+		document.body.appendChild(tempSpan);
+		tempSpan.innerHTML=response;
+		var tempContainer = new dojo.NodeList(tempSpan);
+		var newNodes = tempContainer.query("#ajaxResponse > *").orphan();
+		tempContainer.orphan();
+	
+		//For a modal view, just dump the new nodes into a modal dialog
+		if (modalView) {
+			Spring.remoting.renderNodeListToModalDialog(newNodes);
+		}
+		else {
+			//Insert the new DOM nodes and update the Form's action URL
+			newNodes.forEach(function(item){
+				if (item.id != null && item.id != "") {
+					var target = dojo.byId(item.id);
+					if (!target) {
+						console.error("An existing DOM elment with id '" + item.id + "' could not be found for replacement.");
+					} else {
+						target.parentNode.replaceChild(item, target);
+					}
+				}
+			});
+		}
+		
+		//Evaluate any script code
+		dojo.forEach(extractedScriptNodes, function(script){
+			dojo.eval(script);
+		});
+		
+		return response;
+	},
+	
+	handleError: function(response, ioArgs) {
+		dojo.require("dijit.Dialog");
+		
+		console.error("HTTP status code: ", ioArgs.xhr.status);
+		
+		if (Spring.debug && ioArgs.xhr.status != 200) {
+			var dialog = new dijit.Dialog({});
+			dojo.connect(dialog, "hide", dialog, function(){
+				this.destroyRecursive(false);
+			});
+			dialog.domNode.style.width = "80%";
+			dialog.domNode.style.height = "80%";
+			dialog.domNode.style.textAlign = "left";
+			dialog.setContent(response.responseText);
+			dialog.show();
+		}
+		
+		return response;
+	},
+	
+	renderURLToModalDialog: function(url, ioArgs) {
+		url = url + "&"+dojo.objectToQuery(ioArgs.args.content);
+		
+		Spring.remoting.getResource(url, {}, true);
+	},
+	
+	renderNodeListToModalDialog: function(nodes) {
+		dojo.require("dijit.Dialog");
+		
+		var dialog = new dijit.Dialog({});
+		dialog.setContent(nodes);
+		dojo.connect(dialog, "hide", dialog, function(){
+			this.destroyRecursive(false);
+		});
+		dialog.show();
+	}
+});
+
+dojo.declare("Spring.CommandLinkDecoration", [Spring.AbstractCommandLinkDecoration, Spring.DefaultEquals], {
+	constructor : function(config){
+		dojo.mixin(this, config);
+	},
+	
+	apply : function(){
+		var advisedNode = dojo.byId(this.elementId);
+		if (!dojo.hasClass(advisedNode, "progressiveLink")) {
+			//Node must be replaced
+			var nodeToReplace = new dojo.NodeList(advisedNode);
+			nodeToReplace.addContent(this.linkHtml, "after").orphan("*");
+			//Get the new node
+			advisedNode = dojo.byId(this.elementId);
+		}
+		advisedNode.submitFormFromLink = this.submitFormFromLink;
+		//return this to support method chaining
+   		return this;
+	},
+	
+	submitFormFromLink : function(/*String*/ formId, /*String*/ sourceId, /*Array of name,value params*/ params){
+		var addedNodes = [];
+		var formNode = dojo.byId(formId);
+		var linkNode = document.createElement("input");
+		linkNode.name = sourceId;
+		linkNode.value = "submitted";
+		addedNodes.push(linkNode);
+		
+		dojo.forEach(params, function(param){
+			var paramNode = document.createElement("input");
+			paramNode.name=param.name;
+			paramNode.value=param.value;
+			addedNodes.push(paramNode);
+		});
+		
+		dojo.forEach(addedNodes, function(nodeToAdd){
+			dojo.addClass(nodeToAdd, "SpringLinkInput");
+			dojo.place(nodeToAdd, formNode, "last");
+		});		
+		
+		if ((formNode.onsubmit ? !formNode.onsubmit() : false) || !formNode.submit()) {
+			dojo.forEach(addedNodes, function(hiddenNode){
+				formNode.removeChild(hiddenNode);
+			});
+		}
+	}
+});
+
+dojo.addOnLoad(Spring.initialize);
\ No newline at end of file
diff --git a/spring-js/src/main/resources/META-INF/spring/Spring.js.uncompressed.js b/spring-js/src/main/resources/META-INF/spring/Spring.js.uncompressed.js
new file mode 100644
index 00000000..0cdfcd89
--- /dev/null
+++ b/spring-js/src/main/resources/META-INF/spring/Spring.js.uncompressed.js
@@ -0,0 +1,176 @@
+/*
+ * Copyright 2004-2008 the original author or authors.
+ *
+ * Licensed 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.
+ */
+Spring = {};
+
+Spring.debug = true;
+		
+Spring.decorations = {};
+
+Spring.decorations.applied = false;
+
+Spring.initialize = function(){
+	Spring.applyDecorations();
+	Spring.remoting = new Spring.RemotingHandler();
+};
+
+Spring.addDecoration = function(/*Object*/decoration){
+	//Spring.decorations.push(decoration);
+	
+	if (!Spring.decorations[decoration.elementId]) {
+		Spring.decorations[decoration.elementId] = [];
+		Spring.decorations[decoration.elementId].push(decoration);
+	} else {
+		var replaced = false;
+		for(var i = 0; i<Spring.decorations[decoration.elementId].length; i++) {
+			var existingDecoration = Spring.decorations[decoration.elementId][i];
+			if(existingDecoration.equals(decoration)) {
+				if (existingDecoration.cleanup != undefined) {
+					existingDecoration.cleanup();
+				}
+				Spring.decorations[decoration.elementId][i] = decoration;
+				replaced=true;
+				break;
+			}
+		}
+		if (!replaced) {
+			Spring.decorations[decoration.elementId].push(decoration);
+		}
+	}
+	
+	if(Spring.decorations.applied) {
+		decoration.apply();
+	}
+};
+		
+Spring.applyDecorations = function(){
+	if (!Spring.decorations.applied) {
+		for (var elementId in Spring.decorations) {
+			for (var x = 0; x < Spring.decorations[elementId].length; x++) {
+				Spring.decorations[elementId][x].apply();
+			}
+		}
+		Spring.decorations.applied = true;
+	}
+};
+
+Spring.validateAll = function(){
+	var valid = true;
+	for (var elementId in Spring.decorations) {
+		for (var x = 0; x < Spring.decorations[elementId].length; x++) {
+			if (Spring.decorations[elementId][x].widget && !Spring.decorations[elementId][x].validate()) {
+				valid = false;
+			}
+		}
+	}
+	return valid;
+};
+
+Spring.validateRequired = function(){
+	var valid = true;
+	for (var elementId in Spring.decorations) {
+		for (var x = 0; x < Spring.decorations[elementId].length; x++) {
+			if (Spring.decorations[elementId][x].widget && Spring.decorations[elementId][x].isRequired() && 
+			!Spring.decorations[elementId][x].validate()) {
+				valid = false;
+			}
+		}
+	}
+	return valid;
+};
+
+Spring.AbstractElementDecoration = function(){};
+
+Spring.AbstractElementDecoration.prototype = {
+	
+	elementId : "",
+	widgetType : "",
+	widgetModule : "",
+	widget : null,
+	widgetAttrs : {},
+	
+	apply : function(){},
+	
+	validate : function(){},
+	
+	isRequired : function(){},
+	
+	equals : function(/*Object*/other){}
+};
+
+Spring.AbstractValidateAllDecoration = function(){};
+
+Spring.AbstractValidateAllDecoration.prototype = {
+	
+	event : "",
+	elementId : "",
+	
+	apply : function() {},
+	
+	cleanup : function(){},
+	
+	handleEvent : function(event){},
+	
+	equals : function(/*Object*/other){}
+};
+
+Spring.AbstractCommandLinkDecoration = function(){};
+
+Spring.AbstractCommandLinkDecoration.prototype = {
+	
+	elementId : "",
+	linkHtml : "",
+	
+	apply : function(){},
+	
+	submitFormFromLink : function(/*String*/ formId, /*String*/ sourceId, /*Array of name,value params*/ params){},
+	
+	equals : function(/*Object*/other){}
+};
+
+Spring.AbstractAjaxEventDecoration = function(){};
+
+Spring.AbstractAjaxEventDecoration.prototype = {
+	
+	event : "",
+	elementId : "",
+	sourceId : "",
+	formId : "",
+	popup : false,
+	params : {},
+	
+	apply : function(){},
+	
+	cleanup : function(){},
+	
+	submit : function(event){},
+	
+	equals : function(/*Object*/other){}
+};
+
+Spring.AbstractRemotingHandler = function(){};
+
+Spring.AbstractRemotingHandler.prototype = {
+
+	submitForm : function(/*String */ sourceId, /*String*/formId, /*Object*/ params){}, 
+	
+	getLinkedResource: function(/*String */ linkId, /*Object*/params, /*boolean*/ modal) {},
+	
+	getResource : function(/*String */ resourceUri, /*Object*/params, /*boolean*/ modal) {},
+	
+	handleResponse : function() {},
+	
+	handleError : function() {}
+};