diff --git a/js-assembler/runtime-src/baselib-arity.js b/js-assembler/runtime-src/baselib-arity.js
index bec9790..3fc80d7 100644
--- a/js-assembler/runtime-src/baselib-arity.js
+++ b/js-assembler/runtime-src/baselib-arity.js
@@ -1,11 +1,14 @@
+/*jslint browser: false, unparam: true, vars: true, white: true, plusplus: true, maxerr: 50, indent: 4 */
+
 // Arity structure
 (function(baselib) {
+    'use strict';
     var exports = {};
     baselib.arity = exports;
 
 
 
-    var ArityAtLeast = plt.baselib.structs.makeStructureType(
+    var ArityAtLeast = baselib.structs.makeStructureType(
         'arity-at-least', false, 1, 0, false, false);
 
 
@@ -18,7 +21,7 @@
     var arityAtLeastValue = function(x) { 
         var val = ArityAtLeast.accessor(x, 0);
         return val;
-    }
+    };
 
 
     ArityAtLeast.type.prototype.toString = function() {
@@ -35,7 +38,7 @@
 	} else if (isArityAtLeast(arity)) {
 	    return n >= arityAtLeastValue(arity);
 	} else {
-	    while (arity !== plt.baselib.lists.EMPTY) {
+	    while (arity !== baselib.lists.EMPTY) {
 		if (typeof(arity.first) === 'number') {
 		    if (arity.first === n) { return true; }
 		} else if (isArityAtLeast(arity)) {
@@ -45,7 +48,7 @@
 	    }
 	    return false;
 	}
-    }
+    };
 
 
 
@@ -59,4 +62,4 @@
     exports.isArityMatching = isArityMatching;
     exports.arityAtLeastValue = arityAtLeastValue;
 
-})(this['plt'].baselib);
\ No newline at end of file
+}(this.plt.baselib));
\ No newline at end of file
diff --git a/js-assembler/runtime-src/baselib-boxes.js b/js-assembler/runtime-src/baselib-boxes.js
index acea599..f75053f 100644
--- a/js-assembler/runtime-src/baselib-boxes.js
+++ b/js-assembler/runtime-src/baselib-boxes.js
@@ -1,6 +1,10 @@
+/*jslint browser: true, unparam: true, vars: true, white: true, plusplus: true, maxerr: 50, indent: 4 */
+
+
 // Exceptions
 
 (function(baselib) {
+    'use strict';
     var exports = {};
     baselib.boxes = exports;
 
@@ -25,30 +29,30 @@
 
     Box.prototype.toString = function(cache) {
         cache.put(this, true);
-        return "#&" + plt.baselib.format.toWrittenString(this.val, cache);
+        return "#&" + baselib.format.toWrittenString(this.val, cache);
     };
 
     Box.prototype.toWrittenString = function(cache) {
         cache.put(this, true);
-        return "#&" + plt.baselib.format.toWrittenString(this.val, cache);
+        return "#&" + baselib.format.toWrittenString(this.val, cache);
     };
 
     Box.prototype.toDisplayedString = function(cache) {
         cache.put(this, true);
-        return "#&" + plt.baselib.format.toDisplayedString(this.val, cache);
+        return "#&" + baselib.format.toDisplayedString(this.val, cache);
     };
 
     Box.prototype.toDomNode = function(cache) {
         cache.put(this, true);
         var parent = document.createElement("span");
         parent.appendChild(document.createTextNode('#&'));
-        parent.appendChild(plt.baselib.format.toDomNode(this.val, cache));
+        parent.appendChild(baselib.format.toDomNode(this.val, cache));
         return parent;
     };
 
     Box.prototype.equals = function(other, aUnionFind) {
         return ((other instanceof Box) &&
-	        plt.baselib.equality.equals(this.val, other.val, aUnionFind));
+	        baselib.equality.equals(this.val, other.val, aUnionFind));
     };
     
     var makeBox = function(x) { 
@@ -83,4 +87,4 @@
     exports.makeImmutableBox = makeImmutableBox;
 
 
-})(this['plt'].baselib);
\ No newline at end of file
+}(this.plt.baselib));
\ No newline at end of file
diff --git a/js-assembler/runtime-src/baselib-bytes.js b/js-assembler/runtime-src/baselib-bytes.js
index 89e73be..d608ef1 100644
--- a/js-assembler/runtime-src/baselib-bytes.js
+++ b/js-assembler/runtime-src/baselib-bytes.js
@@ -1,5 +1,9 @@
-// Arity structure
+/*jslint unparam: true, vars: true, white: true, plusplus: true, maxerr: 50, indent: 4 */
+
+
+
 (function(baselib) {
+    'use strict';
     var exports = {};
     baselib.bytes = exports;
 
@@ -30,7 +34,7 @@
     };
 
     Bytes.prototype.subbytes = function(start, end) {
-	if (end == null || end == undefined) {
+	if (end === null || end === undefined) {
 	    end = this.bytes.length;
 	}
 	
@@ -42,23 +46,25 @@
         if (! (other instanceof Bytes)) {
 	    return false;
         }
-        if (this.bytes.length != other.bytes.length) {
+        if (this.bytes.length !== other.bytes.length) {
 	    return false;
         }
         var A = this.bytes;
         var B = other.bytes;
         var n = this.bytes.length;
-        for (var i = 0; i < n; i++) {
-	    if (A[i] !== B[i])
+        var i;
+        for (i = 0; i < n; i++) {
+	    if (A[i] !== B[i]) {
 	        return false;
+            }
         }
         return true;
     };
 
 
     Bytes.prototype.toString = function(cache) {
-	var ret = '';
-	for (var i = 0; i < this.bytes.length; i++) {
+	var ret = '', i;
+	for (i = 0; i < this.bytes.length; i++) {
 	    ret += String.fromCharCode(this.bytes[i]);
 	}
 
@@ -67,15 +73,6 @@
 
     Bytes.prototype.toDisplayedString = Bytes.prototype.toString;
 
-    Bytes.prototype.toWrittenString = function() {
-	var ret = ['#"'];
-	for (var i = 0; i < this.bytes.length; i++) {
-	    ret.push( escapeByte(this.bytes[i]) );
-	}
-	ret.push('"');
-	return ret.join('');
-    };
-
     var escapeByte = function(aByte) {
 	var ret = [];
 	var returnVal;
@@ -100,8 +97,18 @@
 	return returnVal;
     };
 
+    Bytes.prototype.toWrittenString = function() {
+	var ret = ['#"'], i;
+	for (i = 0; i < this.bytes.length; i++) {
+	    ret.push(escapeByte(this.bytes[i]));
+	}
+	ret.push('"');
+	return ret.join('');
+    };
+
+
 
 
     exports.Bytes = Bytes;
 
-})(this['plt'].baselib);
\ No newline at end of file
+}(this.plt.baselib));
\ No newline at end of file
diff --git a/js-assembler/runtime-src/baselib-check.js b/js-assembler/runtime-src/baselib-check.js
index e183dd2..dd1255e 100644
--- a/js-assembler/runtime-src/baselib-check.js
+++ b/js-assembler/runtime-src/baselib-check.js
@@ -1,56 +1,82 @@
+/*jslint vars: true, white: true, plusplus: true, maxerr: 50, indent: 4 */
+
+
 // Helper functions for argument checking.
 
-(function(baselib) {
+(function (baselib) {
     'use strict';
     var exports = {};
     baselib.check = exports;
 
-    var EMPTY = plt.baselib.lists.EMPTY;
-    var isPair = plt.baselib.lists.isPair;
-    var makeLowLevelEqHash = plt.baselib.hashes.makeLowLevelEqHash;
+    var EMPTY = baselib.lists.EMPTY;
+    var isPair = baselib.lists.isPair;
+    var makeLowLevelEqHash = baselib.hashes.makeLowLevelEqHash;
 
 
     //////////////////////////////////////////////////////////////////////
 
-    var makeCheckArgumentType = function(predicate, predicateName) {
-	return function(MACHINE, callerName, position) {
-	    testArgument(
-		MACHINE,
-		predicateName,
-		predicate,
-		MACHINE.env[MACHINE.env.length - 1 - position],
-		position,
-		callerName);
-	    return MACHINE.env[MACHINE.env.length - 1 - position];
-	}
+    // testArgument: (X -> boolean) X number string string -> boolean
+    // Produces true if val is true, and otherwise raises an error.
+    var testArgument = function (MACHINE,
+                                 expectedTypeName,
+                                 predicate,                          
+                                 val, 
+                                 index, 
+                                 callerName) {
+        if (predicate(val)) {
+            return true;
+        } else {
+            if (typeof(expectedTypeName) === 'function') { 
+                expectedTypeName = expectedTypeName(); 
+            }
+            baselib.exceptions.raiseArgumentTypeError(MACHINE, 
+                                                      callerName,
+                                                      expectedTypeName,
+                                                      index,
+                                                      val);
+        }
     };
 
-    var makeCheckParameterizedArgumentType = function(parameterizedPredicate, 
-                                                      parameterizedPredicateName) {
-	return function(MACHINE, callerName, position) {
-            var args = [];
-            for (var i = 3; i < arguments.length; i++) {
+
+    var makeCheckArgumentType = function (predicate, predicateName) {
+        return function (MACHINE, callerName, position) {
+            testArgument(
+                MACHINE,
+                predicateName,
+                predicate,
+                MACHINE.env[MACHINE.env.length - 1 - position],
+                position,
+                callerName);
+            return MACHINE.env[MACHINE.env.length - 1 - position];
+        };
+    };
+
+    var makeCheckParameterizedArgumentType = function (parameterizedPredicate, 
+                                                       parameterizedPredicateName) {
+        return function (MACHINE, callerName, position) {
+            var args = [], i;
+            for (i = 3; i < arguments.length; i++) {
                 args.push(arguments[i]);
             }
-	    testArgument(
-		MACHINE,
-		function() { parameterizedPredicateName.apply(null, args) },
-		function(x) {
+            testArgument(
+                MACHINE,
+                function () { parameterizedPredicateName.apply(null, args); },
+                function (x) {
                     return parameterizedPredicate.apply(null, [x].concat(args));
                 },
-		MACHINE.env[MACHINE.env.length - 1 - position],
-		position,
-		callerName);
-	    return MACHINE.env[MACHINE.env.length - 1 - position];
-	}
+                MACHINE.env[MACHINE.env.length - 1 - position],
+                position,
+                callerName);
+            return MACHINE.env[MACHINE.env.length - 1 - position];
+        };
     };
 
 
 
 
 
-    var makeCheckListofArgumentType = function(predicate, predicateName) {
-        var listPredicate = function(x) {
+    var makeCheckListofArgumentType = function (predicate, predicateName) {
+        var listPredicate = function (x) {
             var seen = makeLowLevelEqHash();
             while (true) {
                 if (x === EMPTY){
@@ -63,7 +89,7 @@
 
                 if(seen.containsKey(x)) {
                     // raise an error? we've got a cycle!
-                    return false
+                    return false;
                 }
 
                 if (! predicate(x.first)) {
@@ -74,16 +100,16 @@
                 x = x.rest;
             }
         };
-	return function(MACHINE, callerName, position) {
-	    testArgument(
-		MACHINE,
-		'list of ' + predicateName,
-		listPredicate,
-		MACHINE.env[MACHINE.env.length - 1 - position],
-		position,
-		callerName);
-	    return MACHINE.env[MACHINE.env.length - 1 - position];
-	}
+        return function (MACHINE, callerName, position) {
+            testArgument(
+                MACHINE,
+                'list of ' + predicateName,
+                listPredicate,
+                MACHINE.env[MACHINE.env.length - 1 - position],
+                position,
+                callerName);
+            return MACHINE.env[MACHINE.env.length - 1 - position];
+        };
     };
 
 
@@ -91,135 +117,111 @@
 
 
 
-    // testArgument: (X -> boolean) X number string string -> boolean
-    // Produces true if val is true, and otherwise raises an error.
-    var testArgument = function(MACHINE,
-				expectedTypeName,
-				predicate, 			    
-				val, 
-				index, 
-				callerName) {
-	if (predicate(val)) {
-	    return true;
-	} else {
-            if (typeof(expectedTypeName) === 'function') { 
-                expectedTypeName = expectedTypeName(); 
-            }
-	    plt.baselib.exceptions.raiseArgumentTypeError(MACHINE, 
-                                                          callerName,
-                                                          expectedTypeName,
-				                          index,
-				                          val);
-	}
-    };
 
-    var testArity = function(callerName, observed, minimum, maximum) {
-	if (observed < minimum || observed > maximum) {
-	    plt.baselib.exceptions.raise(
+    var testArity = function (MACHINE, callerName, observed, minimum, maximum) {
+        if (observed < minimum || observed > maximum) {
+            baselib.exceptions.raise(
                 MACHINE, new Error(callerName + ": expected at least " + minimum
-				   + " arguments "
-				   + " but received " + observed));
+                                   + " arguments "
+                                   + " but received " + observed));
 
-	}
+        }
     };
 
 
 
 
     var checkOutputPort = makeCheckArgumentType(
-        plt.baselib.ports.isOutputPort,
+        baselib.ports.isOutputPort,
         'output port');
 
     var checkSymbol = makeCheckArgumentType(
-	plt.baselib.symbols.isSymbol,
-	'symbol');
+        baselib.symbols.isSymbol,
+        'symbol');
 
     var checkString = makeCheckArgumentType(
-        plt.baselib.strings.isString,
+        baselib.strings.isString,
         'string');
 
     var checkMutableString = makeCheckArgumentType(
-        plt.baselib.strings.isMutableString,
+        baselib.strings.isMutableString,
         'mutable string');
 
     var checkChar = makeCheckArgumentType(
-        plt.baselib.chars.isChar,
+        baselib.chars.isChar,
         'character');
 
     var checkProcedure = makeCheckArgumentType(
-        plt.baselib.functions.isProcedure,
+        baselib.functions.isProcedure,
         'procedure');
 
     var checkNumber = makeCheckArgumentType(
-        plt.baselib.numbers.isNumber,
+        baselib.numbers.isNumber,
         'number');
 
     var checkReal = makeCheckArgumentType(
-        plt.baselib.numbers.isReal,
+        baselib.numbers.isReal,
         'real');
 
     var checkNatural = makeCheckArgumentType(
-        plt.baselib.numbers.isNatural,
+        baselib.numbers.isNatural,
         'natural');
 
     var checkByte = makeCheckArgumentType(
-        function(x) { return (typeof(x) === 'number' && 0 <= x && x < 256) },
+        baselib.numbers.isByte,
         'byte');
 
     var checkNaturalInRange = makeCheckParameterizedArgumentType(
-        function(x, a, b) {
-            if (! plt.baselib.numbers.isNatural(x)) { return false; }
-            return (plt.baselib.numbers.lessThanOrEqual(a, x) &&
-                    plt.baselib.numbers.lessThan(x, b));
+        function (x, a, b) {
+            if (! baselib.numbers.isNatural(x)) { return false; }
+            return (baselib.numbers.lessThanOrEqual(a, x) &&
+                    baselib.numbers.lessThan(x, b));
         },
-        function(a, b) {
-            return plt.baselib.format.format('natural between ~a and ~a', [a, b]);
+        function (a, b) {
+            return baselib.format.format('natural between ~a and ~a', [a, b]);
         });
 
     var checkInteger = makeCheckArgumentType(
-        plt.baselib.numbers.isInteger,
+        baselib.numbers.isInteger,
         'integer');
 
     var checkRational = makeCheckArgumentType(
-        plt.baselib.numbers.isRational,
+        baselib.numbers.isRational,
         'rational');
 
     var checkNonNegativeReal = makeCheckArgumentType(
-        plt.baselib.numbers.isNonNegativeReal,
+        baselib.numbers.isNonNegativeReal,
         'non-negative real');
 
     var checkPair = makeCheckArgumentType(
-        plt.baselib.lists.isPair,
+        baselib.lists.isPair,
         'pair');
 
     var checkList = makeCheckArgumentType(
-        plt.baselib.lists.isList,
+        baselib.lists.isList,
         'list');
 
     var checkVector = makeCheckArgumentType(
-        plt.baselib.vectors.isVector,
+        baselib.vectors.isVector,
         'vector');
 
     var checkBoolean = makeCheckArgumentType(
-        function(x) { return x === true || x === false; },
+        function (x) { return x === true || x === false; },
         'boolean');
 
     var checkBox = makeCheckArgumentType(
-        plt.baselib.boxes.isBox,
+        baselib.boxes.isBox,
         'box');
 
     var checkMutableBox = makeCheckArgumentType(
-        plt.baselib.boxes.isMutableBox,
+        baselib.boxes.isMutableBox,
         'mutable box');
 
     var checkInspector = makeCheckArgumentType(
-        plt.baselib.inspectors.isInspector,
+        baselib.inspectors.isInspector,
         'inspector');
 
 
-    var checkByte = makeCheckArgumentType(
-        plt.baselib.numbers.isByte,
-        'byte');