diff --git a/docs/reference.md b/docs/reference.md
index a8d370a..66a0f8d 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -160,6 +160,7 @@
     *   [public: [file list] Declare public header files for a target.](#var_public)
     *   [public_configs: [label list] Configs applied to dependents.](#var_public_configs)
     *   [public_deps: [label list] Declare public dependencies.](#var_public_deps)
+    *   [public_inputs: [file list] Declare public inputs.](#var_public_inputs)
     *   [rebase: [boolean] Rebase collected metadata as files.](#var_rebase)
     *   [response_file_contents: [string list] Contents of .rsp file for actions.](#var_response_file_contents)
     *   [rustflags: [string list] Flags passed to the Rust compiler.](#var_rustflags)
@@ -6876,6 +6877,43 @@
     public_deps = [ ":c" ]
   }
 ```
+### <a name="var_public_inputs"></a>**public_inputs**: Declare public inputs.&nbsp;[Back to Top](#gn-reference)
+
+```
+  Inputs to a target that should be treated as implicit inputs of any dependent
+  targets.
+
+  If target A declares public_inputs and target B depends on A (either via
+  deps or public_deps), B will inherit A's public_inputs.
+
+  If target B depends on A via public_deps, B's public_inputs will also
+  propagate to any targets depending on B.
+
+  This is particularly useful for actions that generate source code which
+  contain implicit imports/includes of the files declared in public_inputs.
+  Dependent targets will automatically inherit these dependencies and trigger
+  rebuilds when the public inputs change.
+
+  See also "inputs" and "public_deps".
+
+  Example
+
+    action("A") {
+      ...
+      public_inputs = [ "a.in" ]
+    }
+
+    action("B") {
+      ...
+      deps = [ ":A" ]  # B inherits "a.in" as an implicit input
+    }
+
+    action("C") {
+      ...
+      public_deps = [ ":A" ]  # C inherits "a.in", and propagates it to
+                              # C's dependents.
+    }
+```
 ### <a name="var_rebase"></a>**rebase**: Rebase collected metadata as files.&nbsp;[Back to Top](#gn-reference)
 
 ```
diff --git a/src/gn/action_target_generator.cc b/src/gn/action_target_generator.cc
index 9cc9c83..4a7b2b7 100644
--- a/src/gn/action_target_generator.cc
+++ b/src/gn/action_target_generator.cc
@@ -45,6 +45,9 @@
   if (!FillInputs())
     return;
 
+  if (!FillPublicInputs())
+    return;
+
   if (!FillScript())
     return;
 
@@ -260,3 +263,17 @@
   target_->config_values().inputs().swap(dest_inputs);
   return true;
 }
+
+bool ActionTargetGenerator::FillPublicInputs() {
+  const Value* value = scope_->GetValue(variables::kPublicInputs, true);
+  if (!value)
+    return true;
+
+  Target::FileList dest_public_inputs;
+  if (!ExtractListOfRelativeFiles(scope_->settings()->build_settings(), *value,
+                                  scope_->GetSourceDir(), &dest_public_inputs,
+                                  err_))
+    return false;
+  target_->public_inputs().swap(dest_public_inputs);
+  return true;
+}
diff --git a/src/gn/action_target_generator.h b/src/gn/action_target_generator.h
index 6cbe8ae..61e11df 100644
--- a/src/gn/action_target_generator.h
+++ b/src/gn/action_target_generator.h
@@ -29,6 +29,7 @@
   bool FillMnemonic();
   bool FillPool();
   bool FillInputs();
+  bool FillPublicInputs();
 
   // Checks for errors in the outputs variable.
   bool CheckOutputs();
diff --git a/src/gn/ninja_binary_target_writer_unittest.cc b/src/gn/ninja_binary_target_writer_unittest.cc
index e8a6f51..d8e12bc 100644
--- a/src/gn/ninja_binary_target_writer_unittest.cc
+++ b/src/gn/ninja_binary_target_writer_unittest.cc
@@ -198,3 +198,55 @@
     EXPECT_EQ(expected, out_str);
   }
 }
+
+TEST_F(NinjaBinaryTargetWriterTest, PublicInputs) {
+  Err err;
+  TestWithScope setup;
+
+  // Action A has public_inputs.
+  Target a(setup.settings(), Label(SourceDir("//foo/"), "a"));
+  a.set_output_type(Target::ACTION);
+  a.visibility().SetPublic();
+  a.SetToolchain(setup.toolchain());
+  a.action_values().set_script(SourceFile("//foo/script.py"));
+  a.public_inputs().push_back(SourceFile("//foo/a.in"));
+
+  // Source set B depends on A.
+  Target b(setup.settings(), Label(SourceDir("//foo/"), "b"));
+  b.set_output_type(Target::SOURCE_SET);
+  b.visibility().SetPublic();
+  b.sources().push_back(SourceFile("//foo/source1.cc"));
+  b.source_types_used().Set(SourceFile::SOURCE_CPP);
+  b.SetToolchain(setup.toolchain());
+  b.private_deps().push_back(LabelTargetPair(&a));
+
+  ASSERT_TRUE(a.OnResolved(&err));
+  ASSERT_TRUE(b.OnResolved(&err));
+
+  std::ostringstream out;
+  NinjaBinaryTargetWriter writer(&b, out);
+  writer.Run();
+
+  // B's compile lines should depend on a.in (since it inherits it from A).
+  // Because it only has one input (a.in), it is depended on directly instead
+  // of via a phony target.
+  const char expected[] =
+      "defines =\n"
+      "include_dirs =\n"
+      "cflags =\n"
+      "cflags_cc =\n"
+      "root_out_dir = .\n"
+      "target_gen_dir = gen/foo\n"
+      "target_out_dir = obj/foo\n"
+      "target_output_name = b\n"
+      "\n"
+      "build obj/foo/b.source1.o: cxx ../../foo/source1.cc | "
+      "phony/foo/a.public_inputs || phony/foo/a\n"
+      "  source_file_part = source1.cc\n"
+      "  source_name_part = source1\n"
+      "\n"
+      "build phony/foo/b.linkdeps: phony obj/foo/b.source1.o || phony/foo/a\n"
+      "build phony/foo/b: phony phony/foo/b.linkdeps\n";
+  std::string out_str = out.str();
+  EXPECT_EQ(expected, out_str);
+}
diff --git a/src/gn/ninja_outputs_writer_unittest.cc b/src/gn/ninja_outputs_writer_unittest.cc
index 154d84b..8098d02 100644
--- a/src/gn/ninja_outputs_writer_unittest.cc
+++ b/src/gn/ninja_outputs_writer_unittest.cc
@@ -11,6 +11,7 @@
 #include "gn/builder_record.h"
 #include "gn/filesystem_utils.h"
 #include "gn/ninja_target_writer.h"
+#include "gn/resolved_target_data.h"
 #include "gn/setup.h"
 #include "gn/switches.h"
 #include "gn/test_with_scheduler.h"
@@ -33,7 +34,8 @@
 // Called on worker thread to write the ninja file.
 void BackgroundDoWrite(TargetWriteInfo* write_info, const Target* target) {
   std::vector<OutputFile> target_ninja_outputs;
-  std::string rule = NinjaTargetWriter::RunAndWriteFile(target, nullptr,
+  ResolvedTargetData resolved;
+  std::string rule = NinjaTargetWriter::RunAndWriteFile(target, &resolved,
                                                         &target_ninja_outputs);
 
   std::lock_guard<std::mutex> lock(write_info->lock);
diff --git a/src/gn/ninja_target_writer.cc b/src/gn/ninja_target_writer.cc
index 6753701..abdbffc 100644
--- a/src/gn/ninja_target_writer.cc
+++ b/src/gn/ninja_target_writer.cc
@@ -192,6 +192,8 @@
     CHECK(0) << "Output type of target not handled.";
   }
 
+  WritePublicInputsStampOrPhony(target, resolved, rules);
+
   if (needs_file_write) {
     // Write the ninja file.
     SourceFile ninja_file = GetNinjaFileForTarget(target);
@@ -215,6 +217,45 @@
   return storage.str();
 }
 
+// static
+void NinjaTargetWriter::WritePublicInputsStampOrPhony(
+    const Target* target,
+    ResolvedTargetData* resolved,
+    std::ostream& out) {
+  DCHECK(resolved);
+  if (!resolved->ExportsPublicInputs(target))
+    return;
+
+  const BuildSettings* build_settings = target->settings()->build_settings();
+  OutputFile output = GetPublicInputsOutputFile(target, build_settings);
+
+  std::vector<OutputFile> deps;
+  for (const auto& file : target->public_inputs()) {
+    deps.push_back(OutputFile(build_settings, file));
+  }
+  for (const auto& dep : target->public_deps()) {
+    if (resolved->ExportsPublicInputs(dep.ptr)) {
+      deps.push_back(GetPublicInputsOutputFile(dep.ptr, build_settings));
+    }
+  }
+
+  PathOutput path_output(build_settings->build_dir(),
+                         build_settings->root_path_utf8(), ESCAPE_NINJA);
+
+  out << "build ";
+  path_output.WriteFile(out, output);
+
+  if (build_settings->no_stamp_files()) {
+    out << ": " << BuiltinTool::kBuiltinToolPhony;
+  } else {
+    out << ": " << GetNinjaRulePrefixForToolchain(target->settings())
+        << GeneralTool::kGeneralToolStamp;
+  }
+
+  path_output.WriteFiles(out, deps);
+  out << std::endl << std::endl;
+}
+
 void NinjaTargetWriter::WriteEscapedSubstitution(const Substitution* type) {
   EscapeOptions opts;
   opts.mode = ESCAPE_NINJA;
@@ -538,6 +579,27 @@
     return InputDeps{};  // No input dependencies.
 
   InputDeps deps;
+  // Inherited public_inputs target dependencies.
+  std::vector<OutputFile> public_inputs_deps;
+  for (const auto& pair : target_->public_deps()) {
+    if (resolved().ExportsPublicInputs(pair.ptr)) {
+      public_inputs_deps.push_back(
+          GetPublicInputsOutputFile(pair.ptr, settings_->build_settings()));
+    }
+  }
+  for (const auto& pair : target_->private_deps()) {
+    if (resolved().ExportsPublicInputs(pair.ptr)) {
+      public_inputs_deps.push_back(
+          GetPublicInputsOutputFile(pair.ptr, settings_->build_settings()));
+    }
+  }
+  std::sort(public_inputs_deps.begin(), public_inputs_deps.end());
+  public_inputs_deps.erase(
+      std::unique(public_inputs_deps.begin(), public_inputs_deps.end()),
+      public_inputs_deps.end());
+  deps.implicit.insert(deps.implicit.end(), public_inputs_deps.begin(),
+                       public_inputs_deps.end());
+
   // File input deps.
   for (const SourceFile* source : input_deps_sources)
     deps.order_only.push_back(OutputFile(settings_->build_settings(), *source));
diff --git a/src/gn/ninja_target_writer.h b/src/gn/ninja_target_writer.h
index 2da7e76..d7b2883 100644
--- a/src/gn/ninja_target_writer.h
+++ b/src/gn/ninja_target_writer.h
@@ -54,6 +54,13 @@
       ResolvedTargetData* resolved = nullptr,
       std::vector<OutputFile>* ninja_outputs = nullptr);
 
+  // Writes a stamp or phony rule for the target's public inputs if it exports
+  // any. This does nothing if resolved->ExportsPublicInputs(target) returns
+  // false.
+  static void WritePublicInputsStampOrPhony(const Target* target,
+                                            ResolvedTargetData* resolved,
+                                            std::ostream& out);
+
   virtual void Run() = 0;
 
  protected:
diff --git a/src/gn/ninja_target_writer_unittest.cc b/src/gn/ninja_target_writer_unittest.cc
index 9cdfaaa..c4fdbd8 100644
--- a/src/gn/ninja_target_writer_unittest.cc
+++ b/src/gn/ninja_target_writer_unittest.cc
@@ -647,3 +647,53 @@
         stream.str());
   }
 }
+
+TEST(NinjaTargetWriter, PublicInputs) {
+  TestWithScope setup;
+  Err err;
+
+  // Action A has public_inputs.
+  Target a(setup.settings(), Label(SourceDir("//foo/"), "a"));
+  a.set_output_type(Target::ACTION);
+  a.visibility().SetPublic();
+  a.SetToolchain(setup.toolchain());
+  a.action_values().set_script(SourceFile("//foo/script.py"));
+  a.public_inputs().push_back(SourceFile("//foo/a.in"));
+
+  // Action B depends on A.
+  Target b(setup.settings(), Label(SourceDir("//foo/"), "b"));
+  b.set_output_type(Target::ACTION);
+  b.visibility().SetPublic();
+  b.SetToolchain(setup.toolchain());
+  b.action_values().set_script(SourceFile("//foo/script.py"));
+  b.private_deps().push_back(LabelTargetPair(&a));
+
+  ASSERT_TRUE(a.OnResolved(&err));
+  ASSERT_TRUE(b.OnResolved(&err));
+
+  // 1. Verify A's public_inputs phony/stamp target is written.
+  {
+    std::ostringstream stream;
+    ResolvedTargetData resolved;
+    TestingNinjaTargetWriter::WritePublicInputsStampOrPhony(&a, &resolved,
+                                                            stream);
+    EXPECT_EQ("build phony/foo/a.public_inputs: phony ../../foo/a.in\n\n",
+              stream.str());
+  }
+
+  // 2. Verify B's input deps. It should depend on A's public_inputs.
+  {
+    std::ostringstream stream;
+    TestingNinjaTargetWriter writer(&b, setup.toolchain(), stream);
+    auto dep = writer.WriteInputDepsStampOrPhonyAndGetDep(
+        std::vector<const Target*>(), 10u);
+
+    ASSERT_EQ(1u, dep.implicit.size());
+    EXPECT_EQ("phony/foo/b.inputdeps", dep.implicit[0].value());
+
+    std::string out = stream.str();
+    EXPECT_TRUE(out.find("phony/foo/a.public_inputs") != std::string::npos)
+        << out;
+    EXPECT_TRUE(out.find("../../foo/a.in") == std::string::npos) << out;
+  }
+}
diff --git a/src/gn/ninja_utils.cc b/src/gn/ninja_utils.cc
index 95cf3a1..ae03c82 100644
--- a/src/gn/ninja_utils.cc
+++ b/src/gn/ninja_utils.cc
@@ -4,7 +4,9 @@
 
 #include "gn/ninja_utils.h"
 
+#include "gn/build_settings.h"
 #include "gn/filesystem_utils.h"
+#include "gn/output_file.h"
 #include "gn/settings.h"
 #include "gn/target.h"
 
@@ -28,3 +30,18 @@
     return std::string();  // Default toolchain has no prefix.
   return settings->toolchain_label().name() + "_";
 }
+
+OutputFile GetPublicInputsOutputFile(const Target* target,
+                                     const BuildSettings* build_settings) {
+  OutputFile result;
+  if (build_settings->no_stamp_files()) {
+    result = GetBuildDirForTargetAsOutputFile(target, BuildDirType::PHONY);
+    result.append(target->label().name());
+    result.append(".public_inputs");
+  } else {
+    result = GetBuildDirForTargetAsOutputFile(target, BuildDirType::OBJ);
+    result.append(target->label().name());
+    result.append(".public_inputs.stamp");
+  }
+  return result;
+}
diff --git a/src/gn/ninja_utils.h b/src/gn/ninja_utils.h
index 60ae6b2..e629d91 100644
--- a/src/gn/ninja_utils.h
+++ b/src/gn/ninja_utils.h
@@ -7,6 +7,8 @@
 
 #include <string>
 
+class BuildSettings;
+class OutputFile;
 class Settings;
 class SourceFile;
 class Target;
@@ -22,4 +24,9 @@
 // don't collide with rules from other toolchains.
 std::string GetNinjaRulePrefixForToolchain(const Settings* settings);
 
+// Returns the output file path for the target's public inputs stamp or phony
+// target.
+OutputFile GetPublicInputsOutputFile(const Target* target,
+                                     const BuildSettings* build_settings);
+
 #endif  // TOOLS_GN_NINJA_UTILS_H_
diff --git a/src/gn/resolved_target_data.cc b/src/gn/resolved_target_data.cc
index bce9839..90063d9 100644
--- a/src/gn/resolved_target_data.cc
+++ b/src/gn/resolved_target_data.cc
@@ -338,3 +338,20 @@
 
   info->order_only_deps = all_order_only_deps.release();
 }
+
+bool ResolvedTargetData::ComputeExportsPublicInputs(
+    const TargetInfo* info) const {
+  const Target* target = info->target;
+
+  if (!target->public_inputs().empty()) {
+    return true;
+  }
+
+  for (const auto& dep : target->public_deps()) {
+    if (ExportsPublicInputs(dep.ptr)) {
+      return true;
+    }
+  }
+
+  return false;
+}
diff --git a/src/gn/resolved_target_data.h b/src/gn/resolved_target_data.h
index 0046481..e7c6e86 100644
--- a/src/gn/resolved_target_data.h
+++ b/src/gn/resolved_target_data.h
@@ -152,7 +152,27 @@
     return GetTargetOrderOnlyDeps(target)->order_only_deps;
   }
 
+  // Returns true if this target exports public inputs, either directly or from
+  // public dependencies which do.
+  bool ExportsPublicInputs(const Target* target) const {
+    TargetInfo* info = GetTargetInfo(target);
+    LazyBool value =
+        info->does_export_public_inputs.load(std::memory_order_acquire);
+    if (value == LazyBool::kUnknown) {
+      value =
+          ComputeExportsPublicInputs(info) ? LazyBool::kTrue : LazyBool::kFalse;
+      info->does_export_public_inputs.store(value, std::memory_order_release);
+    }
+    return value == LazyBool::kTrue;
+  }
+
  private:
+  enum class LazyBool : uint8_t {
+    kUnknown,
+    kTrue,
+    kFalse,
+  };
+
   // The information associated with a given Target pointer.
   struct TargetInfo {
     TargetInfo() = default;
@@ -175,6 +195,7 @@
     std::atomic<bool> has_rust_libs = false;
     std::atomic<bool> has_swift_values = false;
     std::atomic<bool> has_order_only_deps = false;
+    std::atomic<LazyBool> does_export_public_inputs = LazyBool::kUnknown;
 
     // Only valid if |has_lib_info| is true.
     std::vector<SourceDir> lib_dirs;
@@ -330,6 +351,7 @@
   void ComputeRustLibs(TargetInfo* info) const;
   void ComputeSwiftValues(TargetInfo* info) const;
   void ComputeOrderOnlyDeps(TargetInfo* info) const;
+  bool ComputeExportsPublicInputs(const TargetInfo* info) const;
 
   // Helper function used by ComputeInheritedLibs().
   void ComputeInheritedLibsFor(
diff --git a/src/gn/resolved_target_data_unittest.cc b/src/gn/resolved_target_data_unittest.cc
index 92b965d..be3e950 100644
--- a/src/gn/resolved_target_data_unittest.cc
+++ b/src/gn/resolved_target_data_unittest.cc
@@ -440,3 +440,53 @@
   EXPECT_EQ(&b, a_module_deps[1].target());
   EXPECT_EQ(&c, a_module_deps[2].target());
 }
+
+TEST(ResolvedTargetDataTest, PublicInputsInheritance) {
+  TestWithScope setup;
+  Err err;
+
+  // A has public_inputs.
+  TestTarget a(setup, "//foo:a", Target::ACTION);
+  a.public_inputs().push_back(SourceFile("//foo/a.in"));
+
+  // B depends on A via private deps.
+  TestTarget b(setup, "//foo:b", Target::ACTION);
+  b.private_deps().push_back(LabelTargetPair(&a));
+
+  // C depends on A via public deps.
+  TestTarget c(setup, "//foo:c", Target::ACTION);
+  c.public_deps().push_back(LabelTargetPair(&a));
+
+  // D depends on C (which has A as public dep) via private deps.
+  TestTarget d(setup, "//foo:d", Target::ACTION);
+  d.private_deps().push_back(LabelTargetPair(&c));
+
+  // E depends on B (which has A as private dep) via private deps.
+  TestTarget e(setup, "//foo:e", Target::ACTION);
+  e.private_deps().push_back(LabelTargetPair(&b));
+
+  ASSERT_TRUE(a.OnResolved(&err));
+  ASSERT_TRUE(b.OnResolved(&err));
+  ASSERT_TRUE(c.OnResolved(&err));
+  ASSERT_TRUE(d.OnResolved(&err));
+  ASSERT_TRUE(e.OnResolved(&err));
+
+  ResolvedTargetData resolved;
+
+  // A has public_inputs directly.
+  EXPECT_TRUE(resolved.ExportsPublicInputs(&a));
+
+  // B has A as a private dependency, so B itself does NOT export public_inputs
+  // for its dependents.
+  EXPECT_FALSE(resolved.ExportsPublicInputs(&b));
+
+  // C has A as a public dependency, so C exports public_inputs to propagate.
+  EXPECT_TRUE(resolved.ExportsPublicInputs(&c));
+
+  // D has C as a private dependency, so D itself does NOT export public_inputs
+  // for its dependents.
+  EXPECT_FALSE(resolved.ExportsPublicInputs(&d));
+
+  // E has B as a private dependency, B has no public inputs, so E has none.
+  EXPECT_FALSE(resolved.ExportsPublicInputs(&e));
+}
diff --git a/src/gn/target.h b/src/gn/target.h
index 347ca6b..12cbef8 100644
--- a/src/gn/target.h
+++ b/src/gn/target.h
@@ -166,6 +166,9 @@
   const FileList& sources() const { return sources_; }
   FileList& sources() { return sources_; }
 
+  const FileList& public_inputs() const { return public_inputs_; }
+  FileList& public_inputs() { return public_inputs_; }
+
   const SourceFileTypeSet& source_types_used() const {
     return source_types_used_;
   }
@@ -558,6 +561,7 @@
 
   FileList sources_;
   SourceFileTypeSet source_types_used_;
+  FileList public_inputs_;
   bool all_headers_public_ = true;
   FileList public_headers_;
   bool check_includes_ = true;
diff --git a/src/gn/variables.cc b/src/gn/variables.cc
index dcb46e8..9e99985 100644
--- a/src/gn/variables.cc
+++ b/src/gn/variables.cc
@@ -1393,6 +1393,47 @@
   }
 )";
 
+const char kPublicInputs[] = "public_inputs";
+const char kPublicInputs_HelpShort[] =
+    "public_inputs: [file list] Declare public inputs.";
+const char kPublicInputs_Help[] =
+    R"(public_inputs: Declare public inputs.
+
+  Inputs to a target that should be treated as implicit inputs of any dependent
+  targets.
+
+  If target A declares public_inputs and target B depends on A (either via
+  deps or public_deps), B will inherit A's public_inputs.
+
+  If target B depends on A via public_deps, B's public_inputs will also
+  propagate to any targets depending on B.
+
+  This is particularly useful for actions that generate source code which
+  contain implicit imports/includes of the files declared in public_inputs.
+  Dependent targets will automatically inherit these dependencies and trigger
+  rebuilds when the public inputs change.
+
+  See also "inputs" and "public_deps".
+
+  Example
+
+    action("A") {
+      ...
+      public_inputs = [ "a.in" ]
+    }
+
+    action("B") {
+      ...
+      deps = [ ":A" ]  # B inherits "a.in" as an implicit input
+    }
+
+    action("C") {
+      ...
+      public_deps = [ ":A" ]  # C inherits "a.in", and propagates it to
+                              # C's dependents.
+    }
+)";
+
 const char kLdflags[] = "ldflags";
 const char kLdflags_HelpShort[] =
     "ldflags: [string list] Flags passed to the linker.";
@@ -2551,6 +2592,7 @@
     INSERT_VARIABLE(Public)
     INSERT_VARIABLE(PublicConfigs)
     INSERT_VARIABLE(PublicDeps)
+    INSERT_VARIABLE(PublicInputs)
     INSERT_VARIABLE(Rebase)
     INSERT_VARIABLE(ResponseFileContents)
     INSERT_VARIABLE(Script)
diff --git a/src/gn/variables.h b/src/gn/variables.h
index 66e0680..3ecb62a 100644
--- a/src/gn/variables.h
+++ b/src/gn/variables.h
@@ -222,6 +222,10 @@
 extern const char kInputs_HelpShort[];
 extern const char kInputs_Help[];
 
+extern const char kPublicInputs[];
+extern const char kPublicInputs_HelpShort[];
+extern const char kPublicInputs_Help[];
+
 extern const char kLdflags[];
 extern const char kLdflags_HelpShort[];
 extern const char kLdflags_Help[];