diff --git a/.travis.yml b/.travis.yml
index 61a9eecb5d..e15a321e46 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,7 +11,7 @@ os:
   - osx
 
 env:
-  - V=0.5.3
+  - V=0.12.0
 
 before_install:
   - |
@@ -33,14 +33,19 @@ before_install:
 
 script:
   - |
+    excludes=()
+    if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
+      # https://github.com/bazelbuild/rules_closure/issues/247
+      excludes+=('//closure/testing/test:noto_fonts_render_as_expected')
+    fi
+
+    targets=$(bazel query "... except set($excludes)")
     bazel \
       --output_base=$HOME/.cache/bazel \
       --batch \
       --host_jvm_args=-Xmx500m \
       --host_jvm_args=-Xms500m \
       test \
-      closure/... \
-      javatests/... \
       --worker_verbose \
       --verbose_failures \
       --test_output=errors \
@@ -48,7 +53,8 @@ script:
       --genrule_strategy=sandboxed \
       --local_resources=400,2,1.0 \
       --strategy=Javac=worker \
-      --strategy=Closure=worker
+      --strategy=Closure=worker \
+      $targets
 
 notifications:
   email: false
diff --git a/README.md b/README.md
index dc943033da..5dacc63566 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ JavaScript | Templating | Stylesheets | Miscellaneous
 --- | --- | --- | ---
 [closure_js_library] | [closure_js_template_library] | [closure_css_library] | [closure_js_proto_library]
 [closure_js_binary] | [closure_java_template_library] | [closure_css_binary] | [phantomjs_test]
-[closure_js_deps] | [closure_py_template_library] | |
+[closure_js_deps] | [closure_py_template_library] | | [closure_proto_library] \(Experimental\)
 [closure_js_test] | | |
 
 ## Overview
@@ -950,6 +950,30 @@ This rule can be referenced as though it were the following:
   - `IMPORT_ES6`        // import { member } from ''
 
 
+## closure\_proto\_library
+
+```python
+load("@io_bazel_rules_closure//closure:defs.bzl", "closure_proto_library")
+closure_proto_library(name, deps)
+```
+
+`closure_proto_library` generates JS code from `.proto` files.
+
+`deps` must point to [proto_library] rules.
+
+#### Rule Polymorphism
+
+This rule can be referenced as though it were the following:
+
+- [closure_js_library]: `srcs` will be the generated JS files,
+  and `deps` will contain necessary libraries.
+
+- **name:** ([Name]; required) A unique name for this rule. Convention states
+  that such rules be named `*_closure_proto`.
+
+- **deps:** (List of [labels]; required) The list of [proto_library] rules
+  to generate JS code for.
+
 [Bazel]: http://bazel.io/
 [Closure Compiler]: https://developers.google.com/closure/compiler/
 [Closure Library]: https://developers.google.com/closure/library/
@@ -980,6 +1004,7 @@ This rule can be referenced as though it were the following:
 [closure_js_proto_library]: #closure_js_proto_library
 [closure_js_template_library]: #closure_js_template_library
 [closure_js_test]: #closure_js_test
+[closure_proto_library]: #closure_proto_library
 [closure_py_template_library]: #closure_py_template_library
 [coffeescript]: http://coffeescript.org/
 [compiler-issue]: https://github.com/google/closure-compiler/issues/new
@@ -995,6 +1020,7 @@ This rule can be referenced as though it were the following:
 [output-wrapper-faq]: https://github.com/google/closure-compiler/wiki/FAQ#when-using-advanced-optimizations-closure-compiler-adds-new-variables-to-the-global-scope-how-do-i-make-sure-my-variables-dont-collide-with-other-scripts-on-the-page
 [phantomjs-bug]: https://github.com/ariya/phantomjs/issues/14028
 [phantomjs_test]: #phantomjs_test
+[proto_library]: https://docs.bazel.build/versions/master/be/protocol-buffer.html#proto_library
 [protobuf-generator]: https://github.com/google/protobuf/blob/master/src/google/protobuf/compiler/js/js_generator.h
 [protobuf-js]: https://github.com/google/protobuf/tree/master/js
 [repositories.bzl]: https://github.com/bazelbuild/rules_closure/tree/master/closure/repositories.bzl
diff --git a/closure/compiler/closure_js_binary.bzl b/closure/compiler/closure_js_binary.bzl
index 0521bd7e50..f2f8f61909 100644
--- a/closure/compiler/closure_js_binary.bzl
+++ b/closure/compiler/closure_js_binary.bzl
@@ -43,7 +43,8 @@ def _impl(ctx):
         ctx.attr.language, ", ".join(JS_LANGUAGES)))
 
   deps = unfurl(ctx.attr.deps, provider="closure_js_library")
-  js = collect_js(ctx, deps, css=ctx.attr.css)
+  js = collect_js(deps, ctx.file._closure_library_base,
+                  ctx.file._closure_library_deps, css=ctx.attr.css)
   if not js.srcs:
     fail("There are no JS source files in the transitive closure")
 
@@ -100,8 +101,11 @@ def _impl(ctx):
   # should be cut off. These are basically the same thing as C++ include dirs,
   # except unlike C++ there's no I/O operation penalty to using them since all
   # source paths that exist are being passed as flags.
-  js_module_roots = sort_roots(find_js_module_roots(ctx, [ctx.outputs.bin]) +
-                               js.js_module_roots)
+  js_module_roots = sort_roots(
+      find_js_module_roots(
+          [ctx.outputs.bin], ctx.workspace_name, ctx.label,
+          getattr(ctx.attr, "includes", [])) +
+      js.js_module_roots)
   for root in js_module_roots:
     args.append("--js_module_root")
     args.append(root)
@@ -199,7 +203,7 @@ def _impl(ctx):
 
   # Insert an edge into the build graph that produces the minified version of
   # all JavaScript sources in the transitive closure, sans dead code.
-  argfile = create_argfile(ctx, args)
+  argfile = create_argfile(ctx.actions, ctx.label.name, args)
   inputs.append(argfile)
   ctx.action(
       inputs=inputs,
diff --git a/closure/compiler/closure_js_deps.bzl b/closure/compiler/closure_js_deps.bzl
index 90c05b8174..2cdc4b6e2a 100644
--- a/closure/compiler/closure_js_deps.bzl
+++ b/closure/compiler/closure_js_deps.bzl
@@ -23,7 +23,7 @@ load("//closure/private:defs.bzl",
 
 def _impl(ctx):
   deps = unfurl(ctx.attr.deps, provider="closure_js_library")
-  js = collect_js(ctx, deps)
+  js = collect_js(deps)
   closure_root = _dirname(long_path(ctx, ctx.file._closure_library_base))
   closure_rel = '/'.join(['..' for _ in range(len(closure_root.split('/')))])
   outputs = [ctx.outputs.out]
diff --git a/closure/compiler/closure_js_library.bzl b/closure/compiler/closure_js_library.bzl
index becc678908..ec16bafa2d 100644
--- a/closure/compiler/closure_js_library.bzl
+++ b/closure/compiler/closure_js_library.bzl
@@ -33,28 +33,49 @@ load("//closure/private:defs.bzl",
 load("//closure/compiler:closure_js_aspect.bzl",
      "closure_js_aspect")
 
-def _closure_js_library(ctx):
-  if not ctx.files.srcs and not ctx.files.externs and not ctx.attr.exports:
-    fail("Either 'srcs' or 'exports' must be specified")
-  if not ctx.files.srcs and ctx.attr.deps:
-    fail("'srcs' must be set when using 'deps', otherwise consider 'exports'")
-  if ctx.attr.language:
-    print("The closure_js_library 'language' attribute is now removed and " +
-          "is always set to " + JS_LANGUAGE_IN)
+def _maybe_declare_file(actions, file, name):
+  if file:
+    return file
+  return actions.declare_file(name)
 
-  # Create a list of the sources defined by this specific rule.
-  srcs = ctx.files.srcs
-  if ctx.files.externs:
-    print("closure_js_library 'externs' is deprecated; just use 'srcs'")
-    srcs = ctx.files.externs + srcs
+def closure_js_library_impl(
+    actions, label, workspace_name,
+
+    srcs, deps, testonly, suppress,
+    closure_library_base, closure_library_deps, _ClosureWorker,
+
+    includes=[],
+    exports=depset(),
+    internal_descriptors=depset(),
+    convention='CLOSURE',
+    no_closure_library=False,
+    internal_expect_failure=False,
+
+    # These file definitions for our outputs are deprecated,
+    # and will be replaced with |actions.declare_file()| soon.
+    deprecated_info_file=None,
+    deprecated_stderr_file=None,
+    deprecated_ijs_file=None,
+    deprecated_typecheck_file=None):
+  # TODO(yannic): Figure out how to modify |find_js_module_roots|
+  # so that we won't need |workspace_name| anymore.
+
+  # TODO(yannic): Always use |actions.declare_file()|.
+  info_file = _maybe_declare_file(
+      actions, deprecated_info_file, '%s.pbtxt' % label.name)
+  stderr_file = _maybe_declare_file(
+      actions, deprecated_stderr_file, '%s-stderr.txt' % label.name)
+  ijs_file = _maybe_declare_file(
+      actions, deprecated_ijs_file, '%s.i.js' % label.name)
 
   # Create a list of direct children of this rule. If any direct dependencies
   # have the exports attribute, those labels become direct dependencies here.
-  deps = unfurl(ctx.attr.deps, provider="closure_js_library")
+  deps = unfurl(deps, provider="closure_js_library")
 
   # Collect all the transitive stuff the child rules have propagated. Bazel has
   # a special nested set data structure that makes this efficient.
-  js = collect_js(ctx, deps, bool(srcs), ctx.attr.no_closure_library)
+  js = collect_js(deps, closure_library_base, closure_library_deps,
+                  bool(srcs), no_closure_library)
 
   # If closure_js_library depends on closure_css_library, that means
   # goog.getCssName() is being used in srcs to reference CSS names in the
@@ -77,11 +98,11 @@ def _closure_js_library(ctx):
   # used by the Closure Compiler when producing the final JS binary.
   args = [
       "JsChecker",
-      "--label", str(ctx.label),
-      "--output", ctx.outputs.info.path,
-      "--output_errors", ctx.outputs.stderr.path,
-      "--output_ijs_file", ctx.outputs.ijs.path,
-      "--convention", ctx.attr.convention,
+      "--label", str(label),
+      "--output", info_file.path,
+      "--output_errors", stderr_file.path,
+      "--output_ijs_file", ijs_file.path,
+      "--convention", convention,
   ]
 
   # Because JsChecker is an edge in the build graph, we need to declare all of
@@ -91,19 +112,19 @@ def _closure_js_library(ctx):
   # We want to test the failure conditions of this rule from within Bazel,
   # rather than from a meta-system like shell scripts. In order to do that, we
   # need a way to toggle the return status of the process.
-  if ctx.attr.internal_expect_failure:
+  if internal_expect_failure:
     args.append("--expect_failure")
 
   # JsChecker wants to know if this is a testonly rule so it can throw an error
   # if goog.setTestOnly() is used.
-  if ctx.attr.testonly:
+  if testonly:
     args.append("--testonly")
 
   # The suppress attribute is a Closure Rules feature that makes warnings and
   # errors go away. It's a list of strings containing DiagnosticGroup (coarse
   # grained) or DiagnosticType (fine grained) codes. These apply not only to
   # JsChecker, but also propagate up to closure_js_binary.
-  for s in ctx.attr.suppress:
+  for s in suppress:
     args.append("--suppress")
     args.append(s)
 
@@ -124,7 +145,8 @@ def _closure_js_library(ctx):
   # module name is the same as the filename relative to the root of the
   # repository, ignoring the workspace name. The exception is when the includes
   # attribute is being used, which chops the path down even further.
-  js_module_roots = sort_roots(find_js_module_roots(ctx, srcs))
+  js_module_roots = sort_roots(
+      find_js_module_roots(srcs, workspace_name, label, includes))
   for root in js_module_roots:
     args.append("--js_module_root")
     args.append(root)
@@ -154,27 +176,29 @@ def _closure_js_library(ctx):
   # The list of flags could potentially be very long. So we're going to write
   # them all to a file which gets loaded automatically by our BazelWorker
   # middleware.
-  argfile = create_argfile(ctx, args)
+  argfile = create_argfile(actions, label.name, args) 
   inputs.append(argfile)
 
   # Add a JsChecker edge to the build graph. The command itself will only be
   # executed if something that requires its output is executed.
-  ctx.action(
+  actions.run(
       inputs=inputs,
-      outputs=[ctx.outputs.info, ctx.outputs.stderr, ctx.outputs.ijs],
-      executable=ctx.executable._ClosureWorker,
+      outputs=[info_file, stderr_file, ijs_file],
+      executable=_ClosureWorker,
       arguments=["@@" + argfile.path],
       mnemonic="Closure",
       execution_requirements={"supports-workers": "1"},
-      progress_message=make_jschecker_progress_message(srcs, ctx.label))
+      progress_message=make_jschecker_progress_message(srcs, label))
 
   library_level_checks(
-      ctx=ctx,
+      actions=actions,
+      label=label,
       ijs_deps=js.ijs_files,
       srcs=srcs,
-      executable=ctx.executable._ClosureWorker,
-      output=ctx.outputs.typecheck,
-      suppress=ctx.attr.suppress,
+      executable=_ClosureWorker,
+      output=_maybe_declare_file(
+          actions, deprecated_typecheck_file, '%s_typecheck' % label.name),
+      suppress=suppress,
   )
 
   # We now export providers to any parent Target. This is considered a public
@@ -199,7 +223,7 @@ def _closure_js_library(ctx):
       # the exports attribute does not exist. The exports feature can be abused
       # by users to circumvent strict deps checking and therefore should be
       # used with caution.
-      exports=unfurl(ctx.attr.exports),
+      exports=unfurl(exports),
       # All of the subproviders below are considered optional and MUST be
       # accessed using getattr(x, y, default). See collect_js() in defs.bzl.
       closure_js_library=struct(
@@ -208,13 +232,13 @@ def _closure_js_library(ctx):
           # as well as information extracted from inside the srcs files, e.g.
           # goog.provide'd namespaces. It is used for strict dependency
           # checking, a.k.a. layering checks.
-          info=ctx.outputs.info,
+          info=info_file,
           # NestedSet<File> of all info files in the transitive closure. This
           # is used by JsCompiler to apply error suppression on a file-by-file
           # basis.
-          infos=js.infos + [ctx.outputs.info],
-          ijs = ctx.outputs.ijs,
-          ijs_files = js.ijs_files + [ctx.outputs.ijs],
+          infos=js.infos + [info_file],
+          ijs = ijs_file,
+          ijs_files = js.ijs_files + [ijs_file],
           # NestedSet<File> of all JavaScript source File artifacts in the
           # transitive closure. These files MUST be JavaScript.
           srcs=js.srcs + srcs,
@@ -236,27 +260,72 @@ def _closure_js_library(ctx):
           # closure. It is used so Closure Templates can have information about
           # the structure of protobufs so they can be easily rendered in .soy
           # files with type safety. See closure_js_template_library.bzl.
-          descriptors=js.descriptors + ctx.files.internal_descriptors,
+          descriptors=js.descriptors + internal_descriptors,
           # NestedSet<Label> of all closure_css_library rules in the transitive
           # closure. This is used by closure_js_binary can guarantee the
           # completeness of goog.getCssName() substitutions.
           stylesheets=js.stylesheets + stylesheets,
           # Boolean indicating indicating if Closure Library's base.js is part
           # of the srcs subprovider. This field exists for optimization.
-          has_closure_library=js.has_closure_library),
+          has_closure_library=js.has_closure_library))
+
+def _closure_js_library(ctx):
+  if not ctx.files.srcs and not ctx.files.externs and not ctx.attr.exports:
+    fail("Either 'srcs' or 'exports' must be specified")
+  if not ctx.files.srcs and ctx.attr.deps:
+    fail("'srcs' must be set when using 'deps', otherwise consider 'exports'")
+  if ctx.attr.language:
+    print("The closure_js_library 'language' attribute is now removed and " +
+          "is always set to " + JS_LANGUAGE_IN)
+
+  # Create a list of the sources defined by this specific rule.
+  srcs = ctx.files.srcs
+  if ctx.files.externs:
+    print("closure_js_library 'externs' is deprecated; just use 'srcs'")
+    srcs = ctx.files.externs + srcs
+
+  library = closure_js_library_impl(
+      ctx.actions, ctx.label, ctx.workspace_name,
+      srcs, ctx.attr.deps, ctx.attr.testonly, ctx.attr.suppress,
+
+      ctx.file._closure_library_base,
+      ctx.file._closure_library_deps,
+      ctx.executable._ClosureWorker,
+
+      getattr(ctx.attr, "includes", []),
+      ctx.attr.exports,
+      ctx.files.internal_descriptors,
+      ctx.attr.convention,
+      ctx.attr.no_closure_library,
+      ctx.attr.internal_expect_failure,
+
+      # Deprecated output files.
+      ctx.outputs.info, ctx.outputs.stderr,
+      ctx.outputs.ijs, ctx.outputs.typecheck)
+
+  return struct(
+      files = library.files,
+      exports = library.exports,
+      closure_js_library=library.closure_js_library,
       # The usual suspects are exported as runfiles, in addition to raw source.
       runfiles=ctx.runfiles(
           files=srcs + ctx.files.data,
           transitive_files=(depset([] if ctx.attr.no_closure_library
                                 else [ctx.file._closure_library_base,
                                       ctx.file._closure_library_deps]) |
-                            collect_runfiles(deps) |
+                            collect_runfiles(
+                                unfurl(ctx.attr.deps,
+                                       provider="closure_js_library")) |
                             collect_runfiles(ctx.attr.data))))
 
 closure_js_library = rule(
     implementation=_closure_js_library,
     attrs={
-        "convention": attr.string(default="CLOSURE"),
+        "convention": attr.string(
+            default="CLOSURE",
+            # TODO(yannic): Define valid values.
+            # values=["CLOSURE"],
+        ),
         "data": attr.label_list(cfg="data", allow_files=True),
         "deps": attr.label_list(
             aspects=[closure_js_aspect],
@@ -280,6 +349,8 @@ closure_js_library = rule(
         "_closure_library_base": CLOSURE_LIBRARY_BASE_ATTR,
         "_closure_library_deps": CLOSURE_LIBRARY_DEPS_ATTR,
     },
+    # TODO(yannic): Deprecate.
+    #     https://docs.bazel.build/versions/master/skylark/lib/globals.html#rule.outputs
     outputs={
         "info": "%{name}.pbtxt",
         "stderr": "%{name}-stderr.txt",
diff --git a/closure/defs.bzl b/closure/defs.bzl
index c0bb2affe8..25a0bd7450 100644
--- a/closure/defs.bzl
+++ b/closure/defs.bzl
@@ -18,6 +18,7 @@ load("//closure/compiler:closure_js_deps.bzl", "closure_js_deps")
 load("//closure/compiler:closure_js_library.bzl", "closure_js_library")
 load("//closure/private:files_equal_test.bzl", "files_equal_test")
 load("//closure/protobuf:closure_js_proto_library.bzl", "closure_js_proto_library")
+load("//closure/protobuf:closure_proto_library.bzl", "closure_proto_library")
 load("//closure/stylesheets:closure_css_binary.bzl", "closure_css_binary")
 load("//closure/stylesheets:closure_css_library.bzl", "closure_css_library")
 load("//closure/templates:closure_java_template_library.bzl", "closure_java_template_library")
diff --git a/closure/private/defs.bzl b/closure/private/defs.bzl
index cc004bf026..dfc595b7e8 100644
--- a/closure/private/defs.bzl
+++ b/closure/private/defs.bzl
@@ -58,7 +58,9 @@ def unfurl(deps, provider=""):
           res.append(edep)
   return res
 
-def collect_js(ctx, deps,
+def collect_js(deps,
+               closure_library_base=None,
+               closure_library_deps=None,
                has_direct_srcs=False,
                no_closure_library=False,
                css=None):
@@ -87,13 +89,12 @@ def collect_js(ctx, deps,
       fail("no_closure_library can't be used when Closure Library is " +
            "already part of the transitive closure")
   elif has_direct_srcs and not has_closure_library:
-    tmp = depset([ctx.file._closure_library_base,
-               ctx.file._closure_library_deps])
+    tmp = depset([closure_library_base, closure_library_deps])
     tmp += srcs
     srcs = tmp
     has_closure_library = True
   if css:
-    tmp = depset([ctx.file._closure_library_base,
+    tmp = depset([closure_library_base,
                css.closure_css_binary.renaming_map])
     tmp += srcs
     srcs = tmp
@@ -139,7 +140,7 @@ def collect_runfiles(targets):
       data += target.default_runfiles.files
   return data
 
-def find_js_module_roots(ctx, srcs):
+def find_js_module_roots(srcs, workspace_name, label, includes):
   """Finds roots of JavaScript sources.
 
   This discovers --js_module_root paths for direct srcs that deviate from the
@@ -155,23 +156,23 @@ def find_js_module_roots(ctx, srcs):
   roots = depset([f.root.path for f in srcs if f.root.path])
   # Bazel started prefixing external repo paths with ../
   new_bazel_version = Label('@foo//bar').workspace_root.startswith('../')
-  if ctx.workspace_name != "__main__":
+  if workspace_name != "__main__":
     if new_bazel_version:
       roots += ["%s" % root for root in roots]
-      roots += ["../%s" % ctx.workspace_name]
+      roots += ["../%s" % workspace_name]
     else:
-      roots += ["%s/external/%s" % (root, ctx.workspace_name) for root in roots]
-      roots += ["external/%s" % ctx.workspace_name]
-  if getattr(ctx.attr, "includes", []):
+      roots += ["%s/external/%s" % (root, workspace_name) for root in roots]
+      roots += ["external/%s" % workspace_name]
+  if includes:
     for f in srcs:
-      if f.owner.package != ctx.label.package:
+      if f.owner.package != label.package:
         fail("Can't have srcs from a different package when using includes")
     magic_roots = []
-    for include in ctx.attr.includes:
+    for include in includes:
       if include == ".":
-        prefix = ctx.label.package
+        prefix = label.package
       else:
-        prefix = "%s/%s" % (ctx.label.package, include)
+        prefix = "%s/%s" % (label.package, include)
         found = False
         for f in srcs:
           if f.owner.name.startswith(include + "/"):
@@ -215,15 +216,13 @@ def long_path(ctx, file_):
     return file_.owner.workspace_root + "/" + file_.short_path
   return ctx.workspace_name + "/" + file_.short_path
 
-def create_argfile(ctx, args):
-  bin_dir = ctx.configuration.bin_dir
-  if hasattr(ctx, 'bin_dir'):
-    bin_dir = ctx.bin_dir
-  argfile = ctx.new_file(bin_dir, "%s_worker_input" % ctx.label.name)
-  ctx.file_action(output=argfile, content="\n".join(args))
+def create_argfile(actions, name, args):
+  argfile = actions.declare_file("%s_worker_input" % name)
+  actions.write(output=argfile, content="\n".join(args))
   return argfile
 
-def library_level_checks(ctx, ijs_deps, srcs, executable, output, suppress = []):
+def library_level_checks(
+    actions, label, ijs_deps, srcs, executable, output, suppress = []):
   args = [
       "JsCompiler",
       "--checks_only",
@@ -244,10 +243,10 @@ def library_level_checks(ctx, ijs_deps, srcs, executable, output, suppress = [])
   for s in suppress:
     args.append("--suppress")
     args.append(s)
-  ctx.action(
+  actions.run(
       inputs=inputs,
       outputs=[output],
       executable=executable,
       arguments=args,
       mnemonic="LibraryLevelChecks",
-      progress_message="Doing library-level typechecking of " + str(ctx.label))
+      progress_message="Doing library-level typechecking of " + str(label))
diff --git a/closure/protobuf/closure_proto_library.bzl b/closure/protobuf/closure_proto_library.bzl
new file mode 100644
index 0000000000..e7fba1aff2
--- /dev/null
+++ b/closure/protobuf/closure_proto_library.bzl
@@ -0,0 +1,167 @@
+# Copyright 2018 The Closure Rules 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.
+
+"""Utilities for building JavaScript Protocol Buffers.
+"""
+
+load("//closure/compiler:closure_js_library.bzl", "closure_js_library_impl")
+load("//closure/private:defs.bzl",
+     "CLOSURE_WORKER_ATTR",
+     "CLOSURE_LIBRARY_BASE_ATTR",
+     "CLOSURE_LIBRARY_DEPS_ATTR",
+     "unfurl")
+
+# This was taken from https://github.com/bazelbuild/rules_go/blob/67f44035d84a352cffb9465159e199066ecb814c/proto/compiler.bzl#L72
+def _proto_path(proto):
+  path = proto.path
+  root = proto.root.path
+  ws = proto.owner.workspace_root
+  if path.startswith(root):
+    path = path[len(root):]
+  if path.startswith("/"):
+    path = path[1:]
+  if path.startswith(ws):
+    path = path[len(ws):]
+  if path.startswith("/"):
+    path = path[1:]
+  return path
+
+def _proto_include_path(proto):
+  path = proto.path[:-len(_proto_path(proto))]
+  if not path:
+    return '.'
+  if path.endswith("/"):
+    path = path[:-1]
+  return path
+
+def _proto_include_paths(protos):
+  return depset([_proto_include_path(proto) for proto in protos])
+
+def _generate_closure_js_progress_message(name):
+  # TODO(yannic): Add a better message?
+  return 'Generating JavaScript Protocol Buffer %s' % name
+
+def _generate_closure_js(target, ctx):
+  # Support only `import_style=closure`, and always add
+  # |goog.require()| for enums.
+  js_out_options = [
+      'import_style=closure',
+      'library=%s' % ctx.label.name,
+      'add_require_for_enums',
+  ]
+  if getattr(ctx.rule.attr, 'testonly', False):
+    js_out_options.append('testonly')
+  js = ctx.actions.declare_file('%s.js' % ctx.label.name)
+
+  # Add include paths for all proto files,
+  # to avoid copying/linking the files for every target.
+  protos = target.proto.transitive_imports
+  args = ['-I%s' % p for p in _proto_include_paths(protos)]
+
+  out_options = ','.join(js_out_options)
+  out_path = '/'.join(js.path.split('/')[:-1])
+  args += ['--js_out=%s:%s' % (out_options, out_path)]
+
+  # Add paths of protos we generate files for.
+  args += [file.path for file in target.proto.direct_sources]
+
+  ctx.actions.run(
+      inputs = protos,
+      outputs = [js],
+      executable = ctx.executable._protoc,
+      arguments = args,
+      progress_message =
+          _generate_closure_js_progress_message(ctx.rule.attr.name),
+  )
+
+  return js
+
+def _closure_proto_aspect_impl(target, ctx):
+  js = _generate_closure_js(target, ctx)
+
+  srcs = depset([js])
+  deps = unfurl(ctx.rule.attr.deps, provider="closure_js_library")
+  deps += [ctx.attr._closure_library, ctx.attr._closure_protobuf_jspb]
+
+  suppress = [
+      "analyzerChecks",
+      "missingOverride",
+      "missingProperties",
+      "reportUnknownTypes",
+      "unusedLocalVariables",
+  ]
+
+  library = closure_js_library_impl(
+      ctx.actions, ctx.label, ctx.workspace_name,
+      srcs, deps, ctx.rule.attr.testonly, suppress,
+
+      ctx.file._closure_library_base,
+      ctx.file._closure_library_deps,
+      ctx.executable._ClosureWorker)
+  return struct(
+      exports = library.exports,
+      closure_js_library=library.closure_js_library,
+      # The usual suspects are exported as runfiles, in addition to raw source.
+      runfiles=ctx.runfiles(files=[js]))
+
+_closure_proto_aspect = aspect(
+    attr_aspects = ['deps'],
+    attrs = {
+        # internal only
+        "_protoc": attr.label(
+            default = Label("@com_google_protobuf//:protoc"),
+            executable = True,
+            cfg = "host",
+        ),
+        "_ClosureWorker": CLOSURE_WORKER_ATTR,
+        "_closure_library_base": CLOSURE_LIBRARY_BASE_ATTR,
+        "_closure_library_deps": CLOSURE_LIBRARY_DEPS_ATTR,
+        "_closure_library": attr.label(
+            default = Label("//closure/library"),
+        ),
+        "_closure_protobuf_jspb": attr.label(
+            default = Label("//closure/protobuf:jspb"),
+        ),
+    },
+    implementation = _closure_proto_aspect_impl,
+)
+
+_error_multiple_deps = ''.join([
+  "'deps' attribute must contain exactly one label ",
+  "(we didn't name it 'dep' for consistency). ",
+  "We may revisit this restriction later.",
+])
+
+def _closure_proto_library_impl(ctx):
+  if len(ctx.attr.deps) > 1:
+    # TODO(yannic): Revisit this restriction.
+    fail(_error_multiple_deps, 'deps');
+
+  dep = ctx.attr.deps[0]
+  return struct(
+      files=depset(),
+      exports=dep.exports,
+      closure_js_library=dep.closure_js_library,
+  )
+
+closure_proto_library = rule(
+    attrs = {
+        'deps': attr.label_list(
+            mandatory = True,
+            providers = ['proto'],
+            aspects = [_closure_proto_aspect],
+        ),
+    },
+    implementation = _closure_proto_library_impl,
+)
diff --git a/closure/protobuf/test/BUILD.bazel b/closure/protobuf/test/BUILD.bazel
new file mode 100644
index 0000000000..73f7c32abc
--- /dev/null
+++ b/closure/protobuf/test/BUILD.bazel
@@ -0,0 +1,99 @@
+# Copyright 2018 The Closure Rules 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.
+
+package(default_testonly = True)
+
+licenses(["notice"])  # Apache 2.0
+
+load("//closure/compiler:closure_js_library.bzl", "closure_js_library")
+load("//closure/protobuf:closure_proto_library.bzl", "closure_proto_library")
+load("//closure/testing:closure_js_test.bzl", "closure_js_test")
+
+proto_library(
+    name = "foo_proto",
+    srcs = ["foo.proto"],
+)
+
+closure_proto_library(
+    name = "foo_closure_proto",
+    deps = [":foo_proto"],
+)
+
+closure_js_library(
+    name = "foo",
+    srcs = [
+        "foo.js",
+    ],
+    deps = [
+        ":foo_closure_proto",
+    ],
+)
+
+closure_js_test(
+    name = "foo_test",
+    timeout = "short",
+    srcs = [
+        "foo_test.js",
+    ],
+    entry_points = [
+        "goog:io.bazel.rules.closure.protobuf.FooTest",
+    ],
+    deps = [
+        ":foo",
+        "@io_bazel_rules_closure//closure/library:testing",
+    ],
+)
+
+proto_library(
+    name = "bar_proto",
+    srcs = ["bar.proto"],
+    deps = [":foo_proto"],
+)
+
+proto_library(
+    name = "baz_proto",
+    srcs = ["baz.proto"],
+    deps = [":bar_proto"],
+)
+
+closure_proto_library(
+    name = "baz_closure_proto",
+    deps = [":baz_proto"],
+)
+
+closure_js_library(
+    name = "baz",
+    srcs = [
+        "baz.js",
+    ],
+    deps = [
+        ":baz_closure_proto",
+    ],
+)
+
+closure_js_test(
+    name = "baz_test",
+    timeout = "short",
+    srcs = [
+        "baz_test.js",
+    ],
+    entry_points = [
+        "goog:io.bazel.rules.closure.protobuf.BazTest",
+    ],
+    deps = [
+        ":baz",
+        ":foo",
+        "@io_bazel_rules_closure//closure/library:testing",
+    ],
+)
diff --git a/closure/protobuf/test/bar.proto b/closure/protobuf/test/bar.proto
new file mode 100644
index 0000000000..8e0f2e4636
--- /dev/null
+++ b/closure/protobuf/test/bar.proto
@@ -0,0 +1,23 @@
+// Copyright 2018 The Closure Rules 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.
+
+syntax = "proto3";
+
+package io.bazel.rules.closure.protobuf;
+
+import 'closure/protobuf/test/foo.proto';
+
+message Bar {
+  Foo foo = 1;
+}
diff --git a/closure/protobuf/test/baz.js b/closure/protobuf/test/baz.js
new file mode 100644
index 0000000000..f80818ad4c
--- /dev/null
+++ b/closure/protobuf/test/baz.js
@@ -0,0 +1,45 @@
+// Copyright 2018 The Closure Rules 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.
+
+goog.module('io.bazel.rules.closure.protobuf.Baz');
+
+const PbBaz = goog.require('proto.io.bazel.rules.closure.protobuf.Baz');
+
+
+
+exports = class {
+  /**
+   * Creates a new Foo.
+   *
+   * @param {string} field Value to set for "field".
+   */
+  constructor(field) {
+    /**
+     * @private
+     * @const {!PbBaz}
+     */
+    this.message_ = new PbBaz();
+    this.message_.setBaz(field);
+  }
+
+
+  /**
+   * Return value of "field".
+   *
+   * @return {string}
+   */
+  field() {
+    return this.message_.getBaz();
+  }
+};
diff --git a/closure/protobuf/test/baz.proto b/closure/protobuf/test/baz.proto
new file mode 100644
index 0000000000..83bebcd6c2
--- /dev/null
+++ b/closure/protobuf/test/baz.proto
@@ -0,0 +1,24 @@
+// Copyright 2018 The Closure Rules 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.
+
+syntax = "proto3";
+
+package io.bazel.rules.closure.protobuf;
+
+import 'closure/protobuf/test/bar.proto';
+
+message Baz {
+  string baz = 1;
+  Bar bar = 2;
+}
diff --git a/closure/protobuf/test/baz_test.js b/closure/protobuf/test/baz_test.js
new file mode 100644
index 0000000000..4da6da34da
--- /dev/null
+++ b/closure/protobuf/test/baz_test.js
@@ -0,0 +1,39 @@
+// Copyright 2018 The Closure Rules 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.
+
+goog.module('io.bazel.rules.closure.protobuf.BazTest');
+goog.setTestOnly('io.bazel.rules.closure.protobuf.BazTest');
+
+const Baz = goog.require('io.bazel.rules.closure.protobuf.Baz');
+const Foo = goog.require('io.bazel.rules.closure.protobuf.Foo');
+const testSuite = goog.require('goog.testing.testSuite');
+
+
+
+class BazTest {
+  /** @return {void} */
+  testField() {
+    const baz = new Baz('value');
+    assertEquals('value', baz.field());
+  }
+
+
+  /** @return {void} */
+  testFooField() {
+    // This test verifies that we 
+    const foo = new Foo('value');
+    assertEquals('value', foo.field());
+  }
+}
+testSuite(new BazTest());
diff --git a/closure/protobuf/test/foo.js b/closure/protobuf/test/foo.js
new file mode 100644
index 0000000000..bc1fc817a6
--- /dev/null
+++ b/closure/protobuf/test/foo.js
@@ -0,0 +1,45 @@
+// Copyright 2018 The Closure Rules 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.
+
+goog.module('io.bazel.rules.closure.protobuf.Foo');
+
+const PbFoo = goog.require('proto.io.bazel.rules.closure.protobuf.Foo');
+
+
+
+exports = class {
+  /**
+   * Creates a new Foo.
+   *
+   * @param {string} field Value to set for "field".
+   */
+  constructor(field) {
+    /**
+     * @private
+     * @const {!PbFoo}
+     */
+    this.message_ = new PbFoo();
+    this.message_.setFoo(field);
+  }
+
+
+  /**
+   * Return value of "field".
+   *
+   * @return {string}
+   */
+  field() {
+    return this.message_.getFoo();
+  }
+};
diff --git a/closure/protobuf/test/foo.proto b/closure/protobuf/test/foo.proto
new file mode 100644
index 0000000000..4b09975adb
--- /dev/null
+++ b/closure/protobuf/test/foo.proto
@@ -0,0 +1,21 @@
+// Copyright 2018 The Closure Rules 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.
+
+syntax = "proto3";
+
+package io.bazel.rules.closure.protobuf;
+
+message Foo {
+  string foo = 1;
+}
diff --git a/closure/protobuf/test/foo_test.js b/closure/protobuf/test/foo_test.js
new file mode 100644
index 0000000000..e842cff690
--- /dev/null
+++ b/closure/protobuf/test/foo_test.js
@@ -0,0 +1,33 @@
+// Copyright 2018 The Closure Rules 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.
+
+goog.module('io.bazel.rules.closure.protobuf.FooTest');
+goog.setTestOnly('io.bazel.rules.closure.protobuf.FooTest');
+
+const Foo = goog.require('io.bazel.rules.closure.protobuf.Foo');
+const testSuite = goog.require('goog.testing.testSuite');
+
+
+
+class FooTest {
+  /**
+   * @return {void}
+   * @suppress {visibility}
+   */
+  testField() {
+    const foo = new Foo('value');
+    assertEquals('value', foo.field());
+  }
+}
+testSuite(new FooTest());
diff --git a/closure/protobuf/test/BUILD b/closure/protobuf/test/legacy/BUILD
similarity index 100%
rename from closure/protobuf/test/BUILD
rename to closure/protobuf/test/legacy/BUILD
diff --git a/closure/protobuf/test/example.js b/closure/protobuf/test/legacy/example.js
similarity index 100%
rename from closure/protobuf/test/example.js
rename to closure/protobuf/test/legacy/example.js
diff --git a/closure/protobuf/test/example.proto b/closure/protobuf/test/legacy/example.proto
similarity index 100%
rename from closure/protobuf/test/example.proto
rename to closure/protobuf/test/legacy/example.proto
diff --git a/closure/protobuf/test/example_test.js b/closure/protobuf/test/legacy/example_test.js
similarity index 100%
rename from closure/protobuf/test/example_test.js
rename to closure/protobuf/test/legacy/example_test.js
diff --git a/closure/webfiles/web_library.bzl b/closure/webfiles/web_library.bzl
index 5d0973b84c..fb0cdd645b 100644
--- a/closure/webfiles/web_library.bzl
+++ b/closure/webfiles/web_library.bzl
@@ -101,7 +101,7 @@ def _web_library(ctx):
     inputs.append(man)
     args.append("--transitive_dep")
     args.append(man.path)
-  argfile = create_argfile(ctx, args)
+  argfile = create_argfile(ctx.actions, ctx.label.name, args)
   inputs.append(argfile)
   ctx.action(
       inputs=inputs,