diff --git a/leveldb/leveldb.cc b/leveldb/leveldb.cc
index d5edb7b..a0634ba 100644
--- a/leveldb/leveldb.cc
+++ b/leveldb/leveldb.cc
@@ -25,8 +25,8 @@ namespace {
 
 using ::security::crubit_helpers::StringViewFromVecU8;
 
-rs_std::SliceRef<const uint8_t> StringViewToSliceRef(absl::string_view sv) {
-  return rs_std::SliceRef<const uint8_t>(absl::Span<const uint8_t>(
+rs::SliceRef<const uint8_t> StringViewToSliceRef(absl::string_view sv) {
+  return rs::SliceRef<const uint8_t>(absl::Span<const uint8_t>(
       reinterpret_cast<const uint8_t*>(sv.data()), sv.size()));
 }
 
@@ -64,8 +64,7 @@ absl::Status LevelDBErrorToStatus(const rust::LevelDBError& err) {
 }
 
 template <typename T>
-absl::Status ResultToStatus(
-    rs_std::Result<T, rust::LevelDBError>&& result) {
+absl::Status ResultToStatus(rs::Result<T, rust::LevelDBError>&& result) {
   if (result.has_value()) {
     return absl::OkStatus();
   }
@@ -134,7 +133,7 @@ void WriteBatch::Clear() { rs_batch_.clear(); }
 
 absl::StatusOr<std::unique_ptr<DB>> DB::Open(absl::string_view name,
                                              Options options) {
-  auto name_ref = rs_std::StrRef::FromUtf8(name);
+  auto name_ref = rs::StrRef::FromUtf8(name);
   if (!name_ref.has_value()) {
     return absl::InvalidArgumentError("Invalid UTF-8 in database name");
   }
diff --git a/pixel_bridge/pixel_bridge.cc b/pixel_bridge/pixel_bridge.cc
index 15cc150..31c903d 100644
--- a/pixel_bridge/pixel_bridge.cc
+++ b/pixel_bridge/pixel_bridge.cc
@@ -85,8 +85,8 @@ absl::string_view StringViewFromSpanU8(absl::Span<const uint8_t> data) {
 }
 
 absl::StatusOr<std::optional<std::string>> GetMetadata(
-    rs_std::Result<rs_std::Option<rust::vec_u8::VecU8>,
-                   rust::vec_u8::VecU8>
+    rs::Result<rs::Option<rust::vec_u8::VecU8>,
+               rust::vec_u8::VecU8>
         result_stat) {
   if (!result_stat.has_value()) {
     // NOTE: b/351976355 - Find a better error code for this Rust error.
@@ -241,7 +241,7 @@ bool ImageDecoder::IsAnimated() const { return decoder_.is_animated(); }
 
 absl::StatusOr<Frames> ImageDecoder::GetAllFrames() && {
   Format format = GetFormat();
-  rs_std::Result<rust::image::Frames, rust::vec_u8::VecU8>
+  rs::Result<rust::image::Frames, rust::vec_u8::VecU8>
       result = std::move(decoder_).all_frames();
   if (!result.has_value()) {
     rust::vec_u8::VecU8 err_msg_vec = std::move(result).err();
@@ -315,8 +315,8 @@ absl::StatusOr<std::optional<std::string>> ImageDecoder::GetIptcMetadata() {
 
 absl::StatusOr<ImageReader> ImageReader::NewFromFile(
     absl::string_view filepath) {
-  rs_std::Result<rust::reader::ImageReader,
-                 rust::vec_u8::VecU8>
+  rs::Result<rust::reader::ImageReader,
+             rust::vec_u8::VecU8>
       reader = rust::reader::ImageReader::new_from_file(
           absl::Span<const uint8_t>(
               reinterpret_cast<const uint8_t*>(filepath.data()),
@@ -348,8 +348,8 @@ void ImageReader::SetFormat(Format format) {
 }
 
 absl::StatusOr<ImageDecoder> ImageReader::IntoDecoder() && {
-  rs_std::Result<rust::image::ImageDecoder,
-                 rust::vec_u8::VecU8>
+  rs::Result<rust::image::ImageDecoder,
+             rust::vec_u8::VecU8>
       decoder = std::move(reader_).into_decoder();
   if (!decoder.has_value()) {
     return absl::InvalidArgumentError(
diff --git a/saphyr/node.h b/saphyr/node.h
index 1e3e85d..b7714b4 100644
--- a/saphyr/node.h
+++ b/saphyr/node.h
@@ -58,19 +58,19 @@ class NodeView {
   // Accesses an element in a map by key.
   // Returns a `NodeView` for which `IsDefined()` is false if the node is not a
   // map or the key is not found.
-  NodeView operator[](rs_std::StrRef key) const;
+  NodeView operator[](rs::StrRef key) const;
   NodeView operator[](const char* key) const {
-    return operator[](rs_std::StrRef::FromUtf8Unchecked(key));
+    return operator[](rs::StrRef::FromUtf8Unchecked(key));
   }
   NodeView operator[](absl::string_view key) const {
-    return operator[](rs_std::StrRef::FromUtf8Unchecked(key));
+    return operator[](rs::StrRef::FromUtf8Unchecked(key));
   }
 
   // A safer version of `operator[]` for sequence.
   std::optional<NodeView> Get(size_t index) const;
 
   // A safer version of `operator[]` for map.
-  std::optional<NodeView> Get(rs_std::StrRef key) const;
+  std::optional<NodeView> Get(rs::StrRef key) const;
 
   // For map iteration by index.
   NodeView get_key_at_index(size_t index) const;
@@ -158,7 +158,7 @@ class NodeView::Iterator {
     if (!node_ || !has_value_ || !rust_iter_.has_value()) return;
 
     rust::NodeView key;
-    rs_std::Option<rust::NodeView> value;
+    rs::Option<rust::NodeView> value;
     has_value_ = rust_iter_->next(key, value);
 
     if (has_value_) {
@@ -211,13 +211,13 @@ class Node {
   // Accesses an element in a map by key.
   // Returns a `NodeView` for which `IsDefined()` is false if the node is not a
   // map or the key is not found.
-  NodeView operator[](rs_std::StrRef key) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  NodeView operator[](rs::StrRef key) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
   NodeView operator[](const char* key) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return operator[](rs_std::StrRef::FromUtf8Unchecked(key));
+    return operator[](rs::StrRef::FromUtf8Unchecked(key));
   }
   NodeView operator[](absl::string_view key) const
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return operator[](rs_std::StrRef::FromUtf8Unchecked(key));
+    return operator[](rs::StrRef::FromUtf8Unchecked(key));
   }
   // Accesses an element in a sequence by index.
   // Returns a `NodeView` for which `IsDefined()` is false if the node is not a
@@ -230,7 +230,7 @@ class Node {
   // A safer version of `operator[]` for sequence.
   std::optional<NodeView> Get(size_t index) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
   // A safer version of `operator[]` for map.
-  std::optional<NodeView> Get(rs_std::StrRef key) const
+  std::optional<NodeView> Get(rs::StrRef key) const
       ABSL_ATTRIBUTE_LIFETIME_BOUND;
 
   // Sets the value at a given index in a sequence.
@@ -258,14 +258,14 @@ std::ostream& operator<<(std::ostream& out, const Node& node);
 
 // Parses a YAML string `input` and returns an owning `Node`.
 // Returns an error if parsing fails.
-absl::StatusOr<Node> Load(rs_std::StrRef input);
+absl::StatusOr<Node> Load(rs::StrRef input);
 
 inline absl::StatusOr<Node> Load(absl::string_view input) {
-  return Load(rs_std::StrRef::FromUtf8Unchecked(input));
+  return Load(rs::StrRef::FromUtf8Unchecked(input));
 }
 
 inline absl::StatusOr<Node> Load(const char* input) {
-  return Load(rs_std::StrRef::FromUtf8Unchecked(input));
+  return Load(rs::StrRef::FromUtf8Unchecked(input));
 }
 
 // Helper functions to convert primitive C++ types to `rust::YamlOwned`
diff --git a/serde_json/serde_json_bridge.cc b/serde_json/serde_json_bridge.cc
index 2e8b74d..33f7ba6 100644
--- a/serde_json/serde_json_bridge.cc
+++ b/serde_json/serde_json_bridge.cc
@@ -60,8 +60,8 @@ absl::StatusOr<SerdeJson> SerdeJson::CreateInt(int64_t value) {
 }
 
 absl::StatusOr<SerdeJson> SerdeJson::CreateDouble(double value) {
-  rs_std::Result<rust::json::SerdeJson,
-                 rust::raw_string::RawString>
+  rs::Result<rust::json::SerdeJson,
+             rust::raw_string::RawString>
       rs_result = rust::json::SerdeJson::create_double(value);
 
   if (!rs_result.has_value()) {
@@ -80,8 +80,8 @@ absl::StatusOr<SerdeJson> SerdeJson::CreateNull() {
 }
 
 absl::StatusOr<SerdeJson> SerdeJson::CreateString(absl::string_view value) {
-  rs_std::Result<rust::json::SerdeJson,
-                 rust::raw_string::RawString>
+  rs::Result<rust::json::SerdeJson,
+             rust::raw_string::RawString>
       rs_result = rust::json::SerdeJson::create_string(
           absl::Span<const uint8_t>(
               reinterpret_cast<const uint8_t*>(value.data()), value.size()));
@@ -94,8 +94,8 @@ absl::StatusOr<SerdeJson> SerdeJson::CreateString(absl::string_view value) {
 }
 
 absl::StatusOr<SerdeJson> SerdeJson::Parse(absl::string_view data) {
-  rs_std::Result<rust::json::SerdeJson,
-                 rust::raw_string::RawString>
+  rs::Result<rust::json::SerdeJson,
+             rust::raw_string::RawString>
       rs_result = rust::json::SerdeJson::parse_string(
           absl::Span<const uint8_t>(
               reinterpret_cast<const uint8_t*>(data.data()), data.size()));
@@ -108,8 +108,8 @@ absl::StatusOr<SerdeJson> SerdeJson::Parse(absl::string_view data) {
 }
 
 absl::StatusOr<SerdeJson> SerdeJson::GetField(absl::string_view key) const {
-  rs_std::Result<rust::json::SerdeJson,
-                 rust::raw_string::RawString>
+  rs::Result<rust::json::SerdeJson,
+             rust::raw_string::RawString>
       rs_result = json_obj_.get_field(absl::Span<const uint8_t>(
           reinterpret_cast<const uint8_t*>(key.data()), key.size()));
 
@@ -123,8 +123,8 @@ absl::StatusOr<SerdeJson> SerdeJson::GetField(absl::string_view key) const {
 
 absl::StatusOr<SerdeJson> SerdeJson::GetFieldObject(
     absl::string_view key) const {
-  rs_std::Result<rust::json::SerdeJson,
-                 rust::raw_string::RawString>
+  rs::Result<rust::json::SerdeJson,
+             rust::raw_string::RawString>
       rs_result = json_obj_.get_field_object(absl::Span<const uint8_t>(
           reinterpret_cast<const uint8_t*>(key.data()), key.size()));
 
@@ -137,7 +137,7 @@ absl::StatusOr<SerdeJson> SerdeJson::GetFieldObject(
 }
 
 absl::StatusOr<bool> SerdeJson::GetBool() const {
-  rs_std::Result<bool, rust::raw_string::RawString> rs_result =
+  rs::Result<bool, rust::raw_string::RawString> rs_result =
       json_obj_.get_bool();
 
   if (!rs_result.has_value()) {
@@ -149,8 +149,8 @@ absl::StatusOr<bool> SerdeJson::GetBool() const {
 }
 
 absl::StatusOr<std::string> SerdeJson::GetString() const {
-  rs_std::Result<rust::raw_string::RawString,
-                 rust::raw_string::RawString>
+  rs::Result<rust::raw_string::RawString,
+             rust::raw_string::RawString>
       rs_result = json_obj_.get_string();
 
   if (!rs_result.has_value()) {
@@ -162,8 +162,8 @@ absl::StatusOr<std::string> SerdeJson::GetString() const {
 }
 
 absl::StatusOr<int64_t> SerdeJson::GetInt() const {
-  rs_std::Result<int64_t, rust::raw_string::RawString>
-      rs_result = json_obj_.get_int();
+  rs::Result<int64_t, rust::raw_string::RawString> rs_result =
+      json_obj_.get_int();
 
   if (!rs_result.has_value()) {
     return absl::FailedPreconditionError(
@@ -174,8 +174,8 @@ absl::StatusOr<int64_t> SerdeJson::GetInt() const {
 }
 
 absl::StatusOr<double> SerdeJson::GetDouble() const {
-  rs_std::Result<double, rust::raw_string::RawString>
-      rs_result = json_obj_.get_double();
+  rs::Result<double, rust::raw_string::RawString> rs_result =
+      json_obj_.get_double();
 
   if (!rs_result.has_value()) {
     return absl::FailedPreconditionError(
@@ -186,8 +186,8 @@ absl::StatusOr<double> SerdeJson::GetDouble() const {
 }
 
 absl::StatusOr<std::vector<SerdeJson>> SerdeJson::GetArray() const {
-  rs_std::Result<rust::json::VecSerdeJson,
-                 rust::raw_string::RawString>
+  rs::Result<rust::json::VecSerdeJson,
+             rust::raw_string::RawString>
       rs_result = json_obj_.get_array();
 
   if (!rs_result.has_value()) {
@@ -199,8 +199,8 @@ absl::StatusOr<std::vector<SerdeJson>> SerdeJson::GetArray() const {
 }
 
 absl::StatusOr<SerdeJson> SerdeJson::GetArrayElement(size_t index) const {
-  rs_std::Result<rust::json::SerdeJson,
-                 rust::json::GetArrayElementError>
+  rs::Result<rust::json::SerdeJson,
+             rust::json::GetArrayElementError>
       rs_result = json_obj_.get_array_element(index);
 
   if (!rs_result.has_value()) {
@@ -218,8 +218,8 @@ absl::StatusOr<SerdeJson> SerdeJson::GetArrayElement(size_t index) const {
 
 absl::StatusOr<std::string> SerdeJson::GetFieldString(
     absl::string_view key) const {
-  rs_std::Result<rust::raw_string::RawString,
-                 rust::raw_string::RawString>
+  rs::Result<rust::raw_string::RawString,
+             rust::raw_string::RawString>
       rs_result = json_obj_.get_field_string(absl::Span<const uint8_t>(
           reinterpret_cast<const uint8_t*>(key.data()), key.size()));
 
@@ -232,7 +232,7 @@ absl::StatusOr<std::string> SerdeJson::GetFieldString(
 }
 
 absl::StatusOr<bool> SerdeJson::GetFieldBool(absl::string_view key) const {
-  rs_std::Result<bool, rust::raw_string::RawString> rs_result =
+  rs::Result<bool, rust::raw_string::RawString> rs_result =
       json_obj_.get_field_bool(absl::Span<const uint8_t>(
           reinterpret_cast<const uint8_t*>(key.data()), key.size()));
 
@@ -245,8 +245,8 @@ absl::StatusOr<bool> SerdeJson::GetFieldBool(absl::string_view key) const {
 }
 
 absl::StatusOr<int64_t> SerdeJson::GetFieldInt(absl::string_view key) const {
-  rs_std::Result<int64_t, rust::raw_string::RawString>
-      rs_result = json_obj_.get_field_int(absl::Span<const uint8_t>(
+  rs::Result<int64_t, rust::raw_string::RawString> rs_result =
+      json_obj_.get_field_int(absl::Span<const uint8_t>(
           reinterpret_cast<const uint8_t*>(key.data()), key.size()));
 
   if (!rs_result.has_value()) {
@@ -258,8 +258,8 @@ absl::StatusOr<int64_t> SerdeJson::GetFieldInt(absl::string_view key) const {
 }
 
 absl::StatusOr<double> SerdeJson::GetFieldDouble(absl::string_view key) const {
-  rs_std::Result<double, rust::raw_string::RawString>
-      rs_result = json_obj_.get_field_double(absl::Span<const uint8_t>(
+  rs::Result<double, rust::raw_string::RawString> rs_result =
+      json_obj_.get_field_double(absl::Span<const uint8_t>(
           reinterpret_cast<const uint8_t*>(key.data()), key.size()));
 
   if (!rs_result.has_value()) {
@@ -272,8 +272,8 @@ absl::StatusOr<double> SerdeJson::GetFieldDouble(absl::string_view key) const {
 
 absl::StatusOr<std::vector<SerdeJson>> SerdeJson::GetFieldArray(
     absl::string_view key) const {
-  rs_std::Result<rust::json::VecSerdeJson,
-                 rust::raw_string::RawString>
+  rs::Result<rust::json::VecSerdeJson,
+             rust::raw_string::RawString>
       rs_result = json_obj_.get_field_array(absl::Span<const uint8_t>(
           reinterpret_cast<const uint8_t*>(key.data()), key.size()));
 
@@ -287,8 +287,8 @@ absl::StatusOr<std::vector<SerdeJson>> SerdeJson::GetFieldArray(
 
 absl::StatusOr<SerdeJson> SerdeJson::GetFieldArrayElement(absl::string_view key,
                                                           size_t index) const {
-  rs_std::Result<rust::json::SerdeJson,
-                 rust::json::GetArrayElementError>
+  rs::Result<rust::json::SerdeJson,
+             rust::json::GetArrayElementError>
       rs_result = json_obj_.get_field_array_element(
           absl::Span<const uint8_t>(
               reinterpret_cast<const uint8_t*>(key.data()), key.size()),
@@ -330,8 +330,8 @@ std::string SerdeJson::ToString(bool sort_keys) const {
 }
 
 absl::StatusOr<std::vector<std::string>> SerdeJson::GetKeys() const {
-  rs_std::Result<rust::json::VecRawString,
-                 rust::raw_string::RawString>
+  rs::Result<rust::json::VecRawString,
+             rust::raw_string::RawString>
       rs_result = json_obj_.get_keys();
 
   if (!rs_result.has_value()) {
@@ -350,7 +350,7 @@ absl::StatusOr<std::vector<std::string>> SerdeJson::GetKeys() const {
 }
 
 absl::StatusOr<bool> SerdeJson::HasField(absl::string_view key) const {
-  rs_std::Result<bool, rust::raw_string::RawString> rs_result =
+  rs::Result<bool, rust::raw_string::RawString> rs_result =
       json_obj_.has_field(absl::Span<const uint8_t>(
           reinterpret_cast<const uint8_t*>(key.data()), key.size()));
 
diff --git a/zip/converters.cc b/zip/converters.cc
index 9c5eaa5..4ad0613 100644
--- a/zip/converters.cc
+++ b/zip/converters.cc
@@ -35,7 +35,7 @@ absl::Status ZipErrorToStatus(rust::ZipError err) {
 }  // namespace
 
 absl::StatusOr<RustVecU8Wrapper> FromRustResultVecU8(
-    rs_std::Result<rust::VecU8, rust::ZipError> result_vec_u8) {
+    rs::Result<rust::VecU8, rust::ZipError> result_vec_u8) {
   if (!result_vec_u8.has_value()) {
     return ZipErrorToStatus(std::move(result_vec_u8).err());
   }
@@ -43,7 +43,7 @@ absl::StatusOr<RustVecU8Wrapper> FromRustResultVecU8(
 }
 
 absl::Status FromRustResultUnit(
-    rs_std::Result<uint8_t, rust::ZipError> result_unit) {
+    rs::Result<uint8_t, rust::ZipError> result_unit) {
   if (!result_unit.has_value()) {
     return ZipErrorToStatus(std::move(result_unit).err());
   }
@@ -51,7 +51,7 @@ absl::Status FromRustResultUnit(
 }
 
 absl::StatusOr<rust::BufferedZipArchive> FromRustBufferedZipArchive(
-    rs_std::Result<rust::BufferedZipArchive, rust::ZipError>
+    rs::Result<rust::BufferedZipArchive, rust::ZipError>
         result_buffered_zip_archive) {
   if (!result_buffered_zip_archive.has_value()) {
     return ZipErrorToStatus(std::move(result_buffered_zip_archive).err());
@@ -60,7 +60,7 @@ absl::StatusOr<rust::BufferedZipArchive> FromRustBufferedZipArchive(
 }
 
 absl::StatusOr<rust::FsZipArchive> FromRustFsZipArchive(
-    rs_std::Result<rust::FsZipArchive, rust::ZipError>
+    rs::Result<rust::FsZipArchive, rust::ZipError>
         result_fs_zip_archive) {
   if (!result_fs_zip_archive.has_value()) {
     return ZipErrorToStatus(std::move(result_fs_zip_archive).err());
@@ -69,7 +69,7 @@ absl::StatusOr<rust::FsZipArchive> FromRustFsZipArchive(
 }
 
 absl::StatusOr<rust::BufferedZipFile> FromRustBufferedZipFile(
-    rs_std::Result<rust::BufferedZipFile, rust::ZipError>
+    rs::Result<rust::BufferedZipFile, rust::ZipError>
         result_buffered_zip_file) {
   if (!result_buffered_zip_file.has_value()) {
     return ZipErrorToStatus(std::move(result_buffered_zip_file).err());
@@ -78,7 +78,7 @@ absl::StatusOr<rust::BufferedZipFile> FromRustBufferedZipFile(
 }
 
 absl::StatusOr<rust::FsZipFile> FromRustFsZipFile(
-    rs_std::Result<rust::FsZipFile, rust::ZipError>
+    rs::Result<rust::FsZipFile, rust::ZipError>
         result_fs_zip_file) {
   if (!result_fs_zip_file.has_value()) {
     return ZipErrorToStatus(std::move(result_fs_zip_file).err());
@@ -87,7 +87,7 @@ absl::StatusOr<rust::FsZipFile> FromRustFsZipFile(
 }
 
 absl::StatusOr<rust::BufferedZipWriter> FromRustBufferedZipWriter(
-    rs_std::Result<rust::BufferedZipWriter, rust::ZipError>
+    rs::Result<rust::BufferedZipWriter, rust::ZipError>
         result_buffered_zip_writer) {
   if (!result_buffered_zip_writer.has_value()) {
     return ZipErrorToStatus(std::move(result_buffered_zip_writer).err());
@@ -96,7 +96,7 @@ absl::StatusOr<rust::BufferedZipWriter> FromRustBufferedZipWriter(
 }
 
 absl::StatusOr<rust::FsZipWriter> FromRustFsZipWriter(
-    rs_std::Result<rust::FsZipWriter, rust::ZipError>
+    rs::Result<rust::FsZipWriter, rust::ZipError>
         result_fs_zip_writer) {
   if (!result_fs_zip_writer.has_value()) {
     return ZipErrorToStatus(std::move(result_fs_zip_writer).err());