diff --git a/src/gn/ninja_c_binary_target_writer.cc b/src/gn/ninja_c_binary_target_writer.cc
index 5b518b3..3321191 100644
--- a/src/gn/ninja_c_binary_target_writer.cc
+++ b/src/gn/ninja_c_binary_target_writer.cc
@@ -779,7 +779,8 @@
   // entire tree of transitive rlibs.
   std::vector<OutputFile> transitive_rustlibs;
   if (target_->IsFinal()) {
-    for (const auto* dep : target_->rust_transitive_libs().GetOrdered()) {
+    for (const auto* dep :
+         target_->rust_transitive_inherited_libs().GetOrdered()) {
       if (dep->output_type() == Target::RUST_LIBRARY) {
         transitive_rustlibs.push_back(dep->dependency_output_file());
         implicit_deps.push_back(dep->dependency_output_file());
diff --git a/src/gn/ninja_rust_binary_target_writer.cc b/src/gn/ninja_rust_binary_target_writer.cc
index d894681..0fd26c0 100644
--- a/src/gn/ninja_rust_binary_target_writer.cc
+++ b/src/gn/ninja_rust_binary_target_writer.cc
@@ -13,8 +13,8 @@
 #include "gn/ninja_target_command_util.h"
 #include "gn/ninja_utils.h"
 #include "gn/rust_substitution_type.h"
-#include "gn/substitution_writer.h"
 #include "gn/rust_values.h"
+#include "gn/substitution_writer.h"
 #include "gn/target.h"
 
 namespace {
@@ -113,8 +113,8 @@
 
   size_t num_stamp_uses = target_->sources().size();
 
-  std::vector<OutputFile> input_deps = WriteInputsStampAndGetDep(
-      num_stamp_uses);
+  std::vector<OutputFile> input_deps =
+      WriteInputsStampAndGetDep(num_stamp_uses);
 
   WriteCompilerVars();
 
@@ -176,11 +176,17 @@
     }
   }
 
-  // Bubble up the full list of transitive rlib dependencies.
-  std::vector<OutputFile> transitive_rustlibs;
-  for (const auto* dep : target_->rust_transitive_libs().GetOrdered()) {
-    if (dep->source_types_used().RustSourceUsed()) {
-      transitive_rustlibs.push_back(dep->dependency_output_file());
+  // Collect the full transitive set of rust libraries that this target depends
+  // on, and the public flag represents if the target has direct access to the
+  // dependency through a chain of public_deps.
+  std::vector<ExternCrate> transitive_crates;
+  for (const auto& [dep, has_direct_access] :
+       target_->rust_transitive_inherited_libs().GetOrderedAndPublicFlag()) {
+    // We will tell rustc to look for crate metadata for any rust crate
+    // dependencies except cdylibs, as they have no metadata present.
+    if (dep->source_types_used().RustSourceUsed() &&
+        RustValues::IsRustLibrary(dep)) {
+      transitive_crates.push_back({dep, has_direct_access});
     }
   }
 
@@ -196,8 +202,7 @@
   std::copy(classified_deps.non_linkable_deps.begin(),
             classified_deps.non_linkable_deps.end(),
             std::back_inserter(extern_deps));
-  WriteExterns(extern_deps);
-  WriteRustdeps(transitive_rustlibs, rustdeps, nonrustdeps);
+  WriteExternsAndDeps(extern_deps, transitive_crates, rustdeps, nonrustdeps);
   WriteSourcesAndInputs();
 }
 
@@ -237,7 +242,8 @@
   out_ << "  sources =";
   for (const auto& source : target_->sources()) {
     out_ << " ";
-    path_output_.WriteFile(out_, OutputFile(settings_->build_settings(), source));
+    path_output_.WriteFile(out_,
+                           OutputFile(settings_->build_settings(), source));
   }
   for (const auto& data : target_->config_values().inputs()) {
     out_ << " ";
@@ -246,67 +252,99 @@
   out_ << std::endl;
 }
 
-void NinjaRustBinaryTargetWriter::WriteExterns(
-    const std::vector<const Target*>& deps) {
+void NinjaRustBinaryTargetWriter::WriteExternsAndDeps(
+    const std::vector<const Target*>& deps,
+    const std::vector<ExternCrate>& transitive_rust_deps,
+    const std::vector<OutputFile>& rustdeps,
+    const std::vector<OutputFile>& nonrustdeps) {
+  // Writes a external LibFile which comes from user-specified externs, and may
+  // be either a string or a SourceFile.
+  auto write_extern_lib_file = [this](std::string_view crate_name,
+                                      LibFile lib_file) {
+    out_ << " --extern ";
+    out_ << crate_name;
+    out_ << "=";
+    if (lib_file.is_source_file()) {
+      path_output_.WriteFile(out_, lib_file.source_file());
+    } else {
+      EscapeOptions escape_opts_command;
+      escape_opts_command.mode = ESCAPE_NINJA_COMMAND;
+      EscapeStringToStream(out_, lib_file.value(), escape_opts_command);
+    }
+  };
+  // Writes an external OutputFile which comes from a dependency of the current
+  // target.
+  auto write_extern_target = [this](const Target& dep) {
+    std::string_view crate_name;
+    const auto& aliased_deps = target_->rust_values().aliased_deps();
+    if (auto it = aliased_deps.find(dep.label()); it != aliased_deps.end()) {
+      crate_name = it->second;
+    } else {
+      crate_name = dep.rust_values().crate_name();
+    }
+
+    out_ << " --extern ";
+    out_ << crate_name;
+    out_ << "=";
+    path_output_.WriteFile(out_, dep.dependency_output_file());
+  };
+
+  // Write accessible crates with `--extern` to add them to the extern prelude.
   out_ << "  externs =";
 
-  for (const Target* target : deps) {
-    if (target->output_type() == Target::RUST_LIBRARY ||
-        target->output_type() == Target::RUST_PROC_MACRO ||
-        (target->source_types_used().RustSourceUsed() &&
-         target->rust_values().InferredCrateType(target) ==
-             RustValues::CRATE_DYLIB)) {
-      out_ << " --extern ";
-      const auto& renamed_dep =
-          target_->rust_values().aliased_deps().find(target->label());
-      if (renamed_dep != target_->rust_values().aliased_deps().end()) {
-        out_ << renamed_dep->second << "=";
-      } else {
-        out_ << std::string(target->rust_values().crate_name()) << "=";
+  // Tracking to avoid emitted the same lib twice. We track it instead of
+  // pre-emptively constructing a UniqueVector since we would have to also store
+  // the crate name, and in the future the public-ness.
+  std::unordered_set<OutputFile> emitted_rust_libs;
+  // TODO: We defer private dependencies to -Ldependency until --extern priv is
+  // stabilized.
+  UniqueVector<SourceDir> private_extern_dirs;
+
+  // Walk the transitive closure of all rust dependencies.
+  //
+  // For dependencies that are meant to be accessible we pass them to --extern
+  // in order to add them to the crate's extern prelude.
+  //
+  // For all transitive dependencies, we add them to `private_extern_dirs` in
+  // order to generate a -Ldependency switch that points to them. This ensures
+  // that rustc can find them if they are used by other dependencies. For
+  // example:
+  //
+  //   A -> C --public--> D
+  //     -> B --private-> D
+  //
+  // Here A has direct access to D, but B and C also make use of D, and they
+  // will only search the paths specified to -Ldependency, thus D needs to
+  // appear as both a --extern (for A) and -Ldependency (for B and C).
+  for (const auto& crate : transitive_rust_deps) {
+    const OutputFile& rust_lib = crate.target->dependency_output_file();
+    if (emitted_rust_libs.count(rust_lib) == 0) {
+      if (crate.has_direct_access) {
+        write_extern_target(*crate.target);
       }
-      path_output_.WriteFile(out_, target->dependency_output_file());
+      emitted_rust_libs.insert(rust_lib);
     }
+    private_extern_dirs.push_back(
+        rust_lib.AsSourceFile(settings_->build_settings()).GetDir());
   }
 
-  EscapeOptions extern_escape_opts;
-  extern_escape_opts.mode = ESCAPE_NINJA_COMMAND;
-
+  // Add explicitly specified externs from the GN target.
   for (ConfigValuesIterator iter(target_); !iter.done(); iter.Next()) {
     const ConfigValues& cur = iter.cur();
-    for (const auto& e : cur.externs()) {
-      out_ << " --extern " << std::string(e.first) << "=";
-      if (e.second.is_source_file()) {
-        path_output_.WriteFile(out_, e.second.source_file());
-      } else {
-        EscapeStringToStream(out_, e.second.value(), extern_escape_opts);
-      }
+    for (const auto& [crate_name, lib_file] : cur.externs()) {
+      write_extern_lib_file(crate_name, lib_file);
     }
   }
 
   out_ << std::endl;
-}
-
-void NinjaRustBinaryTargetWriter::WriteRustdeps(
-    const std::vector<OutputFile>& transitive_rustdeps,
-    const std::vector<OutputFile>& rustdeps,
-    const std::vector<OutputFile>& nonrustdeps) {
   out_ << "  rustdeps =";
 
-  // Rust dependencies.
-  UniqueVector<SourceDir> transitive_rustdep_dirs;
-  for (const auto& rustdep : transitive_rustdeps) {
-    // TODO switch to using --extern priv: after stabilization
-    transitive_rustdep_dirs.push_back(
-        rustdep.AsSourceFile(settings_->build_settings()).GetDir());
-  }
-  for (const auto& rustdepdir : transitive_rustdep_dirs) {
+  for (const SourceDir& dir : private_extern_dirs) {
+    // TODO: switch to using `--extern priv:name` after stabilization.
     out_ << " -Ldependency=";
-    path_output_.WriteDir(out_, rustdepdir, PathOutput::DIR_NO_LAST_SLASH);
+    path_output_.WriteDir(out_, dir, PathOutput::DIR_NO_LAST_SLASH);
   }
 
-  EscapeOptions lib_escape_opts;
-  lib_escape_opts.mode = ESCAPE_NINJA_COMMAND;
-
   // Non-Rust native dependencies.
   UniqueVector<SourceDir> nonrustdep_dirs;
   for (const auto& nonrustdep : nonrustdeps) {
diff --git a/src/gn/ninja_rust_binary_target_writer.h b/src/gn/ninja_rust_binary_target_writer.h
index 0319c86..69ec916 100644
--- a/src/gn/ninja_rust_binary_target_writer.h
+++ b/src/gn/ninja_rust_binary_target_writer.h
@@ -6,9 +6,9 @@
 #define TOOLS_GN_NINJA_RUST_BINARY_TARGET_WRITER_H_
 
 #include "gn/ninja_binary_target_writer.h"
+#include "gn/output_file.h"
 #include "gn/rust_tool.h"
-
-struct EscapeOptions;
+#include "gn/target.h"
 
 // Writes a .ninja file for a binary target type (an executable, a shared
 // library, or a static library).
@@ -20,13 +20,18 @@
   void Run() override;
 
  private:
+  struct ExternCrate {
+    const Target* target;
+    bool has_direct_access;
+  };
+
   void WriteCompilerVars();
   void WriteSources(const OutputFile& input_dep,
                     const std::vector<OutputFile>& order_only_deps);
-  void WriteExterns(const std::vector<const Target*>& deps);
-  void WriteRustdeps(const std::vector<OutputFile>& transitive_rustdeps,
-                     const std::vector<OutputFile>& rustdeps,
-                     const std::vector<OutputFile>& nonrustdeps);
+  void WriteExternsAndDeps(const std::vector<const Target*>& deps,
+                           const std::vector<ExternCrate>& transitive_rust_deps,
+                           const std::vector<OutputFile>& rustdeps,
+                           const std::vector<OutputFile>& nonrustdeps);
   // Unlike C/C++, Rust compiles all sources of a crate in one command.
   // Write a ninja variable `sources` that contains all sources and input files.
   void WriteSourcesAndInputs();
diff --git a/src/gn/ninja_rust_binary_target_writer_unittest.cc b/src/gn/ninja_rust_binary_target_writer_unittest.cc
index b4b71d6..29f9756 100644
--- a/src/gn/ninja_rust_binary_target_writer_unittest.cc
+++ b/src/gn/ninja_rust_binary_target_writer_unittest.cc
@@ -73,29 +73,115 @@
   }
 }
 
+// Accessible dependencies appear as --extern switches for rustc, so that the
+// target crate can make use of them whether transitive or not. Transitive
+// dependencies can be accessible if they are in the public_deps of a direct
+// dependency, or part of a chain of public_deps from a direct dependency. Any
+// dependencies used by other crate dependencies also must appear, but are
+// pointed to by -Ldependency as they are not available for use from the target
+// crate. In the future they may move to `--extern priv:` when explicit private
+// dependencies are stabilized.
 TEST_F(NinjaRustBinaryTargetWriterTest, RlibDeps) {
   Err err;
   TestWithScope setup;
 
-  Target rlib(setup.settings(), Label(SourceDir("//bar/"), "mylib"));
-  rlib.set_output_type(Target::RUST_LIBRARY);
-  rlib.visibility().SetPublic();
-  SourceFile barlib("//bar/lib.rs");
-  rlib.sources().push_back(SourceFile("//bar/mylib.rs"));
-  rlib.sources().push_back(barlib);
-  rlib.source_types_used().Set(SourceFile::SOURCE_RS);
-  rlib.rust_values().set_crate_root(barlib);
-  rlib.rust_values().crate_name() = "mylib";
-  rlib.SetToolchain(setup.toolchain());
-  ASSERT_TRUE(rlib.OnResolved(&err));
+  Target private_rlib(setup.settings(), Label(SourceDir("//baz/"), "privatelib"));
+  private_rlib.set_output_type(Target::RUST_LIBRARY);
+  private_rlib.visibility().SetPublic();
+  SourceFile bazlib("//baz/lib.rs");
+  private_rlib.sources().push_back(SourceFile("//baz/privatelib.rs"));
+  private_rlib.sources().push_back(bazlib);
+  private_rlib.source_types_used().Set(SourceFile::SOURCE_RS);
+  private_rlib.rust_values().set_crate_root(bazlib);
+  private_rlib.rust_values().crate_name() = "privatecrate";
+  private_rlib.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(private_rlib.OnResolved(&err));
 
   {
     std::ostringstream out;
-    NinjaRustBinaryTargetWriter writer(&rlib, out);
+    NinjaRustBinaryTargetWriter writer(&private_rlib, out);
     writer.Run();
 
     const char expected[] =
-        "crate_name = mylib\n"
+        "crate_name = privatecrate\n"
+        "crate_type = rlib\n"
+        "output_extension = .rlib\n"
+        "output_dir = \n"
+        "rustflags =\n"
+        "rustenv =\n"
+        "root_out_dir = .\n"
+        "target_out_dir = obj/baz\n"
+        "target_output_name = libprivatelib\n"
+        "\n"
+        "build obj/baz/libprivatelib.rlib: rust_rlib ../../baz/lib.rs | "
+        "../../baz/privatelib.rs ../../baz/lib.rs\n"
+        "  externs =\n"
+        "  rustdeps =\n"
+        "  ldflags =\n"
+        "  sources = ../../baz/privatelib.rs ../../baz/lib.rs\n";
+    std::string out_str = out.str();
+    EXPECT_EQ(expected, out_str) << expected << "\n" << out_str;
+  }
+
+  Target far_public_rlib(setup.settings(),
+                         Label(SourceDir("//far/"), "farlib"));
+  far_public_rlib.set_output_type(Target::RUST_LIBRARY);
+  far_public_rlib.visibility().SetPublic();
+  SourceFile farlib("//far/lib.rs");
+  far_public_rlib.sources().push_back(SourceFile("//far/farlib.rs"));
+  far_public_rlib.sources().push_back(farlib);
+  far_public_rlib.source_types_used().Set(SourceFile::SOURCE_RS);
+  far_public_rlib.rust_values().set_crate_root(farlib);
+  far_public_rlib.rust_values().crate_name() = "farcrate";
+  far_public_rlib.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(far_public_rlib.OnResolved(&err));
+
+  {
+    std::ostringstream out;
+    NinjaRustBinaryTargetWriter writer(&far_public_rlib, out);
+    writer.Run();
+
+    const char expected[] =
+        "crate_name = farcrate\n"
+        "crate_type = rlib\n"
+        "output_extension = .rlib\n"
+        "output_dir = \n"
+        "rustflags =\n"
+        "rustenv =\n"
+        "root_out_dir = .\n"
+        "target_out_dir = obj/far\n"
+        "target_output_name = libfarlib\n"
+        "\n"
+        "build obj/far/libfarlib.rlib: rust_rlib ../../far/lib.rs | "
+        "../../far/farlib.rs ../../far/lib.rs\n"
+        "  externs =\n"
+        "  rustdeps =\n"
+        "  ldflags =\n"
+        "  sources = ../../far/farlib.rs ../../far/lib.rs\n";
+    std::string out_str = out.str();
+    EXPECT_EQ(expected, out_str) << expected << "\n" << out_str;
+  }
+
+  Target public_rlib(setup.settings(), Label(SourceDir("//bar/"), "publiclib"));
+  public_rlib.set_output_type(Target::RUST_LIBRARY);
+  public_rlib.visibility().SetPublic();
+  SourceFile barlib("//bar/lib.rs");
+  public_rlib.sources().push_back(SourceFile("//bar/publiclib.rs"));
+  public_rlib.sources().push_back(barlib);
+  public_rlib.source_types_used().Set(SourceFile::SOURCE_RS);
+  public_rlib.rust_values().set_crate_root(barlib);
+  public_rlib.rust_values().crate_name() = "publiccrate";
+  public_rlib.public_deps().push_back(LabelTargetPair(&far_public_rlib));
+  public_rlib.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(public_rlib.OnResolved(&err));
+
+  {
+    std::ostringstream out;
+    NinjaRustBinaryTargetWriter writer(&public_rlib, out);
+    writer.Run();
+
+    const char expected[] =
+        "crate_name = publiccrate\n"
         "crate_type = rlib\n"
         "output_extension = .rlib\n"
         "output_dir = \n"
@@ -103,41 +189,42 @@
         "rustenv =\n"
         "root_out_dir = .\n"
         "target_out_dir = obj/bar\n"
-        "target_output_name = libmylib\n"
+        "target_output_name = libpubliclib\n"
         "\n"
-        "build obj/bar/libmylib.rlib: rust_rlib ../../bar/lib.rs | "
-        "../../bar/mylib.rs ../../bar/lib.rs\n"
-        "  externs =\n"
-        "  rustdeps =\n"
+        "build obj/bar/libpubliclib.rlib: rust_rlib ../../bar/lib.rs | "
+        "../../bar/publiclib.rs ../../bar/lib.rs obj/far/libfarlib.rlib\n"
+        "  externs = --extern farcrate=obj/far/libfarlib.rlib\n"
+        "  rustdeps = -Ldependency=obj/far\n"
         "  ldflags =\n"
-        "  sources = ../../bar/mylib.rs ../../bar/lib.rs\n";
+        "  sources = ../../bar/publiclib.rs ../../bar/lib.rs\n";
     std::string out_str = out.str();
     EXPECT_EQ(expected, out_str) << expected << "\n" << out_str;
   }
 
-  Target another_rlib(setup.settings(), Label(SourceDir("//foo/"), "direct"));
-  another_rlib.set_output_type(Target::RUST_LIBRARY);
-  another_rlib.visibility().SetPublic();
+  Target rlib(setup.settings(), Label(SourceDir("//foo/"), "direct"));
+  rlib.set_output_type(Target::RUST_LIBRARY);
+  rlib.visibility().SetPublic();
   SourceFile lib("//foo/main.rs");
-  another_rlib.sources().push_back(SourceFile("//foo/direct.rs"));
-  another_rlib.sources().push_back(lib);
-  another_rlib.source_types_used().Set(SourceFile::SOURCE_RS);
-  another_rlib.rust_values().set_crate_root(lib);
-  another_rlib.rust_values().crate_name() = "direct";
-  another_rlib.SetToolchain(setup.toolchain());
-  another_rlib.public_deps().push_back(LabelTargetPair(&rlib));
-  ASSERT_TRUE(another_rlib.OnResolved(&err));
+  rlib.sources().push_back(SourceFile("//foo/direct.rs"));
+  rlib.sources().push_back(lib);
+  rlib.source_types_used().Set(SourceFile::SOURCE_RS);
+  rlib.rust_values().set_crate_root(lib);
+  rlib.rust_values().crate_name() = "direct";
+  rlib.SetToolchain(setup.toolchain());
+  rlib.public_deps().push_back(LabelTargetPair(&public_rlib));
+  rlib.private_deps().push_back(LabelTargetPair(&private_rlib));
+  ASSERT_TRUE(rlib.OnResolved(&err));
 
-  Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+  Target target(setup.settings(), Label(SourceDir("//main/"), "main"));
   target.set_output_type(Target::EXECUTABLE);
   target.visibility().SetPublic();
-  SourceFile main("//foo/main.rs");
-  target.sources().push_back(SourceFile("//foo/source.rs"));
+  SourceFile main("//main/main.rs");
+  target.sources().push_back(SourceFile("//main/source.rs"));
   target.sources().push_back(main);
   target.source_types_used().Set(SourceFile::SOURCE_RS);
   target.rust_values().set_crate_root(main);
-  target.rust_values().crate_name() = "foo_bar";
-  target.private_deps().push_back(LabelTargetPair(&another_rlib));
+  target.rust_values().crate_name() = "main_crate";
+  target.private_deps().push_back(LabelTargetPair(&rlib));
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
@@ -147,22 +234,25 @@
     writer.Run();
 
     const char expected[] =
-        "crate_name = foo_bar\n"
+        "crate_name = main_crate\n"
         "crate_type = bin\n"
         "output_extension = \n"
         "output_dir = \n"
         "rustflags =\n"
         "rustenv =\n"
         "root_out_dir = .\n"
-        "target_out_dir = obj/foo\n"
-        "target_output_name = bar\n"
+        "target_out_dir = obj/main\n"
+        "target_output_name = main\n"
         "\n"
-        "build ./foo_bar: rust_bin ../../foo/main.rs | ../../foo/source.rs "
-        "../../foo/main.rs obj/foo/libdirect.rlib\n"
-        "  externs = --extern direct=obj/foo/libdirect.rlib\n"
-        "  rustdeps = -Ldependency=obj/foo -Ldependency=obj/bar\n"
+        "build ./main_crate: rust_bin ../../main/main.rs | "
+        "../../main/source.rs ../../main/main.rs obj/foo/libdirect.rlib\n"
+        "  externs = --extern direct=obj/foo/libdirect.rlib "
+        "--extern publiccrate=obj/bar/libpubliclib.rlib "
+        "--extern farcrate=obj/far/libfarlib.rlib\n"
+        "  rustdeps = -Ldependency=obj/foo -Ldependency=obj/bar "
+        "-Ldependency=obj/far -Ldependency=obj/baz\n"
         "  ldflags =\n"
-        "  sources = ../../foo/source.rs ../../foo/main.rs\n";
+        "  sources = ../../main/source.rs ../../main/main.rs\n";
     std::string out_str = out.str();
     EXPECT_EQ(expected, out_str) << expected << "\n" << out_str;
   }
@@ -172,6 +262,82 @@
   Err err;
   TestWithScope setup;
 
+  Target private_inside_dylib(setup.settings(), Label(SourceDir("//faz/"), "private_inside"));
+  private_inside_dylib.set_output_type(Target::RUST_LIBRARY);
+  private_inside_dylib.visibility().SetPublic();
+  SourceFile fazlib("//faz/lib.rs");
+  private_inside_dylib.sources().push_back(SourceFile("//faz/private_inside.rs"));
+  private_inside_dylib.sources().push_back(fazlib);
+  private_inside_dylib.source_types_used().Set(SourceFile::SOURCE_RS);
+  private_inside_dylib.rust_values().set_crate_root(fazlib);
+  private_inside_dylib.rust_values().crate_name() = "private_inside";
+  private_inside_dylib.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(private_inside_dylib.OnResolved(&err));
+
+  {
+    std::ostringstream out;
+    NinjaRustBinaryTargetWriter writer(&private_inside_dylib, out);
+    writer.Run();
+
+    const char expected[] =
+        "crate_name = private_inside\n"
+        "crate_type = rlib\n"
+        "output_extension = .rlib\n"
+        "output_dir = \n"
+        "rustflags =\n"
+        "rustenv =\n"
+        "root_out_dir = .\n"
+        "target_out_dir = obj/faz\n"
+        "target_output_name = libprivate_inside\n"
+        "\n"
+        "build obj/faz/libprivate_inside.rlib: rust_rlib ../../faz/lib.rs | "
+        "../../faz/private_inside.rs ../../faz/lib.rs\n"
+        "  externs =\n"
+        "  rustdeps =\n"
+        "  ldflags =\n"
+        "  sources = ../../faz/private_inside.rs ../../faz/lib.rs\n";
+    std::string out_str = out.str();
+    EXPECT_EQ(expected, out_str) << expected << "\n" << out_str;
+  }
+
+  Target inside_dylib(setup.settings(), Label(SourceDir("//baz/"), "inside"));
+  inside_dylib.set_output_type(Target::RUST_LIBRARY);
+  inside_dylib.visibility().SetPublic();
+  SourceFile bazlib("//baz/lib.rs");
+  inside_dylib.sources().push_back(SourceFile("//baz/inside.rs"));
+  inside_dylib.sources().push_back(bazlib);
+  inside_dylib.source_types_used().Set(SourceFile::SOURCE_RS);
+  inside_dylib.rust_values().set_crate_root(bazlib);
+  inside_dylib.rust_values().crate_name() = "inside";
+  inside_dylib.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(inside_dylib.OnResolved(&err));
+
+  {
+    std::ostringstream out;
+    NinjaRustBinaryTargetWriter writer(&inside_dylib, out);
+    writer.Run();
+
+    const char expected[] =
+        "crate_name = inside\n"
+        "crate_type = rlib\n"
+        "output_extension = .rlib\n"
+        "output_dir = \n"
+        "rustflags =\n"
+        "rustenv =\n"
+        "root_out_dir = .\n"
+        "target_out_dir = obj/baz\n"
+        "target_output_name = libinside\n"
+        "\n"
+        "build obj/baz/libinside.rlib: rust_rlib ../../baz/lib.rs | "
+        "../../baz/inside.rs ../../baz/lib.rs\n"
+        "  externs =\n"
+        "  rustdeps =\n"
+        "  ldflags =\n"
+        "  sources = ../../baz/inside.rs ../../baz/lib.rs\n";
+    std::string out_str = out.str();
+    EXPECT_EQ(expected, out_str) << expected << "\n" << out_str;
+  }
+
   Target dylib(setup.settings(), Label(SourceDir("//bar/"), "mylib"));
   dylib.set_output_type(Target::SHARED_LIBRARY);
   dylib.visibility().SetPublic();
@@ -179,9 +345,11 @@
   dylib.sources().push_back(SourceFile("//bar/mylib.rs"));
   dylib.sources().push_back(barlib);
   dylib.source_types_used().Set(SourceFile::SOURCE_RS);
-  dylib.rust_values().set_crate_type(RustValues::CRATE_DYLIB); // TODO
+  dylib.rust_values().set_crate_type(RustValues::CRATE_DYLIB);  // TODO
   dylib.rust_values().set_crate_root(barlib);
   dylib.rust_values().crate_name() = "mylib";
+  dylib.public_deps().push_back(LabelTargetPair(&inside_dylib));
+  dylib.private_deps().push_back(LabelTargetPair(&private_inside_dylib));
   dylib.SetToolchain(setup.toolchain());
   ASSERT_TRUE(dylib.OnResolved(&err));
 
@@ -202,9 +370,11 @@
         "target_output_name = libmylib\n"
         "\n"
         "build obj/bar/libmylib.so: rust_dylib ../../bar/lib.rs | "
-        "../../bar/mylib.rs ../../bar/lib.rs\n"
-        "  externs =\n"
-        "  rustdeps =\n"
+        "../../bar/mylib.rs ../../bar/lib.rs "
+        "obj/baz/libinside.rlib obj/faz/libprivate_inside.rlib\n"
+        "  externs = --extern inside=obj/baz/libinside.rlib "
+        "--extern private_inside=obj/faz/libprivate_inside.rlib\n"
+        "  rustdeps = -Ldependency=obj/baz -Ldependency=obj/faz\n"
         "  ldflags =\n"
         "  sources = ../../bar/mylib.rs ../../bar/lib.rs\n";
     std::string out_str = out.str();
@@ -222,7 +392,7 @@
   another_dylib.rust_values().set_crate_root(lib);
   another_dylib.rust_values().crate_name() = "direct";
   another_dylib.SetToolchain(setup.toolchain());
-  another_dylib.private_deps().push_back(LabelTargetPair(&dylib));
+  another_dylib.public_deps().push_back(LabelTargetPair(&dylib));
   ASSERT_TRUE(another_dylib.OnResolved(&err));
 
   Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
@@ -256,8 +426,11 @@
         "\n"
         "build ./foo_bar: rust_bin ../../foo/main.rs | ../../foo/source.rs "
         "../../foo/main.rs obj/foo/libdirect.so\n"
-        "  externs = --extern direct=obj/foo/libdirect.so\n"
-        "  rustdeps = -Ldependency=obj/foo -Ldependency=obj/bar\n"
+        "  externs = --extern direct=obj/foo/libdirect.so "
+        "--extern mylib=obj/bar/libmylib.so "
+        "--extern inside=obj/baz/libinside.rlib\n"
+        "  rustdeps = -Ldependency=obj/foo -Ldependency=obj/bar "
+        "-Ldependency=obj/baz -Ldependency=obj/faz\n"
         "  ldflags =\n"
         "  sources = ../../foo/source.rs ../../foo/main.rs\n";
     std::string out_str = out.str();
@@ -385,8 +558,10 @@
         "target_output_name = bar\n"
         "\n"
         "build ./foo_bar: rust_bin ../../foo/main.rs | "
-        "../../foo/source.rs ../../foo/main.rs obj/bar/libmylib.rlib\n"
-        "  externs = --extern mylib=obj/bar/libmylib.rlib\n"
+        "../../foo/source.rs ../../foo/main.rs obj/bar/libmylib.rlib || "
+        "obj/baz/group.stamp\n"
+        "  externs = --extern mylib=obj/bar/libmylib.rlib "
+        "--extern mymacro=obj/bar/libmymacro.so\n"
         "  rustdeps = -Ldependency=obj/bar\n"
         "  ldflags =\n"
         "  sources = ../../foo/source.rs ../../foo/main.rs\n";
@@ -399,17 +574,42 @@
   Err err;
   TestWithScope setup;
 
-  Target another_rlib(setup.settings(), Label(SourceDir("//foo/"), "direct"));
-  another_rlib.set_output_type(Target::RUST_LIBRARY);
-  another_rlib.visibility().SetPublic();
-  SourceFile lib("//foo/lib.rs");
-  another_rlib.sources().push_back(SourceFile("//foo/direct.rs"));
-  another_rlib.sources().push_back(lib);
-  another_rlib.source_types_used().Set(SourceFile::SOURCE_RS);
-  another_rlib.rust_values().set_crate_root(lib);
-  another_rlib.rust_values().crate_name() = "direct";
-  another_rlib.SetToolchain(setup.toolchain());
-  ASSERT_TRUE(another_rlib.OnResolved(&err));
+  Target transitive(setup.settings(), Label(SourceDir("//faz/"), "transitive"));
+  transitive.set_output_type(Target::RUST_LIBRARY);
+  transitive.visibility().SetPublic();
+  SourceFile transitive_lib("//faz/transitive/lib.rs");
+  transitive.sources().push_back(SourceFile("//faz/transitive/transitive.rs"));
+  transitive.sources().push_back(transitive_lib);
+  transitive.source_types_used().Set(SourceFile::SOURCE_RS);
+  transitive.rust_values().set_crate_root(transitive_lib);
+  transitive.rust_values().crate_name() = "transitive";
+  transitive.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(transitive.OnResolved(&err));
+
+  Target rlib(setup.settings(), Label(SourceDir("//baz/"), "mylib"));
+  rlib.set_output_type(Target::RUST_LIBRARY);
+  rlib.visibility().SetPublic();
+  SourceFile barlib("//baz/bar/lib.rs");
+  rlib.sources().push_back(SourceFile("//baz/bar/mylib.rs"));
+  rlib.sources().push_back(barlib);
+  rlib.source_types_used().Set(SourceFile::SOURCE_RS);
+  rlib.rust_values().set_crate_root(barlib);
+  rlib.rust_values().crate_name() = "mylib";
+  rlib.SetToolchain(setup.toolchain());
+  rlib.public_deps().push_back(LabelTargetPair(&transitive));
+  ASSERT_TRUE(rlib.OnResolved(&err));
+
+  Target direct(setup.settings(), Label(SourceDir("//bar/"), "direct"));
+  direct.set_output_type(Target::RUST_LIBRARY);
+  direct.visibility().SetPublic();
+  SourceFile direct_lib("//bar/direct/lib.rs");
+  direct.sources().push_back(SourceFile("//bar/direct/direct.rs"));
+  direct.sources().push_back(direct_lib);
+  direct.source_types_used().Set(SourceFile::SOURCE_RS);
+  direct.rust_values().set_crate_root(direct_lib);
+  direct.rust_values().crate_name() = "direct";
+  direct.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(direct.OnResolved(&err));
 
   Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
   target.set_output_type(Target::EXECUTABLE);
@@ -420,8 +620,13 @@
   target.source_types_used().Set(SourceFile::SOURCE_RS);
   target.rust_values().set_crate_root(main);
   target.rust_values().crate_name() = "foo_bar";
-  target.rust_values().aliased_deps()[another_rlib.label()] = "direct_renamed";
-  target.private_deps().push_back(LabelTargetPair(&another_rlib));
+  // A direct dependency is renamed.
+  target.rust_values().aliased_deps()[direct.label()] = "direct_renamed";
+  // A transitive public dependency, through `rlib`, is renamed.
+  target.rust_values().aliased_deps()[transitive.label()] =
+      "transitive_renamed";
+  target.private_deps().push_back(LabelTargetPair(&direct));
+  target.private_deps().push_back(LabelTargetPair(&rlib));
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
@@ -442,9 +647,12 @@
         "target_output_name = bar\n"
         "\n"
         "build ./foo_bar: rust_bin ../../foo/main.rs | ../../foo/source.rs "
-        "../../foo/main.rs obj/foo/libdirect.rlib\n"
-        "  externs = --extern direct_renamed=obj/foo/libdirect.rlib\n"
-        "  rustdeps = -Ldependency=obj/foo\n"
+        "../../foo/main.rs obj/bar/libdirect.rlib obj/baz/libmylib.rlib\n"
+        "  externs = --extern direct_renamed=obj/bar/libdirect.rlib "
+        "--extern mylib=obj/baz/libmylib.rlib "
+        "--extern transitive_renamed=obj/faz/libtransitive.rlib\n"
+        "  rustdeps = -Ldependency=obj/bar -Ldependency=obj/baz "
+        "-Ldependency=obj/faz\n"
         "  ldflags =\n"
         "  sources = ../../foo/source.rs ../../foo/main.rs\n";
     std::string out_str = out.str();
@@ -725,22 +933,39 @@
   }
 }
 
+// Test that neither public nor private rust dependencies of a proc-macro are
+// transitively acquired as accessible dependencies by users of the macro. But
+// the macro itself is listed as an accessible dependency (via --extern).
 TEST_F(NinjaRustBinaryTargetWriterTest, RustProcMacro) {
   Err err;
   TestWithScope setup;
 
-  Target procmacrodep(setup.settings(),
-                      Label(SourceDir("//baz/"), "mymacrodep"));
-  procmacrodep.set_output_type(Target::RUST_LIBRARY);
-  procmacrodep.visibility().SetPublic();
-  SourceFile bazlib("//baz/lib.rs");
-  procmacrodep.sources().push_back(SourceFile("//baz/mylib.rs"));
-  procmacrodep.sources().push_back(bazlib);
-  procmacrodep.source_types_used().Set(SourceFile::SOURCE_RS);
-  procmacrodep.rust_values().set_crate_root(bazlib);
-  procmacrodep.rust_values().crate_name() = "mymacrodep";
-  procmacrodep.SetToolchain(setup.toolchain());
-  ASSERT_TRUE(procmacrodep.OnResolved(&err));
+  Target procmacropublicdep(
+      setup.settings(), Label(SourceDir("//baz/public/"), "mymacropublicdep"));
+  procmacropublicdep.set_output_type(Target::RUST_LIBRARY);
+  procmacropublicdep.visibility().SetPublic();
+  SourceFile publicbazlib("//baz/public/lib.rs");
+  procmacropublicdep.sources().push_back(SourceFile("//baz/public/mylib.rs"));
+  procmacropublicdep.sources().push_back(publicbazlib);
+  procmacropublicdep.source_types_used().Set(SourceFile::SOURCE_RS);
+  procmacropublicdep.rust_values().set_crate_root(publicbazlib);
+  procmacropublicdep.rust_values().crate_name() = "publicdep";
+  procmacropublicdep.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(procmacropublicdep.OnResolved(&err));
+
+  Target procmacroprivatedep(
+      setup.settings(),
+      Label(SourceDir("//baz/private/"), "mymacroprivatedep"));
+  procmacroprivatedep.set_output_type(Target::RUST_LIBRARY);
+  procmacroprivatedep.visibility().SetPublic();
+  SourceFile privatebazlib("//baz/private/lib.rs");
+  procmacroprivatedep.sources().push_back(SourceFile("//baz/private/mylib.rs"));
+  procmacroprivatedep.sources().push_back(privatebazlib);
+  procmacroprivatedep.source_types_used().Set(SourceFile::SOURCE_RS);
+  procmacroprivatedep.rust_values().set_crate_root(privatebazlib);
+  procmacroprivatedep.rust_values().crate_name() = "privatedep";
+  procmacroprivatedep.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(procmacroprivatedep.OnResolved(&err));
 
   Target procmacro(setup.settings(), Label(SourceDir("//bar/"), "mymacro"));
   procmacro.set_output_type(Target::RUST_PROC_MACRO);
@@ -754,7 +979,8 @@
   procmacro.rust_values().set_crate_type(RustValues::CRATE_PROC_MACRO);
   // Add a dependency to the procmacro so we can be sure its output
   // directory is not propagated downstream beyond the proc macro.
-  procmacro.private_deps().push_back(LabelTargetPair(&procmacrodep));
+  procmacro.public_deps().push_back(LabelTargetPair(&procmacropublicdep));
+  procmacro.private_deps().push_back(LabelTargetPair(&procmacroprivatedep));
   procmacro.SetToolchain(setup.toolchain());
   ASSERT_TRUE(procmacro.OnResolved(&err));
 
@@ -775,9 +1001,14 @@
         "target_output_name = libmymacro\n"
         "\n"
         "build obj/bar/libmymacro.so: rust_macro ../../bar/lib.rs | "
-        "../../bar/mylib.rs ../../bar/lib.rs obj/baz/libmymacrodep.rlib\n"
-        "  externs = --extern mymacrodep=obj/baz/libmymacrodep.rlib\n"
-        "  rustdeps = -Ldependency=obj/baz\n"
+        "../../bar/mylib.rs ../../bar/lib.rs "
+        "obj/baz/public/libmymacropublicdep.rlib "
+        "obj/baz/private/libmymacroprivatedep.rlib\n"
+        "  externs = "
+        "--extern publicdep=obj/baz/public/libmymacropublicdep.rlib "
+        "--extern privatedep=obj/baz/private/libmymacroprivatedep.rlib\n"
+        "  rustdeps = -Ldependency=obj/baz/public "
+        "-Ldependency=obj/baz/private\n"
         "  ldflags =\n"
         "  sources = ../../bar/mylib.rs ../../bar/lib.rs\n";
     std::string out_str = out.str();
@@ -989,7 +1220,8 @@
     writer.Run();
 
     const char expected[] =
-        "build obj/foo/bar.inputs.stamp: stamp ../../foo/config.json ../../foo/template.h\n"
+        "build obj/foo/bar.inputs.stamp: stamp ../../foo/config.json "
+        "../../foo/template.h\n"
         "crate_name = foo_bar\n"
         "crate_type = bin\n"
         "output_extension = \n"
@@ -1083,8 +1315,8 @@
         "build ./foo_bar: rust_bin ../../foo/main.rs | ../../foo/source.rs "
         "../../foo/main.rs obj/bar/libmylib.so\n"
         "  externs =\n"
-        "  rustdeps = -Ldependency=obj/bar -Lnative=obj/bar "
-        "-Clink-arg=-Bdynamic -Clink-arg=obj/bar/libmylib.so\n"
+        "  rustdeps = -Lnative=obj/bar -Clink-arg=-Bdynamic "
+        "-Clink-arg=obj/bar/libmylib.so\n"
         "  ldflags =\n"
         "  sources = ../../foo/source.rs ../../foo/main.rs\n";
     std::string out_str = out.str();
diff --git a/src/gn/target.cc b/src/gn/target.cc
index 508ad7e..c491897 100644
--- a/src/gn/target.cc
+++ b/src/gn/target.cc
@@ -769,38 +769,40 @@
 
   if (dep->output_type() == STATIC_LIBRARY ||
       dep->output_type() == SHARED_LIBRARY ||
-      dep->output_type() == RUST_LIBRARY) {
-    rust_transitive_libs_.Append(dep, is_public);
+      dep->output_type() == RUST_LIBRARY ||
+      dep->output_type() == GROUP) {
+    // Here we have: `this` --[depends-on]--> `dep`
+    //
+    // The `this` target has direct access to `dep` since its a direct
+    // dependency, regardless of the edge being a public_dep or not, so we pass
+    // true for public-ness. Whereas, anything depending on `this` can only gain
+    // direct access to `dep` if the edge between `this` and `dep` is public,
+    // so we pass `is_public`.
+    rust_transitive_inherited_libs_.Append(dep, true);
+    rust_transitive_inheritable_libs_.Append(dep, is_public);
 
-    // Propagate public dependent libraries.
-    for (const auto& transitive :
-         dep->rust_transitive_libs_.GetOrderedAndPublicFlag()) {
-      if (transitive.second) {
-        rust_transitive_libs_.Append(transitive.first, is_public);
-      }
-    }
+    rust_transitive_inherited_libs_.AppendInherited(
+        dep->rust_transitive_inheritable_libs(), true);
+    rust_transitive_inheritable_libs_.AppendInherited(
+        dep->rust_transitive_inheritable_libs(), is_public);
+  } else if (dep->output_type() == RUST_PROC_MACRO) {
+    // Proc-macros are inherited as a transitive dependency, but the things they
+    // depend on can't be used elsewhere, as the proc macro is not linked into
+    // the target (as it's only used during compilation).
+    rust_transitive_inherited_libs_.Append(dep, true);
+    rust_transitive_inheritable_libs_.Append(dep, is_public);
   }
 
-  // Rust libraries (those meant for consumption by another Rust target) are
-  // handled the same way, whether static or dynamic.
   if (dep->output_type() == RUST_LIBRARY ||
       RustValues::InferredCrateType(dep) == RustValues::CRATE_DYLIB) {
-    rust_transitive_libs_.AppendInherited(dep->rust_transitive_libs_,
-                                          is_public);
-
-    // If there is a transitive dependency that is not a rust library, place it
-    // in the normal location
-    for (const auto& inherited :
-         rust_transitive_libs_.GetOrderedAndPublicFlag()) {
-      if (!RustValues::IsRustLibrary(inherited.first)) {
-        inherited_libraries_.Append(inherited.first, inherited.second);
+    // Transitive dependencies behind a library (shared or static), that would
+    // be consumed by rustc, gets bumped up to this target.
+    for (const auto& [inherited, inherited_is_public] :
+         rust_transitive_inheritable_libs_.GetOrderedAndPublicFlag()) {
+      if (!RustValues::IsRustLibrary(inherited)) {
+        inherited_libraries_.Append(inherited, inherited_is_public);
       }
     }
-  } else if (dep->output_type() == RUST_PROC_MACRO) {
-    // We will need to specify the path to find a procedural macro,
-    // but have no need to specify the paths to find its dependencies
-    // as the procedural macro is now a complete .so.
-    rust_transitive_libs_.Append(dep, is_public);
   } else if (dep->output_type() == SHARED_LIBRARY) {
     // Shared library dependendencies are inherited across public shared
     // library boundaries.
@@ -828,8 +830,6 @@
     // The current target isn't linked, so propagate linked deps and
     // libraries up the dependency tree.
     inherited_libraries_.AppendInherited(dep->inherited_libraries(), is_public);
-    rust_transitive_libs_.AppendInherited(dep->rust_transitive_libs_,
-                                          is_public);
   } else if (dep->complete_static_lib()) {
     // Inherit only final targets through _complete_ static libraries.
     //
diff --git a/src/gn/target.h b/src/gn/target.h
index d88f0a5..de076a8 100644
--- a/src/gn/target.h
+++ b/src/gn/target.h
@@ -316,9 +316,11 @@
   bool has_rust_values() const { return rust_values_.get(); }
 
   // Transitive closure of libraries that are depended on by this target
-  InheritedLibraries& rust_transitive_libs() { return rust_transitive_libs_; }
-  const InheritedLibraries& rust_transitive_libs() const {
-    return rust_transitive_libs_;
+  const InheritedLibraries& rust_transitive_inherited_libs() const {
+    return rust_transitive_inherited_libs_;
+  }
+  const InheritedLibraries& rust_transitive_inheritable_libs() const {
+    return rust_transitive_inheritable_libs_;
   }
 
   const UniqueVector<SourceDir>& all_lib_dirs() const { return all_lib_dirs_; }
@@ -520,8 +522,18 @@
   // Used for Rust targets.
   std::unique_ptr<RustValues> rust_values_;
 
-  // Used by all targets, only useful to generate Rust targets though.
-  InheritedLibraries rust_transitive_libs_;
+  // Used by all targets, only useful to generate Rust targets though. These
+  // present 2 different views of the public flags:
+  //
+  // Lists all transitive libraries, and for each one the public bit says if
+  // there is a public chain such that this target can make direct use of the
+  // lib. For each library marked public: "I have access to these targets."
+  InheritedLibraries rust_transitive_inherited_libs_;
+  // Lists all transitive libraries, and for each one the public bit says if a
+  // target depending on this target would inherit the libraries as public too.
+  // For each library marked public: "If you depend on me, you get access to
+  // these targets."
+  InheritedLibraries rust_transitive_inheritable_libs_;
 
   // User for Swift targets.
   std::unique_ptr<SwiftValues> swift_values_;