diff --git a/.bazelproject b/.bazelproject
index 4dc8ce1..af125c4 100644
--- a/.bazelproject
+++ b/.bazelproject
@@ -14,6 +14,11 @@
 directories:
   # Add the directories you want added as source here
   # By default, we've added your entire workspace ('.')
+  -examples/node/bazel-node
+  -examples/node/bazel-bin
+  -examples/node/bazel-genfiles
+  -examples/node/bazel-out
+  -examples/node/bazel-testlogs
   .
 
 targets:
diff --git a/examples/node/express/BUILD b/examples/node/express/BUILD
index ca38a89..9c1b022 100644
--- a/examples/node/express/BUILD
+++ b/examples/node/express/BUILD
@@ -25,7 +25,7 @@
 kt_js_library(
     name ="app",
     srcs = [":App.kt"],
-    deps = [":acme-routes"],
+    deps = [":acme-routes"]
 )
 
 # The binary demonstrates an express app composed of three modules. The modules can co-exist in the same directory.
diff --git a/examples/node/package.json b/examples/node/package.json
index 7ae63ad..4f1fe67 100644
--- a/examples/node/package.json
+++ b/examples/node/package.json
@@ -2,9 +2,7 @@
   "name": "node_packages",
   "version": "1.0.0",
   "dependencies": {
-    "express": "^4.16.3",
-    "kotlin": "1.2.60",
-    "kotlin-test": "1.2.60"
+    "express": "^4.16.3"
   },
   "devDependencies": {
     "source-map-support": "^0.5.6"
diff --git a/examples/node/yarn.lock b/examples/node/yarn.lock
index 06dda37..e01d70c 100644
--- a/examples/node/yarn.lock
+++ b/examples/node/yarn.lock
@@ -171,16 +171,6 @@
   version "1.8.0"
   resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-1.8.0.tgz#eaa33d6ddd7ace8f7f6fe0c9ca0440e706738b1e"
 
-kotlin-test@1.2.60:
-  version "1.2.60"
-  resolved "https://registry.yarnpkg.com/kotlin-test/-/kotlin-test-1.2.60.tgz#e238c48740a1c9f1c036d3c3db04d40f47c934db"
-  dependencies:
-    kotlin "1.2.60"
-
-kotlin@1.2.60:
-  version "1.2.60"
-  resolved "https://registry.yarnpkg.com/kotlin/-/kotlin-1.2.60.tgz#3d7ec2328a0d46281e21b9d7cf5314032217b010"
-
 media-typer@0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
diff --git a/kotlin/builder/src/io/bazel/kotlin/builder/tasks/js/Kotlin2JsTaskExecutor.kt b/kotlin/builder/src/io/bazel/kotlin/builder/tasks/js/Kotlin2JsTaskExecutor.kt
index 630bd4b..028130b 100644
--- a/kotlin/builder/src/io/bazel/kotlin/builder/tasks/js/Kotlin2JsTaskExecutor.kt
+++ b/kotlin/builder/src/io/bazel/kotlin/builder/tasks/js/Kotlin2JsTaskExecutor.kt
@@ -21,7 +21,6 @@
     private val invoker: KotlinToolchain.K2JSCompilerInvoker
 ) {
     fun execute(context: CompilationTaskContext, task: JsCompilationTask) {
-        context.print(Paths.get(task.inputs.kotlinSourcesList[0]).toRealPath().toAbsolutePath().toString())
         task.compile(context)
 
         val jsPath = Paths.get(task.outputs.js)
diff --git a/kotlin/internal/defs.bzl b/kotlin/internal/defs.bzl
index cde4313..62690d5 100644
--- a/kotlin/internal/defs.bzl
+++ b/kotlin/internal/defs.bzl
@@ -26,12 +26,10 @@
     },
 )
 
-# TODO when kt_js_import is capable of unpacking the jars and making the js and js_map files available then uncomment
-# the fields below.
 KtJsInfo = provider(
     fields = {
-        # "js": "The primary output of the library",
-        # "js_map": "The map file for the library",
+        "js": "The primary output of the library",
+        "js_map": "The map file for the library",
         "jar": "A jar of the library.",
         "srcjar": "The jar containing the sources of the library",
     },
diff --git a/kotlin/internal/js/BUILD b/kotlin/internal/js/BUILD
index 9c0f139..9f0a0ec 100644
--- a/kotlin/internal/js/BUILD
+++ b/kotlin/internal/js/BUILD
@@ -11,3 +11,9 @@
 # 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.
+
+py_binary(
+    name = "importer",
+    srcs = ["importer.py"],
+    visibility = ["//visibility:public"],
+)
diff --git a/kotlin/internal/js/impl.bzl b/kotlin/internal/js/impl.bzl
index d565ed6..46580fb 100644
--- a/kotlin/internal/js/impl.bzl
+++ b/kotlin/internal/js/impl.bzl
@@ -13,6 +13,7 @@
 # limitations under the License.
 load(
     "//kotlin/internal:defs.bzl",
+    _KT_COMPILER_REPO = "KT_COMPILER_REPO",
     _KtJsInfo = "KtJsInfo",
     _TOOLCHAIN_TYPE = "TOOLCHAIN_TYPE",
 )
@@ -55,6 +56,7 @@
         [
             "-source-map",
             "-meta-info",
+            "-no-stdlib",  # TODO remove this once the stdlib is not conveyed to node via the deps attribute.
             "-module-kind",
             ctx.attr.module_kind,
             "-target",
@@ -93,29 +95,51 @@
     return [
         DefaultInfo(
             files = depset([ctx.outputs.js, ctx.outputs.js_map]),
-            runfiles = ctx.runfiles(files = [
-                ctx.outputs.js,
-                ctx.outputs.js_map,
-            ]),
         ),
         _KtJsInfo(
+            js = ctx.outputs.js,
+            js_map = ctx.outputs.js_map,
             jar = ctx.outputs.jar,
             srcjar = ctx.outputs.srcjar,
         ),
     ]
 
-# This is just a placeholder at the moment.
 def kt_js_import_impl(ctx):
     if len(ctx.files.jars) != 1:
         fail("a single jar should be supplied, multiple jars not supported")
+    jar_file = ctx.files.jars[0]
 
-    files = depset(ctx.files.jars)
+    # Lock the jar name to the label name -- only make an exception for the compiler repo.
+    if not (ctx.label.workspace_root.startswith("external/") and ctx.label.workspace_root.endswith(_KT_COMPILER_REPO)):
+        expected_basename = "%s.jar" % ctx.label.name
+        if not jar_file.basename == expected_basename:
+            fail("label name %s is not the same as the jar name %s" % (jar_file.basename, expected_basename))
+
+    args = ctx.actions.args()
+    args.add("--jar", jar_file)
+    args.add("--out", ctx.outputs.js)
+    args.add("--aux", ctx.outputs.js_map)
+
+    inputs, _, input_manifest = ctx.resolve_command(tools = [ctx.attr._importer])
+    ctx.actions.run(
+        inputs = inputs + [jar_file],
+        executable = ctx.executable._importer,
+        outputs = [
+            ctx.outputs.js,
+            ctx.outputs.js_map,
+        ],
+        arguments = [args],
+        input_manifests = input_manifest,
+    )
+
     return [
         DefaultInfo(
-            files = files,
+            files = depset([ctx.outputs.js, ctx.outputs.js_map]),
         ),
         _KtJsInfo(
-            jar = ctx.attr.jars[0],
-            srcjar = ctx.attr.srcjar,
+            js = ctx.outputs.js,
+            js_map = ctx.outputs.js_map,
+            jar = jar_file,
+            srcjar = ctx.files.srcjar[0],
         ),
     ]
diff --git a/kotlin/internal/js/importer.py b/kotlin/internal/js/importer.py
new file mode 100644
index 0000000..7e54d50
--- /dev/null
+++ b/kotlin/internal/js/importer.py
@@ -0,0 +1,64 @@
+# Copyright 2018 The Bazel Authors. All rights reserved.
+#
+# 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.
+import argparse
+import os
+import zipfile
+
+
+def _is_jar(jar):
+    if not os.path.exists(jar):
+        raise argparse.ArgumentTypeError("jar:{0} does not exist".format(jar))
+    else:
+        return zipfile.ZipFile(jar)
+
+
+def _extract_root_entry(jar, entry_path, touch=False):
+    """
+    Extracts a root entry from a jar. and write it to a path.
+
+    entry_path is absolute and the basename is used to extract the entry from the jar.
+
+    :param jar: The jar from which to make the extraction.
+    :param entry_path: An absolute file path to where the entry should be written.
+    :param touch: Should the file be touched if it was not found in the jar.
+    """
+    basename = os.path.basename(entry_path)
+    try:
+        jar.read(basename)
+    except Exception as ex:
+        if touch:
+            f = open(entry_path, 'a')
+            f.close()
+            return
+        else:
+            raise ex
+    jar.extract(basename, path=os.path.dirname(entry_path))
+
+
+def _main(p):
+    args = p.parse_args()
+    _extract_root_entry(args.jar, args.out)
+    for e in args.aux:
+        _extract_root_entry(args.jar, e, touch=True)
+
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument("--jar", type=_is_jar, required=True)
+parser.add_argument("--out", required=True, help="mandatory paths to files that should be extracted from the root")
+parser.add_argument(
+    "--aux", nargs="*",
+    help="""paths to files that should be extracted from the root, if the files do not exist they are touched.""")
+
+_main(parser)
diff --git a/kotlin/internal/js/js.bzl b/kotlin/internal/js/js.bzl
index d7bdcf3..7360ebb 100644
--- a/kotlin/internal/js/js.bzl
+++ b/kotlin/internal/js/js.bzl
@@ -13,6 +13,7 @@
 # limitations under the License.
 load(
     "//kotlin/internal:defs.bzl",
+    _KT_COMPILER_REPO = "KT_COMPILER_REPO",
     _KtJsInfo = "KtJsInfo",
     _TOOLCHAIN_TYPE = "TOOLCHAIN_TYPE",
 )
@@ -22,6 +23,30 @@
     _kt_js_library_impl = "kt_js_library_impl",
 )
 
+_JS_STDLIB_MAP = {
+    "kotlin-stdlib-js": "kotlin",
+    "kotlin-test-js": "kotlin-test",
+}
+
+# The macro, and the ones using it exist to ensure compatibility with the nodejs rules, the nodejs rules process the
+# attributes and not the providers. Ideally providers would be used so the rules can pass the information along without
+# having to have user facing attributes visible.
+#   module_root: if the module_root is made settable then there is a possibility of collisions. Keeping it simple here.
+#   module_name: The require statement generated by Kotlinc-js seems to be based on the name of the jar. Unlike the jvm
+#       compiler, there is no 'module-name' flag available. So to keep things simple it's hard coded to the module name.
+def _lock_attrs(name, kwargs):
+    if native.repository_name().startswith("@") and native.repository_name().endswith(_KT_COMPILER_REPO):
+        name = _JS_STDLIB_MAP.get(name, default = name)
+    if kwargs.get("module_root") != None:
+        fail("The module_root is an internal attribute.")
+    else:
+        kwargs["module_root"] = name + ".js"
+    if kwargs.get("module_name") != None:
+        fail("module_name is an internal attribute.")
+    else:
+        kwargs["module_name"] = name
+    return kwargs
+
 kt_js_library = rule(
     attrs = {
         "srcs": attr.label_list(
@@ -29,8 +54,20 @@
             allow_files = [".kt"],
             mandatory = True,
         ),
+        "data": attr.label_list(
+            allow_files = True,
+            default = [],
+            cfg = "data",
+        ),
         "deps": attr.label_list(
             doc = """A list of other kotlin JS libraries.""",
+            default = [],
+            allow_empty = True,
+            providers = [_KtJsInfo],
+        ),
+        "runtime_deps": attr.label_list(
+            doc = """A list of other kotlin JS libraries that should be available at runtime.""",
+            default = [],
             allow_empty = True,
             providers = [_KtJsInfo],
         ),
@@ -51,6 +88,11 @@
             doc = "internal attribute",
             mandatory = False,
         ),
+        "_toolchain": attr.label(
+            doc = """The Kotlin JS Runtime.""",
+            default = Label("@" + _KT_COMPILER_REPO + "//:kotlin-stdlib-js"),
+            cfg = "target",
+        ),
     },
     implementation = _kt_js_library_impl,
     outputs = dict(
@@ -63,26 +105,13 @@
     provides = [_KtJsInfo],
 )
 
-# The macro exists to ensure compatibility with the nodejs rules, the nodejs rules process the attributes and not the
-# providers. Ideally providers would be used so the rules can pass the information along without having to have user
-# facing attributes visible.
-#   module_root: if the module_root is made settable then there is a possibility of collisions. Keeping it simple here.
-#   module_name: The require statement generated by Kotlinc-js seems to be based on the name of the jar. Unlike the jvm
-#       compiler, there is no 'module-name' flag available. So to keep things simple it's hard coded to the module name.
 def kt_js_library_macro(name, **kwargs):
-    if kwargs.get("module_root") != None:
-        fail("The module_root is an internal attribute.")
-    else:
-        kwargs["module_root"] = name + ".js"
+    kwargs = _lock_attrs(name, kwargs)
 
-    if kwargs.get("module_name") != None:
-        fail("module_name is an internal attribute.")
-    else:
-        kwargs["module_name"] = name
+    # TODO this is a runtime dep, it should be picked up from the _toolchain attr or from a provider.
+    kwargs["deps"] = kwargs.get("deps", []) + ["@" + _KT_COMPILER_REPO + "//:kotlin-stdlib-js"]
     kt_js_library(name = name, **kwargs)
 
-# TODO for Node the kotlin dependencies have to be provided via node_modules. The correct approach is to unpack the
-# the jars and make the js and js.map files available to node (via the module_root and module_name attributes?).
 kt_js_import = rule(
     attrs = {
         "jars": attr.label_list(
@@ -99,7 +128,29 @@
             allow_files = [".jar"],
             mandatory = False,
         ),
+        "module_name": attr.string(
+            doc = "internal attribute",
+            mandatory = False,
+        ),
+        "module_root": attr.string(
+            doc = "internal attriubte",
+            mandatory = False,
+        ),
+        "_importer": attr.label(
+            default = "//kotlin/internal/js:importer",
+            allow_files = True,
+            executable = True,
+            cfg = "host",
+        ),
     },
+    outputs = dict(
+        js = "%{module_name}.js",
+        js_map = "%{module_name}.js.map",
+    ),
     implementation = _kt_js_import_impl,
     provides = [_KtJsInfo],
 )
+
+def kt_js_import_macro(name, **kwargs):
+    kwargs = _lock_attrs(name, kwargs)
+    kt_js_import(name = name, **kwargs)
diff --git a/kotlin/internal/repositories/BUILD.com_github_jetbrains_kotlin b/kotlin/internal/repositories/BUILD.com_github_jetbrains_kotlin
index 315a242..9d11d95 100644
--- a/kotlin/internal/repositories/BUILD.com_github_jetbrains_kotlin
+++ b/kotlin/internal/repositories/BUILD.com_github_jetbrains_kotlin
@@ -82,7 +82,6 @@
         visibility = ["//visibility:public"],
     )
     for art in [
-        "jslib",
         "test-js",
         "stdlib-js",
     ]
diff --git a/kotlin/internal/toolchains.bzl b/kotlin/internal/toolchains.bzl
index a22cba6..1f37feb 100644
--- a/kotlin/internal/toolchains.bzl
+++ b/kotlin/internal/toolchains.bzl
@@ -56,7 +56,7 @@
             runtime_jars = ctx.files.jvm_runtime,
             use_ijar = False,
         ),
-        js_stdlibs = ctx.files.js_stdlibs,
+        js_stdlibs = ctx.attr.js_stdlibs,
     )
     return [
         platform_common.ToolchainInfo(**toolchain),
diff --git a/kotlin/kotlin.bzl b/kotlin/kotlin.bzl
index 09158d0..bdae1a8 100644
--- a/kotlin/kotlin.bzl
+++ b/kotlin/kotlin.bzl
@@ -32,8 +32,9 @@
 )
 load(
     "//kotlin/internal/js:js.bzl",
-    "kt_js_import",
+    _kt_js_import = "kt_js_import_macro",
     _kt_js_library = "kt_js_library_macro",
 )
 
 kt_js_library = _kt_js_library
+kt_js_import = _kt_js_import