diff --git a/repertory/librepertory/include/app_config.hpp b/repertory/librepertory/include/app_config.hpp
index a2838222..d320109d 100644
--- a/repertory/librepertory/include/app_config.hpp
+++ b/repertory/librepertory/include/app_config.hpp
@@ -57,7 +57,7 @@ public:
   static void set_stop_requested();
 
 public:
-  app_config(provider_type prov, std::string_view data_directory = "");
+  app_config(provider_type prov, std::string_view data_directory);
 
   app_config() = delete;
   app_config(app_config &&) = delete;
@@ -73,7 +73,9 @@ private:
   utils::atomic<std::string> api_password_;
   std::atomic<std::uint16_t> api_port_;
   utils::atomic<std::string> api_user_;
+  std::string cache_directory_;
   std::atomic<bool> config_changed_;
+  std::string data_directory_;
   std::atomic<database_type> db_type_{database_type::rocksdb};
   std::atomic<std::uint8_t> download_timeout_secs_;
   std::atomic<bool> enable_download_timeout_;
@@ -85,6 +87,7 @@ private:
   std::atomic<std::uint32_t> eviction_delay_mins_;
   std::atomic<bool> eviction_uses_accessed_time_;
   std::atomic<std::uint16_t> high_freq_interval_secs_;
+  std::string log_directory_;
   std::atomic<std::uint16_t> low_freq_interval_secs_;
   std::atomic<std::uint64_t> max_cache_size_bytes_;
   std::atomic<std::uint8_t> max_upload_count_;
@@ -96,11 +99,8 @@ private:
   std::atomic<std::uint16_t> task_wait_ms_;
 
 private:
-  std::string cache_directory_;
-  std::string data_directory_;
   utils::atomic<encrypt_config> encrypt_config_;
   utils::atomic<host_config> host_config_;
-  std::string log_directory_;
   mutable std::recursive_mutex read_write_mutex_;
   utils::atomic<remote::remote_config> remote_config_;
   utils::atomic<remote::remote_mount> remote_mount_;
@@ -108,8 +108,7 @@ private:
   utils::atomic<sia_config> sia_config_;
   std::unordered_map<std::string, std::function<std::string()>>
       value_get_lookup_;
-  std::unordered_map<std::string,
-                     std::function<std::string(const std::string &)>>
+  std::unordered_map<std::string, std::function<std::string(std::string_view)>>
       value_set_lookup_;
   std::uint64_t version_{REPERTORY_CONFIG_VERSION};
 
@@ -119,6 +118,8 @@ private:
   template <typename dest, typename source>
   auto set_value(dest &dst, const source &src) -> bool;
 
+  auto set_value(utils::atomic<std::string> &dst, std::string_view src) -> bool;
+
 public:
   [[nodiscard]] auto get_api_password() const -> std::string;
 
@@ -188,21 +189,21 @@ public:
 
   [[nodiscard]] auto get_task_wait_ms() const -> std::uint16_t;
 
-  [[nodiscard]] auto get_value_by_name(const std::string &name) const
+  [[nodiscard]] auto get_value_by_name(std::string_view name) const
       -> std::string;
 
-  [[nodiscard]] auto get_raw_value_by_name(const std::string &name) const
+  [[nodiscard]] auto get_raw_value_by_name(std::string_view name) const
       -> std::string;
 
   [[nodiscard]] auto get_version() const -> std::uint64_t;
 
   void save();
 
-  void set_api_password(const std::string &value);
+  void set_api_password(std::string_view value);
 
   void set_api_port(std::uint16_t value);
 
-  void set_api_user(const std::string &value);
+  void set_api_user(std::string_view value);
 
   void set_download_timeout_secs(std::uint8_t value);
 
@@ -254,8 +255,8 @@ public:
 
   void set_task_wait_ms(std::uint16_t value);
 
-  [[nodiscard]] auto set_value_by_name(const std::string &name,
-                                       const std::string &value) -> std::string;
+  [[nodiscard]] auto set_value_by_name(std::string_view name,
+                                       std::string_view value) -> std::string;
 };
 } // namespace repertory
 
diff --git a/repertory/librepertory/include/comm/curl/curl_comm.hpp b/repertory/librepertory/include/comm/curl/curl_comm.hpp
index cd9590c3..d809b1e3 100644
--- a/repertory/librepertory/include/comm/curl/curl_comm.hpp
+++ b/repertory/librepertory/include/comm/curl/curl_comm.hpp
@@ -62,14 +62,14 @@ public:
 
 public:
   [[nodiscard]] static auto construct_url(CURL *curl,
-                                          const std::string &relative_path,
+                                          std::string_view relative_path,
                                           const host_config &cfg)
       -> std::string;
 
   [[nodiscard]] static auto create_host_config(const s3_config &cfg)
       -> host_config;
 
-  [[nodiscard]] static auto url_encode(CURL *curl, const std::string &data,
+  [[nodiscard]] static auto url_encode(CURL *curl, std::string_view data,
                                        bool allow_slash) -> std::string;
 
   template <typename request_type>
@@ -97,14 +97,15 @@ public:
         request.decryption_token.value());
     if (not utils::encryption::read_encrypted_range(
             request.range.value(), key,
-            [&](data_buffer &ct, std::uint64_t start_offset,
+            [&](data_buffer &buffer, std::uint64_t start_offset,
                 std::uint64_t end_offset) -> bool {
               auto encrypted_request = request;
               encrypted_request.decryption_token = std::nullopt;
               encrypted_request.range = {{start_offset, end_offset}};
               encrypted_request.response_handler =
-                  [&ct](const auto &encrypted_data, long /*response_code*/) {
-                    ct = encrypted_data;
+                  [&buffer](const auto &encrypted_data,
+                            long /*response_code*/) {
+                    buffer = encrypted_data;
                   };
               encrypted_request.total_size = std::nullopt;
 
diff --git a/repertory/librepertory/include/comm/packet/client_pool.hpp b/repertory/librepertory/include/comm/packet/client_pool.hpp
index 9df0ab04..728a665f 100644
--- a/repertory/librepertory/include/comm/packet/client_pool.hpp
+++ b/repertory/librepertory/include/comm/packet/client_pool.hpp
@@ -97,11 +97,11 @@ private:
   static constexpr auto min_pool_size = 10U;
 
 public:
-  void execute(const std::string &client_id, std::uint64_t thread_id,
+  void execute(std::string_view client_id, std::uint64_t thread_id,
                const worker_callback &worker,
                const worker_complete_callback &worker_complete);
 
-  void remove_client(const std::string &client_id);
+  void remove_client(std::string_view client_id);
 
   void shutdown();
 };
diff --git a/repertory/librepertory/include/comm/packet/common.hpp b/repertory/librepertory/include/comm/packet/common.hpp
index edd29225..1cda016f 100644
--- a/repertory/librepertory/include/comm/packet/common.hpp
+++ b/repertory/librepertory/include/comm/packet/common.hpp
@@ -49,12 +49,11 @@ private:
 };
 
 template <class op_t>
-inline void run_with_deadline(boost::asio::io_context &io_ctx,
-                              boost::asio::ip::tcp::socket &sock,
-                              op_t operation,
-                              std::chrono::milliseconds deadline,
-                              const std::string &event_name,
-                              const std::string &function_name);
+inline void
+run_with_deadline(boost::asio::io_context &io_ctx,
+                  boost::asio::ip::tcp::socket &sock, op_t operation,
+                  std::chrono::milliseconds deadline,
+                  std::string_view event_name, std::string_view function_name);
 
 void apply_common_socket_properties(boost::asio::ip::tcp::socket &sock);
 
@@ -78,12 +77,11 @@ void write_all_with_deadline(boost::asio::io_context &io_ctx,
                              std::chrono::milliseconds deadline);
 
 template <class op_t>
-inline void run_with_deadline(boost::asio::io_context &io_ctx,
-                              boost::asio::ip::tcp::socket &sock,
-                              op_t operation,
-                              std::chrono::milliseconds deadline,
-                              const std::string &event_name,
-                              const std::string &function_name) {
+inline void
+run_with_deadline(boost::asio::io_context &io_ctx,
+                  boost::asio::ip::tcp::socket &sock, op_t operation,
+                  std::chrono::milliseconds deadline,
+                  std::string_view event_name, std::string_view function_name) {
   deadline = std::max(deadline, std::chrono::milliseconds{250});
 
   struct request_state final {
@@ -118,12 +116,12 @@ inline void run_with_deadline(boost::asio::io_context &io_ctx,
 
   if (state->timed_out) {
     repertory::event_system::instance().raise<repertory::packet_client_timeout>(
-        std::string(event_name), std::string(function_name));
-    throw std::runtime_error(event_name + " timed-out");
+        event_name, function_name);
+    throw std::runtime_error(std::string{event_name} + " timed-out");
   }
 
   if (state->err) {
-    throw std::runtime_error(event_name + " failed|err|" +
+    throw std::runtime_error(std::string{event_name} + " failed|err|" +
                              state->err.message());
   }
 }
diff --git a/repertory/librepertory/include/comm/packet/packet_server.hpp b/repertory/librepertory/include/comm/packet/packet_server.hpp
index cb33c4a1..cab3669d 100644
--- a/repertory/librepertory/include/comm/packet/packet_server.hpp
+++ b/repertory/librepertory/include/comm/packet/packet_server.hpp
@@ -32,10 +32,10 @@ using boost::asio::ip::tcp;
 namespace repertory {
 class packet_server final {
 public:
-  using closed_callback = std::function<void(const std::string &)>;
+  using closed_callback = std::function<void(std::string_view)>;
   using message_complete_callback = client_pool::worker_complete_callback;
   using message_handler_callback = std::function<void(
-      std::uint32_t, const std::string &, std::uint64_t, const std::string &,
+      std::uint32_t, std::string_view, std::uint64_t, std::string_view,
       packet *, packet &, message_complete_callback)>;
 
 public:
@@ -78,7 +78,7 @@ private:
   std::unordered_map<std::string, std::uint32_t> connection_lookup_;
 
 private:
-  void add_client(connection &conn, const std::string &client_id);
+  void add_client(connection &conn, std::string_view client_id);
 
   [[nodiscard]] auto handshake(std::shared_ptr<connection> conn) const -> bool;
 
diff --git a/repertory/librepertory/include/db/i_file_db.hpp b/repertory/librepertory/include/db/i_file_db.hpp
index c990ec65..ac31e731 100644
--- a/repertory/librepertory/include/db/i_file_db.hpp
+++ b/repertory/librepertory/include/db/i_file_db.hpp
@@ -68,43 +68,43 @@ public:
       std::function<void(const std::vector<i_file_db::file_info> &)> callback,
       stop_type_callback stop_requested_cb) const = 0;
 
-  [[nodiscard]] virtual auto get_api_path(const std::string &source_path,
+  [[nodiscard]] virtual auto get_api_path(std::string_view source_path,
                                           std::string &api_path) const
       -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_directory_api_path(const std::string &source_path,
+  get_directory_api_path(std::string_view source_path,
                          std::string &api_path) const -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_directory_data(const std::string &api_path,
+  [[nodiscard]] virtual auto get_directory_data(std::string_view api_path,
                                                 directory_data &data) const
       -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_directory_source_path(const std::string &api_path,
+  get_directory_source_path(std::string_view api_path,
                             std::string &source_path) const -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_file_api_path(const std::string &source_path,
+  [[nodiscard]] virtual auto get_file_api_path(std::string_view source_path,
                                                std::string &api_path) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_file_data(const std::string &api_path,
+  [[nodiscard]] virtual auto get_file_data(std::string_view api_path,
                                            file_data &data) const
       -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_file_source_path(const std::string &api_path,
+  get_file_source_path(std::string_view api_path,
                        std::string &source_path) const -> api_error = 0;
 
   [[nodiscard]] virtual auto
   get_item_list(stop_type_callback stop_requested_cb) const
       -> std::vector<file_info> = 0;
 
-  [[nodiscard]] virtual auto get_source_path(const std::string &api_path,
+  [[nodiscard]] virtual auto get_source_path(std::string_view api_path,
                                              std::string &source_path) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto remove_item(const std::string &api_path)
+  [[nodiscard]] virtual auto remove_item(std::string_view api_path)
       -> api_error = 0;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/db/i_file_mgr_db.hpp b/repertory/librepertory/include/db/i_file_mgr_db.hpp
index 8d4627f1..e39bc8bc 100644
--- a/repertory/librepertory/include/db/i_file_mgr_db.hpp
+++ b/repertory/librepertory/include/db/i_file_mgr_db.hpp
@@ -59,23 +59,23 @@ public:
   [[nodiscard]] virtual auto get_resume_list() const
       -> std::vector<resume_entry> = 0;
 
-  [[nodiscard]] virtual auto get_upload(const std::string &api_path) const
+  [[nodiscard]] virtual auto get_upload(std::string_view api_path) const
       -> std::optional<upload_entry> = 0;
 
   [[nodiscard]] virtual auto get_upload_active_list() const
       -> std::vector<upload_active_entry> = 0;
 
-  [[nodiscard]] virtual auto remove_resume(const std::string &api_path)
+  [[nodiscard]] virtual auto remove_resume(std::string_view api_path)
       -> bool = 0;
 
-  [[nodiscard]] virtual auto remove_upload(const std::string &api_path)
+  [[nodiscard]] virtual auto remove_upload(std::string_view api_path)
       -> bool = 0;
 
-  [[nodiscard]] virtual auto remove_upload_active(const std::string &api_path)
+  [[nodiscard]] virtual auto remove_upload_active(std::string_view api_path)
       -> bool = 0;
 
-  [[nodiscard]] virtual auto rename_resume(const std::string &from_api_path,
-                                           const std::string &to_api_path)
+  [[nodiscard]] virtual auto rename_resume(std::string_view from_api_path,
+                                           std::string_view to_api_path)
       -> bool = 0;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/db/i_meta_db.hpp b/repertory/librepertory/include/db/i_meta_db.hpp
index a1a0d467..1344f7b1 100644
--- a/repertory/librepertory/include/db/i_meta_db.hpp
+++ b/repertory/librepertory/include/db/i_meta_db.hpp
@@ -35,19 +35,19 @@ public:
       std::function<void(const std::vector<std::string> &)> callback,
       stop_type_callback stop_requested_cb) const = 0;
 
-  [[nodiscard]] virtual auto get_api_path(const std::string &source_path,
+  [[nodiscard]] virtual auto get_api_path(std::string_view source_path,
                                           std::string &api_path) const
       -> api_error = 0;
 
   [[nodiscard]] virtual auto get_api_path_list() const
       -> std::vector<std::string> = 0;
 
-  [[nodiscard]] virtual auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] virtual auto get_item_meta(std::string_view api_path,
                                            api_meta_map &meta) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_item_meta(const std::string &api_path,
-                                           const std::string &key,
+  [[nodiscard]] virtual auto get_item_meta(std::string_view api_path,
+                                           std::string_view key,
                                            std::string &value) const
       -> api_error = 0;
 
@@ -58,22 +58,22 @@ public:
 
   [[nodiscard]] virtual auto get_total_size() const -> std::uint64_t = 0;
 
-  virtual void remove_api_path(const std::string &api_path) = 0;
+  virtual void remove_api_path(std::string_view api_path) = 0;
 
-  [[nodiscard]] virtual auto remove_item_meta(const std::string &api_path,
-                                              const std::string &key)
+  [[nodiscard]] virtual auto remove_item_meta(std::string_view api_path,
+                                              std::string_view key)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto rename_item_meta(const std::string &from_api_path,
-                                              const std::string &to_api_path)
+  [[nodiscard]] virtual auto rename_item_meta(std::string_view from_api_path,
+                                              std::string_view to_api_path)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto set_item_meta(const std::string &api_path,
-                                           const std::string &key,
-                                           const std::string &value)
+  [[nodiscard]] virtual auto set_item_meta(std::string_view api_path,
+                                           std::string_view key,
+                                           std::string_view value)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto set_item_meta(const std::string &api_path,
+  [[nodiscard]] virtual auto set_item_meta(std::string_view api_path,
                                            const api_meta_map &meta)
       -> api_error = 0;
 };
diff --git a/repertory/librepertory/include/db/impl/rdb_file_db.hpp b/repertory/librepertory/include/db/impl/rdb_file_db.hpp
index 68190482..c033c6b2 100644
--- a/repertory/librepertory/include/db/impl/rdb_file_db.hpp
+++ b/repertory/librepertory/include/db/impl/rdb_file_db.hpp
@@ -62,8 +62,8 @@ private:
       std::function<rocksdb::Status(rocksdb::Transaction *txn)> action)
       -> api_error;
 
-  [[nodiscard]] auto remove_item(const std::string &api_path,
-                                 const std::string &source_path,
+  [[nodiscard]] auto remove_item(std::string_view api_path,
+                                 std::string_view source_path,
                                  rocksdb::Transaction *txn) -> rocksdb::Status;
 
 public:
@@ -81,42 +81,42 @@ public:
       std::function<void(const std::vector<i_file_db::file_info> &)> callback,
       stop_type_callback stop_requested_cb) const override;
 
-  [[nodiscard]] auto get_api_path(const std::string &source_path,
+  [[nodiscard]] auto get_api_path(std::string_view source_path,
                                   std::string &api_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_api_path(const std::string &source_path,
+  [[nodiscard]] auto get_directory_api_path(std::string_view source_path,
                                             std::string &api_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_data(const std::string &api_path,
+  [[nodiscard]] auto get_directory_data(std::string_view api_path,
                                         i_file_db::directory_data &data) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_source_path(const std::string &api_path,
+  [[nodiscard]] auto get_directory_source_path(std::string_view api_path,
                                                std::string &source_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file_api_path(const std::string &source_path,
+  [[nodiscard]] auto get_file_api_path(std::string_view source_path,
                                        std::string &api_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file_data(const std::string &api_path,
+  [[nodiscard]] auto get_file_data(std::string_view api_path,
                                    i_file_db::file_data &data) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file_source_path(const std::string &api_path,
+  [[nodiscard]] auto get_file_source_path(std::string_view api_path,
                                           std::string &source_path) const
       -> api_error override;
 
   [[nodiscard]] auto get_item_list(stop_type_callback stop_requested_cb) const
       -> std::vector<i_file_db::file_info> override;
 
-  [[nodiscard]] auto get_source_path(const std::string &api_path,
+  [[nodiscard]] auto get_source_path(std::string_view api_path,
                                      std::string &source_path) const
       -> api_error override;
 
-  [[nodiscard]] auto remove_item(const std::string &api_path)
+  [[nodiscard]] auto remove_item(std::string_view api_path)
       -> api_error override;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/db/impl/rdb_file_mgr_db.hpp b/repertory/librepertory/include/db/impl/rdb_file_mgr_db.hpp
index 1e00f9c7..e57a6e0a 100644
--- a/repertory/librepertory/include/db/impl/rdb_file_mgr_db.hpp
+++ b/repertory/librepertory/include/db/impl/rdb_file_mgr_db.hpp
@@ -61,7 +61,7 @@ private:
       std::string_view function_name,
       std::function<rocksdb::Status(rocksdb::Transaction *txn)> action) -> bool;
 
-  [[nodiscard]] auto remove_resume(const std::string &api_path,
+  [[nodiscard]] auto remove_resume(std::string_view api_path,
                                    rocksdb::Transaction *txn)
       -> rocksdb::Status;
 
@@ -84,23 +84,21 @@ public:
   [[nodiscard]] auto get_resume_list() const
       -> std::vector<resume_entry> override;
 
-  [[nodiscard]] auto get_upload(const std::string &api_path) const
+  [[nodiscard]] auto get_upload(std::string_view api_path) const
       -> std::optional<upload_entry> override;
 
   [[nodiscard]] auto get_upload_active_list() const
       -> std::vector<upload_active_entry> override;
 
-  [[nodiscard]] auto remove_resume(const std::string &api_path)
+  [[nodiscard]] auto remove_resume(std::string_view api_path) -> bool override;
+
+  [[nodiscard]] auto remove_upload(std::string_view api_path) -> bool override;
+
+  [[nodiscard]] auto remove_upload_active(std::string_view api_path)
       -> bool override;
 
-  [[nodiscard]] auto remove_upload(const std::string &api_path)
-      -> bool override;
-
-  [[nodiscard]] auto remove_upload_active(const std::string &api_path)
-      -> bool override;
-
-  [[nodiscard]] auto rename_resume(const std::string &from_api_path,
-                                   const std::string &to_api_path)
+  [[nodiscard]] auto rename_resume(std::string_view from_api_path,
+                                   std::string_view to_api_path)
       -> bool override;
 };
 
diff --git a/repertory/librepertory/include/db/impl/rdb_meta_db.hpp b/repertory/librepertory/include/db/impl/rdb_meta_db.hpp
index b235f779..bf78b282 100644
--- a/repertory/librepertory/include/db/impl/rdb_meta_db.hpp
+++ b/repertory/librepertory/include/db/impl/rdb_meta_db.hpp
@@ -54,7 +54,7 @@ private:
 
   void create_or_open(bool clear);
 
-  [[nodiscard]] auto get_item_meta_json(const std::string &api_path,
+  [[nodiscard]] auto get_item_meta_json(std::string_view api_path,
                                         json &json_data) const -> api_error;
 
   [[nodiscard]] static auto
@@ -66,13 +66,12 @@ private:
       std::function<rocksdb::Status(rocksdb::Transaction *txn)> action)
       -> api_error;
 
-  [[nodiscard]] auto remove_api_path(const std::string &api_path,
-                                     const std::string &source_path,
+  [[nodiscard]] auto remove_api_path(std::string_view api_path,
+                                     std::string_view source_path,
                                      rocksdb::Transaction *txn)
       -> rocksdb::Status;
 
-  [[nodiscard]] auto update_item_meta(const std::string &api_path,
-                                      json json_data,
+  [[nodiscard]] auto update_item_meta(std::string_view api_path, json json_data,
                                       rocksdb::Transaction *base_txn = nullptr,
                                       rocksdb::Status *status = nullptr)
       -> api_error;
@@ -84,19 +83,19 @@ public:
       std::function<void(const std::vector<std::string> &)> callback,
       stop_type_callback stop_requested_cb) const override;
 
-  [[nodiscard]] auto get_api_path(const std::string &source_path,
+  [[nodiscard]] auto get_api_path(std::string_view source_path,
                                   std::string &api_path) const
       -> api_error override;
 
   [[nodiscard]] auto get_api_path_list() const
       -> std::vector<std::string> override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
                                    api_meta_map &meta) const
       -> api_error override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
-                                   const std::string &key,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
+                                   std::string_view key,
                                    std::string &value) const
       -> api_error override;
 
@@ -107,22 +106,21 @@ public:
 
   [[nodiscard]] auto get_total_size() const -> std::uint64_t override;
 
-  void remove_api_path(const std::string &api_path) override;
+  void remove_api_path(std::string_view api_path) override;
 
-  [[nodiscard]] auto remove_item_meta(const std::string &api_path,
-                                      const std::string &key)
+  [[nodiscard]] auto remove_item_meta(std::string_view api_path,
+                                      std::string_view key)
       -> api_error override;
 
-  [[nodiscard]] auto rename_item_meta(const std::string &from_api_path,
-                                      const std::string &to_api_path)
+  [[nodiscard]] auto rename_item_meta(std::string_view from_api_path,
+                                      std::string_view to_api_path)
       -> api_error override;
 
-  [[nodiscard]] auto set_item_meta(const std::string &api_path,
-                                   const std::string &key,
-                                   const std::string &value)
+  [[nodiscard]] auto set_item_meta(std::string_view api_path,
+                                   std::string_view key, std::string_view value)
       -> api_error override;
 
-  [[nodiscard]] auto set_item_meta(const std::string &api_path,
+  [[nodiscard]] auto set_item_meta(std::string_view api_path,
                                    const api_meta_map &meta)
       -> api_error override;
 };
diff --git a/repertory/librepertory/include/db/impl/sqlite_file_db.hpp b/repertory/librepertory/include/db/impl/sqlite_file_db.hpp
index 49f68cf3..6c1266ff 100644
--- a/repertory/librepertory/include/db/impl/sqlite_file_db.hpp
+++ b/repertory/librepertory/include/db/impl/sqlite_file_db.hpp
@@ -57,42 +57,42 @@ public:
       std::function<void(const std::vector<i_file_db::file_info> &)> callback,
       stop_type_callback stop_requested_cb) const override;
 
-  [[nodiscard]] auto get_api_path(const std::string &source_path,
+  [[nodiscard]] auto get_api_path(std::string_view source_path,
                                   std::string &api_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_api_path(const std::string &source_path,
+  [[nodiscard]] auto get_directory_api_path(std::string_view source_path,
                                             std::string &api_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_data(const std::string &api_path,
+  [[nodiscard]] auto get_directory_data(std::string_view api_path,
                                         i_file_db::directory_data &data) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_source_path(const std::string &api_path,
+  [[nodiscard]] auto get_directory_source_path(std::string_view api_path,
                                                std::string &source_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file_api_path(const std::string &source_path,
+  [[nodiscard]] auto get_file_api_path(std::string_view source_path,
                                        std::string &api_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file_data(const std::string &api_path,
+  [[nodiscard]] auto get_file_data(std::string_view api_path,
                                    i_file_db::file_data &data) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file_source_path(const std::string &api_path,
+  [[nodiscard]] auto get_file_source_path(std::string_view api_path,
                                           std::string &source_path) const
       -> api_error override;
 
   [[nodiscard]] auto get_item_list(stop_type_callback stop_requested_cb) const
       -> std::vector<i_file_db::file_info> override;
 
-  [[nodiscard]] auto get_source_path(const std::string &api_path,
+  [[nodiscard]] auto get_source_path(std::string_view api_path,
                                      std::string &source_path) const
       -> api_error override;
 
-  [[nodiscard]] auto remove_item(const std::string &api_path)
+  [[nodiscard]] auto remove_item(std::string_view api_path)
       -> api_error override;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/db/impl/sqlite_file_mgr_db.hpp b/repertory/librepertory/include/db/impl/sqlite_file_mgr_db.hpp
index acdb2a1d..b5081491 100644
--- a/repertory/librepertory/include/db/impl/sqlite_file_mgr_db.hpp
+++ b/repertory/librepertory/include/db/impl/sqlite_file_mgr_db.hpp
@@ -57,23 +57,21 @@ public:
   [[nodiscard]] auto get_resume_list() const
       -> std::vector<resume_entry> override;
 
-  [[nodiscard]] auto get_upload(const std::string &api_path) const
+  [[nodiscard]] auto get_upload(std::string_view api_path) const
       -> std::optional<upload_entry> override;
 
   [[nodiscard]] auto get_upload_active_list() const
       -> std::vector<upload_active_entry> override;
 
-  [[nodiscard]] auto remove_resume(const std::string &api_path)
+  [[nodiscard]] auto remove_resume(std::string_view api_path) -> bool override;
+
+  [[nodiscard]] auto remove_upload(std::string_view api_path) -> bool override;
+
+  [[nodiscard]] auto remove_upload_active(std::string_view api_path)
       -> bool override;
 
-  [[nodiscard]] auto remove_upload(const std::string &api_path)
-      -> bool override;
-
-  [[nodiscard]] auto remove_upload_active(const std::string &api_path)
-      -> bool override;
-
-  [[nodiscard]] auto rename_resume(const std::string &from_api_path,
-                                   const std::string &to_api_path)
+  [[nodiscard]] auto rename_resume(std::string_view from_api_path,
+                                   std::string_view to_api_path)
       -> bool override;
 };
 
diff --git a/repertory/librepertory/include/db/impl/sqlite_meta_db.hpp b/repertory/librepertory/include/db/impl/sqlite_meta_db.hpp
index c1f7691d..f192e3b5 100644
--- a/repertory/librepertory/include/db/impl/sqlite_meta_db.hpp
+++ b/repertory/librepertory/include/db/impl/sqlite_meta_db.hpp
@@ -44,7 +44,7 @@ private:
   constexpr static const auto table_name = "meta";
 
 private:
-  [[nodiscard]] auto update_item_meta(const std::string &api_path,
+  [[nodiscard]] auto update_item_meta(std::string_view api_path,
                                       api_meta_map meta) -> api_error;
 
 public:
@@ -54,19 +54,19 @@ public:
       std::function<void(const std::vector<std::string> &)> callback,
       stop_type_callback stop_requested_cb) const override;
 
-  [[nodiscard]] auto get_api_path(const std::string &source_path,
+  [[nodiscard]] auto get_api_path(std::string_view source_path,
                                   std::string &api_path) const
       -> api_error override;
 
   [[nodiscard]] auto get_api_path_list() const
       -> std::vector<std::string> override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
                                    api_meta_map &meta) const
       -> api_error override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
-                                   const std::string &key,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
+                                   std::string_view key,
                                    std::string &value) const
       -> api_error override;
 
@@ -77,22 +77,21 @@ public:
 
   [[nodiscard]] auto get_total_size() const -> std::uint64_t override;
 
-  void remove_api_path(const std::string &api_path) override;
+  void remove_api_path(std::string_view api_path) override;
 
-  [[nodiscard]] auto remove_item_meta(const std::string &api_path,
-                                      const std::string &key)
+  [[nodiscard]] auto remove_item_meta(std::string_view api_path,
+                                      std::string_view key)
       -> api_error override;
 
-  [[nodiscard]] auto rename_item_meta(const std::string &from_api_path,
-                                      const std::string &to_api_path)
+  [[nodiscard]] auto rename_item_meta(std::string_view from_api_path,
+                                      std::string_view to_api_path)
       -> api_error override;
 
-  [[nodiscard]] auto set_item_meta(const std::string &api_path,
-                                   const std::string &key,
-                                   const std::string &value)
+  [[nodiscard]] auto set_item_meta(std::string_view api_path,
+                                   std::string_view key, std::string_view value)
       -> api_error override;
 
-  [[nodiscard]] auto set_item_meta(const std::string &api_path,
+  [[nodiscard]] auto set_item_meta(std::string_view api_path,
                                    const api_meta_map &meta)
       -> api_error override;
 };
diff --git a/repertory/librepertory/include/drives/directory_cache.hpp b/repertory/librepertory/include/drives/directory_cache.hpp
index 1278d5e1..b8abcf42 100644
--- a/repertory/librepertory/include/drives/directory_cache.hpp
+++ b/repertory/librepertory/include/drives/directory_cache.hpp
@@ -49,18 +49,18 @@ private:
   std::recursive_mutex directory_mutex_;
 
 public:
-  void execute_action(const std::string &api_path,
+  void execute_action(std::string_view api_path,
                       const execute_callback &execute);
 
   [[nodiscard]] auto get_directory(std::uint64_t handle)
       -> std::shared_ptr<directory_iterator>;
 
-  auto remove_directory(const std::string &api_path)
+  auto remove_directory(std::string_view api_path)
       -> std::shared_ptr<directory_iterator>;
 
   void remove_directory(std::uint64_t handle);
 
-  void set_directory(const std::string &api_path, std::uint64_t handle,
+  void set_directory(std::string_view api_path, std::uint64_t handle,
                      std::shared_ptr<directory_iterator> iterator);
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/drives/directory_iterator.hpp b/repertory/librepertory/include/drives/directory_iterator.hpp
index d8a0874d..00aafedd 100644
--- a/repertory/librepertory/include/drives/directory_iterator.hpp
+++ b/repertory/librepertory/include/drives/directory_iterator.hpp
@@ -30,8 +30,8 @@ class directory_iterator final {
 public:
 #if !defined(_WIN32)
   using populate_stat_callback =
-      std::function<void(const std::string &, std::uint64_t,
-                         const api_meta_map &, bool, struct stat *)>;
+      std::function<void(std::string_view, std::uint64_t, const api_meta_map &,
+                         bool, struct stat *)>;
 #endif
 public:
   explicit directory_iterator(directory_item_list list)
@@ -59,13 +59,13 @@ public:
   [[nodiscard]] auto get_directory_item(std::size_t offset, directory_item &di)
       -> api_error;
 
-  [[nodiscard]] auto get_directory_item(const std::string &api_path,
+  [[nodiscard]] auto get_directory_item(std::string_view api_path,
                                         directory_item &di) -> api_error;
 
   [[nodiscard]] auto get_json(std::size_t offset, json &item) -> int;
 
-  [[nodiscard]] auto
-  get_next_directory_offset(const std::string &api_path) const -> std::size_t;
+  [[nodiscard]] auto get_next_directory_offset(std::string_view api_path) const
+      -> std::size_t;
 
 public:
   auto operator=(const directory_iterator &iterator) noexcept
diff --git a/repertory/librepertory/include/drives/eviction.hpp b/repertory/librepertory/include/drives/eviction.hpp
index 0fc48b59..cb8250e7 100644
--- a/repertory/librepertory/include/drives/eviction.hpp
+++ b/repertory/librepertory/include/drives/eviction.hpp
@@ -46,7 +46,7 @@ private:
   i_provider &provider_;
 
 private:
-  [[nodiscard]] auto check_minimum_requirements(const std::string &file_path)
+  [[nodiscard]] auto check_minimum_requirements(std::string_view file_path)
       -> bool;
 
   [[nodiscard]] auto get_filtered_cached_files() -> std::deque<std::string>;
diff --git a/repertory/librepertory/include/drives/fuse/fuse_base.hpp b/repertory/librepertory/include/drives/fuse/fuse_base.hpp
index 0ef7c20b..ca6e1a60 100644
--- a/repertory/librepertory/include/drives/fuse/fuse_base.hpp
+++ b/repertory/librepertory/include/drives/fuse/fuse_base.hpp
@@ -622,7 +622,7 @@ public:
 
   static void display_version_information(std::vector<const char *> args);
 
-  auto unmount(const std::string &mount_location) -> int;
+  auto unmount(std::string_view mount_location) -> int;
 
   [[nodiscard]] auto get_mount_location() const -> std::string {
     return mount_location_;
diff --git a/repertory/librepertory/include/drives/fuse/fuse_drive.hpp b/repertory/librepertory/include/drives/fuse/fuse_drive.hpp
index 4c8b3e91..a2a83922 100644
--- a/repertory/librepertory/include/drives/fuse/fuse_drive.hpp
+++ b/repertory/librepertory/include/drives/fuse/fuse_drive.hpp
@@ -67,7 +67,7 @@ private:
   bool was_mounted_{false};
 
 private:
-  void update_accessed_time(const std::string &api_path);
+  void update_accessed_time(std::string_view api_path);
 
   void stop_all();
 
@@ -293,21 +293,21 @@ protected:
       -> api_error override;
 
 public:
-  [[nodiscard]] auto get_directory_item_count(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_item_count(std::string_view api_path) const
       -> std::uint64_t override;
 
-  [[nodiscard]] auto get_directory_items(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_items(std::string_view api_path) const
       -> directory_item_list override;
 
-  [[nodiscard]] auto get_file_size(const std::string &api_path) const
+  [[nodiscard]] auto get_file_size(std::string_view api_path) const
       -> std::uint64_t override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
                                    api_meta_map &meta) const
       -> api_error override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
-                                   const std::string &name,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
+                                   std::string_view name,
                                    std::string &value) const
       -> api_error override;
 
@@ -324,21 +324,21 @@ public:
   void get_volume_info(UINT64 &total_size, UINT64 &free_size,
                        std::string &volume_label) const override;
 
-  [[nodiscard]] auto is_processing(const std::string &api_path) const
+  [[nodiscard]] auto is_processing(std::string_view api_path) const
       -> bool override;
 
-  [[nodiscard]] auto rename_directory(const std::string &from_api_path,
-                                      const std::string &to_api_path)
+  [[nodiscard]] auto rename_directory(std::string_view from_api_path,
+                                      std::string_view to_api_path)
       -> int override;
 
-  [[nodiscard]] auto rename_file(const std::string &from_api_path,
-                                 const std::string &to_api_path, bool overwrite)
+  [[nodiscard]] auto rename_file(std::string_view from_api_path,
+                                 std::string_view to_api_path, bool overwrite)
       -> int override;
 
-  void set_item_meta(const std::string &api_path, const std::string &key,
-                     const std::string &value) override;
+  void set_item_meta(std::string_view api_path, std::string_view key,
+                     std::string_view value) override;
 
-  void set_item_meta(const std::string &api_path,
+  void set_item_meta(std::string_view api_path,
                      const api_meta_map &meta) override;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/drives/fuse/fuse_drive_base.hpp b/repertory/librepertory/include/drives/fuse/fuse_drive_base.hpp
index 9c4d8b60..01bbe4ee 100644
--- a/repertory/librepertory/include/drives/fuse/fuse_drive_base.hpp
+++ b/repertory/librepertory/include/drives/fuse/fuse_drive_base.hpp
@@ -47,11 +47,11 @@ protected:
       -> api_error override;
 
 protected:
-  [[nodiscard]] auto check_access(const std::string &api_path, int mask) const
+  [[nodiscard]] auto check_access(std::string_view api_path, int mask) const
       -> api_error;
 
   [[nodiscard]] auto
-  check_and_perform(const std::string &api_path, int parent_mask,
+  check_and_perform(std::string_view api_path, int parent_mask,
                     const std::function<api_error(api_meta_map &meta)> &action)
       -> api_error;
 
@@ -86,22 +86,21 @@ protected:
       -> mode_t;
 
   static void get_timespec_from_meta(const api_meta_map &meta,
-                                     const std::string &name,
+                                     std::string_view name,
                                      struct timespec &ts);
 
   [[nodiscard]] static auto get_uid_from_meta(const api_meta_map &meta)
       -> uid_t;
 
 #if defined(__APPLE__)
-  [[nodiscard]] auto parse_xattr_parameters(const char *name,
-                                            const uint32_t &position,
-                                            std::string &attribute_name,
-                                            const std::string &api_path)
+  [[nodiscard]] auto
+  parse_xattr_parameters(const char *name, const uint32_t &position,
+                         std::string &attribute_name, std::string_view api_path)
       -> api_error;
 #else  // !defined(__APPLE__)
   [[nodiscard]] auto parse_xattr_parameters(const char *name,
                                             std::string &attribute_name,
-                                            const std::string &api_path)
+                                            std::string_view api_path)
       -> api_error;
 #endif // defined(__APPLE__)
 
@@ -109,29 +108,28 @@ protected:
   [[nodiscard]] auto
   parse_xattr_parameters(const char *name, const char *value, size_t size,
                          const uint32_t &position, std::string &attribute_name,
-                         const std::string &api_path) -> api_error;
+                         std::string_view api_path) -> api_error;
 #else  // !defined(__APPLE__)
-  [[nodiscard]] auto parse_xattr_parameters(const char *name, const char *value,
-                                            size_t size,
-                                            std::string &attribute_name,
-                                            const std::string &api_path)
+  [[nodiscard]] auto
+  parse_xattr_parameters(const char *name, const char *value, size_t size,
+                         std::string &attribute_name, std::string_view api_path)
       -> api_error;
 #endif // defined(__APPLE__)
 
-  static void populate_stat(const std::string &api_path,
+  static void populate_stat(std::string_view api_path,
                             std::uint64_t size_or_count,
                             const api_meta_map &meta, bool directory,
                             i_provider &provider, struct stat *u_stat);
 
   static void set_timespec_from_meta(const api_meta_map &meta,
-                                     const std::string &name,
+                                     std::string_view name,
                                      struct timespec &ts);
 
 public:
-  [[nodiscard]] auto check_owner(const std::string &api_path) const
+  [[nodiscard]] auto check_owner(std::string_view api_path) const
       -> api_error override;
 
-  [[nodiscard]] auto check_parent_access(const std::string &api_path,
+  [[nodiscard]] auto check_parent_access(std::string_view api_path,
                                          int mask) const -> api_error override;
 
   [[nodiscard]] static auto validate_timespec(const timespec &spec) -> bool;
diff --git a/repertory/librepertory/include/drives/fuse/i_fuse_drive.hpp b/repertory/librepertory/include/drives/fuse/i_fuse_drive.hpp
index d51143b7..106f29e0 100644
--- a/repertory/librepertory/include/drives/fuse/i_fuse_drive.hpp
+++ b/repertory/librepertory/include/drives/fuse/i_fuse_drive.hpp
@@ -32,30 +32,30 @@ class i_fuse_drive {
   INTERFACE_SETUP(i_fuse_drive);
 
 public:
-  [[nodiscard]] virtual auto check_owner(const std::string &api_path) const
+  [[nodiscard]] virtual auto check_owner(std::string_view api_path) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto check_parent_access(const std::string &api_path,
+  [[nodiscard]] virtual auto check_parent_access(std::string_view api_path,
                                                  int mask) const
       -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_directory_item_count(const std::string &api_path) const
+  get_directory_item_count(std::string_view api_path) const
       -> std::uint64_t = 0;
 
   [[nodiscard]] virtual auto
-  get_directory_items(const std::string &api_path) const
+  get_directory_items(std::string_view api_path) const
       -> directory_item_list = 0;
 
-  [[nodiscard]] virtual auto get_file_size(const std::string &api_path) const
+  [[nodiscard]] virtual auto get_file_size(std::string_view api_path) const
       -> std::uint64_t = 0;
 
-  [[nodiscard]] virtual auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] virtual auto get_item_meta(std::string_view api_path,
                                            api_meta_map &meta) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_item_meta(const std::string &api_path,
-                                           const std::string &name,
+  [[nodiscard]] virtual auto get_item_meta(std::string_view api_path,
+                                           std::string_view name,
                                            std::string &value) const
       -> api_error = 0;
 
@@ -72,22 +72,21 @@ public:
   virtual void get_volume_info(UINT64 &total_size, UINT64 &free_size,
                                std::string &volume_label) const = 0;
 
-  [[nodiscard]] virtual auto is_processing(const std::string &api_path) const
+  [[nodiscard]] virtual auto is_processing(std::string_view api_path) const
       -> bool = 0;
 
-  [[nodiscard]] virtual auto rename_directory(const std::string &from_api_path,
-                                              const std::string &to_api_path)
+  [[nodiscard]] virtual auto rename_directory(std::string_view from_api_path,
+                                              std::string_view to_api_path)
       -> int = 0;
 
-  [[nodiscard]] virtual auto rename_file(const std::string &from_api_path,
-                                         const std::string &to_api_path,
+  [[nodiscard]] virtual auto rename_file(std::string_view from_api_path,
+                                         std::string_view to_api_path,
                                          bool overwrite) -> int = 0;
 
-  virtual void set_item_meta(const std::string &api_path,
-                             const std::string &key,
-                             const std::string &value) = 0;
+  virtual void set_item_meta(std::string_view api_path, std::string_view key,
+                             std::string_view value) = 0;
 
-  virtual void set_item_meta(const std::string &api_path,
+  virtual void set_item_meta(std::string_view api_path,
                              const api_meta_map &meta) = 0;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/drives/fuse/remotefuse/remote_client.hpp b/repertory/librepertory/include/drives/fuse/remotefuse/remote_client.hpp
index 4ce8e184..6f040940 100644
--- a/repertory/librepertory/include/drives/fuse/remotefuse/remote_client.hpp
+++ b/repertory/librepertory/include/drives/fuse/remotefuse/remote_client.hpp
@@ -198,17 +198,17 @@ public:
                                        remote::file_handle handle)
       -> packet::error_type override;
 
-  [[nodiscard]] auto json_create_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_create_directory_snapshot(std::string_view path,
                                                     json &json_data)
       -> packet::error_type override;
 
-  [[nodiscard]] auto json_read_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_read_directory_snapshot(std::string_view path,
                                                   remote::file_handle handle,
                                                   std::uint32_t page,
                                                   json &json_data)
       -> packet::error_type override;
 
-  [[nodiscard]] auto json_release_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_release_directory_snapshot(std::string_view path,
                                                      remote::file_handle handle)
       -> packet::error_type override;
 
diff --git a/repertory/librepertory/include/drives/fuse/remotefuse/remote_server.hpp b/repertory/librepertory/include/drives/fuse/remotefuse/remote_server.hpp
index 048203bb..5ccb1c63 100644
--- a/repertory/librepertory/include/drives/fuse/remotefuse/remote_server.hpp
+++ b/repertory/librepertory/include/drives/fuse/remotefuse/remote_server.hpp
@@ -34,31 +34,31 @@ namespace remote_fuse {
 class remote_server final : public virtual remote_server_base<i_fuse_drive> {
 public:
   remote_server(app_config &config, i_fuse_drive &drive,
-                const std::string &mount_location);
+                std::string_view mount_location);
 
 private:
   directory_cache directory_cache_;
   std::atomic<std::uint64_t> next_handle_{0U};
 
 private:
-  [[nodiscard]] auto construct_path(std::string path) -> std::string;
+  [[nodiscard]] auto construct_path(std::string_view path) -> std::string;
 
-  [[nodiscard]] auto construct_path(const std::wstring &path) -> std::string;
+  [[nodiscard]] auto construct_path(std::wstring_view path) -> std::string;
 
   [[nodiscard]] static auto empty_as_zero(const json &data) -> std::string;
 
   [[nodiscard]] auto get_next_handle() -> std::uint64_t;
 
-  [[nodiscard]] auto populate_file_info(const std::string &api_path,
+  [[nodiscard]] auto populate_file_info(std::string_view api_path,
                                         remote::file_info &r_info)
       -> packet::error_type;
 
-  void populate_file_info(const std::string &api_path, UINT64 file_size,
+  void populate_file_info(std::string_view api_path, UINT64 file_size,
                           UINT32 attributes, remote::file_info &r_info);
 
   static void populate_stat(const struct stat64 &u_stat, remote::stat &r_stat);
 
-  [[nodiscard]] auto update_to_windows_format(const std::string &root_api_path,
+  [[nodiscard]] auto update_to_windows_format(std::string_view root_api_path,
                                               json &item) -> json &;
 
 public:
@@ -228,17 +228,17 @@ public:
     return static_cast<packet::error_type>(STATUS_INVALID_HANDLE);
   }
 
-  [[nodiscard]] auto json_create_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_create_directory_snapshot(std::string_view path,
                                                     json &json_data)
       -> packet::error_type override;
 
-  [[nodiscard]] auto json_read_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_read_directory_snapshot(std::string_view path,
                                                   remote::file_handle handle,
                                                   std::uint32_t page,
                                                   json &json_data)
       -> packet::error_type override;
 
-  [[nodiscard]] auto json_release_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_release_directory_snapshot(std::string_view path,
                                                      remote::file_handle handle)
       -> packet::error_type override;
 
@@ -277,7 +277,7 @@ public:
                                             std::string &volume_label)
       -> packet::error_type override;
 
-  [[nodiscard]] auto winfsp_mounted(const std::wstring &location)
+  [[nodiscard]] auto winfsp_mounted(std::wstring_view location)
       -> packet::error_type override;
 
   [[nodiscard]] auto winfsp_open(PWSTR file_name, UINT32 create_options,
@@ -315,7 +315,7 @@ public:
                                           remote::file_info *r_info)
       -> packet::error_type override;
 
-  [[nodiscard]] auto winfsp_unmounted(const std::wstring &location)
+  [[nodiscard]] auto winfsp_unmounted(std::wstring_view location)
       -> packet::error_type override;
 
   [[nodiscard]] auto
diff --git a/repertory/librepertory/include/drives/remote/i_remote_json.hpp b/repertory/librepertory/include/drives/remote/i_remote_json.hpp
index 48265c13..571e1b46 100644
--- a/repertory/librepertory/include/drives/remote/i_remote_json.hpp
+++ b/repertory/librepertory/include/drives/remote/i_remote_json.hpp
@@ -30,16 +30,18 @@ class i_remote_json {
 
 public:
   [[nodiscard]] virtual auto
-  json_create_directory_snapshot(const std::string &path,
-                                 json &json_data) -> packet::error_type = 0;
+  json_create_directory_snapshot(std::string_view path, json &json_data)
+      -> packet::error_type = 0;
 
-  [[nodiscard]] virtual auto json_read_directory_snapshot(
-      const std::string &path, remote::file_handle handle,
-      std::uint32_t page, json &json_data) -> packet::error_type = 0;
+  [[nodiscard]] virtual auto
+  json_read_directory_snapshot(std::string_view path,
+                               remote::file_handle handle, std::uint32_t page,
+                               json &json_data) -> packet::error_type = 0;
 
-  [[nodiscard]] virtual auto json_release_directory_snapshot(
-      const std::string &path,
-      remote::file_handle handle) -> packet::error_type = 0;
+  [[nodiscard]] virtual auto
+  json_release_directory_snapshot(std::string_view path,
+                                  remote::file_handle handle)
+      -> packet::error_type = 0;
 };
 } // namespace repertory
 
diff --git a/repertory/librepertory/include/drives/remote/remote_open_file_table.hpp b/repertory/librepertory/include/drives/remote/remote_open_file_table.hpp
index 826cde0c..0c37b17e 100644
--- a/repertory/librepertory/include/drives/remote/remote_open_file_table.hpp
+++ b/repertory/librepertory/include/drives/remote/remote_open_file_table.hpp
@@ -62,9 +62,9 @@ private:
   mutable std::recursive_mutex file_mutex_;
 
 protected:
-  void add_directory(const std::string &client_id, std::uint64_t handle);
+  void add_directory(std::string_view client_id, std::uint64_t handle);
 
-  void close_all(const std::string &client_id);
+  void close_all(std::string_view client_id);
 
 #if defined(_WIN32)
   [[nodiscard]] auto get_directory_buffer(const native_handle &handle,
@@ -77,7 +77,7 @@ protected:
   [[nodiscard]] auto get_open_info(const native_handle &handle, open_info &oi)
       -> bool;
 
-  [[nodiscard]] auto has_open_directory(const std::string &client_id,
+  [[nodiscard]] auto has_open_directory(std::string_view client_id,
                                         std::uint64_t handle) -> bool;
 
   [[nodiscard]] auto has_compat_open_info(remote::file_handle handle,
@@ -91,29 +91,29 @@ protected:
     return handle_lookup_.contains(handle) ? 0 : error_return;
   }
 
-  void remove_all(const std::string &file_path);
+  void remove_all(std::string_view file_path);
 
   void remove_and_close_all(const native_handle &handle);
 
   void remove_compat_open_info(remote::file_handle handle);
 
-  auto remove_directory(const std::string &client_id, std::uint64_t handle)
+  auto remove_directory(std::string_view client_id, std::uint64_t handle)
       -> bool;
 
   void remove_open_info(const native_handle &handle);
 
-  void set_client_id(const native_handle &handle, const std::string &client_id);
+  void set_client_id(const native_handle &handle, std::string_view client_id);
 
   void set_compat_client_id(remote::file_handle handle,
-                            const std::string &client_id);
+                            std::string_view client_id);
 
   void set_compat_open_info(remote::file_handle handle,
-                            const std::string &file_path);
+                            std::string_view file_path);
 
   void set_open_info(const native_handle &handle, open_info op_info);
 
 public:
-  [[nodiscard]] auto get_open_file_count(const std::string &file_path) const
+  [[nodiscard]] auto get_open_file_count(std::string_view file_path) const
       -> std::size_t;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/drives/remote/remote_server_base.hpp b/repertory/librepertory/include/drives/remote/remote_server_base.hpp
index 4ec6c076..2b77933e 100644
--- a/repertory/librepertory/include/drives/remote/remote_server_base.hpp
+++ b/repertory/librepertory/include/drives/remote/remote_server_base.hpp
@@ -46,7 +46,7 @@ class remote_server_base : public remote_open_file_table,
                            public virtual remote_fuse::i_remote_instance {
 public:
   using handler_callback = std::function<packet::error_type(
-      std::uint32_t, const std::string &, std::uint64_t, const std::string &,
+      std::uint32_t, std::string_view, std::uint64_t, std::string_view,
       packet *, packet &)>;
 
 public:
@@ -56,10 +56,11 @@ public:
   auto operator=(remote_server_base &&) -> remote_server_base & = delete;
 
 public:
-  remote_server_base(app_config &config, drive &drv, std::string mount_location)
+  remote_server_base(app_config &config, drive &drv,
+                     std::string_view mount_location)
       : config_(config),
         drive_(drv),
-        mount_location_(std::move(mount_location)),
+        mount_location_(std::string(mount_location)),
         client_pool_(config.get_remote_mount().client_pool_size) {
     REPERTORY_USES_FUNCTION_NAME();
 
@@ -102,461 +103,463 @@ private:
   std::unique_ptr<packet_server> packet_server_;
 
 private:
-  const std::unordered_map<std::string, handler_callback> handler_lookup_ = {
+  const std::unordered_map<std::string_view, handler_callback> handler_lookup_ =
       {
-          "::check",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */,
-                 auto && /* request */,
-                 auto && /* response */) -> auto { return 0; },
-      },
-      {
-          "::fuse_access",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_access(request);
+          {
+              "::check",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto && /* request */,
+                     auto && /* response */) -> auto { return 0; },
           },
-      },
-      {
-          "::fuse_chflags",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_chflags(request);
+          {
+              "::fuse_access",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_access(request);
+              },
           },
-      },
-      {
-          "::fuse_chmod",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_chmod(request);
+          {
+              "::fuse_chflags",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_chflags(request);
+              },
           },
-      },
-      {
-          "::fuse_chown",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_chown(request);
+          {
+              "::fuse_chmod",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_chmod(request);
+              },
           },
-      },
-      {
-          "::fuse_create",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_create(client_id, request, response);
+          {
+              "::fuse_chown",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_chown(request);
+              },
           },
-      },
-      {
-          "::fuse_destroy",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */,
-                 auto && /* request */, auto && /* response */) -> auto {
-            return this->handle_fuse_destroy();
+          {
+              "::fuse_create",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_create(client_id, request, response);
+              },
           },
-      },
-      {
-          "::fuse_fgetattr",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_fgetattr(request, response);
+          {
+              "::fuse_destroy",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto && /* request */, auto && /* response */) -> auto {
+                return this->handle_fuse_destroy();
+              },
           },
-      },
-      {
-          "::fuse_fsetattr_x",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_fsetattr_x(request);
+          {
+              "::fuse_fgetattr",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_fgetattr(request, response);
+              },
           },
-      },
-      {
-          "::fuse_fsync",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_fsync(request);
+          {
+              "::fuse_fsetattr_x",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_fsetattr_x(request);
+              },
           },
-      },
-      {
-          "::fuse_ftruncate",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_ftruncate(request);
+          {
+              "::fuse_fsync",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_fsync(request);
+              },
           },
-      },
-      {
-          "::fuse_getattr",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_getattr(request, response);
+          {
+              "::fuse_ftruncate",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_ftruncate(request);
+              },
           },
-      },
-      {
-          "::fuse_getxtimes",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_getxtimes(request, response);
+          {
+              "::fuse_getattr",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_getattr(request, response);
+              },
           },
-      },
-      {
-          "::fuse_init",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */,
-                 auto && /* request */, auto && /* response */) -> auto {
-            return this->handle_fuse_init();
+          {
+              "::fuse_getxtimes",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_getxtimes(request, response);
+              },
           },
-      },
-      {
-          "::fuse_mkdir",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_mkdir(request);
+          {
+              "::fuse_init",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto && /* request */, auto && /* response */) -> auto {
+                return this->handle_fuse_init();
+              },
           },
-      },
-      {
-          "::fuse_open",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_open(client_id, request, response);
+          {
+              "::fuse_mkdir",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_mkdir(request);
+              },
           },
-      },
-      {
-          "::fuse_opendir",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_opendir(client_id, request, response);
+          {
+              "::fuse_open",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_open(client_id, request, response);
+              },
           },
-      },
-      {
-          "::fuse_read",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_read(request, response);
+          {
+              "::fuse_opendir",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_opendir(client_id, request, response);
+              },
           },
-      },
-      {
-          "::fuse_readdir",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_readdir(client_id, request, response);
+          {
+              "::fuse_read",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_read(request, response);
+              },
           },
-      },
-      {
-          "::fuse_release",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_release(request);
+          {
+              "::fuse_readdir",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_readdir(client_id, request, response);
+              },
           },
-      },
-      {
-          "::fuse_releasedir",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_releasedir(client_id, request);
+          {
+              "::fuse_release",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_release(request);
+              },
           },
-      },
-      {
-          "::fuse_rename",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_rename(request);
+          {
+              "::fuse_releasedir",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_releasedir(client_id, request);
+              },
           },
-      },
-      {
-          "::fuse_rmdir",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_rmdir(request);
+          {
+              "::fuse_rename",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_rename(request);
+              },
           },
-      },
-      {
-          "::fuse_setattr_x",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_setattr_x(request);
+          {
+              "::fuse_rmdir",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_rmdir(request);
+              },
           },
-      },
-      {
-          "::fuse_setbkuptime",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_setbkuptime(request);
+          {
+              "::fuse_setattr_x",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_setattr_x(request);
+              },
           },
-      },
-      {
-          "::fuse_setchgtime",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_setchgtime(request);
+          {
+              "::fuse_setbkuptime",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_setbkuptime(request);
+              },
           },
-      },
-      {
-          "::fuse_setcrtime",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_setcrtime(request);
+          {
+              "::fuse_setchgtime",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_setchgtime(request);
+              },
           },
-      },
-      {
-          "::fuse_setvolname",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_setvolname(request);
+          {
+              "::fuse_setcrtime",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_setcrtime(request);
+              },
           },
-      },
-      {
-          "::fuse_statfs",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_statfs(request, response);
+          {
+              "::fuse_setvolname",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_setvolname(request);
+              },
           },
-      },
-      {
-          "::fuse_statfs_x",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_fuse_statfs_x(request, response);
+          {
+              "::fuse_statfs",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_statfs(request, response);
+              },
           },
-      },
-      {
-          "::fuse_truncate",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_truncate(request);
+          {
+              "::fuse_statfs_x",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_fuse_statfs_x(request, response);
+              },
           },
-      },
-      {
-          "::fuse_unlink",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_unlink(request);
+          {
+              "::fuse_truncate",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_truncate(request);
+              },
           },
-      },
-      {
-          "::fuse_utimens",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_utimens(request);
+          {
+              "::fuse_unlink",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_unlink(request);
+              },
           },
-      },
-      {
-          "::fuse_write",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_write(request);
+          {
+              "::fuse_utimens",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_utimens(request);
+              },
           },
-      },
-      {
-          "::fuse_write_base64",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_fuse_write_base64(request);
+          {
+              "::fuse_write",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_write(request);
+              },
           },
-      },
-      {
-          "::json_create_directory_snapshot",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_json_create_directory_snapshot(
-                client_id, request, response);
+          {
+              "::fuse_write_base64",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_fuse_write_base64(request);
+              },
           },
-      },
-      {
-          "::json_read_directory_snapshot",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_json_read_directory_snapshot(client_id, request,
-                                                             response);
+          {
+              "::json_create_directory_snapshot",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_json_create_directory_snapshot(
+                    client_id, request, response);
+              },
           },
-      },
-      {
-          "::json_release_directory_snapshot",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_json_release_directory_snapshot(client_id,
-                                                                request);
+          {
+              "::json_read_directory_snapshot",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_json_read_directory_snapshot(
+                    client_id, request, response);
+              },
           },
-      },
-      {
-          "::winfsp_can_delete",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_winfsp_can_delete(request);
+          {
+              "::json_release_directory_snapshot",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_json_release_directory_snapshot(client_id,
+                                                                    request);
+              },
           },
-      },
-      {
-          "::winfsp_cleanup",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_cleanup(request, response);
+          {
+              "::winfsp_can_delete",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_winfsp_can_delete(request);
+              },
           },
-      },
-      {
-          "::winfsp_close",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_winfsp_close(request);
+          {
+              "::winfsp_cleanup",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_cleanup(request, response);
+              },
           },
-      },
-      {
-          "::winfsp_create",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_create(client_id, request, response);
+          {
+              "::winfsp_close",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_winfsp_close(request);
+              },
           },
-      },
-      {
-          "::winfsp_flush",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_flush(request, response);
+          {
+              "::winfsp_create",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_create(client_id, request, response);
+              },
           },
-      },
-      {
-          "::winfsp_get_file_info",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_get_file_info(request, response);
+          {
+              "::winfsp_flush",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_flush(request, response);
+              },
           },
-      },
-      {
-          "::winfsp_get_security_by_name",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_get_security_by_name(request, response);
+          {
+              "::winfsp_get_file_info",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_get_file_info(request, response);
+              },
           },
-      },
-      {
-          "::winfsp_get_volume_info",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */,
-                 auto && /* request */, auto &&response) -> auto {
-            return this->handle_winfsp_get_volume_info(response);
+          {
+              "::winfsp_get_security_by_name",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_get_security_by_name(request,
+                                                                response);
+              },
           },
-      },
-      {
-          "::winfsp_mounted",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_winfsp_mounted(request);
+          {
+              "::winfsp_get_volume_info",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto && /* request */, auto &&response) -> auto {
+                return this->handle_winfsp_get_volume_info(response);
+              },
           },
-      },
-      {
-          "::winfsp_open",
-          [this](auto && /* service_flags */, auto &&client_id,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_open(client_id, request, response);
+          {
+              "::winfsp_mounted",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_winfsp_mounted(request);
+              },
           },
-      },
-      {
-          "::winfsp_overwrite",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_overwrite(request, response);
+          {
+              "::winfsp_open",
+              [this](auto && /* service_flags */, auto &&client_id,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_open(client_id, request, response);
+              },
           },
-      },
-      {
-          "::winfsp_read",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_read(request, response);
+          {
+              "::winfsp_overwrite",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_overwrite(request, response);
+              },
           },
-      },
-      {
-          "::winfsp_read_directory",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_read_directory(request, response);
+          {
+              "::winfsp_read",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_read(request, response);
+              },
           },
-      },
-      {
-          "::winfsp_rename",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_winfsp_rename(request);
+          {
+              "::winfsp_read_directory",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_read_directory(request, response);
+              },
           },
-      },
-      {
-          "::winfsp_set_basic_info",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_set_basic_info(request, response);
+          {
+              "::winfsp_rename",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_winfsp_rename(request);
+              },
           },
-      },
-      {
-          "::winfsp_set_file_size",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_set_file_size(request, response);
+          {
+              "::winfsp_set_basic_info",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_set_basic_info(request, response);
+              },
           },
-      },
-      {
-          "::winfsp_unmounted",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto && /* response */) -> auto {
-            return this->handle_winfsp_unmounted(request);
+          {
+              "::winfsp_set_file_size",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_set_file_size(request, response);
+              },
           },
-      },
-      {
-          "::winfsp_write",
-          [this](auto && /* service_flags */, auto && /* client_id */,
-                 auto && /* thread_id */, auto && /* method */, auto &&request,
-                 auto &&response) -> auto {
-            return this->handle_winfsp_write(request, response);
+          {
+              "::winfsp_unmounted",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto && /* response */) -> auto {
+                return this->handle_winfsp_unmounted(request);
+              },
           },
-      },
-  };
+          {
+              "::winfsp_write",
+              [this](auto && /* service_flags */, auto && /* client_id */,
+                     auto && /* thread_id */, auto && /* method */,
+                     auto &&request, auto &&response) -> auto {
+                return this->handle_winfsp_write(request, response);
+              },
+          },
+      };
 
 private:
-  void closed_handler(const std::string &client_id) {
+  void closed_handler(std::string_view client_id) {
     client_pool_.remove_client(client_id);
     close_all(client_id);
   }
@@ -613,7 +616,7 @@ private:
     return this->fuse_chown(path.c_str(), uid, gid);
   }
 
-  [[nodiscard]] auto handle_fuse_create(const std::string &client_id,
+  [[nodiscard]] auto handle_fuse_create(std::string_view client_id,
                                         packet *request, packet &response)
       -> packet::error_type {
     auto ret{0};
@@ -779,7 +782,7 @@ private:
     return this->fuse_mkdir(path.c_str(), mode);
   }
 
-  [[nodiscard]] auto handle_fuse_open(const std::string &client_id,
+  [[nodiscard]] auto handle_fuse_open(std::string_view client_id,
                                       packet *request, packet &response)
       -> packet::error_type {
     auto ret{0};
@@ -803,7 +806,7 @@ private:
     return ret;
   }
 
-  [[nodiscard]] auto handle_fuse_opendir(const std::string &client_id,
+  [[nodiscard]] auto handle_fuse_opendir(std::string_view client_id,
                                          packet *request, packet &response)
       -> packet::error_type {
     auto ret{0};
@@ -846,7 +849,7 @@ private:
     return ret;
   }
 
-  [[nodiscard]] auto handle_fuse_readdir(const std::string &client_id,
+  [[nodiscard]] auto handle_fuse_readdir(std::string_view client_id,
                                          packet *request, packet &response)
       -> packet::error_type {
     auto ret{0};
@@ -886,7 +889,7 @@ private:
     return this->fuse_release(path.c_str(), handle);
   }
 
-  [[nodiscard]] auto handle_fuse_releasedir(const std::string &client_id,
+  [[nodiscard]] auto handle_fuse_releasedir(std::string_view client_id,
                                             packet *request)
       -> packet::error_type {
     auto ret{0};
@@ -1131,7 +1134,7 @@ private:
   }
 
   [[nodiscard]] auto
-  handle_json_create_directory_snapshot(const std::string &client_id,
+  handle_json_create_directory_snapshot(std::string_view client_id,
                                         packet *request, packet &response)
       -> packet::error_type {
     std::int32_t ret{};
@@ -1152,7 +1155,7 @@ private:
   }
 
   [[nodiscard]] auto
-  handle_json_read_directory_snapshot(const std::string &client_id,
+  handle_json_read_directory_snapshot(std::string_view client_id,
                                       packet *request, packet &response)
       -> packet::error_type {
     std::int32_t ret{0};
@@ -1181,7 +1184,7 @@ private:
   }
 
   [[nodiscard]] auto handle_json_release_directory_snapshot(
-      const std::string &client_id, packet *request) -> packet::error_type {
+      std::string_view client_id, packet *request) -> packet::error_type {
     std::int32_t ret{0};
 
     std::string path;
@@ -1240,7 +1243,7 @@ private:
     return this->winfsp_close(file_desc);
   }
 
-  [[nodiscard]] auto handle_winfsp_create(const std::string &client_id,
+  [[nodiscard]] auto handle_winfsp_create(std::string_view client_id,
                                           packet *request, packet &response)
       -> packet::error_type {
     auto ret = static_cast<packet::error_type>(STATUS_SUCCESS);
@@ -1380,7 +1383,7 @@ private:
     return ret;
   }
 
-  [[nodiscard]] auto handle_winfsp_open(const std::string &client_id,
+  [[nodiscard]] auto handle_winfsp_open(std::string_view client_id,
                                         packet *request, packet &response)
       -> packet::error_type {
     auto ret = static_cast<packet::error_type>(STATUS_SUCCESS);
@@ -1612,13 +1615,14 @@ private:
   }
 
   void
-  message_handler(std::uint32_t service_flags, const std::string &client_id,
-                  std::uint64_t thread_id, const std::string &method,
+  message_handler(std::uint32_t service_flags, std::string_view client_id,
+                  std::uint64_t thread_id, std::string_view method,
                   packet *request, packet &response,
                   packet_server::message_complete_callback message_complete) {
     auto idx{method.find_last_of("::")};
     auto lookup_method_name{
-        ((idx == std::string::npos) ? "::" + method : method.substr(idx - 1)),
+        ((idx == std::string::npos) ? "::" + std::string{method}
+                                    : method.substr(idx - 1)),
     };
     if (handler_lookup_.find(lookup_method_name) == handler_lookup_.end()) {
       message_complete(static_cast<packet::error_type>(STATUS_NOT_IMPLEMENTED));
diff --git a/repertory/librepertory/include/drives/winfsp/i_winfsp_drive.hpp b/repertory/librepertory/include/drives/winfsp/i_winfsp_drive.hpp
index bf0a77b9..54e81a39 100644
--- a/repertory/librepertory/include/drives/winfsp/i_winfsp_drive.hpp
+++ b/repertory/librepertory/include/drives/winfsp/i_winfsp_drive.hpp
@@ -32,22 +32,22 @@ class i_winfsp_drive {
 
 public:
   [[nodiscard]] virtual auto
-  get_directory_item_count(const std::string &api_path) const
+  get_directory_item_count(std::string_view api_path) const
       -> std::uint64_t = 0;
 
   [[nodiscard]] virtual auto
-  get_directory_items(const std::string &api_path) const
+  get_directory_items(std::string_view api_path) const
       -> directory_item_list = 0;
 
-  [[nodiscard]] virtual auto get_file_size(const std::string &api_path) const
+  [[nodiscard]] virtual auto get_file_size(std::string_view api_path) const
       -> std::uint64_t = 0;
 
-  [[nodiscard]] virtual auto get_item_meta(const std::string &api_path,
-                                           const std::string &name,
+  [[nodiscard]] virtual auto get_item_meta(std::string_view api_path,
+                                           std::string_view name,
                                            std::string &value) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] virtual auto get_item_meta(std::string_view api_path,
                                            api_meta_map &meta) const
       -> api_error = 0;
 
@@ -65,7 +65,7 @@ public:
   virtual void get_volume_info(UINT64 &total_size, UINT64 &free_size,
                                std::string &volume_label) const = 0;
 
-  [[nodiscard]] virtual auto populate_file_info(const std::string &api_path,
+  [[nodiscard]] virtual auto populate_file_info(std::string_view api_path,
                                                 remote::file_info &r_info) const
       -> api_error = 0;
 };
diff --git a/repertory/librepertory/include/drives/winfsp/remotewinfsp/i_remote_instance.hpp b/repertory/librepertory/include/drives/winfsp/remotewinfsp/i_remote_instance.hpp
index 3434bab1..05c90d98 100644
--- a/repertory/librepertory/include/drives/winfsp/remotewinfsp/i_remote_instance.hpp
+++ b/repertory/librepertory/include/drives/winfsp/remotewinfsp/i_remote_instance.hpp
@@ -68,7 +68,7 @@ public:
                                                     std::string &volume_label)
       -> packet::error_type = 0;
 
-  [[nodiscard]] virtual auto winfsp_mounted(const std::wstring &location)
+  [[nodiscard]] virtual auto winfsp_mounted(std::wstring_view location)
       -> packet::error_type = 0;
 
   [[nodiscard]] virtual auto
@@ -107,7 +107,7 @@ public:
                        BOOLEAN set_allocation_size, remote::file_info *r_info)
       -> packet::error_type = 0;
 
-  [[nodiscard]] virtual auto winfsp_unmounted(const std::wstring &location)
+  [[nodiscard]] virtual auto winfsp_unmounted(std::wstring_view location)
       -> packet::error_type = 0;
 
   [[nodiscard]] virtual auto
diff --git a/repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_client.hpp b/repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_client.hpp
index 36879427..3087a9a0 100644
--- a/repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_client.hpp
+++ b/repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_client.hpp
@@ -50,17 +50,18 @@ private:
 public:
   [[nodiscard]] auto check() -> packet::error_type;
 
-  [[nodiscard]] auto json_create_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_create_directory_snapshot(std::string_view path,
                                                     json &json_data)
       -> packet::error_type override;
 
-  [[nodiscard]] auto json_read_directory_snapshot(
-      const std::string &path, remote::file_handle handle,
-      std::uint32_t page, json &json_data) -> packet::error_type override;
+  [[nodiscard]] auto json_read_directory_snapshot(std::string_view path,
+                                                  remote::file_handle handle,
+                                                  std::uint32_t page,
+                                                  json &json_data)
+      -> packet::error_type override;
 
-  [[nodiscard]] auto
-  json_release_directory_snapshot(const std::string &path,
-                                  remote::file_handle handle)
+  [[nodiscard]] auto json_release_directory_snapshot(std::string_view path,
+                                                     remote::file_handle handle)
       -> packet::error_type override;
 
   [[nodiscard]] auto winfsp_can_delete(PVOID file_desc, PWSTR file_name)
@@ -98,7 +99,7 @@ public:
                                             std::string &volume_label)
       -> packet::error_type override;
 
-  [[nodiscard]] auto winfsp_mounted(const std::wstring &location)
+  [[nodiscard]] auto winfsp_mounted(std::wstring_view location)
       -> packet::error_type override;
 
   [[nodiscard]] auto winfsp_open(PWSTR file_name, UINT32 create_options,
@@ -136,7 +137,7 @@ public:
                                           remote::file_info *r_info)
       -> packet::error_type override;
 
-  [[nodiscard]] auto winfsp_unmounted(const std::wstring &location)
+  [[nodiscard]] auto winfsp_unmounted(std::wstring_view location)
       -> packet::error_type override;
 
   [[nodiscard]] auto
diff --git a/repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_server.hpp b/repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_server.hpp
index e11369f4..519463e6 100644
--- a/repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_server.hpp
+++ b/repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_server.hpp
@@ -36,7 +36,7 @@ namespace remote_winfsp {
 class remote_server final : public virtual remote_server_base<i_winfsp_drive> {
 public:
   remote_server(app_config &config, i_winfsp_drive &drive,
-                const std::string &mount_location)
+                std::string_view mount_location)
       : remote_server_base(config, drive,
                            utils::string::to_lower(mount_location)) {}
 
@@ -49,7 +49,7 @@ private:
 
   [[nodiscard]] auto get_next_handle() -> std::uint64_t;
 
-  [[nodiscard]] auto populate_file_info(const std::string &api_path,
+  [[nodiscard]] auto populate_file_info(std::string_view api_path,
                                         remote::file_info &r_info)
       -> packet::error_type;
 
@@ -215,17 +215,17 @@ public:
                         remote::group_id /* gid */) override {}
 
   // JSON Layer
-  [[nodiscard]] auto json_create_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_create_directory_snapshot(std::string_view path,
                                                     json &json_data)
       -> packet::error_type override;
 
-  [[nodiscard]] auto json_read_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_read_directory_snapshot(std::string_view path,
                                                   remote::file_handle handle,
                                                   std::uint32_t page,
                                                   json &json_data)
       -> packet::error_type override;
 
-  [[nodiscard]] auto json_release_directory_snapshot(const std::string &path,
+  [[nodiscard]] auto json_release_directory_snapshot(std::string_view path,
                                                      remote::file_handle handle)
       -> packet::error_type override;
 
@@ -265,7 +265,7 @@ public:
                                             std::string &volume_label)
       -> packet::error_type override;
 
-  [[nodiscard]] auto winfsp_mounted(const std::wstring &location)
+  [[nodiscard]] auto winfsp_mounted(std::wstring_view location)
       -> packet::error_type override;
 
   [[nodiscard]] auto winfsp_open(PWSTR file_name, UINT32 create_options,
@@ -303,7 +303,7 @@ public:
                                           remote::file_info *r_info)
       -> packet::error_type override;
 
-  [[nodiscard]] auto winfsp_unmounted(const std::wstring &location)
+  [[nodiscard]] auto winfsp_unmounted(std::wstring_view location)
       -> packet::error_type override;
 
   [[nodiscard]] auto
diff --git a/repertory/librepertory/include/drives/winfsp/winfsp_drive.hpp b/repertory/librepertory/include/drives/winfsp/winfsp_drive.hpp
index 28bb1858..0b88a29f 100644
--- a/repertory/librepertory/include/drives/winfsp/winfsp_drive.hpp
+++ b/repertory/librepertory/include/drives/winfsp/winfsp_drive.hpp
@@ -77,15 +77,15 @@ private:
 
 private:
   [[nodiscard]] auto handle_error(std::string_view function_name,
-                                  const std::string &api_path, api_error error,
+                                  std::string_view api_path, api_error error,
                                   FileInfo *f_info, std::uint64_t file_size,
                                   bool raise_on_failure_only = false) const
       -> NTSTATUS;
 
-  static auto parse_mount_location(const std::wstring &mount_location)
+  static auto parse_mount_location(std::wstring_view mount_location)
       -> std::string;
 
-  void populate_file_info(const std::string &api_path, std::uint64_t file_size,
+  void populate_file_info(std::string_view api_path, std::uint64_t file_size,
                           const api_meta_map &meta,
                           FSP_FSCTL_OPEN_FILE_INFO &ofi) const;
 
@@ -114,24 +114,24 @@ public:
   auto Flush(PVOID file_node, PVOID file_desc, FileInfo *f_info)
       -> NTSTATUS override;
 
-  [[nodiscard]] auto get_directory_item_count(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_item_count(std::string_view api_path) const
       -> std::uint64_t override;
 
-  [[nodiscard]] auto get_directory_items(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_items(std::string_view api_path) const
       -> directory_item_list override;
 
   auto GetFileInfo(PVOID file_node, PVOID file_desc, FileInfo *f_info)
       -> NTSTATUS override;
 
-  [[nodiscard]] auto get_file_size(const std::string &api_path) const
+  [[nodiscard]] auto get_file_size(std::string_view api_path) const
       -> std::uint64_t override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
                                    api_meta_map &meta) const
       -> api_error override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
-                                   const std::string &name,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
+                                   std::string_view name,
                                    std::string &value) const
       -> api_error override;
 
@@ -172,7 +172,7 @@ public:
                  BOOLEAN replace_attributes, UINT64 allocation_size,
                  FileInfo *f_info) -> NTSTATUS override;
 
-  [[nodiscard]] auto populate_file_info(const std::string &api_path,
+  [[nodiscard]] auto populate_file_info(std::string_view api_path,
                                         remote::file_info &r_info) const
       -> api_error override;
 
diff --git a/repertory/librepertory/include/events/types/curl_error.hpp b/repertory/librepertory/include/events/types/curl_error.hpp
index a255fd59..b2f0d3ea 100644
--- a/repertory/librepertory/include/events/types/curl_error.hpp
+++ b/repertory/librepertory/include/events/types/curl_error.hpp
@@ -28,12 +28,9 @@
 namespace repertory {
 struct curl_error final : public i_event {
   curl_error() = default;
-  curl_error(CURLcode code_, std::string_view function_name_, std::string type_,
-             std::string url_)
-      : code(code_),
-        function_name(std::string{function_name_}),
-        type(std::move(type_)),
-        url(std::move(url_)) {}
+  curl_error(CURLcode code_, std::string_view function_name_,
+             std::string_view type_, std::string_view url_)
+      : code(code_), function_name(function_name_), type(type_), url(url_) {}
 
   static constexpr event_level level{event_level::error};
   static constexpr std::string_view name{"curl_error"};
diff --git a/repertory/librepertory/include/events/types/debug_log.hpp b/repertory/librepertory/include/events/types/debug_log.hpp
index 2642d003..acf08c3c 100644
--- a/repertory/librepertory/include/events/types/debug_log.hpp
+++ b/repertory/librepertory/include/events/types/debug_log.hpp
@@ -28,8 +28,8 @@
 namespace repertory {
 struct debug_log final : public i_event {
   debug_log() = default;
-  debug_log(std::string_view function_name_, std::string msg_)
-      : function_name(std::string(function_name_)), msg(std::move(msg_)) {}
+  debug_log(std::string_view function_name_, std::string_view msg_)
+      : function_name(function_name_), msg(msg_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"debug_log"};
diff --git a/repertory/librepertory/include/events/types/directory_remove_failed.hpp b/repertory/librepertory/include/events/types/directory_remove_failed.hpp
index a044ed75..cd42a290 100644
--- a/repertory/librepertory/include/events/types/directory_remove_failed.hpp
+++ b/repertory/librepertory/include/events/types/directory_remove_failed.hpp
@@ -28,11 +28,9 @@
 namespace repertory {
 struct directory_remove_failed final : public i_event {
   directory_remove_failed() = default;
-  directory_remove_failed(std::string api_path_, api_error error_,
+  directory_remove_failed(std::string_view api_path_, api_error error_,
                           std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        error(error_),
-        function_name(std::string(function_name_)) {}
+      : api_path(api_path_), error(error_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::error};
   static constexpr std::string_view name{"directory_remove_failed"};
diff --git a/repertory/librepertory/include/events/types/directory_removed.hpp b/repertory/librepertory/include/events/types/directory_removed.hpp
index 922e7047..9e065342 100644
--- a/repertory/librepertory/include/events/types/directory_removed.hpp
+++ b/repertory/librepertory/include/events/types/directory_removed.hpp
@@ -28,9 +28,8 @@
 namespace repertory {
 struct directory_removed final : public i_event {
   directory_removed() = default;
-  directory_removed(std::string api_path_, std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)) {}
+  directory_removed(std::string_view api_path_, std::string_view function_name_)
+      : api_path(api_path_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"directory_removed"};
diff --git a/repertory/librepertory/include/events/types/directory_removed_externally.hpp b/repertory/librepertory/include/events/types/directory_removed_externally.hpp
index 95b87ae7..eac0dc5f 100644
--- a/repertory/librepertory/include/events/types/directory_removed_externally.hpp
+++ b/repertory/librepertory/include/events/types/directory_removed_externally.hpp
@@ -28,12 +28,12 @@
 namespace repertory {
 struct directory_removed_externally final : public i_event {
   directory_removed_externally() = default;
-  directory_removed_externally(std::string api_path_,
+  directory_removed_externally(std::string_view api_path_,
                                std::string_view function_name_,
-                               std::string source_path_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+                               std::string_view source_path_)
+      : api_path(api_path_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"directory_removed_externally"};
diff --git a/repertory/librepertory/include/events/types/download_begin.hpp b/repertory/librepertory/include/events/types/download_begin.hpp
index 0fa3d3dd..b8c5c8d6 100644
--- a/repertory/librepertory/include/events/types/download_begin.hpp
+++ b/repertory/librepertory/include/events/types/download_begin.hpp
@@ -28,11 +28,11 @@
 namespace repertory {
 struct download_begin final : public i_event {
   download_begin() = default;
-  download_begin(std::string api_path_, std::string dest_path_,
+  download_begin(std::string_view api_path_, std::string_view dest_path_,
                  std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
-        function_name(std::string(function_name_)) {}
+      : api_path(api_path_),
+        dest_path(dest_path_),
+        function_name(function_name_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"download_begin"};
diff --git a/repertory/librepertory/include/events/types/download_end.hpp b/repertory/librepertory/include/events/types/download_end.hpp
index e4cebe2d..abb4ffad 100644
--- a/repertory/librepertory/include/events/types/download_end.hpp
+++ b/repertory/librepertory/include/events/types/download_end.hpp
@@ -28,12 +28,12 @@
 namespace repertory {
 struct download_end final : public i_event {
   download_end() = default;
-  download_end(std::string api_path_, std::string dest_path_, api_error error_,
-               std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
+  download_end(std::string_view api_path_, std::string_view dest_path_,
+               api_error error_, std::string_view function_name_)
+      : api_path(api_path_),
+        dest_path(dest_path_),
         error(error_),
-        function_name(std::string(function_name_)) {}
+        function_name(function_name_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"download_end"};
diff --git a/repertory/librepertory/include/events/types/download_progress.hpp b/repertory/librepertory/include/events/types/download_progress.hpp
index 1361ef19..2cc82384 100644
--- a/repertory/librepertory/include/events/types/download_progress.hpp
+++ b/repertory/librepertory/include/events/types/download_progress.hpp
@@ -28,11 +28,11 @@
 namespace repertory {
 struct download_progress final : public i_event {
   download_progress() = default;
-  download_progress(std::string api_path_, std::string dest_path_,
+  download_progress(std::string_view api_path_, std::string_view dest_path_,
                     std::string_view function_name_, double progress_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
-        function_name(std::string(function_name_)),
+      : api_path(api_path_),
+        dest_path(dest_path_),
+        function_name(function_name_),
         progress(progress_) {}
 
   static constexpr event_level level{event_level::info};
diff --git a/repertory/librepertory/include/events/types/download_restore_failed.hpp b/repertory/librepertory/include/events/types/download_restore_failed.hpp
index 2c834967..739bf1ac 100644
--- a/repertory/librepertory/include/events/types/download_restore_failed.hpp
+++ b/repertory/librepertory/include/events/types/download_restore_failed.hpp
@@ -28,12 +28,13 @@
 namespace repertory {
 struct download_restore_failed final : public i_event {
   download_restore_failed() = default;
-  download_restore_failed(std::string api_path_, std::string dest_path_,
-                          std::string error_, std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
-        error(std::move(error_)),
-        function_name(std::string(function_name_)) {}
+  download_restore_failed(std::string_view api_path_,
+                          std::string_view dest_path_, std::string_view error_,
+                          std::string_view function_name_)
+      : api_path(api_path_),
+        dest_path(dest_path_),
+        error(error_),
+        function_name(function_name_) {}
 
   static constexpr event_level level{event_level::error};
   static constexpr std::string_view name{"download_restore_failed"};
diff --git a/repertory/librepertory/include/events/types/download_restored.hpp b/repertory/librepertory/include/events/types/download_restored.hpp
index 67536cf4..22214744 100644
--- a/repertory/librepertory/include/events/types/download_restored.hpp
+++ b/repertory/librepertory/include/events/types/download_restored.hpp
@@ -28,11 +28,11 @@
 namespace repertory {
 struct download_restored final : public i_event {
   download_restored() = default;
-  download_restored(std::string api_path_, std::string dest_path_,
+  download_restored(std::string_view api_path_, std::string_view dest_path_,
                     std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
-        function_name(std::string(function_name_)) {}
+      : api_path(api_path_),
+        dest_path(dest_path_),
+        function_name(function_name_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"download_restored"};
diff --git a/repertory/librepertory/include/events/types/download_resume_add_failed.hpp b/repertory/librepertory/include/events/types/download_resume_add_failed.hpp
index 7741caa6..96e090ad 100644
--- a/repertory/librepertory/include/events/types/download_resume_add_failed.hpp
+++ b/repertory/librepertory/include/events/types/download_resume_add_failed.hpp
@@ -28,13 +28,14 @@
 namespace repertory {
 struct download_resume_add_failed final : public i_event {
   download_resume_add_failed() = default;
-  download_resume_add_failed(std::string api_path_, std::string dest_path_,
-                             std::string error_,
+  download_resume_add_failed(std::string_view api_path_,
+                             std::string_view dest_path_,
+                             std::string_view error_,
                              std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
-        error(std::move(error_)),
-        function_name(std::string(function_name_)) {}
+      : api_path(api_path_),
+        dest_path(dest_path_),
+        error(error_),
+        function_name(function_name_) {}
 
   static constexpr event_level level{event_level::error};
   static constexpr std::string_view name{"download_resume_add_failed"};
diff --git a/repertory/librepertory/include/events/types/download_resume_added.hpp b/repertory/librepertory/include/events/types/download_resume_added.hpp
index a2935079..c49af159 100644
--- a/repertory/librepertory/include/events/types/download_resume_added.hpp
+++ b/repertory/librepertory/include/events/types/download_resume_added.hpp
@@ -28,11 +28,11 @@
 namespace repertory {
 struct download_resume_added final : public i_event {
   download_resume_added() = default;
-  download_resume_added(std::string api_path_, std::string dest_path_,
+  download_resume_added(std::string_view api_path_, std::string_view dest_path_,
                         std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
-        function_name(std::string(function_name_)) {}
+      : api_path(api_path_),
+        dest_path(dest_path_),
+        function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"download_resume_added"};
diff --git a/repertory/librepertory/include/events/types/download_resume_removed.hpp b/repertory/librepertory/include/events/types/download_resume_removed.hpp
index 0ea3c0d9..aabd62d4 100644
--- a/repertory/librepertory/include/events/types/download_resume_removed.hpp
+++ b/repertory/librepertory/include/events/types/download_resume_removed.hpp
@@ -28,11 +28,12 @@
 namespace repertory {
 struct download_resume_removed final : public i_event {
   download_resume_removed() = default;
-  download_resume_removed(std::string api_path_, std::string dest_path_,
+  download_resume_removed(std::string_view api_path_,
+                          std::string_view dest_path_,
                           std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
-        function_name(std::string(function_name_)) {}
+      : api_path(api_path_),
+        dest_path(dest_path_),
+        function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"download_resume_removed"};
diff --git a/repertory/librepertory/include/events/types/download_type_selected.hpp b/repertory/librepertory/include/events/types/download_type_selected.hpp
index 92d15978..15a3595d 100644
--- a/repertory/librepertory/include/events/types/download_type_selected.hpp
+++ b/repertory/librepertory/include/events/types/download_type_selected.hpp
@@ -28,11 +28,12 @@
 namespace repertory {
 struct download_type_selected final : public i_event {
   download_type_selected() = default;
-  download_type_selected(std::string api_path_, std::string dest_path_,
+  download_type_selected(std::string_view api_path_,
+                         std::string_view dest_path_,
                          std::string_view function_name_, download_type type_)
-      : api_path(std::move(api_path_)),
-        dest_path(std::move(dest_path_)),
-        function_name(std::string(function_name_)),
+      : api_path(api_path_),
+        dest_path(dest_path_),
+        function_name(function_name_),
         type(type_) {}
 
   static constexpr event_level level{event_level::debug};
diff --git a/repertory/librepertory/include/events/types/drive_mount_failed.hpp b/repertory/librepertory/include/events/types/drive_mount_failed.hpp
index ad76e9e0..e28dbdb3 100644
--- a/repertory/librepertory/include/events/types/drive_mount_failed.hpp
+++ b/repertory/librepertory/include/events/types/drive_mount_failed.hpp
@@ -30,9 +30,9 @@ namespace repertory {
 struct drive_mount_failed final : public i_event {
   drive_mount_failed() = default;
   drive_mount_failed(NTSTATUS error_, std::string_view function_name_,
-                     std::string mount_location_)
+                     std::string_view mount_location_)
       : error(error_),
-        function_name(std::string(function_name_)),
+        function_name(function_name_),
         mount_location(std::move(mount_location_)) {}
 
   static constexpr event_level level{event_level::error};
diff --git a/repertory/librepertory/include/events/types/drive_mount_result.hpp b/repertory/librepertory/include/events/types/drive_mount_result.hpp
index ada57745..4d4d49bf 100644
--- a/repertory/librepertory/include/events/types/drive_mount_result.hpp
+++ b/repertory/librepertory/include/events/types/drive_mount_result.hpp
@@ -29,10 +29,10 @@ namespace repertory {
 struct drive_mount_result final : public i_event {
   drive_mount_result() = default;
   drive_mount_result(std::string_view function_name_,
-                     std::string mount_location_, std::string result_)
-      : function_name(std::string(function_name_)),
-        mount_location(std::move(mount_location_)),
-        result(std::move(result_)) {}
+                     std::string_view mount_location_, std::string result_)
+      : function_name(function_name_),
+        mount_location(mount_location_),
+        result(result_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"drive_mount_result"};
diff --git a/repertory/librepertory/include/events/types/drive_mounted.hpp b/repertory/librepertory/include/events/types/drive_mounted.hpp
index 67c7c07d..92b115cb 100644
--- a/repertory/librepertory/include/events/types/drive_mounted.hpp
+++ b/repertory/librepertory/include/events/types/drive_mounted.hpp
@@ -28,9 +28,9 @@
 namespace repertory {
 struct drive_mounted final : public i_event {
   drive_mounted() = default;
-  drive_mounted(std::string_view function_name_, std::string mount_location_)
-      : function_name(std::string(function_name_)),
-        mount_location(std::move(mount_location_)) {}
+  drive_mounted(std::string_view function_name_,
+                std::string_view mount_location_)
+      : function_name(function_name_), mount_location(mount_location_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"drive_mounted"};
diff --git a/repertory/librepertory/include/events/types/drive_stop_timed_out.hpp b/repertory/librepertory/include/events/types/drive_stop_timed_out.hpp
index 4f54f7e1..03061bc7 100644
--- a/repertory/librepertory/include/events/types/drive_stop_timed_out.hpp
+++ b/repertory/librepertory/include/events/types/drive_stop_timed_out.hpp
@@ -29,7 +29,7 @@ namespace repertory {
 struct drive_stop_timed_out final : public i_event {
   drive_stop_timed_out() = default;
   drive_stop_timed_out(std::string_view function_name_)
-      : function_name(std::string(function_name_)) {}
+      : function_name(function_name_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"drive_stop_timed_out"};
diff --git a/repertory/librepertory/include/events/types/drive_unmount_pending.hpp b/repertory/librepertory/include/events/types/drive_unmount_pending.hpp
index 75162598..fba886cd 100644
--- a/repertory/librepertory/include/events/types/drive_unmount_pending.hpp
+++ b/repertory/librepertory/include/events/types/drive_unmount_pending.hpp
@@ -29,9 +29,8 @@ namespace repertory {
 struct drive_unmount_pending final : public i_event {
   drive_unmount_pending() = default;
   drive_unmount_pending(std::string_view function_name_,
-                        std::string mount_location_)
-      : function_name(std::string(function_name_)),
-        mount_location(std::move(mount_location_)) {}
+                        std::string_view mount_location_)
+      : function_name(function_name_), mount_location(mount_location_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"drive_unmount_pending"};
diff --git a/repertory/librepertory/include/events/types/drive_unmounted.hpp b/repertory/librepertory/include/events/types/drive_unmounted.hpp
index e9d69aad..e14e20df 100644
--- a/repertory/librepertory/include/events/types/drive_unmounted.hpp
+++ b/repertory/librepertory/include/events/types/drive_unmounted.hpp
@@ -28,9 +28,9 @@
 namespace repertory {
 struct drive_unmounted final : public i_event {
   drive_unmounted() = default;
-  drive_unmounted(std::string_view function_name_, std::string mount_location_)
-      : function_name(std::string(function_name_)),
-        mount_location(std::move(mount_location_)) {}
+  drive_unmounted(std::string_view function_name_,
+                  std::string_view mount_location_)
+      : function_name(function_name_), mount_location(mount_location_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"drive_unmounted"};
diff --git a/repertory/librepertory/include/events/types/event_level_changed.hpp b/repertory/librepertory/include/events/types/event_level_changed.hpp
index aca9122b..5d77bc1c 100644
--- a/repertory/librepertory/include/events/types/event_level_changed.hpp
+++ b/repertory/librepertory/include/events/types/event_level_changed.hpp
@@ -29,7 +29,7 @@ namespace repertory {
 struct event_level_changed final : public i_event {
   event_level_changed() = default;
   event_level_changed(std::string_view function_name_, event_level new_level_)
-      : function_name(std::string(function_name_)), new_level(new_level_) {}
+      : function_name(function_name_), new_level(new_level_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"event_level_changed"};
diff --git a/repertory/librepertory/include/events/types/file_pinned.hpp b/repertory/librepertory/include/events/types/file_pinned.hpp
index fdc742a8..879e4ab1 100644
--- a/repertory/librepertory/include/events/types/file_pinned.hpp
+++ b/repertory/librepertory/include/events/types/file_pinned.hpp
@@ -28,9 +28,8 @@
 namespace repertory {
 struct file_pinned final : public i_event {
   file_pinned() = default;
-  file_pinned(std::string api_path_, std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)) {}
+  file_pinned(std::string_view api_path_, std::string_view function_name_)
+      : api_path(api_path_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"file_pinned"};
diff --git a/repertory/librepertory/include/events/types/file_remove_failed.hpp b/repertory/librepertory/include/events/types/file_remove_failed.hpp
index 37c2c6f3..ae216b25 100644
--- a/repertory/librepertory/include/events/types/file_remove_failed.hpp
+++ b/repertory/librepertory/include/events/types/file_remove_failed.hpp
@@ -28,11 +28,9 @@
 namespace repertory {
 struct file_remove_failed final : public i_event {
   file_remove_failed() = default;
-  file_remove_failed(std::string api_path_, api_error error_,
+  file_remove_failed(std::string_view api_path_, api_error error_,
                      std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        error(error_),
-        function_name(std::string(function_name_)) {}
+      : api_path(api_path_), error(error_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::error};
   static constexpr std::string_view name{"file_remove_failed"};
diff --git a/repertory/librepertory/include/events/types/file_removed.hpp b/repertory/librepertory/include/events/types/file_removed.hpp
index b1156b8b..5acb4765 100644
--- a/repertory/librepertory/include/events/types/file_removed.hpp
+++ b/repertory/librepertory/include/events/types/file_removed.hpp
@@ -28,9 +28,8 @@
 namespace repertory {
 struct file_removed final : public i_event {
   file_removed() = default;
-  file_removed(std::string api_path_, std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)) {}
+  file_removed(std::string_view api_path_, std::string_view function_name_)
+      : api_path(api_path_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"file_removed"};
diff --git a/repertory/librepertory/include/events/types/file_removed_externally.hpp b/repertory/librepertory/include/events/types/file_removed_externally.hpp
index 079f3110..1d277410 100644
--- a/repertory/librepertory/include/events/types/file_removed_externally.hpp
+++ b/repertory/librepertory/include/events/types/file_removed_externally.hpp
@@ -28,12 +28,12 @@
 namespace repertory {
 struct file_removed_externally final : public i_event {
   file_removed_externally() = default;
-  file_removed_externally(std::string api_path_,
+  file_removed_externally(std::string_view api_path_,
                           std::string_view function_name_,
-                          std::string source_path_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+                          std::string_view source_path_)
+      : api_path(api_path_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"file_removed_externally"};
diff --git a/repertory/librepertory/include/events/types/file_unpinned.hpp b/repertory/librepertory/include/events/types/file_unpinned.hpp
index eb3b629f..3f53eefb 100644
--- a/repertory/librepertory/include/events/types/file_unpinned.hpp
+++ b/repertory/librepertory/include/events/types/file_unpinned.hpp
@@ -28,9 +28,8 @@
 namespace repertory {
 struct file_unpinned final : public i_event {
   file_unpinned() = default;
-  file_unpinned(std::string api_path_, std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)) {}
+  file_unpinned(std::string_view api_path_, std::string_view function_name_)
+      : api_path(api_path_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"file_unpinned"};
diff --git a/repertory/librepertory/include/events/types/file_upload_completed.hpp b/repertory/librepertory/include/events/types/file_upload_completed.hpp
index 3ecb7766..ad22ef4b 100644
--- a/repertory/librepertory/include/events/types/file_upload_completed.hpp
+++ b/repertory/librepertory/include/events/types/file_upload_completed.hpp
@@ -28,14 +28,14 @@
 namespace repertory {
 struct file_upload_completed final : public i_event {
   file_upload_completed() = default;
-  file_upload_completed(std::string api_path_, bool cancelled_,
+  file_upload_completed(std::string_view api_path_, bool cancelled_,
                         api_error error_, std::string_view function_name_,
-                        std::string source_path_)
-      : api_path(std::move(api_path_)),
+                        std::string_view source_path_)
+      : api_path(api_path_),
         cancelled(cancelled_),
         error(error_),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"file_upload_completed"};
diff --git a/repertory/librepertory/include/events/types/file_upload_failed.hpp b/repertory/librepertory/include/events/types/file_upload_failed.hpp
index 93800b8c..66eeca76 100644
--- a/repertory/librepertory/include/events/types/file_upload_failed.hpp
+++ b/repertory/librepertory/include/events/types/file_upload_failed.hpp
@@ -28,12 +28,13 @@
 namespace repertory {
 struct file_upload_failed final : public i_event {
   file_upload_failed() = default;
-  file_upload_failed(std::string api_path_, std::string error_,
-                     std::string_view function_name_, std::string source_path_)
-      : api_path(std::move(api_path_)),
-        error(std::move(error_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+  file_upload_failed(std::string_view api_path_, std::string_view error_,
+                     std::string_view function_name_,
+                     std::string_view source_path_)
+      : api_path(api_path_),
+        error(error_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"file_upload_failed"};
diff --git a/repertory/librepertory/include/events/types/file_upload_not_found.hpp b/repertory/librepertory/include/events/types/file_upload_not_found.hpp
index 1b74330e..5e076727 100644
--- a/repertory/librepertory/include/events/types/file_upload_not_found.hpp
+++ b/repertory/librepertory/include/events/types/file_upload_not_found.hpp
@@ -28,11 +28,12 @@
 namespace repertory {
 struct file_upload_not_found final : public i_event {
   file_upload_not_found() = default;
-  file_upload_not_found(std::string api_path_, std::string_view function_name_,
-                        std::string source_path_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+  file_upload_not_found(std::string_view api_path_,
+                        std::string_view function_name_,
+                        std::string_view source_path_)
+      : api_path(api_path_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"file_upload_not_found"};
diff --git a/repertory/librepertory/include/events/types/file_upload_queued.hpp b/repertory/librepertory/include/events/types/file_upload_queued.hpp
index 41949302..cd4af05c 100644
--- a/repertory/librepertory/include/events/types/file_upload_queued.hpp
+++ b/repertory/librepertory/include/events/types/file_upload_queued.hpp
@@ -28,11 +28,12 @@
 namespace repertory {
 struct file_upload_queued final : public i_event {
   file_upload_queued() = default;
-  file_upload_queued(std::string api_path_, std::string_view function_name_,
-                     std::string source_path_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+  file_upload_queued(std::string_view api_path_,
+                     std::string_view function_name_,
+                     std::string_view source_path_)
+      : api_path(api_path_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"file_upload_queued"};
diff --git a/repertory/librepertory/include/events/types/file_upload_removed.hpp b/repertory/librepertory/include/events/types/file_upload_removed.hpp
index 04ba865e..c7406a7a 100644
--- a/repertory/librepertory/include/events/types/file_upload_removed.hpp
+++ b/repertory/librepertory/include/events/types/file_upload_removed.hpp
@@ -28,9 +28,9 @@
 namespace repertory {
 struct file_upload_removed final : public i_event {
   file_upload_removed() = default;
-  file_upload_removed(std::string api_path_, std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)) {}
+  file_upload_removed(std::string_view api_path_,
+                      std::string_view function_name_)
+      : api_path(api_path_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"file_upload_removed"};
diff --git a/repertory/librepertory/include/events/types/file_upload_retry.hpp b/repertory/librepertory/include/events/types/file_upload_retry.hpp
index 7296a364..44a4e09a 100644
--- a/repertory/librepertory/include/events/types/file_upload_retry.hpp
+++ b/repertory/librepertory/include/events/types/file_upload_retry.hpp
@@ -28,12 +28,13 @@
 namespace repertory {
 struct file_upload_retry final : public i_event {
   file_upload_retry() = default;
-  file_upload_retry(std::string api_path_, api_error error_,
-                    std::string_view function_name_, std::string source_path_)
-      : api_path(std::move(api_path_)),
-        error(std::move(error_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+  file_upload_retry(std::string_view api_path_, api_error error_,
+                    std::string_view function_name_,
+                    std::string_view source_path_)
+      : api_path(api_path_),
+        error(error_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"file_upload_retry"};
diff --git a/repertory/librepertory/include/events/types/filesystem_item_added.hpp b/repertory/librepertory/include/events/types/filesystem_item_added.hpp
index 853da92b..eb30e23f 100644
--- a/repertory/librepertory/include/events/types/filesystem_item_added.hpp
+++ b/repertory/librepertory/include/events/types/filesystem_item_added.hpp
@@ -28,12 +28,13 @@
 namespace repertory {
 struct filesystem_item_added final : public i_event {
   filesystem_item_added() = default;
-  filesystem_item_added(std::string api_parent_, std::string api_path_,
-                        bool directory_, std::string_view function_name_)
-      : api_parent(std::move(api_parent_)),
-        api_path(std::move(api_path_)),
+  filesystem_item_added(std::string_view api_parent_,
+                        std::string_view api_path_, bool directory_,
+                        std::string_view function_name_)
+      : api_parent(api_parent_),
+        api_path(api_path_),
         directory(directory_),
-        function_name(std::string(function_name_)) {}
+        function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"filesystem_item_added"};
diff --git a/repertory/librepertory/include/events/types/filesystem_item_closed.hpp b/repertory/librepertory/include/events/types/filesystem_item_closed.hpp
index b5d1340c..4946bfe2 100644
--- a/repertory/librepertory/include/events/types/filesystem_item_closed.hpp
+++ b/repertory/librepertory/include/events/types/filesystem_item_closed.hpp
@@ -28,14 +28,14 @@
 namespace repertory {
 struct filesystem_item_closed final : public i_event {
   filesystem_item_closed() = default;
-  filesystem_item_closed(std::string api_path_, bool changed_, bool directory_,
-                         std::string_view function_name_,
-                         std::string source_path_)
-      : api_path(std::move(api_path_)),
+  filesystem_item_closed(std::string_view api_path_, bool changed_,
+                         bool directory_, std::string_view function_name_,
+                         std::string_view source_path_)
+      : api_path(api_path_),
         changed(changed_),
         directory(directory_),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::trace};
   static constexpr std::string_view name{"filesystem_item_closed"};
diff --git a/repertory/librepertory/include/events/types/filesystem_item_evicted.hpp b/repertory/librepertory/include/events/types/filesystem_item_evicted.hpp
index 5821d896..d08f226f 100644
--- a/repertory/librepertory/include/events/types/filesystem_item_evicted.hpp
+++ b/repertory/librepertory/include/events/types/filesystem_item_evicted.hpp
@@ -28,12 +28,12 @@
 namespace repertory {
 struct filesystem_item_evicted final : public i_event {
   filesystem_item_evicted() = default;
-  filesystem_item_evicted(std::string api_path_,
+  filesystem_item_evicted(std::string_view api_path_,
                           std::string_view function_name_,
-                          std::string source_path_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+                          std::string_view source_path_)
+      : api_path(api_path_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"filesystem_item_evicted"};
diff --git a/repertory/librepertory/include/events/types/filesystem_item_handle_closed.hpp b/repertory/librepertory/include/events/types/filesystem_item_handle_closed.hpp
index b84627d9..b07f3c6f 100644
--- a/repertory/librepertory/include/events/types/filesystem_item_handle_closed.hpp
+++ b/repertory/librepertory/include/events/types/filesystem_item_handle_closed.hpp
@@ -28,16 +28,17 @@
 namespace repertory {
 struct filesystem_item_handle_closed final : public i_event {
   filesystem_item_handle_closed() = default;
-  filesystem_item_handle_closed(std::string api_path_, bool changed_,
+  filesystem_item_handle_closed(std::string_view api_path_, bool changed_,
                                 bool directory_,
                                 std::string_view function_name_,
-                                std::uint64_t handle_, std::string source_path_)
-      : api_path(std::move(api_path_)),
+                                std::uint64_t handle_,
+                                std::string_view source_path_)
+      : api_path(api_path_),
         changed(changed_),
         directory(directory_),
-        function_name(std::string(function_name_)),
+        function_name(function_name_),
         handle(handle_),
-        source_path(std::move(source_path_)) {}
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::trace};
   static constexpr std::string_view name{"filesystem_item_handle_closed"};
diff --git a/repertory/librepertory/include/events/types/filesystem_item_handle_opened.hpp b/repertory/librepertory/include/events/types/filesystem_item_handle_opened.hpp
index 0ea6f0ad..d24a565b 100644
--- a/repertory/librepertory/include/events/types/filesystem_item_handle_opened.hpp
+++ b/repertory/librepertory/include/events/types/filesystem_item_handle_opened.hpp
@@ -28,14 +28,15 @@
 namespace repertory {
 struct filesystem_item_handle_opened final : public i_event {
   filesystem_item_handle_opened() = default;
-  filesystem_item_handle_opened(std::string api_path_, bool directory_,
+  filesystem_item_handle_opened(std::string_view api_path_, bool directory_,
                                 std::string_view function_name_,
-                                std::uint64_t handle_, std::string source_path_)
-      : api_path(std::move(api_path_)),
+                                std::uint64_t handle_,
+                                std::string_view source_path_)
+      : api_path(api_path_),
         directory(directory_),
-        function_name(std::string(function_name_)),
+        function_name(function_name_),
         handle(handle_),
-        source_path(std::move(source_path_)) {}
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::trace};
   static constexpr std::string_view name{"filesystem_item_handle_opened"};
diff --git a/repertory/librepertory/include/events/types/filesystem_item_opened.hpp b/repertory/librepertory/include/events/types/filesystem_item_opened.hpp
index 5d19f839..d9d44e93 100644
--- a/repertory/librepertory/include/events/types/filesystem_item_opened.hpp
+++ b/repertory/librepertory/include/events/types/filesystem_item_opened.hpp
@@ -28,13 +28,13 @@
 namespace repertory {
 struct filesystem_item_opened final : public i_event {
   filesystem_item_opened() = default;
-  filesystem_item_opened(std::string api_path_, bool directory_,
+  filesystem_item_opened(std::string_view api_path_, bool directory_,
                          std::string_view function_name_,
-                         std::string source_path_)
-      : api_path(std::move(api_path_)),
+                         std::string_view source_path_)
+      : api_path(api_path_),
         directory(directory_),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::trace};
   static constexpr std::string_view name{"filesystem_item_opened"};
diff --git a/repertory/librepertory/include/events/types/fuse_args_parsed.hpp b/repertory/librepertory/include/events/types/fuse_args_parsed.hpp
index 795bf4e5..e03c387c 100644
--- a/repertory/librepertory/include/events/types/fuse_args_parsed.hpp
+++ b/repertory/librepertory/include/events/types/fuse_args_parsed.hpp
@@ -30,7 +30,7 @@ namespace repertory {
 struct fuse_args_parsed final : public i_event {
   fuse_args_parsed() = default;
   fuse_args_parsed(std::string_view args_, std::string_view function_name_)
-      : args(std::move(args_)), function_name(std::string{function_name_}) {}
+      : args(args_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"fuse_args_parsed"};
diff --git a/repertory/librepertory/include/events/types/fuse_event.hpp b/repertory/librepertory/include/events/types/fuse_event.hpp
index a1f717ce..68679022 100644
--- a/repertory/librepertory/include/events/types/fuse_event.hpp
+++ b/repertory/librepertory/include/events/types/fuse_event.hpp
@@ -31,9 +31,7 @@ struct fuse_event final : public i_event {
   fuse_event() = default;
   fuse_event(std::string_view api_path_, std::int32_t error_,
              std::string_view function_name_)
-      : api_path(std::string{api_path_}),
-        error(error_),
-        function_name(std::string{function_name_}) {}
+      : api_path(api_path_), error(error_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"fuse_event"};
diff --git a/repertory/librepertory/include/events/types/info_log.hpp b/repertory/librepertory/include/events/types/info_log.hpp
index 36e1e1cb..60653451 100644
--- a/repertory/librepertory/include/events/types/info_log.hpp
+++ b/repertory/librepertory/include/events/types/info_log.hpp
@@ -28,8 +28,8 @@
 namespace repertory {
 struct info_log final : public i_event {
   info_log() = default;
-  info_log(std::string_view function_name_, std::string msg_)
-      : function_name(std::string(function_name_)), msg(std::move(msg_)) {}
+  info_log(std::string_view function_name_, std::string_view msg_)
+      : function_name(function_name_), msg(msg_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"info_log"};
diff --git a/repertory/librepertory/include/events/types/invalid_cache_size.hpp b/repertory/librepertory/include/events/types/invalid_cache_size.hpp
index b6f21ab7..f059c33d 100644
--- a/repertory/librepertory/include/events/types/invalid_cache_size.hpp
+++ b/repertory/librepertory/include/events/types/invalid_cache_size.hpp
@@ -31,7 +31,7 @@ struct invalid_cache_size final : public i_event {
   invalid_cache_size(std::uint64_t cache_size_, std::string_view function_name_,
                      std::uint64_t invalid_size_)
       : cache_size(cache_size_),
-        function_name(std::string{function_name_}),
+        function_name(function_name_),
         invalid_size(invalid_size_) {}
 
   static constexpr event_level level{event_level::warn};
diff --git a/repertory/librepertory/include/events/types/item_timeout.hpp b/repertory/librepertory/include/events/types/item_timeout.hpp
index ac128a16..3da5898a 100644
--- a/repertory/librepertory/include/events/types/item_timeout.hpp
+++ b/repertory/librepertory/include/events/types/item_timeout.hpp
@@ -28,9 +28,8 @@
 namespace repertory {
 struct item_timeout final : public i_event {
   item_timeout() = default;
-  item_timeout(std::string api_path_, std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)) {}
+  item_timeout(std::string_view api_path_, std::string_view function_name_)
+      : api_path(api_path_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::trace};
   static constexpr std::string_view name{"item_timeout"};
diff --git a/repertory/librepertory/include/events/types/max_cache_size_reached.hpp b/repertory/librepertory/include/events/types/max_cache_size_reached.hpp
index 3da04e59..d8e26972 100644
--- a/repertory/librepertory/include/events/types/max_cache_size_reached.hpp
+++ b/repertory/librepertory/include/events/types/max_cache_size_reached.hpp
@@ -32,7 +32,7 @@ struct max_cache_size_reached final : public i_event {
                          std::string_view function_name_,
                          std::uint64_t max_cache_size_)
       : cache_size(cache_size_),
-        function_name(std::string{function_name_}),
+        function_name(function_name_),
         max_cache_size(max_cache_size_) {}
 
   static constexpr event_level level{event_level::warn};
diff --git a/repertory/librepertory/include/events/types/orphaned_file_detected.hpp b/repertory/librepertory/include/events/types/orphaned_file_detected.hpp
index d299a0a5..644363fc 100644
--- a/repertory/librepertory/include/events/types/orphaned_file_detected.hpp
+++ b/repertory/librepertory/include/events/types/orphaned_file_detected.hpp
@@ -29,9 +29,8 @@ namespace repertory {
 struct orphaned_file_detected final : public i_event {
   orphaned_file_detected() = default;
   orphaned_file_detected(std::string_view function_name_,
-                         std::string source_path_)
-      : function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+                         std::string_view source_path_)
+      : function_name(function_name_), source_path(source_path_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"orphaned_file_detected"};
diff --git a/repertory/librepertory/include/events/types/orphaned_file_processing_failed.hpp b/repertory/librepertory/include/events/types/orphaned_file_processing_failed.hpp
index 9476a972..3be9d9c7 100644
--- a/repertory/librepertory/include/events/types/orphaned_file_processing_failed.hpp
+++ b/repertory/librepertory/include/events/types/orphaned_file_processing_failed.hpp
@@ -28,13 +28,14 @@
 namespace repertory {
 struct orphaned_file_processing_failed final : public i_event {
   orphaned_file_processing_failed() = default;
-  orphaned_file_processing_failed(std::string dest_path_, std::string error_,
+  orphaned_file_processing_failed(std::string_view dest_path_,
+                                  std::string_view error_,
                                   std::string_view function_name_,
-                                  std::string source_path_)
-      : dest_path(std::move(dest_path_)),
-        error(std::move(error_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+                                  std::string_view source_path_)
+      : dest_path(dest_path_),
+        error(error_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::error};
   static constexpr std::string_view name{
diff --git a/repertory/librepertory/include/events/types/orphaned_source_file_detected.hpp b/repertory/librepertory/include/events/types/orphaned_source_file_detected.hpp
index 14aeb11a..bcee6f6a 100644
--- a/repertory/librepertory/include/events/types/orphaned_source_file_detected.hpp
+++ b/repertory/librepertory/include/events/types/orphaned_source_file_detected.hpp
@@ -29,9 +29,8 @@ namespace repertory {
 struct orphaned_source_file_detected final : public i_event {
   orphaned_source_file_detected() = default;
   orphaned_source_file_detected(std::string_view function_name_,
-                                std::string source_path_)
-      : function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+                                std::string_view source_path_)
+      : function_name(function_name_), source_path(source_path_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"orphaned_source_file_detected"};
diff --git a/repertory/librepertory/include/events/types/orphaned_source_file_removed.hpp b/repertory/librepertory/include/events/types/orphaned_source_file_removed.hpp
index 22d81529..dfcf3fb3 100644
--- a/repertory/librepertory/include/events/types/orphaned_source_file_removed.hpp
+++ b/repertory/librepertory/include/events/types/orphaned_source_file_removed.hpp
@@ -29,9 +29,8 @@ namespace repertory {
 struct orphaned_source_file_removed final : public i_event {
   orphaned_source_file_removed() = default;
   orphaned_source_file_removed(std::string_view function_name_,
-                               std::string source_path_)
-      : function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+                               std::string_view source_path_)
+      : function_name(function_name_), source_path(source_path_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"orphaned_source_file_removed"};
diff --git a/repertory/librepertory/include/events/types/packet_client_timeout.hpp b/repertory/librepertory/include/events/types/packet_client_timeout.hpp
index ff58753b..f87fddad 100644
--- a/repertory/librepertory/include/events/types/packet_client_timeout.hpp
+++ b/repertory/librepertory/include/events/types/packet_client_timeout.hpp
@@ -30,8 +30,7 @@ struct packet_client_timeout final : public i_event {
   packet_client_timeout() = default;
   packet_client_timeout(std::string_view event_name_,
                         std::string_view function_name_)
-      : event_name(std::string(event_name_)),
-        function_name(std::string(function_name_)) {}
+      : event_name(event_name_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"packet_client_timeout"};
diff --git a/repertory/librepertory/include/events/types/polling_item_begin.hpp b/repertory/librepertory/include/events/types/polling_item_begin.hpp
index fd98cbe5..7e496f3d 100644
--- a/repertory/librepertory/include/events/types/polling_item_begin.hpp
+++ b/repertory/librepertory/include/events/types/polling_item_begin.hpp
@@ -28,9 +28,9 @@
 namespace repertory {
 struct polling_item_begin final : public i_event {
   polling_item_begin() = default;
-  polling_item_begin(std::string_view function_name_, std::string item_name_)
-      : function_name(std::string(function_name_)),
-        item_name(std::move(item_name_)) {}
+  polling_item_begin(std::string_view function_name_,
+                     std::string_view item_name_)
+      : function_name(function_name_), item_name(item_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"polling_item_begin"};
diff --git a/repertory/librepertory/include/events/types/polling_item_end.hpp b/repertory/librepertory/include/events/types/polling_item_end.hpp
index 5bc6075e..8446e31c 100644
--- a/repertory/librepertory/include/events/types/polling_item_end.hpp
+++ b/repertory/librepertory/include/events/types/polling_item_end.hpp
@@ -28,9 +28,8 @@
 namespace repertory {
 struct polling_item_end final : public i_event {
   polling_item_end() = default;
-  polling_item_end(std::string_view function_name_, std::string item_name_)
-      : function_name(std::string(function_name_)),
-        item_name(std::move(item_name_)) {}
+  polling_item_end(std::string_view function_name_, std::string_view item_name_)
+      : function_name(function_name_), item_name(item_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"polling_item_end"};
diff --git a/repertory/librepertory/include/events/types/provider_invalid_version.hpp b/repertory/librepertory/include/events/types/provider_invalid_version.hpp
index cc6e84b0..df26c3f9 100644
--- a/repertory/librepertory/include/events/types/provider_invalid_version.hpp
+++ b/repertory/librepertory/include/events/types/provider_invalid_version.hpp
@@ -29,11 +29,11 @@ namespace repertory {
 struct provider_invalid_version final : public i_event {
   provider_invalid_version() = default;
   provider_invalid_version(std::string_view function_name_,
-                           std::string required_version_,
-                           std::string returned_version_)
-      : function_name(std::string(function_name_)),
-        required_version(std::move(required_version_)),
-        returned_version(std::move(returned_version_)) {}
+                           std::string_view required_version_,
+                           std::string_view returned_version_)
+      : function_name(function_name_),
+        required_version(required_version_),
+        returned_version(returned_version_) {}
 
   static constexpr event_level level{event_level::error};
   static constexpr std::string_view name{"provider_invalid_version"};
diff --git a/repertory/librepertory/include/events/types/provider_offline.hpp b/repertory/librepertory/include/events/types/provider_offline.hpp
index e1f3b82e..72512da3 100644
--- a/repertory/librepertory/include/events/types/provider_offline.hpp
+++ b/repertory/librepertory/include/events/types/provider_offline.hpp
@@ -29,9 +29,9 @@ namespace repertory {
 struct provider_offline final : public i_event {
   provider_offline() = default;
   provider_offline(std::string_view function_name_,
-                   std::string host_name_or_ip_, std::uint16_t port_)
-      : function_name(std::string(function_name_)),
-        host_name_or_ip(std::move(host_name_or_ip_)),
+                   std::string_view host_name_or_ip_, std::uint16_t port_)
+      : function_name(function_name_),
+        host_name_or_ip(host_name_or_ip_),
         port(port_) {}
 
   static constexpr event_level level{event_level::warn};
diff --git a/repertory/librepertory/include/events/types/provider_upload_begin.hpp b/repertory/librepertory/include/events/types/provider_upload_begin.hpp
index 5a7fc5e2..6872c868 100644
--- a/repertory/librepertory/include/events/types/provider_upload_begin.hpp
+++ b/repertory/librepertory/include/events/types/provider_upload_begin.hpp
@@ -28,11 +28,12 @@
 namespace repertory {
 struct provider_upload_begin final : public i_event {
   provider_upload_begin() = default;
-  provider_upload_begin(std::string api_path_, std::string_view function_name_,
-                        std::string source_path_)
-      : api_path(std::move(api_path_)),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+  provider_upload_begin(std::string_view api_path_,
+                        std::string_view function_name_,
+                        std::string_view source_path_)
+      : api_path(api_path_),
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"provider_upload_begin"};
diff --git a/repertory/librepertory/include/events/types/provider_upload_end.hpp b/repertory/librepertory/include/events/types/provider_upload_end.hpp
index 7e69118a..4cfd62d4 100644
--- a/repertory/librepertory/include/events/types/provider_upload_end.hpp
+++ b/repertory/librepertory/include/events/types/provider_upload_end.hpp
@@ -28,12 +28,13 @@
 namespace repertory {
 struct provider_upload_end final : public i_event {
   provider_upload_end() = default;
-  provider_upload_end(std::string api_path_, api_error error_,
-                      std::string_view function_name_, std::string source_path_)
-      : api_path(std::move(api_path_)),
+  provider_upload_end(std::string_view api_path_, api_error error_,
+                      std::string_view function_name_,
+                      std::string_view source_path_)
+      : api_path(api_path_),
         error(error_),
-        function_name(std::string(function_name_)),
-        source_path(std::move(source_path_)) {}
+        function_name(function_name_),
+        source_path(source_path_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"provider_upload_end"};
diff --git a/repertory/librepertory/include/events/types/remote_server_event.hpp b/repertory/librepertory/include/events/types/remote_server_event.hpp
index d13d368a..45547772 100644
--- a/repertory/librepertory/include/events/types/remote_server_event.hpp
+++ b/repertory/librepertory/include/events/types/remote_server_event.hpp
@@ -29,11 +29,9 @@
 namespace repertory {
 struct remote_server_event final : public i_event {
   remote_server_event() = default;
-  remote_server_event(std::string api_path_, packet::error_type error_,
+  remote_server_event(std::string_view api_path_, packet::error_type error_,
                       std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        error(error_),
-        function_name(std::string{function_name_}) {}
+      : api_path(api_path_), error(error_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"remote_server_event"};
diff --git a/repertory/librepertory/include/events/types/repertory_exception.hpp b/repertory/librepertory/include/events/types/repertory_exception.hpp
index 6b901ec7..39847b53 100644
--- a/repertory/librepertory/include/events/types/repertory_exception.hpp
+++ b/repertory/librepertory/include/events/types/repertory_exception.hpp
@@ -28,8 +28,8 @@
 namespace repertory {
 struct repertory_exception final : public i_event {
   repertory_exception() = default;
-  repertory_exception(std::string_view function_name_, std::string msg_)
-      : function_name(std::string(function_name_)), msg(std::move(msg_)) {}
+  repertory_exception(std::string_view function_name_, std::string_view msg_)
+      : function_name(function_name_), msg(msg_) {}
 
   static constexpr event_level level{event_level::error};
   static constexpr std::string_view name{"repertory_exception"};
diff --git a/repertory/librepertory/include/events/types/service_start_begin.hpp b/repertory/librepertory/include/events/types/service_start_begin.hpp
index 384c437a..303acc3f 100644
--- a/repertory/librepertory/include/events/types/service_start_begin.hpp
+++ b/repertory/librepertory/include/events/types/service_start_begin.hpp
@@ -29,9 +29,8 @@ namespace repertory {
 struct service_start_begin final : public i_event {
   service_start_begin() = default;
   service_start_begin(std::string_view function_name_,
-                      std::string service_name_)
-      : function_name(std::string(function_name_)),
-        service_name(std::move(service_name_)) {}
+                      std::string_view service_name_)
+      : function_name(function_name_), service_name(service_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"service_start_begin"};
diff --git a/repertory/librepertory/include/events/types/service_start_end.hpp b/repertory/librepertory/include/events/types/service_start_end.hpp
index 470bdddd..ee559c64 100644
--- a/repertory/librepertory/include/events/types/service_start_end.hpp
+++ b/repertory/librepertory/include/events/types/service_start_end.hpp
@@ -28,9 +28,9 @@
 namespace repertory {
 struct service_start_end final : public i_event {
   service_start_end() = default;
-  service_start_end(std::string_view function_name_, std::string service_name_)
-      : function_name(std::string(function_name_)),
-        service_name(std::move(service_name_)) {}
+  service_start_end(std::string_view function_name_,
+                    std::string_view service_name_)
+      : function_name(function_name_), service_name(std::move(service_name_)) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"service_start_end"};
diff --git a/repertory/librepertory/include/events/types/service_stop_begin.hpp b/repertory/librepertory/include/events/types/service_stop_begin.hpp
index 8b41a6f1..ce28c63a 100644
--- a/repertory/librepertory/include/events/types/service_stop_begin.hpp
+++ b/repertory/librepertory/include/events/types/service_stop_begin.hpp
@@ -28,9 +28,9 @@
 namespace repertory {
 struct service_stop_begin final : public i_event {
   service_stop_begin() = default;
-  service_stop_begin(std::string_view function_name_, std::string service_name_)
-      : function_name(std::string(function_name_)),
-        service_name(std::move(service_name_)) {}
+  service_stop_begin(std::string_view function_name_,
+                     std::string_view service_name_)
+      : function_name(function_name_), service_name(service_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"service_stop_begin"};
diff --git a/repertory/librepertory/include/events/types/service_stop_end.hpp b/repertory/librepertory/include/events/types/service_stop_end.hpp
index ad4c3a89..6c12163a 100644
--- a/repertory/librepertory/include/events/types/service_stop_end.hpp
+++ b/repertory/librepertory/include/events/types/service_stop_end.hpp
@@ -28,9 +28,9 @@
 namespace repertory {
 struct service_stop_end final : public i_event {
   service_stop_end() = default;
-  service_stop_end(std::string_view function_name_, std::string service_name_)
-      : function_name(std::string(function_name_)),
-        service_name(std::move(service_name_)) {}
+  service_stop_end(std::string_view function_name_,
+                   std::string_view service_name_)
+      : function_name(function_name_), service_name(service_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"service_stop_end"};
diff --git a/repertory/librepertory/include/events/types/trace_log.hpp b/repertory/librepertory/include/events/types/trace_log.hpp
index 7ad52be0..b1d79bb9 100644
--- a/repertory/librepertory/include/events/types/trace_log.hpp
+++ b/repertory/librepertory/include/events/types/trace_log.hpp
@@ -28,8 +28,8 @@
 namespace repertory {
 struct trace_log final : public i_event {
   trace_log() = default;
-  trace_log(std::string_view function_name_, std::string msg_)
-      : function_name(std::string(function_name_)), msg(std::move(msg_)) {}
+  trace_log(std::string_view function_name_, std::string_view msg_)
+      : function_name(function_name_), msg(msg_) {}
 
   static constexpr event_level level{event_level::trace};
   static constexpr std::string_view name{"trace_log"};
diff --git a/repertory/librepertory/include/events/types/unmount_requested.hpp b/repertory/librepertory/include/events/types/unmount_requested.hpp
index ab470889..a16db278 100644
--- a/repertory/librepertory/include/events/types/unmount_requested.hpp
+++ b/repertory/librepertory/include/events/types/unmount_requested.hpp
@@ -29,7 +29,7 @@ namespace repertory {
 struct unmount_requested final : public i_event {
   unmount_requested() = default;
   unmount_requested(std::string_view function_name_)
-      : function_name(std::string(function_name_)) {}
+      : function_name(function_name_) {}
 
   static constexpr event_level level{event_level::info};
   static constexpr std::string_view name{"unmount_requested"};
diff --git a/repertory/librepertory/include/events/types/unmount_result.hpp b/repertory/librepertory/include/events/types/unmount_result.hpp
index 1ae99aea..1ba18f38 100644
--- a/repertory/librepertory/include/events/types/unmount_result.hpp
+++ b/repertory/librepertory/include/events/types/unmount_result.hpp
@@ -29,10 +29,10 @@
 namespace repertory {
 struct unmount_result final : public i_event {
   unmount_result() = default;
-  unmount_result(std::string_view function_name_, std::string mount_location_,
-                 std::int32_t result_)
-      : function_name(std::string(function_name_)),
-        mount_location(std::move(mount_location_)),
+  unmount_result(std::string_view function_name_,
+                 std::string_view mount_location_, std::int32_t result_)
+      : function_name(function_name_),
+        mount_location(mount_location_),
         result(result_) {}
 
   static constexpr event_level level{event_level::info};
diff --git a/repertory/librepertory/include/events/types/warn_log.hpp b/repertory/librepertory/include/events/types/warn_log.hpp
index f75d48ad..ba127ba1 100644
--- a/repertory/librepertory/include/events/types/warn_log.hpp
+++ b/repertory/librepertory/include/events/types/warn_log.hpp
@@ -28,8 +28,8 @@
 namespace repertory {
 struct warn_log final : public i_event {
   warn_log() = default;
-  warn_log(std::string_view function_name_, std::string msg_)
-      : function_name(std::string(function_name_)), msg(std::move(msg_)) {}
+  warn_log(std::string_view function_name_, std::string_view msg_)
+      : function_name(function_name_), msg(msg_) {}
 
   static constexpr event_level level{event_level::warn};
   static constexpr std::string_view name{"warn_log"};
diff --git a/repertory/librepertory/include/events/types/winfsp_event.hpp b/repertory/librepertory/include/events/types/winfsp_event.hpp
index 21fb01df..7d0391bd 100644
--- a/repertory/librepertory/include/events/types/winfsp_event.hpp
+++ b/repertory/librepertory/include/events/types/winfsp_event.hpp
@@ -29,11 +29,9 @@
 namespace repertory {
 struct winfsp_event final : public i_event {
   winfsp_event() = default;
-  winfsp_event(std::string api_path_, NTSTATUS error_,
+  winfsp_event(std::string_view api_path_, NTSTATUS error_,
                std::string_view function_name_)
-      : api_path(std::move(api_path_)),
-        error(error_),
-        function_name(std::string{function_name_}) {}
+      : api_path(api_path_), error(error_), function_name(function_name_) {}
 
   static constexpr event_level level{event_level::debug};
   static constexpr std::string_view name{"winfsp_event"};
diff --git a/repertory/librepertory/include/file_manager/file_manager.hpp b/repertory/librepertory/include/file_manager/file_manager.hpp
index 56ac87b4..d48ad3d0 100644
--- a/repertory/librepertory/include/file_manager/file_manager.hpp
+++ b/repertory/librepertory/include/file_manager/file_manager.hpp
@@ -81,27 +81,27 @@ private:
                                              bool &is_unlinked) const
       -> std::shared_ptr<i_closeable_open_file>;
 
-  [[nodiscard]] auto get_open_file_count(const std::string &api_path) const
+  [[nodiscard]] auto get_open_file_count(std::string_view api_path) const
       -> std::size_t;
 
   [[nodiscard]] auto get_stop_requested() const -> bool;
 
-  [[nodiscard]] auto open(const std::string &api_path, bool directory,
+  [[nodiscard]] auto open(std::string_view api_path, bool directory,
                           const open_file_data &ofd, std::uint64_t &handle,
                           std::shared_ptr<i_open_file> &file,
                           std::shared_ptr<i_closeable_open_file> closeable_file)
       -> api_error;
 
-  void queue_upload(const std::string &api_path, const std::string &source_path,
+  void queue_upload(std::string_view api_path, std::string_view source_path,
                     bool is_unlinked, bool no_lock);
 
-  void remove_resume(const std::string &api_path,
-                     const std::string &source_path, bool no_lock);
+  void remove_resume(std::string_view api_path, std::string_view source_path,
+                     bool no_lock);
 
-  void remove_upload(const std::string &api_path, bool no_lock);
+  void remove_upload(std::string_view api_path, bool no_lock);
 
-  void swap_renamed_items(std::string from_api_path, std::string to_api_path,
-                          bool directory);
+  void swap_renamed_items(std::string_view from_api_path,
+                          std::string_view to_api_path, bool directory);
 
   void upload_completed(const file_upload_completed &evt);
 
@@ -110,43 +110,43 @@ private:
 public:
   [[nodiscard]] auto get_next_handle() -> std::uint64_t;
 
-  auto handle_file_rename(const std::string &from_api_path,
-                          const std::string &to_api_path) -> api_error;
+  auto handle_file_rename(std::string_view from_api_path,
+                          std::string_view to_api_path) -> api_error;
 
   void queue_upload(const i_open_file &file) override;
 
-  void remove_resume(const std::string &api_path,
-                     const std::string &source_path) override;
+  void remove_resume(std::string_view api_path,
+                     std::string_view source_path) override;
 
-  static auto remove_source_and_shrink_cache(const std::string &api_path,
-                                             const std::string &source_path,
+  static auto remove_source_and_shrink_cache(std::string_view api_path,
+                                             std::string_view source_path,
                                              std::uint64_t file_size,
                                              bool allocated) -> bool;
 
-  void remove_upload(const std::string &api_path) override;
+  void remove_upload(std::string_view api_path) override;
 
   void store_resume(const i_open_file &file) override;
 
 public:
   void close(std::uint64_t handle);
 
-  [[nodiscard]] auto create(const std::string &api_path, api_meta_map &meta,
+  [[nodiscard]] auto create(std::string_view api_path, api_meta_map &meta,
                             open_file_data ofd, std::uint64_t &handle,
                             std::shared_ptr<i_open_file> &file) -> api_error;
 
-  [[nodiscard]] auto download_pinned_file(const std::string &api_path)
+  [[nodiscard]] auto download_pinned_file(std::string_view api_path)
       -> bool override;
 
-  [[nodiscard]] auto evict_file(const std::string &api_path) -> bool override;
+  [[nodiscard]] auto evict_file(std::string_view api_path) -> bool override;
 
-  [[nodiscard]] auto get_directory_item(const std::string &api_path,
+  [[nodiscard]] auto get_directory_item(std::string_view api_path,
                                         directory_item &item) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_items(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_items(std::string_view api_path) const
       -> directory_item_list override;
 
-  [[nodiscard]] auto get_open_file(const std::string &api_path,
+  [[nodiscard]] auto get_open_file(std::string_view api_path,
                                    std::shared_ptr<i_open_file> &file) -> bool;
 
   [[nodiscard]] auto get_open_file(std::uint64_t handle, bool write_supported,
@@ -164,7 +164,7 @@ public:
 
   [[nodiscard]] auto has_no_open_file_handles() const -> bool override;
 
-  [[nodiscard]] auto is_processing(const std::string &api_path) const
+  [[nodiscard]] auto is_processing(std::string_view api_path) const
       -> bool override;
 
 #if defined(PROJECT_TESTING)
@@ -172,20 +172,20 @@ public:
                           const open_file_data &ofd, std::uint64_t &handle,
                           std::shared_ptr<i_open_file> &file) -> api_error;
 #endif // defined(PROJECT_TESTING)
-  [[nodiscard]] auto open(const std::string &api_path, bool directory,
+  [[nodiscard]] auto open(std::string_view api_path, bool directory,
                           const open_file_data &ofd, std::uint64_t &handle,
                           std::shared_ptr<i_open_file> &file) -> api_error;
 
-  [[nodiscard]] auto remove_directory(const std::string &api_path) -> api_error;
+  [[nodiscard]] auto remove_directory(std::string_view api_path) -> api_error;
 
-  [[nodiscard]] auto remove_file(const std::string &api_path) -> api_error;
+  [[nodiscard]] auto remove_file(std::string_view api_path) -> api_error;
 
-  [[nodiscard]] auto rename_directory(const std::string &from_api_path,
-                                      const std::string &to_api_path)
+  [[nodiscard]] auto rename_directory(std::string_view from_api_path,
+                                      std::string_view to_api_path)
       -> api_error;
 
-  [[nodiscard]] auto rename_file(const std::string &from_api_path,
-                                 const std::string &to_api_path, bool overwrite)
+  [[nodiscard]] auto rename_file(std::string_view from_api_path,
+                                 std::string_view to_api_path, bool overwrite)
       -> api_error;
 
   void start();
diff --git a/repertory/librepertory/include/file_manager/i_file_manager.hpp b/repertory/librepertory/include/file_manager/i_file_manager.hpp
index 1484a568..b3f5b9d2 100644
--- a/repertory/librepertory/include/file_manager/i_file_manager.hpp
+++ b/repertory/librepertory/include/file_manager/i_file_manager.hpp
@@ -31,18 +31,17 @@ class i_file_manager {
   INTERFACE_SETUP(i_file_manager);
 
 public:
-  [[nodiscard]] virtual auto download_pinned_file(const std::string &api_path)
+  [[nodiscard]] virtual auto download_pinned_file(std::string_view api_path)
       -> bool = 0;
 
-  [[nodiscard]] virtual auto evict_file(const std::string &api_path)
-      -> bool = 0;
+  [[nodiscard]] virtual auto evict_file(std::string_view api_path) -> bool = 0;
 
-  [[nodiscard]] virtual auto get_directory_item(const std::string &api_path,
+  [[nodiscard]] virtual auto get_directory_item(std::string_view api_path,
                                                 directory_item &item) const
       -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_directory_items(const std::string &api_path) const
+  get_directory_items(std::string_view api_path) const
       -> directory_item_list = 0;
 
   [[nodiscard]] virtual auto get_open_files() const
@@ -50,7 +49,7 @@ public:
 
   [[nodiscard]] virtual auto has_no_open_file_handles() const -> bool = 0;
 
-  [[nodiscard]] virtual auto is_processing(const std::string &api_path) const
+  [[nodiscard]] virtual auto is_processing(std::string_view api_path) const
       -> bool = 0;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/file_manager/i_open_file.hpp b/repertory/librepertory/include/file_manager/i_open_file.hpp
index 6d6bdef7..cfdcd4d1 100644
--- a/repertory/librepertory/include/file_manager/i_open_file.hpp
+++ b/repertory/librepertory/include/file_manager/i_open_file.hpp
@@ -90,7 +90,7 @@ public:
   [[nodiscard]] virtual auto resize(std::uint64_t new_file_size)
       -> api_error = 0;
 
-  virtual void set_api_path(const std::string &api_path) = 0;
+  virtual void set_api_path(std::string_view api_path) = 0;
 
   [[nodiscard]] virtual auto write(std::uint64_t write_offset,
                                    const data_buffer &data,
diff --git a/repertory/librepertory/include/file_manager/i_upload_manager.hpp b/repertory/librepertory/include/file_manager/i_upload_manager.hpp
index e66d77d6..309ea612 100644
--- a/repertory/librepertory/include/file_manager/i_upload_manager.hpp
+++ b/repertory/librepertory/include/file_manager/i_upload_manager.hpp
@@ -31,10 +31,10 @@ class i_upload_manager {
 public:
   virtual void queue_upload(const i_open_file &file) = 0;
 
-  virtual void remove_resume(const std::string &api_path,
-                             const std::string &source_path) = 0;
+  virtual void remove_resume(std::string_view api_path,
+                             std::string_view source_path) = 0;
 
-  virtual void remove_upload(const std::string &api_path) = 0;
+  virtual void remove_upload(std::string_view api_path) = 0;
 
   virtual void store_resume(const i_open_file &file) = 0;
 };
diff --git a/repertory/librepertory/include/file_manager/open_file_base.hpp b/repertory/librepertory/include/file_manager/open_file_base.hpp
index 5cb866d9..f306b04b 100644
--- a/repertory/librepertory/include/file_manager/open_file_base.hpp
+++ b/repertory/librepertory/include/file_manager/open_file_base.hpp
@@ -220,7 +220,7 @@ public:
 
   void remove_all() override;
 
-  void set_api_path(const std::string &api_path) override;
+  void set_api_path(std::string_view api_path) override;
 
   void set_unlinked(bool value) override;
 
diff --git a/repertory/librepertory/include/file_manager/ring_buffer_base.hpp b/repertory/librepertory/include/file_manager/ring_buffer_base.hpp
index 7da05a35..1026ee71 100644
--- a/repertory/librepertory/include/file_manager/ring_buffer_base.hpp
+++ b/repertory/librepertory/include/file_manager/ring_buffer_base.hpp
@@ -139,7 +139,7 @@ public:
 
   void set(std::size_t first_chunk, std::size_t current_chunk);
 
-  void set_api_path(const std::string &api_path) override;
+  void set_api_path(std::string_view api_path) override;
 
   [[nodiscard]] auto write(std::uint64_t /* write_offset */,
                            const data_buffer & /* data */,
diff --git a/repertory/librepertory/include/platform/unix_platform.hpp b/repertory/librepertory/include/platform/unix_platform.hpp
index 96f239eb..7e6ec5f6 100644
--- a/repertory/librepertory/include/platform/unix_platform.hpp
+++ b/repertory/librepertory/include/platform/unix_platform.hpp
@@ -30,7 +30,7 @@ class i_provider;
 
 class lock_data final {
 public:
-  lock_data(std::string data_directory, provider_type prov,
+  lock_data(std::string_view data_directory, provider_type prov,
             std::string_view unique_id);
 
   lock_data(const lock_data &) = delete;
@@ -73,13 +73,14 @@ public:
       -> bool;
 };
 
-[[nodiscard]] auto create_meta_attributes(
-    std::uint64_t accessed_date, std::uint32_t attributes,
-    std::uint64_t changed_date, std::uint64_t creation_date, bool directory,
-    std::uint32_t gid, const std::string &key, std::uint32_t mode,
-    std::uint64_t modified_date, std::uint32_t osx_flags, std::uint64_t size,
-    const std::string &source_path, std::uint32_t uid,
-    std::uint64_t written_date) -> api_meta_map;
+[[nodiscard]] auto
+create_meta_attributes(std::uint64_t accessed_date, std::uint32_t attributes,
+                       std::uint64_t changed_date, std::uint64_t creation_date,
+                       bool directory, std::uint32_t gid, std::string_view key,
+                       std::uint32_t mode, std::uint64_t modified_date,
+                       std::uint32_t osx_flags, std::uint64_t size,
+                       std::string_view source_path, std::uint32_t uid,
+                       std::uint64_t written_date) -> api_meta_map;
 
 [[nodiscard]] auto provider_meta_creator(bool directory, const api_file &file)
     -> api_meta_map;
diff --git a/repertory/librepertory/include/platform/win32_platform.hpp b/repertory/librepertory/include/platform/win32_platform.hpp
index c629e0b0..7c488bc4 100644
--- a/repertory/librepertory/include/platform/win32_platform.hpp
+++ b/repertory/librepertory/include/platform/win32_platform.hpp
@@ -60,13 +60,14 @@ public:
                                      std::int64_t pid) -> bool;
 };
 
-[[nodiscard]] auto create_meta_attributes(
-    std::uint64_t accessed_date, std::uint32_t attributes,
-    std::uint64_t changed_date, std::uint64_t creation_date, bool directory,
-    std::uint32_t gid, const std::string &key, std::uint32_t mode,
-    std::uint64_t modified_date, std::uint32_t osx_flags, std::uint64_t size,
-    const std::string &source_path, std::uint32_t uid,
-    std::uint64_t written_date) -> api_meta_map;
+[[nodiscard]] auto
+create_meta_attributes(std::uint64_t accessed_date, std::uint32_t attributes,
+                       std::uint64_t changed_date, std::uint64_t creation_date,
+                       bool directory, std::uint32_t gid, std::string_view key,
+                       std::uint32_t mode, std::uint64_t modified_date,
+                       std::uint32_t osx_flags, std::uint64_t size,
+                       std::string_view source_path, std::uint32_t uid,
+                       std::uint64_t written_date) -> api_meta_map;
 
 [[nodiscard]] auto provider_meta_creator(bool directory, const api_file &file)
     -> api_meta_map;
diff --git a/repertory/librepertory/include/providers/base_provider.hpp b/repertory/librepertory/include/providers/base_provider.hpp
index 93726a98..6cd55e97 100644
--- a/repertory/librepertory/include/providers/base_provider.hpp
+++ b/repertory/librepertory/include/providers/base_provider.hpp
@@ -68,22 +68,21 @@ private:
   void remove_unmatched_source_files(stop_type &stop_requested);
 
 protected:
-  [[nodiscard]] static auto create_api_file(std::string path, std::string key,
-                                            std::uint64_t size,
-                                            std::uint64_t file_time)
-      -> api_file;
+  [[nodiscard]] static auto
+  create_api_file(std::string_view path, std::string_view key,
+                  std::uint64_t size, std::uint64_t file_time) -> api_file;
 
-  [[nodiscard]] static auto create_api_file(std::string path,
+  [[nodiscard]] static auto create_api_file(std::string_view path,
                                             std::uint64_t size,
                                             api_meta_map &meta) -> api_file;
 
-  [[nodiscard]] virtual auto create_directory_impl(const std::string &api_path,
+  [[nodiscard]] virtual auto create_directory_impl(std::string_view api_path,
                                                    api_meta_map &meta)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto
-  create_file_extra(const std::string & /* api_path */,
-                    api_meta_map & /* meta */) -> api_error {
+  [[nodiscard]] virtual auto create_file_extra(std::string_view /* api_path */,
+                                               api_meta_map & /* meta */)
+      -> api_error {
     return api_error::success;
   }
 
@@ -111,7 +110,7 @@ protected:
   [[nodiscard]] auto get_db() const -> const i_meta_db & { return *meta_db_; }
 
   [[nodiscard]] virtual auto
-  get_directory_items_impl(const std::string &api_path,
+  get_directory_items_impl(std::string_view api_path,
                            directory_item_list &list) const -> api_error = 0;
 
   [[nodiscard]] auto get_file_mgr() -> i_file_manager * { return fm_; }
@@ -120,61 +119,61 @@ protected:
     return fm_;
   }
 
-  [[nodiscard]] virtual auto remove_directory_impl(const std::string &api_path)
+  [[nodiscard]] virtual auto remove_directory_impl(std::string_view api_path)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto remove_file_impl(const std::string &api_path)
+  [[nodiscard]] virtual auto remove_file_impl(std::string_view api_path)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto upload_file_impl(const std::string &api_path,
-                                              const std::string &source_path,
+  [[nodiscard]] virtual auto upload_file_impl(std::string_view api_path,
+                                              std::string_view source_path,
                                               stop_type &stop_requested)
       -> api_error = 0;
 
 public:
   [[nodiscard]] auto
-  create_directory_clone_source_meta(const std::string &source_api_path,
-                                     const std::string &api_path)
+  create_directory_clone_source_meta(std::string_view source_api_path,
+                                     std::string_view api_path)
       -> api_error override;
 
-  [[nodiscard]] auto create_directory(const std::string &api_path,
+  [[nodiscard]] auto create_directory(std::string_view api_path,
                                       api_meta_map &meta) -> api_error override;
 
-  [[nodiscard]] auto create_file(const std::string &api_path,
-                                 api_meta_map &meta) -> api_error override;
+  [[nodiscard]] auto create_file(std::string_view api_path, api_meta_map &meta)
+      -> api_error override;
 
-  [[nodiscard]] auto get_api_path_from_source(const std::string &source_path,
+  [[nodiscard]] auto get_api_path_from_source(std::string_view source_path,
                                               std::string &api_path) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_item(const std::string &api_path,
+  [[nodiscard]] auto get_directory_item(std::string_view api_path,
                                         directory_item &item) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_items(const std::string &api_path,
+  [[nodiscard]] auto get_directory_items(std::string_view api_path,
                                          directory_item_list &list) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file_size(const std::string &api_path,
+  [[nodiscard]] auto get_file_size(std::string_view api_path,
                                    std::uint64_t &file_size) const
       -> api_error override;
 
-  [[nodiscard]] auto get_filesystem_item(const std::string &api_path,
+  [[nodiscard]] auto get_filesystem_item(std::string_view api_path,
                                          bool directory,
                                          filesystem_item &fsi) const
       -> api_error override;
 
   [[nodiscard]] auto
-  get_filesystem_item_from_source_path(const std::string &source_path,
+  get_filesystem_item_from_source_path(std::string_view source_path,
                                        filesystem_item &fsi) const
       -> api_error override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
                                    api_meta_map &meta) const
       -> api_error override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
-                                   const std::string &key,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
+                                   std::string_view key,
                                    std::string &value) const
       -> api_error override;
 
@@ -187,31 +186,30 @@ public:
 
   [[nodiscard]] auto is_read_only() const -> bool override { return false; }
 
-  [[nodiscard]] auto remove_directory(const std::string &api_path)
+  [[nodiscard]] auto remove_directory(std::string_view api_path)
       -> api_error override;
 
-  [[nodiscard]] auto remove_file(const std::string &api_path)
+  [[nodiscard]] auto remove_file(std::string_view api_path)
       -> api_error override;
 
-  [[nodiscard]] auto remove_item_meta(const std::string &api_path,
-                                      const std::string &key)
+  [[nodiscard]] auto remove_item_meta(std::string_view api_path,
+                                      std::string_view key)
       -> api_error override;
 
-  [[nodiscard]] auto set_item_meta(const std::string &api_path,
-                                   const std::string &key,
-                                   const std::string &value)
+  [[nodiscard]] auto set_item_meta(std::string_view api_path,
+                                   std::string_view key, std::string_view value)
       -> api_error override;
 
-  [[nodiscard]] auto set_item_meta(const std::string &api_path,
-                                   api_meta_map meta) -> api_error override;
+  [[nodiscard]] auto set_item_meta(std::string_view api_path, api_meta_map meta)
+      -> api_error override;
 
   [[nodiscard]] auto start(api_item_added_callback api_item_added,
                            i_file_manager *mgr) -> bool override;
 
   void stop() override;
 
-  [[nodiscard]] auto upload_file(const std::string &api_path,
-                                 const std::string &source_path,
+  [[nodiscard]] auto upload_file(std::string_view api_path,
+                                 std::string_view source_path,
                                  stop_type &stop_requested)
       -> api_error override;
 };
diff --git a/repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp b/repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp
index 30b9bf84..2a861086 100644
--- a/repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp
+++ b/repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp
@@ -63,18 +63,18 @@ private:
   std::recursive_mutex reader_lookup_mtx_;
 
 private:
-  [[nodiscard]] static auto create_api_file(const std::string &api_path,
+  [[nodiscard]] static auto create_api_file(std::string_view api_path,
                                             bool directory,
-                                            const std::string &source_path)
+                                            std::string_view source_path)
       -> api_file;
 
   static void create_item_meta(api_meta_map &meta, bool directory,
                                const api_file &file);
 
   [[nodiscard]] auto do_fs_operation(
-      const std::string &api_path, bool directory,
+      std::string_view api_path, bool directory,
       std::function<api_error(const encrypt_config &cfg,
-                              const std::string &source_path)> callback) const
+                              std::string_view source_path)> callback) const
       -> api_error;
 
   [[nodiscard]] auto get_encrypt_config() const -> const encrypt_config & {
@@ -97,68 +97,67 @@ public:
     return true;
   }
 
-  [[nodiscard]] auto create_directory(const std::string &api_path,
+  [[nodiscard]] auto create_directory(std::string_view api_path,
                                       api_meta_map &meta) -> api_error override;
 
   [[nodiscard]] auto
-  create_directory_clone_source_meta(const std::string & /*source_api_path*/,
-                                     const std::string & /*api_path*/)
+  create_directory_clone_source_meta(std::string_view /*source_api_path*/,
+                                     std::string_view /*api_path*/)
       -> api_error override {
     return api_error::not_implemented;
   }
 
-  [[nodiscard]] auto create_file(const std::string & /*api_path*/,
+  [[nodiscard]] auto create_file(std::string_view /*api_path*/,
                                  api_meta_map & /*meta*/)
       -> api_error override {
     return api_error::not_implemented;
   }
 
-  [[nodiscard]] auto
-  get_api_path_from_source(const std::string & /*source_path*/,
-                           std::string & /*api_path*/) const
+  [[nodiscard]] auto get_api_path_from_source(std::string_view /*source_path*/,
+                                              std::string & /*api_path*/) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_item_count(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_item_count(std::string_view api_path) const
       -> std::uint64_t override;
 
-  [[nodiscard]] auto get_directory_item(const std::string &api_path,
+  [[nodiscard]] auto get_directory_item(std::string_view api_path,
                                         directory_item &item) const
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_items(const std::string &api_path,
+  [[nodiscard]] auto get_directory_items(std::string_view api_path,
                                          directory_item_list &list) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file(const std::string &api_path, api_file &file) const
+  [[nodiscard]] auto get_file(std::string_view api_path, api_file &file) const
       -> api_error override;
 
   [[nodiscard]] auto get_file_list(api_file_list &list,
                                    std::string &marker) const
       -> api_error override;
 
-  [[nodiscard]] auto get_file_size(const std::string &api_path,
+  [[nodiscard]] auto get_file_size(std::string_view api_path,
                                    std::uint64_t &file_size) const
       -> api_error override;
 
-  [[nodiscard]] auto get_filesystem_item(const std::string &api_path,
+  [[nodiscard]] auto get_filesystem_item(std::string_view api_path,
                                          bool directory,
                                          filesystem_item &fsi) const
       -> api_error override;
 
   [[nodiscard]] auto
-  get_filesystem_item_from_source_path(const std::string &source_path,
+  get_filesystem_item_from_source_path(std::string_view source_path,
                                        filesystem_item &fsi) const
       -> api_error override;
 
   [[nodiscard]] auto get_pinned_files() const
       -> std::vector<std::string> override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
                                    api_meta_map &meta) const
       -> api_error override;
 
-  [[nodiscard]] auto get_item_meta(const std::string &api_path,
-                                   const std::string &key,
+  [[nodiscard]] auto get_item_meta(std::string_view api_path,
+                                   std::string_view key,
                                    std::string &value) const
       -> api_error override;
 
@@ -172,10 +171,10 @@ public:
 
   [[nodiscard]] auto get_used_drive_space() const -> std::uint64_t override;
 
-  [[nodiscard]] auto is_directory(const std::string &api_path,
-                                  bool &exists) const -> api_error override;
+  [[nodiscard]] auto is_directory(std::string_view api_path, bool &exists) const
+      -> api_error override;
 
-  [[nodiscard]] auto is_file(const std::string &api_path, bool &exists) const
+  [[nodiscard]] auto is_file(std::string_view api_path, bool &exists) const
       -> api_error override;
 
   [[nodiscard]] auto is_online() const -> bool override;
@@ -186,40 +185,40 @@ public:
     return false;
   }
 
-  [[nodiscard]] auto read_file_bytes(const std::string &api_path,
+  [[nodiscard]] auto read_file_bytes(std::string_view api_path,
                                      std::size_t size, std::uint64_t offset,
                                      data_buffer &data,
                                      stop_type &stop_requested)
       -> api_error override;
 
-  [[nodiscard]] auto remove_directory(const std::string & /*api_path*/)
+  [[nodiscard]] auto remove_directory(std::string_view /*api_path*/)
       -> api_error override {
     return api_error::not_implemented;
   }
 
-  [[nodiscard]] auto remove_file(const std::string & /*api_path*/)
+  [[nodiscard]] auto remove_file(std::string_view /*api_path*/)
       -> api_error override {
     return api_error::not_implemented;
   }
 
-  [[nodiscard]] auto remove_item_meta(const std::string &api_path,
-                                      const std::string &key)
+  [[nodiscard]] auto remove_item_meta(std::string_view api_path,
+                                      std::string_view key)
       -> api_error override;
 
-  [[nodiscard]] auto rename_file(const std::string & /*from_api_path*/,
-                                 const std::string & /*to_api_path*/)
+  [[nodiscard]] auto rename_file(std::string_view /*from_api_path*/,
+                                 std::string_view /*to_api_path*/)
       -> api_error override {
     return api_error::not_implemented;
   }
 
-  [[nodiscard]] auto set_item_meta(const std::string & /*api_path*/,
-                                   const std::string & /*key*/,
-                                   const std::string & /*value*/)
+  [[nodiscard]] auto set_item_meta(std::string_view /*api_path*/,
+                                   std::string_view /*key*/,
+                                   std::string_view /*value*/)
       -> api_error override {
     return api_error::success;
   }
 
-  [[nodiscard]] auto set_item_meta(const std::string & /*api_path*/,
+  [[nodiscard]] auto set_item_meta(std::string_view /*api_path*/,
                                    api_meta_map /*meta*/)
       -> api_error override {
     return api_error::success;
@@ -230,8 +229,8 @@ public:
 
   void stop() override;
 
-  [[nodiscard]] auto upload_file(const std::string & /*api_path*/,
-                                 const std::string & /*source_path*/,
+  [[nodiscard]] auto upload_file(std::string_view /*api_path*/,
+                                 std::string_view /*source_path*/,
                                  stop_type & /*stop_requested*/)
       -> api_error override {
     return api_error::not_implemented;
diff --git a/repertory/librepertory/include/providers/i_provider.hpp b/repertory/librepertory/include/providers/i_provider.hpp
index 3c9587cc..09cb0463 100644
--- a/repertory/librepertory/include/providers/i_provider.hpp
+++ b/repertory/librepertory/include/providers/i_provider.hpp
@@ -35,61 +35,61 @@ public:
                                            std::string &returned_version) const
       -> bool = 0;
 
-  [[nodiscard]] virtual auto create_directory(const std::string &api_path,
+  [[nodiscard]] virtual auto create_directory(std::string_view api_path,
                                               api_meta_map &meta)
       -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  create_directory_clone_source_meta(const std::string &source_api_path,
-                                     const std::string &api_path)
+  create_directory_clone_source_meta(std::string_view source_api_path,
+                                     std::string_view api_path)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto create_file(const std::string &api_path,
+  [[nodiscard]] virtual auto create_file(std::string_view api_path,
                                          api_meta_map &meta) -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_api_path_from_source(const std::string &source_path,
+  get_api_path_from_source(std::string_view source_path,
                            std::string &api_path) const -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_directory_item_count(const std::string &api_path) const
+  get_directory_item_count(std::string_view api_path) const
       -> std::uint64_t = 0;
 
-  [[nodiscard]] virtual auto get_directory_item(const std::string &api_path,
+  [[nodiscard]] virtual auto get_directory_item(std::string_view api_path,
                                                 directory_item &list) const
       -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_directory_items(const std::string &api_path,
+  get_directory_items(std::string_view api_path,
                       directory_item_list &list) const -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_file(const std::string &api_path,
+  [[nodiscard]] virtual auto get_file(std::string_view api_path,
                                       api_file &file) const -> api_error = 0;
 
   [[nodiscard]] virtual auto get_file_list(api_file_list &list,
                                            std::string &marker) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_file_size(const std::string &api_path,
+  [[nodiscard]] virtual auto get_file_size(std::string_view api_path,
                                            std::uint64_t &file_size) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_filesystem_item(const std::string &api_path,
+  [[nodiscard]] virtual auto get_filesystem_item(std::string_view api_path,
                                                  bool directory,
                                                  filesystem_item &fsi) const
       -> api_error = 0;
 
   [[nodiscard]] virtual auto
-  get_filesystem_item_from_source_path(const std::string &source_path,
+  get_filesystem_item_from_source_path(std::string_view source_path,
                                        filesystem_item &fsi) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_item_meta(const std::string &api_path,
+  [[nodiscard]] virtual auto get_item_meta(std::string_view api_path,
                                            api_meta_map &meta) const
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto get_item_meta(const std::string &api_path,
-                                           const std::string &key,
+  [[nodiscard]] virtual auto get_item_meta(std::string_view api_path,
+                                           std::string_view key,
                                            std::string &value) const
       -> api_error = 0;
 
@@ -104,10 +104,10 @@ public:
 
   [[nodiscard]] virtual auto get_used_drive_space() const -> std::uint64_t = 0;
 
-  [[nodiscard]] virtual auto is_directory(const std::string &api_path,
+  [[nodiscard]] virtual auto is_directory(std::string_view api_path,
                                           bool &exists) const -> api_error = 0;
 
-  [[nodiscard]] virtual auto is_file(const std::string &api_path,
+  [[nodiscard]] virtual auto is_file(std::string_view api_path,
                                      bool &exists) const -> api_error = 0;
 
   [[nodiscard]] virtual auto is_online() const -> bool = 0;
@@ -117,30 +117,30 @@ public:
   [[nodiscard]] virtual auto is_rename_supported() const -> bool = 0;
 
   [[nodiscard]] virtual auto
-  read_file_bytes(const std::string &api_path, std::size_t size,
+  read_file_bytes(std::string_view api_path, std::size_t size,
                   std::uint64_t offset, data_buffer &data,
                   stop_type &stop_requested) -> api_error = 0;
 
-  [[nodiscard]] virtual auto remove_directory(const std::string &api_path)
+  [[nodiscard]] virtual auto remove_directory(std::string_view api_path)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto remove_file(const std::string &api_path)
+  [[nodiscard]] virtual auto remove_file(std::string_view api_path)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto remove_item_meta(const std::string &api_path,
-                                              const std::string &key)
+  [[nodiscard]] virtual auto remove_item_meta(std::string_view api_path,
+                                              std::string_view key)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto rename_file(const std::string &from_api_path,
-                                         const std::string &to_api_path)
+  [[nodiscard]] virtual auto rename_file(std::string_view from_api_path,
+                                         std::string_view to_api_path)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto set_item_meta(const std::string &api_path,
-                                           const std::string &key,
-                                           const std::string &value)
+  [[nodiscard]] virtual auto set_item_meta(std::string_view api_path,
+                                           std::string_view key,
+                                           std::string_view value)
       -> api_error = 0;
 
-  [[nodiscard]] virtual auto set_item_meta(const std::string &api_path,
+  [[nodiscard]] virtual auto set_item_meta(std::string_view api_path,
                                            api_meta_map meta) -> api_error = 0;
 
   [[nodiscard]] virtual auto start(api_item_added_callback api_item_added,
@@ -148,8 +148,8 @@ public:
 
   virtual void stop() = 0;
 
-  [[nodiscard]] virtual auto upload_file(const std::string &api_path,
-                                         const std::string &source_path,
+  [[nodiscard]] virtual auto upload_file(std::string_view api_path,
+                                         std::string_view source_path,
                                          stop_type &stop_requested)
       -> api_error = 0;
 };
diff --git a/repertory/librepertory/include/providers/s3/s3_provider.hpp b/repertory/librepertory/include/providers/s3/s3_provider.hpp
index eeb78d52..7b49be16 100644
--- a/repertory/librepertory/include/providers/s3/s3_provider.hpp
+++ b/repertory/librepertory/include/providers/s3/s3_provider.hpp
@@ -36,8 +36,8 @@ struct head_object_result;
 class s3_provider final : public base_provider {
 private:
   using interate_callback_t = std::function<api_error(
-      const std::string &prefix, const pugi::xml_node &node,
-      const std::string &api_prefix)>;
+      std::string_view prefix, const pugi::xml_node &node,
+      std::string_view api_prefix)>;
 
 public:
   static const constexpr auto type{provider_type::s3};
@@ -63,18 +63,18 @@ private:
 
 private:
   [[nodiscard]] auto add_if_not_found(api_file &file,
-                                      const std::string &object_name) const
+                                      std::string_view object_name) const
       -> api_error;
 
-  [[nodiscard]] auto
-  create_directory_object(const std::string &api_path,
-                          const std::string &object_name) const -> api_error;
-
-  [[nodiscard]] auto create_directory_paths(const std::string &api_path,
-                                            const std::string &key) const
+  [[nodiscard]] auto create_directory_object(std::string_view api_path,
+                                             std::string_view object_name) const
       -> api_error;
 
-  [[nodiscard]] auto create_file_extra(const std::string &api_path,
+  [[nodiscard]] auto create_directory_paths(std::string_view api_path,
+                                            std::string_view key) const
+      -> api_error;
+
+  [[nodiscard]] auto create_file_extra(std::string_view api_path,
                                        api_meta_map &meta)
       -> api_error override;
 
@@ -82,25 +82,25 @@ private:
       -> api_error;
 
   [[nodiscard]] auto
-  get_kdf_config_from_meta(const std::string &api_path,
+  get_kdf_config_from_meta(std::string_view api_path,
                            utils::encryption::kdf_config &cfg) const
       -> api_error;
 
   [[nodiscard]] auto get_last_modified(bool directory,
-                                       const std::string &api_path,
+                                       std::string_view api_path,
                                        std::uint64_t &last_modified) const
       -> api_error;
 
   [[nodiscard]] auto
-  get_object_info(bool directory, const std::string &api_path,
-                  bool &is_encrypted, std::string &object_name,
-                  head_object_result &result) const -> api_error;
+  get_object_info(bool directory, std::string_view api_path, bool &is_encrypted,
+                  std::string &object_name, head_object_result &result) const
+      -> api_error;
 
   [[nodiscard]] auto
   get_object_list(std::string &response_data, long &response_code,
-                  std::optional<std::string> delimiter = std::nullopt,
-                  std::optional<std::string> prefix = std::nullopt,
-                  std::optional<std::string> token = std::nullopt) const
+                  std::optional<std::string_view> delimiter = std::nullopt,
+                  std::optional<std::string_view> prefix = std::nullopt,
+                  std::optional<std::string_view> token = std::nullopt) const
       -> bool;
 
   [[nodiscard]] auto get_s3_config() const -> const s3_config & {
@@ -111,28 +111,28 @@ private:
       -> bool;
 
   [[nodiscard]] auto
-  search_keys_for_master_kdf(const std::string &encryption_token) -> bool;
+  search_keys_for_master_kdf(std::string_view encryption_token) -> bool;
 
-  [[nodiscard]] auto set_meta_key(const std::string &api_path,
-                                  api_meta_map &meta) -> api_error;
+  [[nodiscard]] auto set_meta_key(std::string_view api_path, api_meta_map &meta)
+      -> api_error;
 
 protected:
-  [[nodiscard]] auto create_directory_impl(const std::string &api_path,
+  [[nodiscard]] auto create_directory_impl(std::string_view api_path,
                                            api_meta_map &meta)
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_items_impl(const std::string &api_path,
+  [[nodiscard]] auto get_directory_items_impl(std::string_view api_path,
                                               directory_item_list &list) const
       -> api_error override;
 
-  [[nodiscard]] auto remove_directory_impl(const std::string &api_path)
+  [[nodiscard]] auto remove_directory_impl(std::string_view api_path)
       -> api_error override;
 
-  [[nodiscard]] auto remove_file_impl(const std::string &api_path)
+  [[nodiscard]] auto remove_file_impl(std::string_view api_path)
       -> api_error override;
 
-  [[nodiscard]] auto upload_file_impl(const std::string &api_path,
-                                      const std::string &source_path,
+  [[nodiscard]] auto upload_file_impl(std::string_view api_path,
+                                      std::string_view source_path,
                                       stop_type &stop_requested)
       -> api_error override;
 
@@ -147,10 +147,10 @@ public:
   [[nodiscard]] static auto convert_api_date(std::string_view date)
       -> std::uint64_t;
 
-  [[nodiscard]] auto get_directory_item_count(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_item_count(std::string_view api_path) const
       -> std::uint64_t override;
 
-  [[nodiscard]] auto get_file(const std::string &api_path, api_file &file) const
+  [[nodiscard]] auto get_file(std::string_view api_path, api_file &file) const
       -> api_error override;
 
   [[nodiscard]] auto get_file_list(api_file_list &list,
@@ -163,10 +163,10 @@ public:
     return type;
   }
 
-  [[nodiscard]] auto is_directory(const std::string &api_path,
-                                  bool &exists) const -> api_error override;
+  [[nodiscard]] auto is_directory(std::string_view api_path, bool &exists) const
+      -> api_error override;
 
-  [[nodiscard]] auto is_file(const std::string &api_path, bool &exists) const
+  [[nodiscard]] auto is_file(std::string_view api_path, bool &exists) const
       -> api_error override;
 
   [[nodiscard]] auto is_online() const -> bool override;
@@ -175,19 +175,19 @@ public:
     return false;
   };
 
-  [[nodiscard]] auto iterate_prefix(const std::string &prefix,
+  [[nodiscard]] auto iterate_prefix(std::string_view prefix,
                                     interate_callback_t prefix_action,
                                     interate_callback_t key_action) const
       -> api_error;
 
-  [[nodiscard]] auto read_file_bytes(const std::string &api_path,
+  [[nodiscard]] auto read_file_bytes(std::string_view api_path,
                                      std::size_t size, std::uint64_t offset,
                                      data_buffer &data,
                                      stop_type &stop_requested)
       -> api_error override;
 
-  [[nodiscard]] auto rename_file(const std::string &from_api_path,
-                                 const std::string &to_api_path)
+  [[nodiscard]] auto rename_file(std::string_view from_api_path,
+                                 std::string_view to_api_path)
       -> api_error override;
 
   auto start(api_item_added_callback api_item_added, i_file_manager *mgr)
diff --git a/repertory/librepertory/include/providers/sia/sia_provider.hpp b/repertory/librepertory/include/providers/sia/sia_provider.hpp
index fc564f45..bdc0e2de 100644
--- a/repertory/librepertory/include/providers/sia/sia_provider.hpp
+++ b/repertory/librepertory/include/providers/sia/sia_provider.hpp
@@ -49,17 +49,17 @@ private:
   sia_config sia_config_;
 
 private:
-  [[nodiscard]] auto create_directory_key(const std::string &api_path) const
+  [[nodiscard]] auto create_directory_key(std::string_view api_path) const
       -> repertory::api_error;
 
-  [[nodiscard]] auto ensure_directory_exists(const std::string &api_path) const
+  [[nodiscard]] auto ensure_directory_exists(std::string_view api_path) const
       -> api_error;
 
-  [[nodiscard]] auto get_object_info(const std::string &api_path,
+  [[nodiscard]] auto get_object_info(std::string_view api_path,
                                      json &object_info) const -> api_error;
 
   [[nodiscard]] auto
-  get_object_list(const std::string &api_path, nlohmann::json &object_list,
+  get_object_list(std::string_view api_path, nlohmann::json &object_list,
                   std::optional<std::string> marker = std::nullopt) const
       -> bool;
 
@@ -68,26 +68,26 @@ private:
   }
 
   void iterate_objects(
-      const std::string &api_path, const json &object_list,
-      std::function<void(const std::string &, bool, json)> handle_entry) const;
+      std::string_view api_path, const json &object_list,
+      std::function<void(std::string_view, bool, json)> handle_entry) const;
 
 protected:
-  [[nodiscard]] auto create_directory_impl(const std::string &api_path,
+  [[nodiscard]] auto create_directory_impl(std::string_view api_path,
                                            api_meta_map &meta)
       -> api_error override;
 
-  [[nodiscard]] auto get_directory_items_impl(const std::string &api_path,
+  [[nodiscard]] auto get_directory_items_impl(std::string_view api_path,
                                               directory_item_list &list) const
       -> api_error override;
 
-  [[nodiscard]] auto remove_directory_impl(const std::string &api_path)
+  [[nodiscard]] auto remove_directory_impl(std::string_view api_path)
       -> api_error override;
 
-  [[nodiscard]] auto remove_file_impl(const std::string &api_path)
+  [[nodiscard]] auto remove_file_impl(std::string_view api_path)
       -> api_error override;
 
-  [[nodiscard]] auto upload_file_impl(const std::string &api_path,
-                                      const std::string &source_path,
+  [[nodiscard]] auto upload_file_impl(std::string_view api_path,
+                                      std::string_view source_path,
                                       stop_type &stop_requested)
       -> api_error override;
 
@@ -96,10 +96,10 @@ public:
                                    std::string &returned_version) const
       -> bool override;
 
-  [[nodiscard]] auto get_directory_item_count(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_item_count(std::string_view api_path) const
       -> std::uint64_t override;
 
-  [[nodiscard]] auto get_file(const std::string &api_path, api_file &file) const
+  [[nodiscard]] auto get_file(std::string_view api_path, api_file &file) const
       -> api_error override;
 
   [[nodiscard]] auto get_file_list(api_file_list &list,
@@ -112,10 +112,10 @@ public:
 
   [[nodiscard]] auto get_total_drive_space() const -> std::uint64_t override;
 
-  [[nodiscard]] auto is_directory(const std::string &api_path,
-                                  bool &exists) const -> api_error override;
+  [[nodiscard]] auto is_directory(std::string_view api_path, bool &exists) const
+      -> api_error override;
 
-  [[nodiscard]] auto is_file(const std::string &api_path, bool &exists) const
+  [[nodiscard]] auto is_file(std::string_view api_path, bool &exists) const
       -> api_error override;
 
   [[nodiscard]] auto is_online() const -> bool override;
@@ -124,14 +124,14 @@ public:
     return true;
   }
 
-  [[nodiscard]] auto read_file_bytes(const std::string &api_path,
+  [[nodiscard]] auto read_file_bytes(std::string_view api_path,
                                      std::size_t size, std::uint64_t offset,
                                      data_buffer &buffer,
                                      stop_type &stop_requested)
       -> api_error override;
 
-  [[nodiscard]] auto rename_file(const std::string &from_api_path,
-                                 const std::string &to_api_path)
+  [[nodiscard]] auto rename_file(std::string_view from_api_path,
+                                 std::string_view to_api_path)
       -> api_error override;
 
   [[nodiscard]] auto start(api_item_added_callback api_item_added,
diff --git a/repertory/librepertory/include/rpc/client/client.hpp b/repertory/librepertory/include/rpc/client/client.hpp
index bdb1e8f4..baef3fa8 100644
--- a/repertory/librepertory/include/rpc/client/client.hpp
+++ b/repertory/librepertory/include/rpc/client/client.hpp
@@ -38,32 +38,31 @@ public:
 
   [[nodiscard]] auto get_config() const -> rpc_response;
 
-  [[nodiscard]] auto get_config_value_by_name(const std::string &name) const
+  [[nodiscard]] auto get_config_value_by_name(std::string_view name) const
       -> rpc_response;
 
-  [[nodiscard]] auto get_directory_items(const std::string &api_path) const
+  [[nodiscard]] auto get_directory_items(std::string_view api_path) const
       -> rpc_response;
 
-  [[nodiscard]] auto get_item_info(const std::string &api_path) const
+  [[nodiscard]] auto get_item_info(std::string_view api_path) const
       -> rpc_response;
 
   [[nodiscard]] auto get_open_files() const -> rpc_response;
 
   [[nodiscard]] auto get_pinned_files() const -> rpc_response;
 
-  [[nodiscard]] auto pin_file(const std::string &api_path) const
+  [[nodiscard]] auto pin_file(std::string_view api_path) const -> rpc_response;
+
+  [[nodiscard]] auto pinned_status(std::string_view api_path) const
       -> rpc_response;
 
-  [[nodiscard]] auto pinned_status(const std::string &api_path) const
-      -> rpc_response;
-
-  [[nodiscard]] auto set_config_value_by_name(const std::string &name,
-                                              const std::string &value) const
+  [[nodiscard]] auto set_config_value_by_name(std::string_view name,
+                                              std::string_view value) const
       -> rpc_response;
 
   [[nodiscard]] auto unmount() const -> rpc_response;
 
-  [[nodiscard]] auto unpin_file(const std::string &api_path) const
+  [[nodiscard]] auto unpin_file(std::string_view api_path) const
       -> rpc_response;
 };
 } // namespace repertory
diff --git a/repertory/librepertory/include/types/repertory.hpp b/repertory/librepertory/include/types/repertory.hpp
index 0b8f259e..96aa19dd 100644
--- a/repertory/librepertory/include/types/repertory.hpp
+++ b/repertory/librepertory/include/types/repertory.hpp
@@ -147,7 +147,7 @@ enum class database_type {
   sqlite,
 };
 [[nodiscard]] auto
-database_type_from_string(std::string type,
+database_type_from_string(std::string_view type,
                           database_type default_type = database_type::rocksdb)
     -> database_type;
 
@@ -160,7 +160,7 @@ enum class download_type {
   ring_buffer,
 };
 [[nodiscard]] auto
-download_type_from_string(std::string type,
+download_type_from_string(std::string_view type,
                           download_type default_type = download_type::default_)
     -> download_type;
 
@@ -177,7 +177,7 @@ enum class event_level {
 };
 
 [[nodiscard]] auto
-event_level_from_string(std::string level,
+event_level_from_string(std::string_view type,
                         event_level default_level = event_level::info)
     -> event_level;
 
diff --git a/repertory/librepertory/include/types/s3.hpp b/repertory/librepertory/include/types/s3.hpp
index add306a1..f20954eb 100644
--- a/repertory/librepertory/include/types/s3.hpp
+++ b/repertory/librepertory/include/types/s3.hpp
@@ -31,16 +31,16 @@ namespace repertory {
 using get_key_callback = std::function<std::string()>;
 
 using get_api_file_token_callback =
-    std::function<std::string(const std::string &api_path)>;
+    std::function<std::string(std::string_view api_path)>;
 
 using get_name_callback = std::function<std::string(
-    const std::string &key, const std::string &object_name)>;
+    std::string_view key, std::string_view object_name)>;
 
 using get_size_callback = std::function<std::uint64_t()>;
 
 using get_token_callback = std::function<std::string()>;
 
-using set_key_callback = std::function<api_error(const std::string &key)>;
+using set_key_callback = std::function<api_error(std::string_view key)>;
 
 using list_directories_result = api_file_list;
 
diff --git a/repertory/librepertory/include/types/startup_exception.hpp b/repertory/librepertory/include/types/startup_exception.hpp
index 22d672e0..12132a5d 100644
--- a/repertory/librepertory/include/types/startup_exception.hpp
+++ b/repertory/librepertory/include/types/startup_exception.hpp
@@ -25,8 +25,8 @@
 namespace repertory {
 class startup_exception : public virtual std::runtime_error {
 public:
-  explicit startup_exception(const std::string &msg)
-      : std::runtime_error(msg) {}
+  explicit startup_exception(std::string_view msg)
+      : std::runtime_error(std::string{msg}) {}
 };
 } // namespace repertory
 
diff --git a/repertory/librepertory/include/utils/cli_utils.hpp b/repertory/librepertory/include/utils/cli_utils.hpp
index b34cb387..7029736c 100644
--- a/repertory/librepertory/include/utils/cli_utils.hpp
+++ b/repertory/librepertory/include/utils/cli_utils.hpp
@@ -96,20 +96,20 @@ inline const std::vector<option> option_list = {
 
 // Prototypes
 void get_api_authentication_data(std::string &user, std::string &password,
-                                 std::uint16_t &port, provider_type prov,
-                                 const std::string &data_directory);
+                                 std::uint16_t &port,
+                                 std::string_view data_directory);
 
 [[nodiscard]] auto get_provider_type_from_args(std::vector<const char *> args)
     -> provider_type;
 
 [[nodiscard]] auto has_option(std::vector<const char *> args,
-                              const std::string &option_name) -> bool;
+                              std::string_view option_name) -> bool;
 
 [[nodiscard]] auto has_option(std::vector<const char *> args, const option &opt)
     -> bool;
 
 [[nodiscard]] auto parse_option(std::vector<const char *> args,
-                                const std::string &option_name,
+                                std::string_view option_name,
                                 std::uint8_t count) -> std::vector<std::string>;
 
 [[nodiscard]] auto parse_string_option(std::vector<const char *> args,
diff --git a/repertory/librepertory/include/utils/file_utils.hpp b/repertory/librepertory/include/utils/file_utils.hpp
index a835abac..051084ae 100644
--- a/repertory/librepertory/include/utils/file_utils.hpp
+++ b/repertory/librepertory/include/utils/file_utils.hpp
@@ -25,14 +25,14 @@
 #include "utils/file.hpp"
 
 namespace repertory::utils::file {
-[[nodiscard]] auto
-get_directory_files(std::string_view path, bool oldest_first,
-                    bool recursive = false) -> std::deque<std::string>;
+[[nodiscard]] auto get_directory_files(std::string_view path, bool oldest_first,
+                                       bool recursive = false)
+    -> std::deque<std::string>;
 
-[[nodiscard]] auto
-read_file_lines(const std::string &path) -> std::vector<std::string>;
+[[nodiscard]] auto read_file_lines(std::string_view path)
+    -> std::vector<std::string>;
 
-[[nodiscard]] auto reset_modified_time(const std::string &path) -> bool;
+[[nodiscard]] auto reset_modified_time(std::string_view path) -> bool;
 } // namespace repertory::utils::file
 
 #endif // REPERTORY_INCLUDE_UTILS_FILE_UTILS_HPP_
diff --git a/repertory/librepertory/include/utils/polling.hpp b/repertory/librepertory/include/utils/polling.hpp
index 8cd1d692..4813e25c 100644
--- a/repertory/librepertory/include/utils/polling.hpp
+++ b/repertory/librepertory/include/utils/polling.hpp
@@ -78,7 +78,7 @@ private:
   [[nodiscard]] auto get_stop_requested() const -> bool;
 
 public:
-  void remove_callback(const std::string &name);
+  void remove_callback(std::string_view name);
 
   void set_callback(const polling_item &item);
 
diff --git a/repertory/librepertory/include/utils/utils.hpp b/repertory/librepertory/include/utils/utils.hpp
index 90aec22e..8d6c4cc5 100644
--- a/repertory/librepertory/include/utils/utils.hpp
+++ b/repertory/librepertory/include/utils/utils.hpp
@@ -33,7 +33,7 @@ void calculate_allocation_size(bool directory, std::uint64_t file_size,
                                std::string &allocation_meta_size);
 
 [[nodiscard]] auto
-create_rocksdb(const app_config &cfg, const std::string &name,
+create_rocksdb(const app_config &cfg, std::string_view name,
                const std::vector<rocksdb::ColumnFamilyDescriptor> &families,
                std::vector<rocksdb::ColumnFamilyHandle *> &handles, bool clear)
     -> std::unique_ptr<rocksdb::TransactionDB>;
diff --git a/repertory/librepertory/src/app_config.cpp b/repertory/librepertory/src/app_config.cpp
index 5359be69..d1c52fa3 100644
--- a/repertory/librepertory/src/app_config.cpp
+++ b/repertory/librepertory/src/app_config.cpp
@@ -35,8 +35,8 @@
 
 namespace {
 template <typename dest>
-auto get_value(const json &data, const std::string &name, dest &dst,
-               bool &found) -> bool {
+auto get_value(const json &data, std::string_view name, dest &dst, bool &found)
+    -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -69,7 +69,9 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       api_password_(utils::generate_random_string(default_api_password_size)),
       api_port_(default_rpc_port),
       api_user_(std::string{REPERTORY}),
+      cache_directory_(utils::path::combine(data_directory, {"cache"})),
       config_changed_(false),
+      data_directory_(utils::path::absolute(data_directory)),
       download_timeout_secs_(default_download_timeout_secs),
       enable_download_timeout_(true),
       enable_drive_events_(false),
@@ -80,6 +82,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       eviction_delay_mins_(default_eviction_delay_mins),
       eviction_uses_accessed_time_(false),
       high_freq_interval_secs_(default_high_freq_interval_secs),
+      log_directory_(utils::path::combine(data_directory, {"logs"})),
       low_freq_interval_secs_(default_low_freq_interval_secs),
       max_cache_size_bytes_(default_max_cache_size_bytes),
       max_upload_count_(default_max_upload_count),
@@ -89,12 +92,6 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       retry_read_count_(default_retry_read_count),
       ring_buffer_file_size_(default_ring_buffer_file_size),
       task_wait_ms_(default_task_wait_ms) {
-  data_directory_ = data_directory.empty()
-                        ? default_data_directory(prov)
-                        : utils::path::absolute(data_directory);
-  cache_directory_ = utils::path::combine(data_directory_, {"cache"});
-  log_directory_ = utils::path::combine(data_directory_, {"logs"});
-
   auto host_cfg = get_host_config();
   host_cfg.agent_string = default_agent_name(prov_);
   host_cfg.api_port = default_api_port(prov_);
@@ -263,57 +260,59 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
   value_set_lookup_ = {
       {
           JSON_API_PASSWORD,
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             set_api_password(value);
             return get_api_password();
           },
       },
       {
           JSON_API_PORT,
-          [this](const std::string &value) {
-            set_api_port(utils::string::to_uint16(value));
+          [this](std::string_view value) {
+            set_api_port(utils::string::to_uint16(std::string{value}));
             return std::to_string(get_api_port());
           },
       },
       {
           JSON_API_USER,
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             set_api_user(value);
             return get_api_user();
           },
       },
       {
           JSON_DATABASE_TYPE,
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             set_database_type(database_type_from_string(value));
             return database_type_to_string(db_type_);
           },
       },
       {
           JSON_DOWNLOAD_TIMEOUT_SECS,
-          [this](const std::string &value) {
-            set_download_timeout_secs(utils::string::to_uint8(value));
+          [this](std::string_view value) {
+            set_download_timeout_secs(
+                utils::string::to_uint8(std::string{value}));
             return std::to_string(get_download_timeout_secs());
           },
       },
       {
           JSON_ENABLE_DOWNLOAD_TIMEOUT,
-          [this](const std::string &value) {
-            set_enable_download_timeout(utils::string::to_bool(value));
+          [this](std::string_view value) {
+            set_enable_download_timeout(
+                utils::string::to_bool(std::string{value}));
             return utils::string::from_bool(get_enable_download_timeout());
           },
       },
       {
           JSON_ENABLE_DRIVE_EVENTS,
-          [this](const std::string &value) {
-            set_enable_drive_events(utils::string::to_bool(value));
+          [this](std::string_view value) {
+            set_enable_drive_events(utils::string::to_bool(std::string{value}));
             return utils::string::from_bool(get_enable_drive_events());
           },
       },
 #if defined(_WIN32)
       {
           JSON_ENABLE_MOUNT_MANAGER,
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             set_enable_mount_manager(utils::string::to_bool(value));
             return utils::string::from_bool(get_enable_mount_manager());
           },
@@ -321,7 +320,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
 #endif // defined(_WIN32)
       {
           fmt::format("{}.{}", JSON_ENCRYPT_CONFIG, JSON_ENCRYPTION_TOKEN),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_encrypt_config();
             cfg.encryption_token = value;
             set_encrypt_config(cfg);
@@ -330,7 +329,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_ENCRYPT_CONFIG, JSON_PATH),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_encrypt_config();
             cfg.path = value;
             set_encrypt_config(cfg);
@@ -339,35 +338,38 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           JSON_EVENT_LEVEL,
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             set_event_level(event_level_from_string(value));
             return event_level_to_string(get_event_level());
           },
       },
       {
           JSON_EVICTION_DELAY_MINS,
-          [this](const std::string &value) {
-            set_eviction_delay_mins(utils::string::to_uint32(value));
+          [this](std::string_view value) {
+            set_eviction_delay_mins(
+                utils::string::to_uint32(std::string{value}));
             return std::to_string(get_eviction_delay_mins());
           },
       },
       {
           JSON_EVICTION_USE_ACCESS_TIME,
-          [this](const std::string &value) {
-            set_eviction_uses_accessed_time(utils::string::to_bool(value));
+          [this](std::string_view value) {
+            set_eviction_uses_accessed_time(
+                utils::string::to_bool(std::string{value}));
             return utils::string::from_bool(get_eviction_uses_accessed_time());
           },
       },
       {
           JSON_HIGH_FREQ_INTERVAL_SECS,
-          [this](const std::string &value) {
-            set_high_frequency_interval_secs(utils::string::to_uint16(value));
+          [this](std::string_view value) {
+            set_high_frequency_interval_secs(
+                utils::string::to_uint16(std::string{value}));
             return std::to_string(get_high_frequency_interval_secs());
           },
       },
       {
           fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_AGENT_STRING),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_host_config();
             cfg.agent_string = value;
             set_host_config(cfg);
@@ -376,7 +378,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_API_PASSWORD),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_host_config();
             cfg.api_password = value;
             set_host_config(cfg);
@@ -385,16 +387,16 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_API_PORT),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_host_config();
-            cfg.api_port = utils::string::to_uint16(value);
+            cfg.api_port = utils::string::to_uint16(std::string{value});
             set_host_config(cfg);
             return std::to_string(get_host_config().api_port);
           },
       },
       {
           fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_API_USER),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_host_config();
             cfg.api_user = value;
             set_host_config(cfg);
@@ -403,7 +405,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_HOST_NAME_OR_IP),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_host_config();
             cfg.host_name_or_ip = value;
             set_host_config(cfg);
@@ -412,7 +414,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_PATH),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_host_config();
             cfg.path = value;
             set_host_config(cfg);
@@ -421,7 +423,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_PROTOCOL),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_host_config();
             cfg.protocol = value;
             set_host_config(cfg);
@@ -430,76 +432,80 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_TIMEOUT_MS),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_host_config();
-            cfg.timeout_ms = utils::string::to_uint32(value);
+            cfg.timeout_ms = utils::string::to_uint32(std::string{value});
             set_host_config(cfg);
             return std::to_string(get_host_config().timeout_ms);
           },
       },
       {
           JSON_LOW_FREQ_INTERVAL_SECS,
-          [this](const std::string &value) {
-            set_low_frequency_interval_secs(utils::string::to_uint16(value));
+          [this](std::string_view value) {
+            set_low_frequency_interval_secs(
+                utils::string::to_uint16(std::string{value}));
             return std::to_string(get_low_frequency_interval_secs());
           },
       },
       {
           JSON_MED_FREQ_INTERVAL_SECS,
-          [this](const std::string &value) {
-            set_med_frequency_interval_secs(utils::string::to_uint16(value));
+          [this](std::string_view value) {
+            set_med_frequency_interval_secs(
+                utils::string::to_uint16(std::string{value}));
             return std::to_string(get_med_frequency_interval_secs());
           },
       },
       {
           JSON_MAX_CACHE_SIZE_BYTES,
-          [this](const std::string &value) {
-            set_max_cache_size_bytes(utils::string::to_uint64(value));
+          [this](std::string_view value) {
+            set_max_cache_size_bytes(
+                utils::string::to_uint64(std::string{value}));
             return std::to_string(get_max_cache_size_bytes());
           },
       },
       {
           JSON_MAX_UPLOAD_COUNT,
-          [this](const std::string &value) {
-            set_max_upload_count(utils::string::to_uint8(value));
+          [this](std::string_view value) {
+            set_max_upload_count(utils::string::to_uint8(std::string{value}));
             return std::to_string(get_max_upload_count());
           },
       },
       {
           JSON_ONLINE_CHECK_RETRY_SECS,
-          [this](const std::string &value) {
-            set_online_check_retry_secs(utils::string::to_uint16(value));
+          [this](std::string_view value) {
+            set_online_check_retry_secs(
+                utils::string::to_uint16(std::string{value}));
             return std::to_string(get_online_check_retry_secs());
           },
       },
       {
           JSON_PREFERRED_DOWNLOAD_TYPE,
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             set_preferred_download_type(download_type_from_string(value));
             return download_type_to_string(get_preferred_download_type());
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_API_PORT),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_config();
-            cfg.api_port = utils::string::to_uint16(value);
+            cfg.api_port = utils::string::to_uint16(std::string{value});
             set_remote_config(cfg);
             return std::to_string(get_remote_config().api_port);
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_CONNECT_TIMEOUT_MS),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_config();
-            cfg.conn_timeout_ms = utils::string::to_uint32(value);
+            cfg.conn_timeout_ms = utils::string::to_uint32(std::string{value});
             set_remote_config(cfg);
             return std::to_string(get_remote_config().conn_timeout_ms);
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_ENCRYPTION_TOKEN),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_config();
             cfg.encryption_token = value;
             set_remote_config(cfg);
@@ -508,7 +514,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_HOST_NAME_OR_IP),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_config();
             cfg.host_name_or_ip = value;
             set_remote_config(cfg);
@@ -517,61 +523,61 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_MAX_CONNECTIONS),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_config();
-            cfg.max_connections = utils::string::to_uint8(value);
+            cfg.max_connections = utils::string::to_uint8(std::string{value});
             set_remote_config(cfg);
             return std::to_string(get_remote_config().max_connections);
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_RECV_TIMEOUT_MS),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_config();
-            cfg.recv_timeout_ms = utils::string::to_uint32(value);
+            cfg.recv_timeout_ms = utils::string::to_uint32(std::string{value});
             set_remote_config(cfg);
             return std::to_string(get_remote_config().recv_timeout_ms);
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_SEND_TIMEOUT_MS),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_config();
-            cfg.send_timeout_ms = utils::string::to_uint32(value);
+            cfg.send_timeout_ms = utils::string::to_uint32(std::string{value});
             set_remote_config(cfg);
             return std::to_string(get_remote_config().send_timeout_ms);
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_MOUNT, JSON_API_PORT),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_mount();
-            cfg.api_port = utils::string::to_uint16(value);
+            cfg.api_port = utils::string::to_uint16(std::string{value});
             set_remote_mount(cfg);
             return std::to_string(get_remote_mount().api_port);
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_MOUNT, JSON_CLIENT_POOL_SIZE),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_mount();
-            cfg.client_pool_size = utils::string::to_uint8(value);
+            cfg.client_pool_size = utils::string::to_uint8(std::string{value});
             set_remote_mount(cfg);
             return std::to_string(get_remote_mount().client_pool_size);
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_MOUNT, JSON_ENABLE_REMOTE_MOUNT),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_mount();
-            cfg.enable = utils::string::to_bool(value);
+            cfg.enable = utils::string::to_bool(std::string{value});
             set_remote_mount(cfg);
             return utils::string::from_bool(get_remote_mount().enable);
           },
       },
       {
           fmt::format("{}.{}", JSON_REMOTE_MOUNT, JSON_ENCRYPTION_TOKEN),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_remote_mount();
             cfg.encryption_token = value;
             set_remote_mount(cfg);
@@ -580,21 +586,22 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           JSON_RETRY_READ_COUNT,
-          [this](const std::string &value) {
-            set_retry_read_count(utils::string::to_uint16(value));
+          [this](std::string_view value) {
+            set_retry_read_count(utils::string::to_uint16(std::string{value}));
             return std::to_string(get_retry_read_count());
           },
       },
       {
           JSON_RING_BUFFER_FILE_SIZE,
-          [this](const std::string &value) {
-            set_ring_buffer_file_size(utils::string::to_uint16(value));
+          [this](std::string_view value) {
+            set_ring_buffer_file_size(
+                utils::string::to_uint16(std::string{value}));
             return std::to_string(get_ring_buffer_file_size());
           },
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_ACCESS_KEY),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
             cfg.access_key = value;
             set_s3_config(cfg);
@@ -603,7 +610,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_BUCKET),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
             cfg.bucket = value;
             set_s3_config(cfg);
@@ -612,7 +619,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_ENCRYPTION_TOKEN),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
             cfg.encryption_token = value;
             set_s3_config(cfg);
@@ -621,9 +628,10 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_FORCE_LEGACY_ENCRYPTION),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
-            cfg.force_legacy_encryption = utils::string::to_bool(value);
+            cfg.force_legacy_encryption =
+                utils::string::to_bool(std::string{value});
             set_s3_config(cfg);
             return utils::string::from_bool(
                 get_s3_config().force_legacy_encryption);
@@ -631,7 +639,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_REGION),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
             cfg.region = value;
             set_s3_config(cfg);
@@ -640,7 +648,7 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_SECRET_KEY),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
             cfg.secret_key = value;
             set_s3_config(cfg);
@@ -649,16 +657,16 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_TIMEOUT_MS),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
-            cfg.timeout_ms = utils::string::to_uint32(value);
+            cfg.timeout_ms = utils::string::to_uint32(std::string{value});
             set_s3_config(cfg);
             return std::to_string(get_s3_config().timeout_ms);
           },
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_URL),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
             cfg.url = value;
             set_s3_config(cfg);
@@ -667,25 +675,25 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_USE_PATH_STYLE),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
-            cfg.use_path_style = utils::string::to_bool(value);
+            cfg.use_path_style = utils::string::to_bool(std::string{value});
             set_s3_config(cfg);
             return utils::string::from_bool(get_s3_config().use_path_style);
           },
       },
       {
           fmt::format("{}.{}", JSON_S3_CONFIG, JSON_USE_REGION_IN_URL),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_s3_config();
-            cfg.use_region_in_url = utils::string::to_bool(value);
+            cfg.use_region_in_url = utils::string::to_bool(std::string{value});
             set_s3_config(cfg);
             return utils::string::from_bool(get_s3_config().use_region_in_url);
           },
       },
       {
           fmt::format("{}.{}", JSON_SIA_CONFIG, JSON_BUCKET),
-          [this](const std::string &value) {
+          [this](std::string_view value) {
             auto cfg = get_sia_config();
             cfg.bucket = value;
             set_sia_config(cfg);
@@ -694,8 +702,8 @@ app_config::app_config(provider_type prov, std::string_view data_directory)
       },
       {
           JSON_TASK_WAIT_MS,
-          [this](const std::string &value) {
-            set_task_wait_ms(utils::string::to_uint16(value));
+          [this](std::string_view value) {
+            set_task_wait_ms(utils::string::to_uint16(std::string{value}));
             return std::to_string(get_task_wait_ms());
           },
       },
@@ -1000,12 +1008,11 @@ auto app_config::get_task_wait_ms() const -> std::uint16_t {
   return std::max(min_task_wait_ms, task_wait_ms_.load());
 }
 
-auto app_config::get_value_by_name(const std::string &name) const
-    -> std::string {
+auto app_config::get_value_by_name(std::string_view name) const -> std::string {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
-    return value_get_lookup_.at(name)();
+    return value_get_lookup_.at(std::string{name})();
   } catch (const std::exception &e) {
     utils::error::raise_error(function_name, e,
                               fmt::format("value not found|name|{}", name));
@@ -1158,7 +1165,7 @@ void app_config::save() {
   });
 }
 
-void app_config::set_api_password(const std::string &value) {
+void app_config::set_api_password(std::string_view value) {
   set_value(api_password_, value);
 }
 
@@ -1166,7 +1173,7 @@ void app_config::set_api_port(std::uint16_t value) {
   set_value(api_port_, value);
 }
 
-void app_config::set_api_user(const std::string &value) {
+void app_config::set_api_user(std::string_view value) {
   set_value(api_user_, value);
 }
 
@@ -1291,12 +1298,18 @@ auto app_config::set_value(dest &dst, const source &src) -> bool {
   return true;
 }
 
-auto app_config::set_value_by_name(const std::string &name,
-                                   const std::string &value) -> std::string {
+auto app_config::set_value(utils::atomic<std::string> &dst,
+                           std::string_view src) -> bool {
+  return set_value<utils::atomic<std::string>, std::string>(dst,
+                                                            std::string{src});
+}
+
+auto app_config::set_value_by_name(std::string_view name,
+                                   std::string_view value) -> std::string {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
-    return value_set_lookup_.at(name)(value);
+    return value_set_lookup_.at(std::string{name})(value);
   } catch (const std::exception &e) {
     utils::error::raise_error(function_name, e,
                               fmt::format("value not found|name|{}", name));
diff --git a/repertory/librepertory/src/comm/curl/curl_comm.cpp b/repertory/librepertory/src/comm/curl/curl_comm.cpp
index 40e31062..94d46a88 100644
--- a/repertory/librepertory/src/comm/curl/curl_comm.cpp
+++ b/repertory/librepertory/src/comm/curl/curl_comm.cpp
@@ -60,7 +60,7 @@ curl_comm::curl_comm(host_config cfg)
 curl_comm::curl_comm(s3_config cfg)
     : host_config_(std::nullopt), s3_config_(std::move(cfg)) {}
 
-auto curl_comm::construct_url(CURL *curl, const std::string &relative_path,
+auto curl_comm::construct_url(CURL *curl, std::string_view relative_path,
                               const host_config &cfg) -> std::string {
   static constexpr auto http{80U};
   static constexpr auto https{443U};
@@ -74,8 +74,8 @@ auto curl_comm::construct_url(CURL *curl, const std::string &relative_path,
   auto url = cfg.protocol + "://" +
              utils::string::trim_copy(cfg.host_name_or_ip) + custom_port;
 
-  static const auto complete_url = [](const std::string &current_path,
-                                      const std::string &parent_path,
+  static const auto complete_url = [](std::string_view current_path,
+                                      std::string_view parent_path,
                                       std::string &final_url) -> std::string & {
     final_url += utils::path::create_api_path(current_path);
     if (utils::string::ends_with(parent_path, "/")) {
@@ -174,10 +174,10 @@ auto curl_comm::make_request(const curl::requests::http_put_file &put_file,
                       put_file, response_code, stop_requested);
 }
 
-auto curl_comm::url_encode(CURL *curl, const std::string &data,
-                           bool allow_slash) -> std::string {
-  auto *value =
-      curl_easy_escape(curl, data.c_str(), static_cast<int>(data.size()));
+auto curl_comm::url_encode(CURL *curl, std::string_view data, bool allow_slash)
+    -> std::string {
+  auto *value = curl_easy_escape(curl, std::string{data}.c_str(),
+                                 static_cast<int>(data.size()));
   std::string ret = value;
   curl_free(value);
 
diff --git a/repertory/librepertory/src/comm/packet/client_pool.cpp b/repertory/librepertory/src/comm/packet/client_pool.cpp
index 73f7cc1a..161fc1ad 100644
--- a/repertory/librepertory/src/comm/packet/client_pool.cpp
+++ b/repertory/librepertory/src/comm/packet/client_pool.cpp
@@ -130,7 +130,7 @@ void client_pool::pool::shutdown() {
   pool_threads_.clear();
 }
 
-void client_pool::execute(const std::string &client_id, std::uint64_t thread_id,
+void client_pool::execute(std::string_view client_id, std::uint64_t thread_id,
                           const worker_callback &worker,
                           const worker_complete_callback &worker_complete) {
   unique_mutex_lock pool_lock(pool_mutex_);
@@ -139,17 +139,18 @@ void client_pool::execute(const std::string &client_id, std::uint64_t thread_id,
     throw std::runtime_error("Client pool is shutdown");
   }
 
-  if (not pool_lookup_[client_id]) {
-    pool_lookup_[client_id] = std::make_shared<pool>(pool_size_);
+  auto str_id = std::string{client_id};
+  if (not pool_lookup_[str_id]) {
+    pool_lookup_[str_id] = std::make_shared<pool>(pool_size_);
   }
 
-  pool_lookup_[client_id]->execute(thread_id, worker, worker_complete);
+  pool_lookup_[str_id]->execute(thread_id, worker, worker_complete);
   pool_lock.unlock();
 }
 
-void client_pool::remove_client(const std::string &client_id) {
+void client_pool::remove_client(std::string_view client_id) {
   mutex_lock pool_lock(pool_mutex_);
-  pool_lookup_.erase(client_id);
+  pool_lookup_.erase(std::string{client_id});
 }
 
 void client_pool::shutdown() {
diff --git a/repertory/librepertory/src/comm/packet/packet_server.cpp b/repertory/librepertory/src/comm/packet/packet_server.cpp
index 102696e2..1bc6a27f 100644
--- a/repertory/librepertory/src/comm/packet/packet_server.cpp
+++ b/repertory/librepertory/src/comm/packet/packet_server.cpp
@@ -72,14 +72,15 @@ packet_server::~packet_server() {
                                                    "packet_server");
 }
 
-void packet_server::add_client(connection &conn, const std::string &client_id) {
+void packet_server::add_client(connection &conn, std::string_view client_id) {
   conn.client_id = client_id;
 
   recur_mutex_lock connection_lock(connection_mutex_);
-  if (connection_lookup_.contains(client_id)) {
-    connection_lookup_.at(client_id)++;
+  auto str_id = std::string{client_id};
+  if (connection_lookup_.contains(str_id)) {
+    connection_lookup_.at(str_id)++;
   } else {
-    connection_lookup_[client_id] = 1U;
+    connection_lookup_[str_id] = 1U;
   }
 }
 
diff --git a/repertory/librepertory/src/db/impl/rdb_file_db.cpp b/repertory/librepertory/src/db/impl/rdb_file_db.cpp
index 79ea6bad..d65d0346 100644
--- a/repertory/librepertory/src/db/impl/rdb_file_db.cpp
+++ b/repertory/librepertory/src/db/impl/rdb_file_db.cpp
@@ -204,7 +204,7 @@ void rdb_file_db::enumerate_item_list(
   }
 }
 
-auto rdb_file_db::get_api_path(const std::string &source_path,
+auto rdb_file_db::get_api_path(std::string_view source_path,
                                std::string &api_path) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -214,7 +214,7 @@ auto rdb_file_db::get_api_path(const std::string &source_path,
   });
 }
 
-auto rdb_file_db::get_directory_api_path(const std::string &source_path,
+auto rdb_file_db::get_directory_api_path(std::string_view source_path,
                                          std::string &api_path) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -239,7 +239,7 @@ auto rdb_file_db::get_directory_api_path(const std::string &source_path,
                                              : result;
 }
 
-auto rdb_file_db::get_directory_data(const std::string &api_path,
+auto rdb_file_db::get_directory_data(std::string_view api_path,
                                      i_file_db::directory_data &data) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -264,7 +264,7 @@ auto rdb_file_db::get_directory_data(const std::string &api_path,
                                              : result;
 }
 
-auto rdb_file_db::get_directory_source_path(const std::string &api_path,
+auto rdb_file_db::get_directory_source_path(std::string_view api_path,
                                             std::string &source_path) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -285,7 +285,7 @@ auto rdb_file_db::get_directory_source_path(const std::string &api_path,
                                              : result;
 }
 
-auto rdb_file_db::get_file_api_path(const std::string &source_path,
+auto rdb_file_db::get_file_api_path(std::string_view source_path,
                                     std::string &api_path) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -307,7 +307,7 @@ auto rdb_file_db::get_file_api_path(const std::string &source_path,
   return result;
 }
 
-auto rdb_file_db::get_file_data(const std::string &api_path,
+auto rdb_file_db::get_file_data(std::string_view api_path,
                                 i_file_db::file_data &data) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -335,7 +335,7 @@ auto rdb_file_db::get_file_data(const std::string &api_path,
   return result;
 }
 
-auto rdb_file_db::get_file_source_path(const std::string &api_path,
+auto rdb_file_db::get_file_source_path(std::string_view api_path,
                                        std::string &source_path) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -387,7 +387,7 @@ auto rdb_file_db::get_item_list(stop_type_callback stop_requested_cb) const
   return ret;
 }
 
-auto rdb_file_db::get_source_path(const std::string &api_path,
+auto rdb_file_db::get_source_path(std::string_view api_path,
                                   std::string &source_path) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -447,7 +447,7 @@ auto rdb_file_db::perform_action(
   return api_error::error;
 }
 
-auto rdb_file_db::remove_item(const std::string &api_path) -> api_error {
+auto rdb_file_db::remove_item(std::string_view api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   std::string source_path;
@@ -462,8 +462,8 @@ auto rdb_file_db::remove_item(const std::string &api_path) -> api_error {
                         });
 }
 
-auto rdb_file_db::remove_item(const std::string &api_path,
-                              const std::string &source_path,
+auto rdb_file_db::remove_item(std::string_view api_path,
+                              std::string_view source_path,
                               rocksdb::Transaction *txn) -> rocksdb::Status {
   auto res = txn->Delete(source_family_, source_path);
   if (not res.ok()) {
diff --git a/repertory/librepertory/src/db/impl/rdb_file_mgr_db.cpp b/repertory/librepertory/src/db/impl/rdb_file_mgr_db.cpp
index 66cd8fbb..33fe374a 100644
--- a/repertory/librepertory/src/db/impl/rdb_file_mgr_db.cpp
+++ b/repertory/librepertory/src/db/impl/rdb_file_mgr_db.cpp
@@ -143,7 +143,7 @@ auto rdb_file_mgr_db::get_resume_list() const -> std::vector<resume_entry> {
   return ret;
 }
 
-auto rdb_file_mgr_db::get_upload(const std::string &api_path) const
+auto rdb_file_mgr_db::get_upload(std::string_view api_path) const
     -> std::optional<upload_entry> {
   auto iter = create_iterator(upload_family_);
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
@@ -155,7 +155,7 @@ auto rdb_file_mgr_db::get_upload(const std::string &api_path) const
     }
 
     return upload_entry{
-        api_path,
+        std::string{api_path},
         iter->value().ToString(),
     };
   }
@@ -229,7 +229,7 @@ auto rdb_file_mgr_db::perform_action(
   return false;
 }
 
-auto rdb_file_mgr_db::remove_resume(const std::string &api_path) -> bool {
+auto rdb_file_mgr_db::remove_resume(std::string_view api_path) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   return perform_action(
@@ -239,13 +239,13 @@ auto rdb_file_mgr_db::remove_resume(const std::string &api_path) -> bool {
       });
 }
 
-auto rdb_file_mgr_db::remove_resume(const std::string &api_path,
+auto rdb_file_mgr_db::remove_resume(std::string_view api_path,
                                     rocksdb::Transaction *txn)
     -> rocksdb::Status {
   return txn->Delete(resume_family_, api_path);
 }
 
-auto rdb_file_mgr_db::remove_upload(const std::string &api_path) -> bool {
+auto rdb_file_mgr_db::remove_upload(std::string_view api_path) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto iter = create_iterator(upload_family_);
@@ -267,8 +267,7 @@ auto rdb_file_mgr_db::remove_upload(const std::string &api_path) -> bool {
   return true;
 }
 
-auto rdb_file_mgr_db::remove_upload_active(const std::string &api_path)
-    -> bool {
+auto rdb_file_mgr_db::remove_upload_active(std::string_view api_path) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   return perform_action(
@@ -278,8 +277,8 @@ auto rdb_file_mgr_db::remove_upload_active(const std::string &api_path)
       });
 }
 
-auto rdb_file_mgr_db::rename_resume(const std::string &from_api_path,
-                                    const std::string &to_api_path) -> bool {
+auto rdb_file_mgr_db::rename_resume(std::string_view from_api_path,
+                                    std::string_view to_api_path) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   bool not_found{false};
@@ -305,7 +304,7 @@ auto rdb_file_mgr_db::rename_resume(const std::string &from_api_path,
 
   auto data = json::parse(value);
   resume_entry entry{
-      to_api_path,
+      std::string{to_api_path},
       data.at("chunk_size").get<std::uint64_t>(),
       utils::string::to_dynamic_bitset(
           data.at("read_state").get<std::string>()),
diff --git a/repertory/librepertory/src/db/impl/rdb_meta_db.cpp b/repertory/librepertory/src/db/impl/rdb_meta_db.cpp
index 663abba0..b94d8afd 100644
--- a/repertory/librepertory/src/db/impl/rdb_meta_db.cpp
+++ b/repertory/librepertory/src/db/impl/rdb_meta_db.cpp
@@ -88,7 +88,7 @@ void rdb_meta_db::enumerate_api_path_list(
   }
 }
 
-auto rdb_meta_db::get_api_path(const std::string &source_path,
+auto rdb_meta_db::get_api_path(std::string_view source_path,
                                std::string &api_path) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -112,7 +112,7 @@ auto rdb_meta_db::get_api_path_list() const -> std::vector<std::string> {
   return ret;
 }
 
-auto rdb_meta_db::get_item_meta_json(const std::string &api_path,
+auto rdb_meta_db::get_item_meta_json(std::string_view api_path,
                                      json &json_data) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -169,7 +169,7 @@ auto rdb_meta_db::get_item_meta_json(const std::string &api_path,
   return api_error::error;
 }
 
-auto rdb_meta_db::get_item_meta(const std::string &api_path,
+auto rdb_meta_db::get_item_meta(std::string_view api_path,
                                 api_meta_map &meta) const -> api_error {
   json json_data;
   auto ret = get_item_meta_json(api_path, json_data);
@@ -184,8 +184,7 @@ auto rdb_meta_db::get_item_meta(const std::string &api_path,
   return api_error::success;
 }
 
-auto rdb_meta_db::get_item_meta(const std::string &api_path,
-                                const std::string &key,
+auto rdb_meta_db::get_item_meta(std::string_view api_path, std::string_view key,
                                 std::string &value) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -298,7 +297,7 @@ auto rdb_meta_db::perform_action(
   return api_error::error;
 }
 
-void rdb_meta_db::remove_api_path(const std::string &api_path) {
+void rdb_meta_db::remove_api_path(std::string_view api_path) {
   REPERTORY_USES_FUNCTION_NAME();
 
   std::string source_path;
@@ -319,8 +318,8 @@ void rdb_meta_db::remove_api_path(const std::string &api_path) {
   }
 }
 
-auto rdb_meta_db::remove_api_path(const std::string &api_path,
-                                  const std::string &source_path,
+auto rdb_meta_db::remove_api_path(std::string_view api_path,
+                                  std::string_view source_path,
                                   rocksdb::Transaction *txn)
     -> rocksdb::Status {
   auto txn_res = txn->Delete(pinned_family_, api_path);
@@ -343,11 +342,11 @@ auto rdb_meta_db::remove_api_path(const std::string &api_path,
   return txn->Delete(meta_family_, api_path);
 }
 
-auto rdb_meta_db::remove_item_meta(const std::string &api_path,
-                                   const std::string &key) -> api_error {
+auto rdb_meta_db::remove_item_meta(std::string_view api_path,
+                                   std::string_view key) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
-  if (utils::collection::includes(META_USED_NAMES, key)) {
+  if (utils::collection::includes(META_USED_NAMES, std::string{key})) {
     utils::error::raise_api_path_error(
         function_name, api_path,
         fmt::format("failed to remove item meta-key is restricted|key|{}",
@@ -365,9 +364,8 @@ auto rdb_meta_db::remove_item_meta(const std::string &api_path,
   return update_item_meta(api_path, json_data);
 }
 
-auto rdb_meta_db::rename_item_meta(const std::string &from_api_path,
-                                   const std::string &to_api_path)
-    -> api_error {
+auto rdb_meta_db::rename_item_meta(std::string_view from_api_path,
+                                   std::string_view to_api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   json json_data;
@@ -391,9 +389,8 @@ auto rdb_meta_db::rename_item_meta(const std::string &from_api_path,
       });
 }
 
-auto rdb_meta_db::set_item_meta(const std::string &api_path,
-                                const std::string &key,
-                                const std::string &value) -> api_error {
+auto rdb_meta_db::set_item_meta(std::string_view api_path, std::string_view key,
+                                std::string_view value) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (key == META_PINNED) {
@@ -421,7 +418,7 @@ auto rdb_meta_db::set_item_meta(const std::string &api_path,
   return update_item_meta(api_path, json_data);
 }
 
-auto rdb_meta_db::set_item_meta(const std::string &api_path,
+auto rdb_meta_db::set_item_meta(std::string_view api_path,
                                 const api_meta_map &meta) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -439,7 +436,7 @@ auto rdb_meta_db::set_item_meta(const std::string &api_path,
   return update_item_meta(api_path, json_data);
 }
 
-auto rdb_meta_db::update_item_meta(const std::string &api_path, json json_data,
+auto rdb_meta_db::update_item_meta(std::string_view api_path, json json_data,
                                    rocksdb::Transaction *base_txn,
                                    rocksdb::Status *status) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
diff --git a/repertory/librepertory/src/db/impl/sqlite_file_db.cpp b/repertory/librepertory/src/db/impl/sqlite_file_db.cpp
index 005b5ebb..a689f0e5 100644
--- a/repertory/librepertory/src/db/impl/sqlite_file_db.cpp
+++ b/repertory/librepertory/src/db/impl/sqlite_file_db.cpp
@@ -168,12 +168,12 @@ void sqlite_file_db::enumerate_item_list(
   }
 }
 
-auto sqlite_file_db::get_api_path(const std::string &source_path,
+auto sqlite_file_db::get_api_path(std::string_view source_path,
                                   std::string &api_path) const -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, file_table}
                     .column("api_path")
                     .where("source_path")
-                    .equals(source_path)
+                    .equals(std::string{source_path})
                     .op()
                     .limit(1)
                     .go();
@@ -187,13 +187,13 @@ auto sqlite_file_db::get_api_path(const std::string &source_path,
   return api_error::item_not_found;
 }
 
-auto sqlite_file_db::get_directory_api_path(const std::string &source_path,
+auto sqlite_file_db::get_directory_api_path(std::string_view source_path,
                                             std::string &api_path) const
     -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, file_table}
                     .column("api_path")
                     .where("source_path")
-                    .equals(source_path)
+                    .equals(std::string{source_path})
                     .and_()
                     .where("directory")
                     .equals(1)
@@ -210,14 +210,14 @@ auto sqlite_file_db::get_directory_api_path(const std::string &source_path,
   return api_error::directory_not_found;
 }
 
-auto sqlite_file_db::get_directory_data(const std::string &api_path,
+auto sqlite_file_db::get_directory_data(std::string_view api_path,
                                         i_file_db::directory_data &data) const
     -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, file_table}
                     .column("kdf_configs")
                     .column("source_path")
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .and_()
                     .where("directory")
                     .equals(0)
@@ -241,13 +241,13 @@ auto sqlite_file_db::get_directory_data(const std::string &api_path,
   return api_error::directory_not_found;
 }
 
-auto sqlite_file_db::get_directory_source_path(const std::string &api_path,
+auto sqlite_file_db::get_directory_source_path(std::string_view api_path,
                                                std::string &source_path) const
     -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, file_table}
                     .column("source_path")
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .and_()
                     .where("directory")
                     .equals(1)
@@ -264,13 +264,13 @@ auto sqlite_file_db::get_directory_source_path(const std::string &api_path,
   return api_error::directory_not_found;
 }
 
-auto sqlite_file_db::get_file_api_path(const std::string &source_path,
+auto sqlite_file_db::get_file_api_path(std::string_view source_path,
                                        std::string &api_path) const
     -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, file_table}
                     .column("api_path")
                     .where("source_path")
-                    .equals(source_path)
+                    .equals(std::string{source_path})
                     .and_()
                     .where("directory")
                     .equals(0)
@@ -287,7 +287,7 @@ auto sqlite_file_db::get_file_api_path(const std::string &source_path,
   return api_error::item_not_found;
 }
 
-auto sqlite_file_db::get_file_data(const std::string &api_path,
+auto sqlite_file_db::get_file_data(std::string_view api_path,
                                    i_file_db::file_data &data) const
     -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, file_table}
@@ -296,7 +296,7 @@ auto sqlite_file_db::get_file_data(const std::string &api_path,
                     .column("size")
                     .column("source_path")
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .and_()
                     .where("directory")
                     .equals(0)
@@ -331,13 +331,13 @@ auto sqlite_file_db::get_file_data(const std::string &api_path,
   return api_error::item_not_found;
 }
 
-auto sqlite_file_db::get_file_source_path(const std::string &api_path,
+auto sqlite_file_db::get_file_source_path(std::string_view api_path,
                                           std::string &source_path) const
     -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, file_table}
                     .column("source_path")
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .and_()
                     .where("directory")
                     .equals(0)
@@ -375,13 +375,13 @@ auto sqlite_file_db::get_item_list(stop_type_callback stop_requested_cb) const
   return ret;
 }
 
-auto sqlite_file_db::get_source_path(const std::string &api_path,
+auto sqlite_file_db::get_source_path(std::string_view api_path,
                                      std::string &source_path) const
     -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, file_table}
                     .column("source_path")
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .op()
                     .limit(1)
                     .go();
@@ -395,10 +395,10 @@ auto sqlite_file_db::get_source_path(const std::string &api_path,
   return api_error::item_not_found;
 }
 
-auto sqlite_file_db::remove_item(const std::string &api_path) -> api_error {
+auto sqlite_file_db::remove_item(std::string_view api_path) -> api_error {
   auto result = utils::db::sqlite::db_delete{*db_, file_table}
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .go();
 
   return result.ok() ? api_error::success : api_error::error;
diff --git a/repertory/librepertory/src/db/impl/sqlite_file_mgr_db.cpp b/repertory/librepertory/src/db/impl/sqlite_file_mgr_db.cpp
index 68633447..c5105f42 100644
--- a/repertory/librepertory/src/db/impl/sqlite_file_mgr_db.cpp
+++ b/repertory/librepertory/src/db/impl/sqlite_file_mgr_db.cpp
@@ -193,11 +193,11 @@ auto sqlite_file_mgr_db::get_resume_list() const -> std::vector<resume_entry> {
   return ret;
 }
 
-auto sqlite_file_mgr_db::get_upload(const std::string &api_path) const
+auto sqlite_file_mgr_db::get_upload(std::string_view api_path) const
     -> std::optional<upload_entry> {
   auto result = utils::db::sqlite::db_select{*db_, upload_table}
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .go();
   std::optional<utils::db::sqlite::db_result::row> row;
   if (not result.get_row(row) || not row.has_value()) {
@@ -238,37 +238,37 @@ auto sqlite_file_mgr_db::get_upload_active_list() const
   return ret;
 }
 
-auto sqlite_file_mgr_db::remove_resume(const std::string &api_path) -> bool {
+auto sqlite_file_mgr_db::remove_resume(std::string_view api_path) -> bool {
   return utils::db::sqlite::db_delete{*db_, resume_table}
       .where("api_path")
-      .equals(api_path)
+      .equals(std::string{api_path})
       .go()
       .ok();
 }
 
-auto sqlite_file_mgr_db::remove_upload(const std::string &api_path) -> bool {
+auto sqlite_file_mgr_db::remove_upload(std::string_view api_path) -> bool {
   return utils::db::sqlite::db_delete{*db_, upload_table}
       .where("api_path")
-      .equals(api_path)
+      .equals(std::string{api_path})
       .go()
       .ok();
 }
 
-auto sqlite_file_mgr_db::remove_upload_active(const std::string &api_path)
+auto sqlite_file_mgr_db::remove_upload_active(std::string_view api_path)
     -> bool {
   return utils::db::sqlite::db_delete{*db_, upload_active_table}
       .where("api_path")
-      .equals(api_path)
+      .equals(std::string{api_path})
       .go()
       .ok();
 }
 
-auto sqlite_file_mgr_db::rename_resume(const std::string &from_api_path,
-                                       const std::string &to_api_path) -> bool {
+auto sqlite_file_mgr_db::rename_resume(std::string_view from_api_path,
+                                       std::string_view to_api_path) -> bool {
   return utils::db::sqlite::db_update{*db_, resume_table}
-      .column_value("api_path", to_api_path)
+      .column_value("api_path", std::string{to_api_path})
       .where("api_path")
-      .equals(from_api_path)
+      .equals(std::string{from_api_path})
       .go()
       .ok();
 }
diff --git a/repertory/librepertory/src/db/impl/sqlite_meta_db.cpp b/repertory/librepertory/src/db/impl/sqlite_meta_db.cpp
index 44b674aa..9efb87e6 100644
--- a/repertory/librepertory/src/db/impl/sqlite_meta_db.cpp
+++ b/repertory/librepertory/src/db/impl/sqlite_meta_db.cpp
@@ -102,12 +102,12 @@ void sqlite_meta_db::enumerate_api_path_list(
   }
 }
 
-auto sqlite_meta_db::get_api_path(const std::string &source_path,
+auto sqlite_meta_db::get_api_path(std::string_view source_path,
                                   std::string &api_path) const -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, table_name}
                     .column("api_path")
                     .where("source_path")
-                    .equals(source_path)
+                    .equals(std::string{source_path})
                     .op()
                     .limit(1)
                     .go();
@@ -136,14 +136,14 @@ auto sqlite_meta_db::get_api_path_list() const -> std::vector<std::string> {
   return ret;
 }
 
-auto sqlite_meta_db::get_item_meta(const std::string &api_path,
+auto sqlite_meta_db::get_item_meta(std::string_view api_path,
                                    api_meta_map &meta) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto result = utils::db::sqlite::db_select{*db_, table_name}
                     .column("*")
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .op()
                     .limit(1)
                     .go();
@@ -176,15 +176,15 @@ auto sqlite_meta_db::get_item_meta(const std::string &api_path,
   return api_error::error;
 }
 
-auto sqlite_meta_db::get_item_meta(const std::string &api_path,
-                                   const std::string &key,
+auto sqlite_meta_db::get_item_meta(std::string_view api_path,
+                                   std::string_view key,
                                    std::string &value) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto result = utils::db::sqlite::db_select{*db_, table_name}
                     .column("*")
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .op()
                     .limit(1)
                     .go();
@@ -291,12 +291,12 @@ auto sqlite_meta_db::get_total_size() const -> std::uint64_t {
   return 0U;
 }
 
-void sqlite_meta_db::remove_api_path(const std::string &api_path) {
+void sqlite_meta_db::remove_api_path(std::string_view api_path) {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto result = utils::db::sqlite::db_delete{*db_, table_name}
                     .where("api_path")
-                    .equals(api_path)
+                    .equals(std::string{api_path})
                     .go();
   if (not result.ok()) {
     utils::error::raise_api_path_error(
@@ -304,11 +304,11 @@ void sqlite_meta_db::remove_api_path(const std::string &api_path) {
   }
 }
 
-auto sqlite_meta_db::remove_item_meta(const std::string &api_path,
-                                      const std::string &key) -> api_error {
+auto sqlite_meta_db::remove_item_meta(std::string_view api_path,
+                                      std::string_view key) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
-  if (utils::collection::includes(META_USED_NAMES, key)) {
+  if (utils::collection::includes(META_USED_NAMES, std::string{key})) {
     utils::error::raise_api_path_error(
         function_name, api_path,
         fmt::format("failed to remove item meta-key is restricted|key|{}",
@@ -322,12 +322,12 @@ auto sqlite_meta_db::remove_item_meta(const std::string &api_path,
     return res;
   }
 
-  meta.erase(key);
+  meta.erase(std::string{key});
   return update_item_meta(api_path, meta);
 }
 
-auto sqlite_meta_db::rename_item_meta(const std::string &from_api_path,
-                                      const std::string &to_api_path)
+auto sqlite_meta_db::rename_item_meta(std::string_view from_api_path,
+                                      std::string_view to_api_path)
     -> api_error {
   api_meta_map meta{};
   auto res = get_item_meta(from_api_path, meta);
@@ -339,13 +339,13 @@ auto sqlite_meta_db::rename_item_meta(const std::string &from_api_path,
   return update_item_meta(to_api_path, meta);
 }
 
-auto sqlite_meta_db::set_item_meta(const std::string &api_path,
-                                   const std::string &key,
-                                   const std::string &value) -> api_error {
-  return set_item_meta(api_path, {{key, value}});
+auto sqlite_meta_db::set_item_meta(std::string_view api_path,
+                                   std::string_view key, std::string_view value)
+    -> api_error {
+  return set_item_meta(api_path, {{std::string{key}, std::string{value}}});
 }
 
-auto sqlite_meta_db::set_item_meta(const std::string &api_path,
+auto sqlite_meta_db::set_item_meta(std::string_view api_path,
                                    const api_meta_map &meta) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -363,7 +363,7 @@ auto sqlite_meta_db::set_item_meta(const std::string &api_path,
   return update_item_meta(api_path, existing_meta);
 }
 
-auto sqlite_meta_db::update_item_meta(const std::string &api_path,
+auto sqlite_meta_db::update_item_meta(std::string_view api_path,
                                       api_meta_map meta) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -392,7 +392,7 @@ auto sqlite_meta_db::update_item_meta(const std::string &api_path,
 
     auto result = utils::db::sqlite::db_insert{*db_, table_name}
                       .or_replace()
-                      .column_value("api_path", api_path)
+                      .column_value("api_path", std::string{api_path})
                       .column_value("data", nlohmann::json(meta).dump())
                       .column_value("directory", directory ? 1 : 0)
                       .column_value("pinned", pinned ? 1 : 0)
diff --git a/repertory/librepertory/src/drives/directory_cache.cpp b/repertory/librepertory/src/drives/directory_cache.cpp
index 30827215..244a569c 100644
--- a/repertory/librepertory/src/drives/directory_cache.cpp
+++ b/repertory/librepertory/src/drives/directory_cache.cpp
@@ -27,11 +27,12 @@
 #include "utils/utils.hpp"
 
 namespace repertory {
-void directory_cache::execute_action(const std::string &api_path,
+void directory_cache::execute_action(std::string_view api_path,
                                      const execute_callback &execute) {
   recur_mutex_lock directory_lock(directory_mutex_);
-  if ((directory_lookup_.find(api_path) != directory_lookup_.end())) {
-    execute(*directory_lookup_[api_path].iterator);
+  if ((directory_lookup_.find(std::string{api_path}) !=
+       directory_lookup_.end())) {
+    execute(*directory_lookup_[std::string{api_path}].iterator);
   }
 }
 
@@ -51,14 +52,14 @@ auto directory_cache::get_directory(std::uint64_t handle)
   return nullptr;
 }
 
-auto directory_cache::remove_directory(const std::string &api_path)
+auto directory_cache::remove_directory(std::string_view api_path)
     -> std::shared_ptr<directory_iterator> {
   std::shared_ptr<directory_iterator> ret;
-
   recur_mutex_lock directory_lock(directory_mutex_);
-  if (directory_lookup_.find(api_path) != directory_lookup_.end()) {
-    ret = directory_lookup_[api_path].iterator;
-    directory_lookup_.erase(api_path);
+  if (directory_lookup_.find(std::string{api_path}) !=
+      directory_lookup_.end()) {
+    ret = directory_lookup_[std::string{api_path}].iterator;
+    directory_lookup_.erase(std::string{api_path});
   }
 
   return ret;
@@ -83,10 +84,10 @@ void directory_cache::remove_directory(std::uint64_t handle) {
 }
 
 void directory_cache::set_directory(
-    const std::string &api_path, std::uint64_t handle,
+    std::string_view api_path, std::uint64_t handle,
     std::shared_ptr<directory_iterator> iterator) {
   recur_mutex_lock directory_lock(directory_mutex_);
-  auto &entry = directory_lookup_[api_path];
+  auto &entry = directory_lookup_[std::string{api_path}];
   entry.iterator = std::move(iterator);
   entry.handles.push_back(handle);
 }
diff --git a/repertory/librepertory/src/drives/directory_iterator.cpp b/repertory/librepertory/src/drives/directory_iterator.cpp
index 63aaa51c..0bdee1e7 100644
--- a/repertory/librepertory/src/drives/directory_iterator.cpp
+++ b/repertory/librepertory/src/drives/directory_iterator.cpp
@@ -101,7 +101,7 @@ auto directory_iterator::get_directory_item(std::size_t offset,
   return api_error::success;
 }
 
-auto directory_iterator::get_directory_item(const std::string &api_path,
+auto directory_iterator::get_directory_item(std::string_view api_path,
                                             directory_item &di) -> api_error {
   auto iter = std::ranges::find_if(items_, [&api_path](auto &&item) -> bool {
     return api_path == item.api_path;
@@ -125,7 +125,7 @@ auto directory_iterator::get_json(std::size_t offset, json &item) -> int {
 }
 
 auto directory_iterator::get_next_directory_offset(
-    const std::string &api_path) const -> std::size_t {
+    std::string_view api_path) const -> std::size_t {
   const auto iter =
       std::ranges::find_if(items_, [&api_path](auto &&dir_item) -> bool {
         return api_path == dir_item.api_path;
diff --git a/repertory/librepertory/src/drives/eviction.cpp b/repertory/librepertory/src/drives/eviction.cpp
index 8f93d387..857ccb8e 100644
--- a/repertory/librepertory/src/drives/eviction.cpp
+++ b/repertory/librepertory/src/drives/eviction.cpp
@@ -32,8 +32,7 @@
 #include "utils/utils.hpp"
 
 namespace repertory {
-auto eviction::check_minimum_requirements(const std::string &file_path)
-    -> bool {
+auto eviction::check_minimum_requirements(std::string_view file_path) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto file = utils::file::file{file_path};
diff --git a/repertory/librepertory/src/drives/fuse/fuse_base.cpp b/repertory/librepertory/src/drives/fuse/fuse_base.cpp
index 53f00548..dff7c241 100644
--- a/repertory/librepertory/src/drives/fuse/fuse_base.cpp
+++ b/repertory/librepertory/src/drives/fuse/fuse_base.cpp
@@ -954,7 +954,7 @@ auto fuse_base::unlink_(const char *path) -> int {
       });
 }
 
-auto fuse_base::unmount(const std::string &mount_location) -> int {
+auto fuse_base::unmount(std::string_view mount_location) -> int {
   REPERTORY_USES_FUNCTION_NAME();
 
 #if defined(__APPLE__)
@@ -965,12 +965,14 @@ auto fuse_base::unmount(const std::string &mount_location) -> int {
         function_name,
         fmt::format("failed to remove launchd entry|label|{}", label_));
   }
-  auto cmd = "umount \"" + mount_location + "\" >/dev/null 2>&1";
+  auto cmd = fmt::format("umount \"{}\" >/dev/null 2>&1", mount_location);
 #else // !defined(__APPLE__)
 #if FUSE_USE_VERSION >= 30
-  auto cmd = "fusermount3 -u \"" + mount_location + "\" >/dev/null 2>&1";
+  auto cmd =
+      fmt::format("fusermount3 -u \"{}\" >/dev/null 2>&1", mount_location);
 #else  // FUSE_USE_VERSION < 30
-  auto cmd = "fusermount -u \"" + mount_location + "\" >/dev/null 2>&1";
+  auto cmd =
+      fmt::format("fusermount -u \"{}\" >/dev/null 2>&1", mount_location);
 #endif // FUSE_USE_VERSION >= 30
 #endif // defined(__APPLE__)
 
diff --git a/repertory/librepertory/src/drives/fuse/fuse_drive.cpp b/repertory/librepertory/src/drives/fuse/fuse_drive.cpp
index 85d0bc29..307b38d7 100644
--- a/repertory/librepertory/src/drives/fuse/fuse_drive.cpp
+++ b/repertory/librepertory/src/drives/fuse/fuse_drive.cpp
@@ -460,12 +460,12 @@ auto fuse_drive::ftruncate_impl(std::string /*api_path*/, off_t size,
 }
 #endif
 
-auto fuse_drive::get_directory_item_count(const std::string &api_path) const
+auto fuse_drive::get_directory_item_count(std::string_view api_path) const
     -> std::uint64_t {
   return provider_.get_directory_item_count(api_path);
 }
 
-auto fuse_drive::get_directory_items(const std::string &api_path) const
+auto fuse_drive::get_directory_items(std::string_view api_path) const
     -> directory_item_list {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -479,7 +479,7 @@ auto fuse_drive::get_directory_items(const std::string &api_path) const
   return list;
 }
 
-auto fuse_drive::get_file_size(const std::string &api_path) const
+auto fuse_drive::get_file_size(std::string_view api_path) const
     -> std::uint64_t {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -493,18 +493,17 @@ auto fuse_drive::get_file_size(const std::string &api_path) const
   return file_size;
 }
 
-auto fuse_drive::get_item_meta(const std::string &api_path,
+auto fuse_drive::get_item_meta(std::string_view api_path,
                                api_meta_map &meta) const -> api_error {
   return provider_.get_item_meta(api_path, meta);
 }
 
-auto fuse_drive::get_item_meta(const std::string &api_path,
-                               const std::string &name,
+auto fuse_drive::get_item_meta(std::string_view api_path, std::string_view name,
                                std::string &value) const -> api_error {
   api_meta_map meta{};
   auto ret = get_item_meta(api_path, meta);
   if (ret == api_error::success) {
-    value = meta[name];
+    value = meta[std::string{name}];
   }
 
   return ret;
@@ -691,7 +690,7 @@ auto fuse_drive::ioctl_impl(std::string /* api_path */, int cmd, void *arg,
   return api_error::no_tty;
 }
 
-auto fuse_drive::is_processing(const std::string &api_path) const -> bool {
+auto fuse_drive::is_processing(std::string_view api_path) const -> bool {
   return fm_->is_processing(api_path);
 }
 
@@ -842,9 +841,9 @@ auto fuse_drive::readdir_impl(std::string api_path, void *buf,
     res =
         (iter->fill_buffer(
              static_cast<remote::file_offset>(offset++), fuse_fill_dir, buf,
-             [this](const std::string &cur_api_path,
-                    std::uint64_t cur_file_size, const api_meta_map &meta,
-                    bool directory, struct stat *u_stat) {
+             [this](std::string_view cur_api_path, std::uint64_t cur_file_size,
+                    const api_meta_map &meta, bool directory,
+                    struct stat *u_stat) {
                fuse_drive_base::populate_stat(cur_api_path, cur_file_size, meta,
                                               directory, provider_, u_stat);
              }) == 0)
@@ -877,15 +876,15 @@ auto fuse_drive::releasedir_impl(std::string /*api_path*/,
   return api_error::success;
 }
 
-auto fuse_drive::rename_directory(const std::string &from_api_path,
-                                  const std::string &to_api_path) -> int {
+auto fuse_drive::rename_directory(std::string_view from_api_path,
+                                  std::string_view to_api_path) -> int {
   auto res = fm_->rename_directory(from_api_path, to_api_path);
   errno = std::abs(utils::from_api_error(res));
   return (res == api_error::success) ? 0 : -1;
 }
 
-auto fuse_drive::rename_file(const std::string &from_api_path,
-                             const std::string &to_api_path, bool overwrite)
+auto fuse_drive::rename_file(std::string_view from_api_path,
+                             std::string_view to_api_path, bool overwrite)
     -> int {
   auto res = fm_->rename_file(from_api_path, to_api_path, overwrite);
   errno = std::abs(utils::from_api_error(res));
@@ -1145,9 +1144,8 @@ auto fuse_drive::setxattr_impl(std::string api_path, const char *name,
 }
 #endif // HAS_SETXATTR
 
-void fuse_drive::set_item_meta(const std::string &api_path,
-                               const std::string &key,
-                               const std::string &value) {
+void fuse_drive::set_item_meta(std::string_view api_path, std::string_view key,
+                               std::string_view value) {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto res = provider_.set_item_meta(api_path, key, value);
@@ -1158,7 +1156,7 @@ void fuse_drive::set_item_meta(const std::string &api_path,
   }
 }
 
-void fuse_drive::set_item_meta(const std::string &api_path,
+void fuse_drive::set_item_meta(std::string_view api_path,
                                const api_meta_map &meta) {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -1506,7 +1504,7 @@ auto fuse_drive::write_impl(std::string /*api_path*/
   return api_error::success;
 }
 
-void fuse_drive::update_accessed_time(const std::string &api_path) {
+void fuse_drive::update_accessed_time(std::string_view api_path) {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (atime_enabled_) {
diff --git a/repertory/librepertory/src/drives/fuse/fuse_drive_base.cpp b/repertory/librepertory/src/drives/fuse/fuse_drive_base.cpp
index 31407da0..951b58ef 100644
--- a/repertory/librepertory/src/drives/fuse/fuse_drive_base.cpp
+++ b/repertory/librepertory/src/drives/fuse/fuse_drive_base.cpp
@@ -35,7 +35,7 @@ auto fuse_drive_base::access_impl(std::string api_path, int mask) -> api_error {
   return check_access(api_path, mask);
 }
 
-auto fuse_drive_base::check_access(const std::string &api_path, int mask) const
+auto fuse_drive_base::check_access(std::string_view api_path, int mask) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -116,7 +116,7 @@ auto fuse_drive_base::check_access(const std::string &api_path, int mask) const
 }
 
 auto fuse_drive_base::check_and_perform(
-    const std::string &api_path, int parent_mask,
+    std::string_view api_path, int parent_mask,
     const std::function<api_error(api_meta_map &meta)> &action) -> api_error {
   api_meta_map meta;
   auto ret = get_item_meta(api_path, meta);
@@ -142,7 +142,7 @@ auto fuse_drive_base::check_open_flags(int flags, int mask,
   return (((flags & mask) == 0) ? api_error::success : fail_error);
 }
 
-auto fuse_drive_base::check_owner(const std::string &api_path) const
+auto fuse_drive_base::check_owner(std::string_view api_path) const
     -> api_error {
   api_meta_map meta{};
   auto ret = get_item_meta(api_path, meta);
@@ -167,7 +167,7 @@ auto fuse_drive_base::check_owner(const api_meta_map &meta) const -> api_error {
   return api_error::success;
 }
 
-auto fuse_drive_base::check_parent_access(const std::string &api_path,
+auto fuse_drive_base::check_parent_access(std::string_view api_path,
                                           int mask) const -> api_error {
   auto ret = api_error::success;
 
@@ -240,9 +240,9 @@ auto fuse_drive_base::get_mode_from_meta(const api_meta_map &meta) -> mode_t {
 }
 
 void fuse_drive_base::get_timespec_from_meta(const api_meta_map &meta,
-                                             const std::string &name,
+                                             std::string_view name,
                                              struct timespec &ts) {
-  auto meta_time = utils::string::to_uint64(meta.at(name));
+  auto meta_time = utils::string::to_uint64(meta.at(std::string{name}));
   ts.tv_nsec =
       static_cast<std::int64_t>(meta_time % utils::time::NANOS_PER_SECOND);
   ts.tv_sec =
@@ -257,12 +257,12 @@ auto fuse_drive_base::get_uid_from_meta(const api_meta_map &meta) -> uid_t {
 auto fuse_drive_base::parse_xattr_parameters(const char *name,
                                              const uint32_t &position,
                                              std::string &attribute_name,
-                                             const std::string &api_path)
+                                             std::string_view api_path)
     -> api_error {
 #else  // !defined(__APPLE__)
 auto fuse_drive_base::parse_xattr_parameters(const char *name,
                                              std::string &attribute_name,
-                                             const std::string &api_path)
+                                             std::string_view api_path)
     -> api_error {
 #endif // defined(__APPLE__)
   auto res = api_path.empty() ? api_error::bad_address : api_error::success;
@@ -293,13 +293,13 @@ auto fuse_drive_base::parse_xattr_parameters(const char *name,
 #if defined(__APPLE__)
 auto fuse_drive_base::parse_xattr_parameters(
     const char *name, const char *value, size_t size, const uint32_t &position,
-    std::string &attribute_name, const std::string &api_path) -> api_error {
+    std::string &attribute_name, std::string_view api_path) -> api_error {
   auto res = parse_xattr_parameters(name, position, attribute_name, api_path);
 #else  // !defined(__APPLE__)
 auto fuse_drive_base::parse_xattr_parameters(const char *name,
                                              const char *value, size_t size,
                                              std::string &attribute_name,
-                                             const std::string &api_path)
+                                             std::string_view api_path)
     -> api_error {
   auto res = parse_xattr_parameters(name, attribute_name, api_path);
 #endif // defined(__APPLE__)
@@ -312,7 +312,7 @@ auto fuse_drive_base::parse_xattr_parameters(const char *name,
               : api_error::success);
 }
 
-void fuse_drive_base::populate_stat(const std::string &api_path,
+void fuse_drive_base::populate_stat(std::string_view api_path,
                                     std::uint64_t size_or_count,
                                     const api_meta_map &meta, bool directory,
                                     i_provider &provider, struct stat *u_stat) {
@@ -356,9 +356,9 @@ void fuse_drive_base::populate_stat(const std::string &api_path,
 }
 
 void fuse_drive_base::set_timespec_from_meta(const api_meta_map &meta,
-                                             const std::string &name,
+                                             std::string_view name,
                                              struct timespec &ts) {
-  auto meta_time = utils::string::to_uint64(meta.at(name));
+  auto meta_time = utils::string::to_uint64(meta.at(std::string{name}));
   ts.tv_nsec =
       static_cast<std::int64_t>(meta_time % utils::time::NANOS_PER_SECOND);
   ts.tv_sec =
diff --git a/repertory/librepertory/src/drives/fuse/remotefuse/remote_client.cpp b/repertory/librepertory/src/drives/fuse/remotefuse/remote_client.cpp
index 11a0267e..7f4953e7 100644
--- a/repertory/librepertory/src/drives/fuse/remotefuse/remote_client.cpp
+++ b/repertory/librepertory/src/drives/fuse/remotefuse/remote_client.cpp
@@ -679,7 +679,7 @@ auto remote_client::fuse_utimens(const char *path, const remote::file_time *tv,
   return packet_client_.send(function_name, request, service_flags);
 }
 
-auto remote_client::json_create_directory_snapshot(const std::string &path,
+auto remote_client::json_create_directory_snapshot(std::string_view path,
                                                    json &json_data)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
@@ -698,7 +698,7 @@ auto remote_client::json_create_directory_snapshot(const std::string &path,
   return ret;
 }
 
-auto remote_client::json_read_directory_snapshot(const std::string &path,
+auto remote_client::json_read_directory_snapshot(std::string_view path,
                                                  remote::file_handle handle,
                                                  std::uint32_t page,
                                                  json &json_data)
@@ -721,7 +721,7 @@ auto remote_client::json_read_directory_snapshot(const std::string &path,
   return ret;
 }
 
-auto remote_client::json_release_directory_snapshot(const std::string &path,
+auto remote_client::json_release_directory_snapshot(std::string_view path,
                                                     remote::file_handle handle)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
diff --git a/repertory/librepertory/src/drives/fuse/remotefuse/remote_server.cpp b/repertory/librepertory/src/drives/fuse/remotefuse/remote_server.cpp
index cb3c47d3..6a08300e 100644
--- a/repertory/librepertory/src/drives/fuse/remotefuse/remote_server.cpp
+++ b/repertory/librepertory/src/drives/fuse/remotefuse/remote_server.cpp
@@ -48,19 +48,19 @@ namespace repertory::remote_fuse {
   event_system::instance().raise<remote_server_event>(file, ret, func)
 
 remote_server::remote_server(app_config &config, i_fuse_drive &drive,
-                             const std::string &mount_location)
+                             std::string_view mount_location)
     : remote_server_base(config, drive, mount_location) {}
 
-auto remote_server::construct_path(std::string path) -> std::string {
-  path = utils::path::combine(mount_location_, {path});
-  if (path == mount_location_) {
-    path += '/';
+auto remote_server::construct_path(std::string_view path) -> std::string {
+  auto ret = utils::path::combine(mount_location_, {path});
+  if (ret == mount_location_) {
+    ret += '/';
   }
 
-  return path;
+  return ret;
 }
 
-auto remote_server::construct_path(const std::wstring &path) -> std::string {
+auto remote_server::construct_path(std::wstring_view path) -> std::string {
   return construct_path(utils::string::to_utf8(path));
 }
 
@@ -79,7 +79,7 @@ auto remote_server::get_next_handle() -> std::uint64_t {
   return next_handle_;
 }
 
-auto remote_server::populate_file_info(const std::string &api_path,
+auto remote_server::populate_file_info(std::string_view api_path,
                                        remote::file_info &r_info)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
@@ -104,7 +104,7 @@ auto remote_server::populate_file_info(const std::string &api_path,
   return static_cast<packet::error_type>(STATUS_OBJECT_NAME_NOT_FOUND);
 }
 
-void remote_server::populate_file_info(const std::string &api_path,
+void remote_server::populate_file_info(std::string_view api_path,
                                        UINT64 file_size, UINT32 attributes,
                                        remote::file_info &r_info) {
   REPERTORY_USES_FUNCTION_NAME();
@@ -1239,7 +1239,7 @@ auto remote_server::winfsp_get_volume_info(UINT64 &total_size,
   return STATUS_SUCCESS;
 }
 
-auto remote_server::winfsp_mounted(const std::wstring &location)
+auto remote_server::winfsp_mounted(std::wstring_view location)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -1557,7 +1557,7 @@ auto remote_server::winfsp_set_file_size(PVOID file_desc, UINT64 new_size,
   return ret;
 }
 
-auto remote_server::winfsp_unmounted(const std::wstring &location)
+auto remote_server::winfsp_unmounted(std::wstring_view location)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -1620,7 +1620,7 @@ auto remote_server::winfsp_write(PVOID file_desc, PVOID buffer, UINT64 offset,
   return ret;
 }
 
-auto remote_server::json_create_directory_snapshot(const std::string &path,
+auto remote_server::json_create_directory_snapshot(std::string_view path,
                                                    json &json_data)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
@@ -1650,7 +1650,7 @@ auto remote_server::json_create_directory_snapshot(const std::string &path,
   return ret;
 }
 
-auto remote_server::json_read_directory_snapshot(const std::string &path,
+auto remote_server::json_read_directory_snapshot(std::string_view path,
                                                  remote::file_handle handle,
                                                  std::uint32_t page,
                                                  json &json_data)
@@ -1683,7 +1683,7 @@ auto remote_server::json_read_directory_snapshot(const std::string &path,
   return ret;
 }
 
-auto remote_server::json_release_directory_snapshot(const std::string &path,
+auto remote_server::json_release_directory_snapshot(std::string_view path,
                                                     remote::file_handle handle)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
@@ -1694,7 +1694,7 @@ auto remote_server::json_release_directory_snapshot(const std::string &path,
   return 0;
 }
 
-auto remote_server::update_to_windows_format(const std::string &root_api_path,
+auto remote_server::update_to_windows_format(std::string_view root_api_path,
                                              json &item) -> json & {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -1721,9 +1721,9 @@ auto remote_server::update_to_windows_format(const std::string &root_api_path,
   }
 
   auto update_meta{false};
-  const auto ensure_set = [&item, &update_meta](
-                              const std::string &name,
-                              const std::string &default_value, bool as_time) {
+  const auto ensure_set = [&item, &update_meta](std::string_view name,
+                                                std::string_view default_value,
+                                                bool as_time) {
     if (not item[JSON_META].contains(name) || item[JSON_META][name].empty() ||
         (as_time && (item[JSON_META][name].template get<std::string>() == "0" ||
                      item[JSON_META][name].template get<std::string>() ==
@@ -1737,8 +1737,10 @@ auto remote_server::update_to_windows_format(const std::string &root_api_path,
   ensure_set(META_ACCESSED, default_time, true);
   ensure_set(META_CREATION, default_time, true);
   ensure_set(META_MODIFIED, default_time, true);
-  ensure_set(META_CHANGED, item[JSON_META][META_MODIFIED], true);
-  ensure_set(META_WRITTEN, item[JSON_META][META_MODIFIED], true);
+  ensure_set(META_CHANGED, item[JSON_META][META_MODIFIED].get<std::string>(),
+             true);
+  ensure_set(META_WRITTEN, item[JSON_META][META_MODIFIED].get<std::string>(),
+             true);
   ensure_set(META_ATTRIBUTES, "0", false);
 
   auto attributes = utils::string::to_uint32(
diff --git a/repertory/librepertory/src/drives/remote/remote_open_file_table.cpp b/repertory/librepertory/src/drives/remote/remote_open_file_table.cpp
index 9dd5ef94..be628d01 100644
--- a/repertory/librepertory/src/drives/remote/remote_open_file_table.cpp
+++ b/repertory/librepertory/src/drives/remote/remote_open_file_table.cpp
@@ -27,16 +27,17 @@
 #include "utils/utils.hpp"
 
 namespace repertory {
-void remote_open_file_table::add_directory(const std::string &client_id,
+void remote_open_file_table::add_directory(std::string_view client_id,
                                            std::uint64_t handle) {
+  auto str_id = std::string{client_id};
   recur_mutex_lock lock(file_mutex_);
-  auto &list = directory_lookup_[client_id];
+  auto &list = directory_lookup_[str_id];
   if (utils::collection::excludes(list, handle)) {
-    directory_lookup_[client_id].emplace_back(handle);
+    directory_lookup_[str_id].emplace_back(handle);
   }
 }
 
-void remote_open_file_table::close_all(const std::string &client_id) {
+void remote_open_file_table::close_all(std::string_view client_id) {
   unique_recur_mutex_lock lock(file_mutex_);
   auto compat_handles =
       std::accumulate(compat_file_lookup_.begin(), compat_file_lookup_.end(),
@@ -110,13 +111,13 @@ auto remote_open_file_table::get_directory_buffer(const native_handle &handle,
 #endif // defined(_WIN32)
 
 auto remote_open_file_table::get_open_file_count(
-    const std::string &file_path) const -> std::size_t {
+    std::string_view file_path) const -> std::size_t {
   recur_mutex_lock lock(file_mutex_);
-  return (file_lookup_.contains(file_path)
-              ? file_lookup_.at(file_path)->handles.size()
+  return (file_lookup_.contains(std::string{file_path})
+              ? file_lookup_.at(std::string{file_path})->handles.size()
               : 0ULL) +
-         (compat_file_lookup_.contains(file_path)
-              ? compat_file_lookup_.at(file_path)->handles.size()
+         (compat_file_lookup_.contains(std::string{file_path})
+              ? compat_file_lookup_.at(std::string{file_path})->handles.size()
               : 0ULL);
 }
 
@@ -141,14 +142,15 @@ auto remote_open_file_table::get_open_file_path(const native_handle &handle)
   return file_lookup_.at(handle_lookup_.at(handle))->path;
 }
 
-auto remote_open_file_table::has_open_directory(const std::string &client_id,
+auto remote_open_file_table::has_open_directory(std::string_view client_id,
                                                 std::uint64_t handle) -> bool {
   recur_mutex_lock lock(file_mutex_);
-  return (utils::collection::includes(directory_lookup_[client_id], handle));
+  return (utils::collection::includes(directory_lookup_[std::string{client_id}],
+                                      handle));
 }
 
-auto remote_open_file_table::has_compat_open_info(
-    remote::file_handle handle, int error_return) -> int {
+auto remote_open_file_table::has_compat_open_info(remote::file_handle handle,
+                                                  int error_return) -> int {
   recur_mutex_lock compat_lock(file_mutex_);
   auto res = compat_handle_lookup_.contains(handle) ? 0 : -1;
   if (res == -1) {
@@ -158,7 +160,7 @@ auto remote_open_file_table::has_compat_open_info(
   return res;
 }
 
-void remote_open_file_table::remove_all(const std::string &file_path) {
+void remote_open_file_table::remove_all(std::string_view file_path) {
   unique_recur_mutex_lock lock(file_mutex_);
   auto compat_open_list =
       std::accumulate(compat_file_lookup_.begin(), compat_file_lookup_.end(),
@@ -213,14 +215,15 @@ void remote_open_file_table::remove_compat_open_info(
   compat_file_lookup_.erase(path);
 }
 
-auto remote_open_file_table::remove_directory(const std::string &client_id,
+auto remote_open_file_table::remove_directory(std::string_view client_id,
                                               std::uint64_t handle) -> bool {
+  auto str_id = std::string{client_id};
   recur_mutex_lock lock(file_mutex_);
-  auto &list = directory_lookup_[client_id];
+  auto &list = directory_lookup_[str_id];
   if (utils::collection::includes(list, handle)) {
     utils::collection::remove_element(list, handle);
-    if (directory_lookup_[client_id].empty()) {
-      directory_lookup_.erase(client_id);
+    if (directory_lookup_[str_id].empty()) {
+      directory_lookup_.erase(str_id);
     }
     return true;
   }
@@ -272,37 +275,37 @@ void remote_open_file_table::remove_and_close_all(const native_handle &handle) {
   }
 }
 
-void remote_open_file_table::set_compat_client_id(
-    remote::file_handle handle, const std::string &client_id) {
+void remote_open_file_table::set_compat_client_id(remote::file_handle handle,
+                                                  std::string_view client_id) {
   recur_mutex_lock compat_lock(file_mutex_);
   compat_file_lookup_.at(compat_handle_lookup_.at(handle))->client_id =
       client_id;
 }
 
 void remote_open_file_table::set_client_id(const native_handle &handle,
-                                           const std::string &client_id) {
+                                           std::string_view client_id) {
   recur_mutex_lock lock(file_mutex_);
   file_lookup_.at(handle_lookup_.at(handle))->client_id = client_id;
 }
 
-void remote_open_file_table::set_compat_open_info(
-    remote::file_handle handle, const std::string &file_path) {
+void remote_open_file_table::set_compat_open_info(remote::file_handle handle,
+                                                  std::string_view file_path) {
   recur_mutex_lock compat_lock(file_mutex_);
   if (compat_handle_lookup_.contains(handle)) {
     return;
   }
 
-  if (not compat_file_lookup_.contains(file_path)) {
-    compat_file_lookup_[file_path] =
+  if (not compat_file_lookup_.contains(std::string{file_path})) {
+    compat_file_lookup_[std::string{file_path}] =
         std::make_unique<compat_open_info>(compat_open_info{
             "",
             {},
-            file_path,
+            std::string{file_path},
         });
   }
 
-  compat_handle_lookup_[handle] = file_path;
-  compat_file_lookup_.at(file_path)->handles.emplace_back(handle);
+  compat_handle_lookup_[handle] = std::string{file_path};
+  compat_file_lookup_.at(std::string{file_path})->handles.emplace_back(handle);
 }
 
 void remote_open_file_table::set_open_info(const native_handle &handle,
diff --git a/repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_client.cpp b/repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_client.cpp
index f9051899..be2de608 100644
--- a/repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_client.cpp
+++ b/repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_client.cpp
@@ -53,7 +53,7 @@ auto remote_client::winfsp_can_delete(PVOID file_desc, PWSTR file_name)
   return packet_client_.send(function_name, request, service_flags);
 }
 
-auto remote_client::json_create_directory_snapshot(const std::string &path,
+auto remote_client::json_create_directory_snapshot(std::string_view path,
                                                    json &json_data)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
@@ -73,9 +73,11 @@ auto remote_client::json_create_directory_snapshot(const std::string &path,
   return ret;
 }
 
-auto remote_client::json_read_directory_snapshot(
-    const std::string &path, remote::file_handle handle,
-    std::uint32_t page, json &json_data) -> packet::error_type {
+auto remote_client::json_read_directory_snapshot(std::string_view path,
+                                                 remote::file_handle handle,
+                                                 std::uint32_t page,
+                                                 json &json_data)
+    -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
   packet request;
@@ -95,8 +97,8 @@ auto remote_client::json_read_directory_snapshot(
   return ret;
 }
 
-auto remote_client::json_release_directory_snapshot(
-    const std::string &path, remote::file_handle handle)
+auto remote_client::json_release_directory_snapshot(std::string_view path,
+                                                    remote::file_handle handle)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -309,7 +311,7 @@ auto remote_client::winfsp_get_volume_info(UINT64 &total_size,
   return ret;
 }
 
-auto remote_client::winfsp_mounted(const std::wstring &location)
+auto remote_client::winfsp_mounted(std::wstring_view location)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -499,7 +501,7 @@ auto remote_client::winfsp_set_file_size(PVOID file_desc, UINT64 new_size,
   return ret;
 }
 
-auto remote_client::winfsp_unmounted(const std::wstring &location)
+auto remote_client::winfsp_unmounted(std::wstring_view location)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
diff --git a/repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_server.cpp b/repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_server.cpp
index 9cf5296e..29feff79 100644
--- a/repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_server.cpp
+++ b/repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_server.cpp
@@ -69,7 +69,7 @@ auto remote_server::construct_path(std::string path) -> std::string {
   return path;
 }
 
-auto remote_server::populate_file_info(const std::string &api_path,
+auto remote_server::populate_file_info(std::string_view api_path,
                                        remote::file_info &r_info)
     -> packet::error_type {
   return (drive_.populate_file_info(api_path, r_info) == api_error::success)
@@ -827,7 +827,7 @@ auto remote_server::fuse_utimens(const char *path, const remote::file_time *tv,
 }
 
 // JSON Layer
-auto remote_server::json_create_directory_snapshot(const std::string &path,
+auto remote_server::json_create_directory_snapshot(std::string_view path,
                                                    json &json_data)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
@@ -856,7 +856,7 @@ auto remote_server::json_create_directory_snapshot(const std::string &path,
   return ret;
 }
 
-auto remote_server::json_read_directory_snapshot(const std::string &path,
+auto remote_server::json_read_directory_snapshot(std::string_view path,
                                                  remote::file_handle handle,
                                                  std::uint32_t page,
                                                  json &json_data)
@@ -890,7 +890,7 @@ auto remote_server::json_read_directory_snapshot(const std::string &path,
 }
 
 auto remote_server::json_release_directory_snapshot(
-    const std::string &path, remote::file_handle /*handle*/)
+    std::string_view path, remote::file_handle /*handle*/)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -1098,7 +1098,7 @@ auto remote_server::winfsp_get_volume_info(UINT64 &total_size,
   return STATUS_SUCCESS;
 }
 
-auto remote_server::winfsp_mounted(const std::wstring &location)
+auto remote_server::winfsp_mounted(std::wstring_view location)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -1342,7 +1342,7 @@ auto remote_server::winfsp_set_file_size(PVOID file_desc, UINT64 new_size,
   return ret;
 }
 
-auto remote_server::winfsp_unmounted(const std::wstring &location)
+auto remote_server::winfsp_unmounted(std::wstring_view location)
     -> packet::error_type {
   REPERTORY_USES_FUNCTION_NAME();
 
diff --git a/repertory/librepertory/src/drives/winfsp/winfsp_drive.cpp b/repertory/librepertory/src/drives/winfsp/winfsp_drive.cpp
index 96cfefcd..a43fe238 100644
--- a/repertory/librepertory/src/drives/winfsp/winfsp_drive.cpp
+++ b/repertory/librepertory/src/drives/winfsp/winfsp_drive.cpp
@@ -69,7 +69,7 @@ winfsp_drive::winfsp_service::winfsp_service(
       lock_(lock) {}
 
 auto winfsp_drive::handle_error(std::string_view function_name,
-                                const std::string &api_path, api_error error,
+                                std::string_view api_path, api_error error,
                                 FileInfo *file_info, std::uint64_t file_size,
                                 bool raise_on_failure_only) const -> NTSTATUS {
   auto ret = utils::from_api_error(error);
@@ -395,12 +395,12 @@ auto winfsp_drive::Flush(PVOID /*file_node*/, PVOID file_desc,
   }));
 }
 
-auto winfsp_drive::get_directory_item_count(const std::string &api_path) const
+auto winfsp_drive::get_directory_item_count(std::string_view api_path) const
     -> std::uint64_t {
   return provider_.get_directory_item_count(api_path);
 }
 
-auto winfsp_drive::get_directory_items(const std::string &api_path) const
+auto winfsp_drive::get_directory_items(std::string_view api_path) const
     -> directory_item_list {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -435,7 +435,7 @@ auto winfsp_drive::GetFileInfo(PVOID /*file_node*/, PVOID file_desc,
   return handle_error(api_error::success);
 }
 
-auto winfsp_drive::get_file_size(const std::string &api_path) const
+auto winfsp_drive::get_file_size(std::string_view api_path) const
     -> std::uint64_t {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -449,13 +449,13 @@ auto winfsp_drive::get_file_size(const std::string &api_path) const
   return file_size;
 }
 
-auto winfsp_drive::get_item_meta(const std::string &api_path,
+auto winfsp_drive::get_item_meta(std::string_view api_path,
                                  api_meta_map &meta) const -> api_error {
   return provider_.get_item_meta(api_path, meta);
 }
 
-auto winfsp_drive::get_item_meta(const std::string &api_path,
-                                 const std::string &name,
+auto winfsp_drive::get_item_meta(std::string_view api_path,
+                                 std::string_view name,
                                  std::string &value) const -> api_error {
   api_meta_map meta{};
   auto ret = provider_.get_item_meta(api_path, meta);
@@ -784,14 +784,14 @@ auto winfsp_drive::Overwrite(PVOID /*file_node*/, PVOID file_desc,
   return handle_error(api_error::success);
 }
 
-auto winfsp_drive::parse_mount_location(const std::wstring &mount_location)
+auto winfsp_drive::parse_mount_location(std::wstring_view mount_location)
     -> std::string {
   return utils::string::to_utf8((mount_location.substr(0, 4) == L"\\\\.\\")
                                     ? mount_location.substr(4)
                                     : mount_location);
 }
 
-void winfsp_drive::populate_file_info(const std::string &api_path,
+void winfsp_drive::populate_file_info(std::string_view api_path,
                                       std::uint64_t file_size,
                                       const api_meta_map &meta,
                                       FSP_FSCTL_OPEN_FILE_INFO &ofi) const {
@@ -805,7 +805,7 @@ void winfsp_drive::populate_file_info(const std::string &api_path,
   populate_file_info(file_size, meta, ofi.FileInfo);
 }
 
-auto winfsp_drive::populate_file_info(const std::string &api_path,
+auto winfsp_drive::populate_file_info(std::string_view api_path,
                                       remote::file_info &file_info) const
     -> api_error {
   api_meta_map meta{};
diff --git a/repertory/librepertory/src/file_manager/file_manager.cpp b/repertory/librepertory/src/file_manager/file_manager.cpp
index 93b25505..c46326a9 100644
--- a/repertory/librepertory/src/file_manager/file_manager.cpp
+++ b/repertory/librepertory/src/file_manager/file_manager.cpp
@@ -143,7 +143,7 @@ void file_manager::close_timed_out_files() {
   closeable_list.clear();
 }
 
-auto file_manager::create(const std::string &api_path, api_meta_map &meta,
+auto file_manager::create(std::string_view api_path, api_meta_map &meta,
                           open_file_data ofd, std::uint64_t &handle,
                           std::shared_ptr<i_open_file> &file) -> api_error {
   recur_mutex_lock file_lock(open_file_mtx_);
@@ -161,7 +161,7 @@ auto file_manager::create(const std::string &api_path, api_meta_map &meta,
   return open(api_path, false, ofd, handle, file);
 }
 
-auto file_manager::download_pinned_file(const std::string &api_path) -> bool {
+auto file_manager::download_pinned_file(std::string_view api_path) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   recur_mutex_lock file_lock(open_file_mtx_);
@@ -221,7 +221,7 @@ auto file_manager::download_pinned_file(const std::string &api_path) -> bool {
   return false;
 }
 
-auto file_manager::evict_file(const std::string &api_path) -> bool {
+auto file_manager::evict_file(std::string_view api_path) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (provider_.is_read_only()) {
@@ -260,11 +260,11 @@ auto file_manager::evict_file(const std::string &api_path) -> bool {
   }
 
   std::shared_ptr<i_closeable_open_file> closeable_file;
-  if (open_file_lookup_.contains(api_path)) {
-    closeable_file = open_file_lookup_.at(api_path);
+  if (open_file_lookup_.contains(std::string{api_path})) {
+    closeable_file = open_file_lookup_.at(std::string{api_path});
   }
 
-  open_file_lookup_.erase(api_path);
+  open_file_lookup_.erase(std::string{api_path});
   open_lock.unlock();
 
   auto allocated = closeable_file ? closeable_file->get_allocated() : true;
@@ -280,7 +280,7 @@ auto file_manager::evict_file(const std::string &api_path) -> bool {
   return removed;
 }
 
-auto file_manager::get_directory_items(const std::string &api_path) const
+auto file_manager::get_directory_items(std::string_view api_path) const
     -> directory_item_list {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -293,7 +293,7 @@ auto file_manager::get_directory_items(const std::string &api_path) const
   return list;
 }
 
-auto file_manager::get_directory_item(const std::string &api_path,
+auto file_manager::get_directory_item(std::string_view api_path,
                                       directory_item &item) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -333,19 +333,19 @@ auto file_manager::get_open_file_by_handle(std::uint64_t handle,
   return (file_iter == open_file_lookup_.end()) ? nullptr : file_iter->second;
 }
 
-auto file_manager::get_open_file_count(const std::string &api_path) const
+auto file_manager::get_open_file_count(std::string_view api_path) const
     -> std::size_t {
-  auto file_iter = open_file_lookup_.find(api_path);
+  auto file_iter = open_file_lookup_.find(std::string{api_path});
   return (file_iter == open_file_lookup_.end())
              ? 0U
              : file_iter->second->get_open_file_count();
 }
 
-auto file_manager::get_open_file(const std::string &api_path,
+auto file_manager::get_open_file(std::string_view api_path,
                                  std::shared_ptr<i_open_file> &file) -> bool {
   unique_recur_mutex_lock open_lock(open_file_mtx_);
-  if (open_file_lookup_.contains(api_path)) {
-    file = open_file_lookup_.at(api_path);
+  if (open_file_lookup_.contains(std::string{api_path})) {
+    file = open_file_lookup_.at(std::string{api_path});
     return true;
   }
 
@@ -432,19 +432,20 @@ auto file_manager::get_stored_downloads() const
   return mgr_db_->get_resume_list();
 }
 
-auto file_manager::handle_file_rename(const std::string &from_api_path,
-                                      const std::string &to_api_path)
+auto file_manager::handle_file_rename(std::string_view from_api_path,
+                                      std::string_view to_api_path)
     -> api_error {
   std::string source_path{};
-  auto file_iter = open_file_lookup_.find(from_api_path);
+  auto file_iter = open_file_lookup_.find(std::string{from_api_path});
   if (file_iter != open_file_lookup_.end()) {
     source_path = file_iter->second->get_source_path();
   }
 
-  auto should_upload{upload_lookup_.contains(from_api_path)};
+  auto should_upload{upload_lookup_.contains(std::string{from_api_path})};
   if (should_upload) {
     if (source_path.empty()) {
-      source_path = upload_lookup_.at(from_api_path)->get_source_path();
+      source_path =
+          upload_lookup_.at(std::string{from_api_path})->get_source_path();
     }
   } else {
     auto upload = mgr_db_->get_upload(from_api_path);
@@ -479,13 +480,13 @@ auto file_manager::has_no_open_file_handles() const -> bool {
   return get_open_handle_count() == 0U;
 }
 
-auto file_manager::is_processing(const std::string &api_path) const -> bool {
+auto file_manager::is_processing(std::string_view api_path) const -> bool {
   if (provider_.is_read_only()) {
     return false;
   }
 
   unique_mutex_lock upload_lock(upload_mtx_);
-  if (upload_lookup_.contains(api_path)) {
+  if (upload_lookup_.contains(std::string{api_path})) {
     return true;
   }
   upload_lock.unlock();
@@ -496,7 +497,7 @@ auto file_manager::is_processing(const std::string &api_path) const -> bool {
   };
 
   unique_recur_mutex_lock open_lock(open_file_mtx_);
-  auto file_iter = open_file_lookup_.find(api_path);
+  auto file_iter = open_file_lookup_.find(std::string{api_path});
   if (file_iter == open_file_lookup_.end()) {
     return false;
   }
@@ -510,14 +511,14 @@ auto file_manager::is_processing(const std::string &api_path) const -> bool {
              : false;
 }
 
-auto file_manager::open(const std::string &api_path, bool directory,
+auto file_manager::open(std::string_view api_path, bool directory,
                         const open_file_data &ofd, std::uint64_t &handle,
                         std::shared_ptr<i_open_file> &file) -> api_error {
   recur_mutex_lock open_lock(open_file_mtx_);
   return open(api_path, directory, ofd, handle, file, nullptr);
 }
 
-auto file_manager::open(const std::string &api_path, bool directory,
+auto file_manager::open(std::string_view api_path, bool directory,
                         const open_file_data &ofd, std::uint64_t &handle,
                         std::shared_ptr<i_open_file> &file,
                         std::shared_ptr<i_closeable_open_file> closeable_file)
@@ -531,7 +532,7 @@ auto file_manager::open(const std::string &api_path, bool directory,
         file = cur_file;
       };
 
-  auto file_iter = open_file_lookup_.find(api_path);
+  auto file_iter = open_file_lookup_.find(std::string{api_path});
   if (file_iter != open_file_lookup_.end()) {
     create_and_add_handle(file_iter->second);
     return api_error::success;
@@ -650,7 +651,7 @@ auto file_manager::open(const std::string &api_path, bool directory,
     }
   }
 
-  open_file_lookup_[api_path] = closeable_file;
+  open_file_lookup_[std::string{api_path}] = closeable_file;
   create_and_add_handle(closeable_file);
   return api_error::success;
 }
@@ -660,9 +661,9 @@ void file_manager::queue_upload(const i_open_file &file) {
                false);
 }
 
-void file_manager::queue_upload(const std::string &api_path,
-                                const std::string &source_path,
-                                bool is_unlinked, bool no_lock) {
+void file_manager::queue_upload(std::string_view api_path,
+                                std::string_view source_path, bool is_unlinked,
+                                bool no_lock) {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (provider_.is_read_only() || is_unlinked) {
@@ -677,8 +678,8 @@ void file_manager::queue_upload(const std::string &api_path,
   remove_upload(api_path, true);
 
   if (mgr_db_->add_upload(i_file_mgr_db::upload_entry{
-          api_path,
-          source_path,
+          std::string{api_path},
+          std::string{source_path},
       })) {
     remove_resume(api_path, source_path, true);
     event_system::instance().raise<file_upload_queued>(api_path, function_name,
@@ -693,7 +694,7 @@ void file_manager::queue_upload(const std::string &api_path,
   }
 }
 
-auto file_manager::remove_directory(const std::string &api_path) -> api_error {
+auto file_manager::remove_directory(std::string_view api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (api_path == "/") {
@@ -710,13 +711,13 @@ auto file_manager::remove_directory(const std::string &api_path) -> api_error {
     return res;
   }
 
-  auto file_iter = open_file_lookup_.find(api_path);
+  auto file_iter = open_file_lookup_.find(std::string{api_path});
   if (file_iter == open_file_lookup_.end()) {
     return api_error::success;
   }
 
   auto closed_file = file_iter->second;
-  open_file_lookup_.erase(api_path);
+  open_file_lookup_.erase(std::string{api_path});
 
   closed_file->set_unlinked(true);
   for (const auto &[handle, ofd] : closed_file->get_open_data()) {
@@ -727,7 +728,7 @@ auto file_manager::remove_directory(const std::string &api_path) -> api_error {
   return api_error::success;
 }
 
-auto file_manager::remove_file(const std::string &api_path) -> api_error {
+auto file_manager::remove_file(std::string_view api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   unique_recur_mutex_lock open_lock(open_file_mtx_);
@@ -755,14 +756,14 @@ auto file_manager::remove_file(const std::string &api_path) -> api_error {
     return res;
   }
 
-  auto file_iter = open_file_lookup_.find(api_path);
+  auto file_iter = open_file_lookup_.find(std::string{api_path});
   if (file_iter == open_file_lookup_.end()) {
     remove_source_and_shrink_cache(api_path, fsi.source_path, fsi.size, true);
     return api_error::success;
   }
 
   auto closed_file = file_iter->second;
-  open_file_lookup_.erase(api_path);
+  open_file_lookup_.erase(std::string{api_path});
 
   auto allocated = closed_file->get_allocated();
   closed_file->set_unlinked(true);
@@ -786,13 +787,13 @@ auto file_manager::remove_file(const std::string &api_path) -> api_error {
   return api_error::success;
 }
 
-void file_manager::remove_resume(const std::string &api_path,
-                                 const std::string &source_path) {
+void file_manager::remove_resume(std::string_view api_path,
+                                 std::string_view source_path) {
   remove_resume(api_path, source_path, false);
 }
 
-void file_manager::remove_resume(const std::string &api_path,
-                                 const std::string &source_path, bool no_lock) {
+void file_manager::remove_resume(std::string_view api_path,
+                                 std::string_view source_path, bool no_lock) {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (provider_.is_read_only()) {
@@ -814,9 +815,10 @@ void file_manager::remove_resume(const std::string &api_path,
   }
 }
 
-auto file_manager::remove_source_and_shrink_cache(
-    const std::string &api_path, const std::string &source_path,
-    std::uint64_t file_size, bool allocated) -> bool {
+auto file_manager::remove_source_and_shrink_cache(std::string_view api_path,
+                                                  std::string_view source_path,
+                                                  std::uint64_t file_size,
+                                                  bool allocated) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto file = utils::file::file{source_path};
@@ -848,11 +850,11 @@ auto file_manager::remove_source_and_shrink_cache(
   return true;
 }
 
-void file_manager::remove_upload(const std::string &api_path) {
+void file_manager::remove_upload(std::string_view api_path) {
   remove_upload(api_path, false);
 }
 
-void file_manager::remove_upload(const std::string &api_path, bool no_lock) {
+void file_manager::remove_upload(std::string_view api_path, bool no_lock) {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (provider_.is_read_only()) {
@@ -876,9 +878,9 @@ void file_manager::remove_upload(const std::string &api_path, bool no_lock) {
                                        "failed to remove active upload");
   }
 
-  if (upload_lookup_.contains(api_path)) {
-    upload_lookup_.at(api_path)->cancel();
-    upload_lookup_.erase(api_path);
+  if (upload_lookup_.contains(std::string{api_path})) {
+    upload_lookup_.at(std::string{api_path})->cancel();
+    upload_lookup_.erase(std::string{api_path});
   }
 
   if (removed) {
@@ -891,9 +893,8 @@ void file_manager::remove_upload(const std::string &api_path, bool no_lock) {
   }
 }
 
-auto file_manager::rename_directory(const std::string &from_api_path,
-                                    const std::string &to_api_path)
-    -> api_error {
+auto file_manager::rename_directory(std::string_view from_api_path,
+                                    std::string_view to_api_path) -> api_error {
   if (not provider_.is_rename_supported()) {
     return api_error::not_implemented;
   }
@@ -967,8 +968,8 @@ auto file_manager::rename_directory(const std::string &from_api_path,
   return api_error::success;
 }
 
-auto file_manager::rename_file(const std::string &from_api_path,
-                               const std::string &to_api_path, bool overwrite)
+auto file_manager::rename_file(std::string_view from_api_path,
+                               std::string_view to_api_path, bool overwrite)
     -> api_error {
   if (not provider_.is_rename_supported()) {
     return api_error::not_implemented;
@@ -1208,16 +1209,18 @@ void file_manager::store_resume(const i_open_file &file) {
       function_name);
 }
 
-void file_manager::swap_renamed_items(std::string from_api_path,
-                                      std::string to_api_path, bool directory) {
+void file_manager::swap_renamed_items(std::string_view from_api_path,
+                                      std::string_view to_api_path,
+                                      bool directory) {
   REPERTORY_USES_FUNCTION_NAME();
 
-  auto file_iter = open_file_lookup_.find(from_api_path);
+  auto file_iter = open_file_lookup_.find(std::string{from_api_path});
   if (file_iter != open_file_lookup_.end()) {
-    auto closeable_file = std::move(open_file_lookup_[from_api_path]);
-    open_file_lookup_.erase(from_api_path);
+    auto closeable_file =
+        std::move(open_file_lookup_[std::string{from_api_path}]);
+    open_file_lookup_.erase(std::string{from_api_path});
     closeable_file->set_api_path(to_api_path);
-    open_file_lookup_[to_api_path] = std::move(closeable_file);
+    open_file_lookup_[std::string{to_api_path}] = std::move(closeable_file);
   }
 
   if (directory) {
diff --git a/repertory/librepertory/src/file_manager/open_file_base.cpp b/repertory/librepertory/src/file_manager/open_file_base.cpp
index 7aa90fd2..d24e655a 100644
--- a/repertory/librepertory/src/file_manager/open_file_base.cpp
+++ b/repertory/librepertory/src/file_manager/open_file_base.cpp
@@ -398,7 +398,7 @@ auto open_file_base::set_api_error(api_error err) -> api_error {
                          : error_)));
 }
 
-void open_file_base::set_api_path(const std::string &api_path) {
+void open_file_base::set_api_path(std::string_view api_path) {
   recur_mutex_lock file_lock(file_mtx_);
   fsi_.api_path = api_path;
   fsi_.api_parent = utils::path::get_parent_api_path(api_path);
diff --git a/repertory/librepertory/src/file_manager/ring_buffer_base.cpp b/repertory/librepertory/src/file_manager/ring_buffer_base.cpp
index 491dbd9e..fe7b4d1c 100644
--- a/repertory/librepertory/src/file_manager/ring_buffer_base.cpp
+++ b/repertory/librepertory/src/file_manager/ring_buffer_base.cpp
@@ -343,7 +343,7 @@ void ring_buffer_base::set(std::size_t first_chunk, std::size_t current_chunk) {
   chunk_notify_.notify_all();
 }
 
-void ring_buffer_base::set_api_path(const std::string &api_path) {
+void ring_buffer_base::set_api_path(std::string_view api_path) {
   mutex_lock chunk_lock(chunk_mtx_);
   open_file_base::set_api_path(api_path);
   chunk_notify_.notify_all();
diff --git a/repertory/librepertory/src/platform/unix_platform.cpp b/repertory/librepertory/src/platform/unix_platform.cpp
index 7bf823b6..7ebc81bc 100644
--- a/repertory/librepertory/src/platform/unix_platform.cpp
+++ b/repertory/librepertory/src/platform/unix_platform.cpp
@@ -37,14 +37,13 @@
 #include "utils/unix.hpp"
 
 namespace repertory {
-lock_data::lock_data(std::string data_directory, provider_type prov,
+lock_data::lock_data(std::string_view data_directory, provider_type prov,
                      std::string_view unique_id)
-    : data_directory_(data_directory.empty()
-                          ? app_config::default_data_directory(prov)
-                          : utils::path::absolute(data_directory)),
+    : data_directory_(utils::path::absolute(data_directory)),
       mutex_id_(create_lock_id(prov, unique_id)) {
   handle_ =
       ::open(get_lock_file().c_str(), O_CREAT | O_RDWR, S_IWUSR | S_IRUSR);
+  fmt::println("{}", data_directory_);
 }
 
 lock_data::~lock_data() { release(); }
@@ -211,10 +210,10 @@ auto create_meta_attributes(std::uint64_t accessed_date,
                             std::uint32_t attributes,
                             std::uint64_t changed_date,
                             std::uint64_t creation_date, bool directory,
-                            std::uint32_t gid, const std::string &key,
+                            std::uint32_t gid, std::string_view key,
                             std::uint32_t mode, std::uint64_t modified_date,
                             std::uint32_t osx_flags, std::uint64_t size,
-                            const std::string &source_path, std::uint32_t uid,
+                            std::string_view source_path, std::uint32_t uid,
                             std::uint64_t written_date) -> api_meta_map {
   api_meta_map meta{
       {META_ACCESSED, std::to_string(accessed_date)},
@@ -223,12 +222,12 @@ auto create_meta_attributes(std::uint64_t accessed_date,
       {META_CREATION, std::to_string(creation_date)},
       {META_DIRECTORY, utils::string::from_bool(directory)},
       {META_GID, std::to_string(gid)},
-      {META_KEY, key},
+      {META_KEY, std::string{key}},
       {META_MODE, std::to_string(mode)},
       {META_MODIFIED, std::to_string(modified_date)},
       {META_OSXFLAGS, std::to_string(osx_flags)},
       {META_PINNED, utils::string::from_bool(false)},
-      {META_SOURCE, source_path},
+      {META_SOURCE, std::string{source_path}},
       {META_SIZE, std::to_string(size)},
       {META_UID, std::to_string(uid)},
       {META_WRITTEN, std::to_string(written_date)},
diff --git a/repertory/librepertory/src/platform/win32_platform.cpp b/repertory/librepertory/src/platform/win32_platform.cpp
index 047d7c87..e1b2cd5c 100644
--- a/repertory/librepertory/src/platform/win32_platform.cpp
+++ b/repertory/librepertory/src/platform/win32_platform.cpp
@@ -44,11 +44,9 @@ namespace {
 namespace repertory {
 lock_data::lock_data(std::string_view data_directory, provider_type prov,
                      std::string unique_id)
-    : dir_id_(utils::collection::to_hex_string(
-          utils::hash::create_hash_blake2b_64(utils::string::to_lower(
-              data_directory.empty()
-                  ? app_config::default_data_directory(prov)
-                  : utils::path::absolute(data_directory))))),
+    : dir_id_(
+          utils::collection::to_hex_string(utils::hash::create_hash_blake2b_64(
+              utils::string::to_lower(utils::path::absolute(data_directory))))),
       mutex_id_(create_lock_id(prov, unique_id)),
       mutex_handle_(::CreateMutex(nullptr, FALSE,
                                   create_lock_id(prov, unique_id).c_str())) {}
@@ -205,10 +203,10 @@ auto create_meta_attributes(std::uint64_t accessed_date,
                             std::uint32_t attributes,
                             std::uint64_t changed_date,
                             std::uint64_t creation_date, bool directory,
-                            std::uint32_t gid, const std::string &key,
+                            std::uint32_t gid, std::string_view key,
                             std::uint32_t mode, std::uint64_t modified_date,
                             std::uint32_t osx_flags, std::uint64_t size,
-                            const std::string &source_path, std::uint32_t uid,
+                            std::string_view source_path, std::uint32_t uid,
                             std::uint64_t written_date) -> api_meta_map {
   api_meta_map meta{
       {META_ACCESSED, std::to_string(accessed_date)},
@@ -217,13 +215,13 @@ auto create_meta_attributes(std::uint64_t accessed_date,
       {META_CREATION, std::to_string(creation_date)},
       {META_DIRECTORY, utils::string::from_bool(directory)},
       {META_GID, std::to_string(gid)},
-      {META_KEY, key},
+      {META_KEY, std::string{key}},
       {META_MODE, std::to_string(mode)},
       {META_MODIFIED, std::to_string(modified_date)},
       {META_OSXFLAGS, std::to_string(osx_flags)},
       {META_PINNED, utils::string::from_bool(false)},
       {META_SIZE, std::to_string(size)},
-      {META_SOURCE, source_path},
+      {META_SOURCE, std::string{source_path}},
       {META_UID, std::to_string(uid)},
       {META_WRITTEN, std::to_string(written_date)},
   };
diff --git a/repertory/librepertory/src/providers/base_provider.cpp b/repertory/librepertory/src/providers/base_provider.cpp
index 68dd6dab..2bc01bff 100644
--- a/repertory/librepertory/src/providers/base_provider.cpp
+++ b/repertory/librepertory/src/providers/base_provider.cpp
@@ -69,7 +69,7 @@ void base_provider::add_all_items(stop_type &stop_requested) {
   }
 }
 
-auto base_provider::create_api_file(std::string path, std::string key,
+auto base_provider::create_api_file(std::string_view path, std::string_view key,
                                     std::uint64_t size, std::uint64_t file_time)
     -> api_file {
   auto api_path = utils::path::create_api_path(path);
@@ -80,7 +80,7 @@ auto base_provider::create_api_file(std::string path, std::string key,
       .changed_date = file_time,
       .creation_date = file_time,
       .file_size = size,
-      .key = key,
+      .key = std::string{key},
       .modified_date = file_time,
       .source_path = "",
       .written_date = file_time,
@@ -88,7 +88,7 @@ auto base_provider::create_api_file(std::string path, std::string key,
   return file;
 }
 
-auto base_provider::create_api_file(std::string path, std::uint64_t size,
+auto base_provider::create_api_file(std::string_view path, std::uint64_t size,
                                     api_meta_map &meta) -> api_file {
   auto current_size = utils::string::to_uint64(meta[META_SIZE]);
   if (current_size == 0U) {
@@ -112,8 +112,7 @@ auto base_provider::create_api_file(std::string path, std::uint64_t size,
 }
 
 auto base_provider::create_directory_clone_source_meta(
-    const std::string &source_api_path, const std::string &api_path)
-    -> api_error {
+    std::string_view source_api_path, std::string_view api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   bool exists{};
@@ -164,7 +163,7 @@ auto base_provider::create_directory_clone_source_meta(
   return create_directory(api_path, meta);
 }
 
-auto base_provider::create_directory(const std::string &api_path,
+auto base_provider::create_directory(std::string_view api_path,
                                      api_meta_map &meta) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -211,7 +210,7 @@ auto base_provider::create_directory(const std::string &api_path,
   return api_error::error;
 }
 
-auto base_provider::create_file(const std::string &api_path, api_meta_map &meta)
+auto base_provider::create_file(std::string_view api_path, api_meta_map &meta)
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -269,7 +268,7 @@ auto base_provider::create_file(const std::string &api_path, api_meta_map &meta)
   return api_error::error;
 }
 
-auto base_provider::get_api_path_from_source(const std::string &source_path,
+auto base_provider::get_api_path_from_source(std::string_view source_path,
                                              std::string &api_path) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -284,7 +283,7 @@ auto base_provider::get_api_path_from_source(const std::string &source_path,
   return meta_db_->get_api_path(source_path, api_path);
 }
 
-auto base_provider::get_directory_item(const std::string &api_path,
+auto base_provider::get_directory_item(std::string_view api_path,
                                        directory_item &item) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -325,7 +324,7 @@ auto base_provider::get_directory_item(const std::string &api_path,
   return api_error::error;
 }
 
-auto base_provider::get_directory_items(const std::string &api_path,
+auto base_provider::get_directory_items(std::string_view api_path,
                                         directory_item_list &list) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -387,7 +386,7 @@ auto base_provider::get_directory_items(const std::string &api_path,
   return api_error::success;
 }
 
-auto base_provider::get_file_size(const std::string &api_path,
+auto base_provider::get_file_size(std::string_view api_path,
                                   std::uint64_t &file_size) const -> api_error {
   bool exists{};
   auto res = is_directory(api_path, exists);
@@ -408,7 +407,7 @@ auto base_provider::get_file_size(const std::string &api_path,
   return api_error::success;
 }
 
-auto base_provider::get_filesystem_item(const std::string &api_path,
+auto base_provider::get_filesystem_item(std::string_view api_path,
                                         bool directory,
                                         filesystem_item &fsi) const
     -> api_error {
@@ -445,7 +444,7 @@ auto base_provider::get_filesystem_item(const std::string &api_path,
 }
 
 auto base_provider::get_filesystem_item_from_source_path(
-    const std::string &source_path, filesystem_item &fsi) const -> api_error {
+    std::string_view source_path, filesystem_item &fsi) const -> api_error {
   std::string api_path{};
   auto res = get_api_path_from_source(source_path, api_path);
   if (res != api_error::success) {
@@ -455,13 +454,13 @@ auto base_provider::get_filesystem_item_from_source_path(
   return get_filesystem_item(api_path, false, fsi);
 }
 
-auto base_provider::get_item_meta(const std::string &api_path,
+auto base_provider::get_item_meta(std::string_view api_path,
                                   api_meta_map &meta) const -> api_error {
   return meta_db_->get_item_meta(api_path, meta);
 }
 
-auto base_provider::get_item_meta(const std::string &api_path,
-                                  const std::string &key,
+auto base_provider::get_item_meta(std::string_view api_path,
+                                  std::string_view key,
                                   std::string &value) const -> api_error {
   return meta_db_->get_item_meta(api_path, key, value);
 }
@@ -654,7 +653,7 @@ void base_provider::remove_deleted_items(stop_type &stop_requested) {
   process_removed_items(stop_requested);
 }
 
-auto base_provider::remove_file(const std::string &api_path) -> api_error {
+auto base_provider::remove_file(std::string_view api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto notify_end = [&api_path](api_error error) -> api_error {
@@ -703,7 +702,7 @@ auto base_provider::remove_file(const std::string &api_path) -> api_error {
   return remove_file_meta();
 }
 
-auto base_provider::remove_directory(const std::string &api_path) -> api_error {
+auto base_provider::remove_directory(std::string_view api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto notify_end = [&api_path](api_error error) -> api_error {
@@ -736,8 +735,8 @@ auto base_provider::remove_directory(const std::string &api_path) -> api_error {
   return notify_end(api_error::success);
 }
 
-auto base_provider::remove_item_meta(const std::string &api_path,
-                                     const std::string &key) -> api_error {
+auto base_provider::remove_item_meta(std::string_view api_path,
+                                     std::string_view key) -> api_error {
   return meta_db_->remove_item_meta(api_path, key);
 }
 
@@ -793,9 +792,9 @@ void base_provider::remove_unmatched_source_files(stop_type &stop_requested) {
   }
 }
 
-auto base_provider::set_item_meta(const std::string &api_path,
-                                  const std::string &key,
-                                  const std::string &value) -> api_error {
+auto base_provider::set_item_meta(std::string_view api_path,
+                                  std::string_view key, std::string_view value)
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto ret = meta_db_->set_item_meta(api_path, key, value);
@@ -803,7 +802,7 @@ auto base_provider::set_item_meta(const std::string &api_path,
     return ret;
   }
 
-  if (key == META_PINNED && utils::string::to_bool(value)) {
+  if (key == META_PINNED && utils::string::to_bool(std::string{value})) {
     if (fm_ == nullptr || not fm_->download_pinned_file(api_path)) {
       utils::error::raise_api_path_error(function_name, api_path,
                                          "failed to pin file");
@@ -813,8 +812,8 @@ auto base_provider::set_item_meta(const std::string &api_path,
   return ret;
 }
 
-auto base_provider::set_item_meta(const std::string &api_path,
-                                  api_meta_map meta) -> api_error {
+auto base_provider::set_item_meta(std::string_view api_path, api_meta_map meta)
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto ret = meta_db_->set_item_meta(api_path, meta);
@@ -902,8 +901,8 @@ void base_provider::stop() {
   meta_db_.reset();
 }
 
-auto base_provider::upload_file(const std::string &api_path,
-                                const std::string &source_path,
+auto base_provider::upload_file(std::string_view api_path,
+                                std::string_view source_path,
                                 stop_type &stop_requested) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
diff --git a/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp b/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp
index a92ed03e..f6f4b038 100644
--- a/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp
+++ b/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp
@@ -48,9 +48,9 @@ namespace repertory {
 encrypt_provider::encrypt_provider(app_config &config)
     : config_(config), encrypt_config_(config.get_encrypt_config()) {}
 
-auto encrypt_provider::create_api_file(const std::string &api_path,
+auto encrypt_provider::create_api_file(std::string_view api_path,
                                        bool directory,
-                                       const std::string &source_path)
+                                       std::string_view source_path)
     -> api_file {
   auto times{utils::file::get_times(source_path)};
   if (not times.has_value()) {
@@ -58,7 +58,7 @@ auto encrypt_provider::create_api_file(const std::string &api_path,
   }
 
   api_file file{
-      .api_path = api_path,
+      .api_path = std::string{api_path},
       .api_parent = utils::path::get_parent_api_path(api_path),
       .accessed_date = times->get(utils::file::time_type::accessed),
       .changed_date = times->get(utils::file::time_type::changed),
@@ -70,7 +70,7 @@ auto encrypt_provider::create_api_file(const std::string &api_path,
                     source_path, true),
       .key = "",
       .modified_date = times->get(utils::file::time_type::modified),
-      .source_path = source_path,
+      .source_path = std::string{source_path},
       .written_date = times->get(utils::file::time_type::written),
   };
 
@@ -105,7 +105,7 @@ void encrypt_provider::create_item_meta(api_meta_map &meta, bool directory,
 #endif // defined(__APPLE__)
 }
 
-auto encrypt_provider::create_directory(const std::string &api_path,
+auto encrypt_provider::create_directory(std::string_view api_path,
                                         api_meta_map & /*meta*/) -> api_error {
   if (api_path == "/") {
     return api_error::success;
@@ -115,9 +115,9 @@ auto encrypt_provider::create_directory(const std::string &api_path,
 }
 
 auto encrypt_provider::do_fs_operation(
-    const std::string &api_path, bool directory,
+    std::string_view api_path, bool directory,
     std::function<api_error(const encrypt_config &cfg,
-                            const std::string &source_path)>
+                            std::string_view source_path)>
         callback) const -> api_error {
   const auto &cfg{get_encrypt_config()};
 
@@ -156,7 +156,7 @@ auto encrypt_provider::do_fs_operation(
   return callback(cfg, source_path);
 }
 
-auto encrypt_provider::get_api_path_from_source(const std::string &source_path,
+auto encrypt_provider::get_api_path_from_source(std::string_view source_path,
                                                 std::string &api_path) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -171,8 +171,8 @@ auto encrypt_provider::get_api_path_from_source(const std::string &source_path,
   return api_error::error;
 }
 
-auto encrypt_provider::get_directory_item_count(
-    const std::string &api_path) const -> std::uint64_t {
+auto encrypt_provider::get_directory_item_count(std::string_view api_path) const
+    -> std::uint64_t {
   REPERTORY_USES_FUNCTION_NAME();
 
   std::uint64_t count{};
@@ -198,7 +198,7 @@ auto encrypt_provider::get_directory_item_count(
   return count;
 }
 
-auto encrypt_provider::get_directory_item(const std::string &api_path,
+auto encrypt_provider::get_directory_item(std::string_view api_path,
                                           directory_item &item) const
     -> api_error {
   bool directory{};
@@ -230,7 +230,7 @@ auto encrypt_provider::get_directory_item(const std::string &api_path,
   return ret;
 }
 
-auto encrypt_provider::get_directory_items(const std::string &api_path,
+auto encrypt_provider::get_directory_items(std::string_view api_path,
                                            directory_item_list &list) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -341,8 +341,8 @@ auto encrypt_provider::get_directory_items(const std::string &api_path,
       });
 }
 
-auto encrypt_provider::get_file(const std::string &api_path,
-                                api_file &file) const -> api_error {
+auto encrypt_provider::get_file(std::string_view api_path, api_file &file) const
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -406,7 +406,7 @@ auto encrypt_provider::get_file_list(api_file_list &list,
   return api_error::error;
 }
 
-auto encrypt_provider::get_file_size(const std::string &api_path,
+auto encrypt_provider::get_file_size(std::string_view api_path,
                                      std::uint64_t &file_size) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -429,7 +429,7 @@ auto encrypt_provider::get_file_size(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::get_filesystem_item(const std::string &api_path,
+auto encrypt_provider::get_filesystem_item(std::string_view api_path,
                                            bool directory,
                                            filesystem_item &fsi) const
     -> api_error {
@@ -464,7 +464,7 @@ auto encrypt_provider::get_filesystem_item(const std::string &api_path,
 }
 
 auto encrypt_provider::get_filesystem_item_from_source_path(
-    const std::string &source_path, filesystem_item &fsi) const -> api_error {
+    std::string_view source_path, filesystem_item &fsi) const -> api_error {
   std::string api_path{};
   auto res{get_api_path_from_source(source_path, api_path)};
   if (res != api_error::success) {
@@ -478,7 +478,7 @@ auto encrypt_provider::get_pinned_files() const -> std::vector<std::string> {
   return {};
 }
 
-auto encrypt_provider::get_item_meta(const std::string &api_path,
+auto encrypt_provider::get_item_meta(std::string_view api_path,
                                      api_meta_map &meta) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -506,8 +506,8 @@ auto encrypt_provider::get_item_meta(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::get_item_meta(const std::string &api_path,
-                                     const std::string &key,
+auto encrypt_provider::get_item_meta(std::string_view api_path,
+                                     std::string_view key,
                                      std::string &value) const -> api_error {
   api_meta_map meta{};
   auto ret{get_item_meta(api_path, meta)};
@@ -515,7 +515,7 @@ auto encrypt_provider::get_item_meta(const std::string &api_path,
     return ret;
   }
 
-  value = meta[key];
+  value = meta[std::string{key}];
   return api_error::success;
 }
 
@@ -545,7 +545,7 @@ auto encrypt_provider::get_used_drive_space() const -> std::uint64_t {
                                 : 0U;
 }
 
-auto encrypt_provider::is_directory(const std::string &api_path,
+auto encrypt_provider::is_directory(std::string_view api_path,
                                     bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -572,7 +572,7 @@ auto encrypt_provider::is_directory(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::is_file(const std::string &api_path, bool &exists) const
+auto encrypt_provider::is_file(std::string_view api_path, bool &exists) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -757,7 +757,7 @@ auto encrypt_provider::process_directory_entry(
   return false;
 }
 
-auto encrypt_provider::read_file_bytes(const std::string &api_path,
+auto encrypt_provider::read_file_bytes(std::string_view api_path,
                                        std::size_t size, std::uint64_t offset,
                                        data_buffer &data,
                                        stop_type &stop_requested) -> api_error {
@@ -903,11 +903,11 @@ void encrypt_provider::remove_expired_files() {
   }
 }
 
-auto encrypt_provider::remove_item_meta(const std::string &api_path,
-                                        const std::string &key) -> api_error {
+auto encrypt_provider::remove_item_meta(std::string_view api_path,
+                                        std::string_view key) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
-  if (utils::collection::includes(META_USED_NAMES, key)) {
+  if (utils::collection::includes(META_USED_NAMES, std::string{key})) {
     utils::error::raise_api_path_error(
         function_name, api_path,
         fmt::format("failed to remove item meta-key is restricted|key|{}",
diff --git a/repertory/librepertory/src/providers/s3/s3_provider.cpp b/repertory/librepertory/src/providers/s3/s3_provider.cpp
index 82686e9a..8e9c8c42 100644
--- a/repertory/librepertory/src/providers/s3/s3_provider.cpp
+++ b/repertory/librepertory/src/providers/s3/s3_provider.cpp
@@ -70,7 +70,7 @@ s3_provider::s3_provider(app_config &config, i_http_comm &comm)
     : base_provider(config, comm), s3_config_(config.get_s3_config()) {}
 
 auto s3_provider::add_if_not_found(api_file &file,
-                                   const std::string &object_name) const
+                                   std::string_view object_name) const
     -> api_error {
   api_meta_map meta{};
   auto res{get_item_meta(file.api_path, meta)};
@@ -110,8 +110,8 @@ auto s3_provider::convert_api_date(std::string_view date) -> std::uint64_t {
 #endif // defined(_WIN32)
 }
 
-auto s3_provider::create_directory_object(const std::string &api_path,
-                                          const std::string &object_name) const
+auto s3_provider::create_directory_object(std::string_view api_path,
+                                          std::string_view object_name) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -127,7 +127,7 @@ auto s3_provider::create_directory_object(const std::string &api_path,
     response_data = std::string(data.begin(), data.end());
   };
 
-  auto res{set_request_path(put_dir, object_name + '/')};
+  auto res{set_request_path(put_dir, std::string{object_name} + '/')};
   if (res != api_error::success) {
     return res;
   }
@@ -151,7 +151,7 @@ auto s3_provider::create_directory_object(const std::string &api_path,
   return api_error::success;
 }
 
-auto s3_provider::create_directory_impl(const std::string &api_path,
+auto s3_provider::create_directory_impl(std::string_view api_path,
                                         api_meta_map &meta) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -168,8 +168,8 @@ auto s3_provider::create_directory_impl(const std::string &api_path,
       utils::path::create_api_path(is_encrypted ? meta[META_KEY] : api_path));
 }
 
-auto s3_provider::create_directory_paths(const std::string &api_path,
-                                         const std::string &key) const
+auto s3_provider::create_directory_paths(std::string_view api_path,
+                                         std::string_view key) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -246,7 +246,7 @@ auto s3_provider::create_directory_paths(const std::string &api_path,
   return api_error::success;
 }
 
-auto s3_provider::create_file_extra(const std::string &api_path,
+auto s3_provider::create_file_extra(std::string_view api_path,
                                     api_meta_map &meta) -> api_error {
   return set_meta_key(api_path, meta);
 }
@@ -269,7 +269,7 @@ auto s3_provider::decrypt_object_name(std::string &object_name) const
   return api_error::decryption_error;
 }
 
-auto s3_provider::get_directory_item_count(const std::string &api_path) const
+auto s3_provider::get_directory_item_count(std::string_view api_path) const
     -> std::uint64_t {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -313,7 +313,7 @@ auto s3_provider::get_directory_item_count(const std::string &api_path) const
   return 0U;
 }
 
-auto s3_provider::get_directory_items_impl(const std::string &api_path,
+auto s3_provider::get_directory_items_impl(std::string_view api_path,
                                            directory_item_list &list) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -322,7 +322,7 @@ auto s3_provider::get_directory_items_impl(const std::string &api_path,
   auto is_encrypted{not cfg.encryption_token.empty()};
 
   const auto add_directory_item =
-      [this, &is_encrypted, &list](const std::string &child_object_name,
+      [this, &is_encrypted, &list](std::string_view child_object_name,
                                    bool directory, auto node) -> api_error {
     auto res{api_error::success};
 
@@ -426,7 +426,7 @@ auto s3_provider::get_directory_items_impl(const std::string &api_path,
       });
 }
 
-auto s3_provider::get_file(const std::string &api_path, api_file &file) const
+auto s3_provider::get_file(std::string_view api_path, api_file &file) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -567,7 +567,7 @@ auto s3_provider::get_file_list(api_file_list &list, std::string &marker) const
 }
 
 auto s3_provider::get_kdf_config_from_meta(
-    const std::string &api_path, utils::encryption::kdf_config &cfg) const
+    std::string_view api_path, utils::encryption::kdf_config &cfg) const
     -> api_error {
   std::string kdf_str;
   auto ret = get_item_meta(api_path, META_KDF, kdf_str);
@@ -583,7 +583,7 @@ auto s3_provider::get_kdf_config_from_meta(
   return api_error::success;
 }
 
-auto s3_provider::get_last_modified(bool directory, const std::string &api_path,
+auto s3_provider::get_last_modified(bool directory, std::string_view api_path,
                                     std::uint64_t &last_modified) const
     -> api_error {
   bool is_encrypted{};
@@ -598,7 +598,7 @@ auto s3_provider::get_last_modified(bool directory, const std::string &api_path,
   return res;
 }
 
-auto s3_provider::get_object_info(bool directory, const std::string &api_path,
+auto s3_provider::get_object_info(bool directory, std::string_view api_path,
                                   bool &is_encrypted, std::string &object_name,
                                   head_object_result &result) const
     -> api_error {
@@ -663,9 +663,9 @@ auto s3_provider::get_object_info(bool directory, const std::string &api_path,
 
 auto s3_provider::get_object_list(std::string &response_data,
                                   long &response_code,
-                                  std::optional<std::string> delimiter,
-                                  std::optional<std::string> prefix,
-                                  std::optional<std::string> token) const
+                                  std::optional<std::string_view> delimiter,
+                                  std::optional<std::string_view> prefix,
+                                  std::optional<std::string_view> token) const
     -> bool {
   curl::requests::http_get get{};
   get.allow_timeout = true;
@@ -762,7 +762,7 @@ auto s3_provider::initialize_crypto(const s3_config &cfg, bool is_retry)
   return ret;
 }
 
-auto s3_provider::is_directory(const std::string &api_path, bool &exists) const
+auto s3_provider::is_directory(std::string_view api_path, bool &exists) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -791,7 +791,7 @@ auto s3_provider::is_directory(const std::string &api_path, bool &exists) const
   return api_error::error;
 }
 
-auto s3_provider::is_file(const std::string &api_path, bool &exists) const
+auto s3_provider::is_file(std::string_view api_path, bool &exists) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -834,7 +834,7 @@ auto s3_provider::is_online() const -> bool {
   return false;
 }
 
-auto s3_provider::iterate_prefix(const std::string &prefix,
+auto s3_provider::iterate_prefix(std::string_view prefix,
                                  interate_callback_t prefix_action,
                                  interate_callback_t key_action) const
     -> api_error {
@@ -942,7 +942,7 @@ auto s3_provider::iterate_prefix(const std::string &prefix,
   return api_error::success;
 }
 
-auto s3_provider::remove_directory_impl(const std::string &api_path)
+auto s3_provider::remove_directory_impl(std::string_view api_path)
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -996,7 +996,7 @@ auto s3_provider::remove_directory_impl(const std::string &api_path)
   return api_error::success;
 }
 
-auto s3_provider::remove_file_impl(const std::string &api_path) -> api_error {
+auto s3_provider::remove_file_impl(std::string_view api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto &cfg{get_s3_config()};
@@ -1048,14 +1048,13 @@ auto s3_provider::remove_file_impl(const std::string &api_path) -> api_error {
   return api_error::success;
 }
 
-auto s3_provider::rename_file(const std::string & /* from_api_path */,
-                              const std::string & /* to_api_path */)
-    -> api_error {
+auto s3_provider::rename_file(std::string_view /* from_api_path */,
+                              std::string_view /* to_api_path */) -> api_error {
   return api_error::not_implemented;
 }
 
-auto s3_provider::search_keys_for_master_kdf(
-    const std::string &encryption_token) -> bool {
+auto s3_provider::search_keys_for_master_kdf(std::string_view encryption_token)
+    -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   std::string token{};
@@ -1134,7 +1133,7 @@ auto s3_provider::search_keys_for_master_kdf(
   return false;
 }
 
-auto s3_provider::set_meta_key(const std::string &api_path, api_meta_map &meta)
+auto s3_provider::set_meta_key(std::string_view api_path, api_meta_map &meta)
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -1219,8 +1218,8 @@ void s3_provider::stop() {
                                                    "s3_provider");
 }
 
-auto s3_provider::upload_file_impl(const std::string &api_path,
-                                   const std::string &source_path,
+auto s3_provider::upload_file_impl(std::string_view api_path,
+                                   std::string_view source_path,
                                    stop_type &stop_requested) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -1298,7 +1297,7 @@ auto s3_provider::upload_file_impl(const std::string &api_path,
   return api_error::success;
 }
 
-auto s3_provider::read_file_bytes(const std::string &api_path, std::size_t size,
+auto s3_provider::read_file_bytes(std::string_view api_path, std::size_t size,
                                   std::uint64_t offset, data_buffer &data,
                                   stop_type &stop_requested) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
diff --git a/repertory/librepertory/src/providers/sia/sia_provider.cpp b/repertory/librepertory/src/providers/sia/sia_provider.cpp
index 3909c255..3292d0e3 100644
--- a/repertory/librepertory/src/providers/sia/sia_provider.cpp
+++ b/repertory/librepertory/src/providers/sia/sia_provider.cpp
@@ -104,14 +104,14 @@ auto sia_provider::check_version(std::string &required_version,
   return false;
 }
 
-auto sia_provider::create_directory_impl(const std::string &api_path,
+auto sia_provider::create_directory_impl(std::string_view api_path,
                                          api_meta_map & /* meta */)
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   curl::requests::http_put_file put_file{};
   put_file.allow_timeout = true;
-  put_file.path = "/api/worker/object" + api_path + "/";
+  put_file.path = fmt::format("/api/worker/object{}/", api_path);
   put_file.query["bucket"] = get_sia_config().bucket;
 
   std::string error_data;
@@ -142,7 +142,7 @@ auto sia_provider::create_directory_impl(const std::string &api_path,
   return api_error::success;
 }
 
-auto sia_provider::create_directory_key(const std::string &api_path) const
+auto sia_provider::create_directory_key(std::string_view api_path) const
     -> api_error {
   auto parent_api_path = utils::path::get_parent_api_path(api_path);
 
@@ -157,7 +157,8 @@ auto sia_provider::create_directory_key(const std::string &api_path) const
 
   const auto &list = object_list.at("objects");
   if (std::ranges::find_if(list, [&api_path](auto &&entry) -> bool {
-        return entry.at("key").template get<std::string>() == api_path + '/';
+        return entry.at("key").template get<std::string>() ==
+               std::string{api_path} + '/';
       }) == list.end()) {
     return api_error::directory_not_found;
   }
@@ -167,7 +168,7 @@ auto sia_provider::create_directory_key(const std::string &api_path) const
                                                                  meta);
 }
 
-auto sia_provider::ensure_directory_exists(const std::string &api_path) const
+auto sia_provider::ensure_directory_exists(std::string_view api_path) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -188,7 +189,7 @@ auto sia_provider::ensure_directory_exists(const std::string &api_path) const
   return api_error::success;
 }
 
-auto sia_provider::get_directory_item_count(const std::string &api_path) const
+auto sia_provider::get_directory_item_count(std::string_view api_path) const
     -> std::uint64_t {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -226,7 +227,7 @@ auto sia_provider::get_directory_item_count(const std::string &api_path) const
   return 0U;
 }
 
-auto sia_provider::get_directory_items_impl(const std::string &api_path,
+auto sia_provider::get_directory_items_impl(std::string_view api_path,
                                             directory_item_list &list) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
@@ -263,7 +264,7 @@ auto sia_provider::get_directory_items_impl(const std::string &api_path,
   return api_error::success;
 }
 
-auto sia_provider::get_file(const std::string &api_path, api_file &file) const
+auto sia_provider::get_file(std::string_view api_path, api_file &file) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -348,14 +349,14 @@ auto sia_provider::get_file_list(api_file_list &list, std::string &marker) const
   return api_error::error;
 }
 
-auto sia_provider::get_object_info(const std::string &api_path,
+auto sia_provider::get_object_info(std::string_view api_path,
                                    json &object_info) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
     curl::requests::http_get get{};
     get.allow_timeout = true;
-    get.path = "/api/bus/object" + api_path;
+    get.path = fmt::format("/api/bus/object{}", api_path);
     get.query["bucket"] = get_sia_config().bucket;
     get.query["onlymetadata"] = "true";
 
@@ -396,7 +397,7 @@ auto sia_provider::get_object_info(const std::string &api_path,
   return api_error::error;
 }
 
-auto sia_provider::get_object_list(const std::string &api_path,
+auto sia_provider::get_object_list(std::string_view api_path,
                                    nlohmann::json &object_list,
                                    std::optional<std::string> marker) const
     -> bool {
@@ -405,7 +406,7 @@ auto sia_provider::get_object_list(const std::string &api_path,
   try {
     curl::requests::http_get get{};
     get.allow_timeout = true;
-    get.path = "/api/bus/objects" + api_path + "/";
+    get.path = fmt::format("/api/bus/objects{}/", api_path);
     get.query["bucket"] = get_sia_config().bucket;
     if (marker.has_value()) {
       get.query["limit"] = "1000";
@@ -494,7 +495,7 @@ auto sia_provider::get_total_drive_space() const -> std::uint64_t {
   return 0U;
 }
 
-auto sia_provider::is_directory(const std::string &api_path, bool &exists) const
+auto sia_provider::is_directory(std::string_view api_path, bool &exists) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -507,7 +508,7 @@ auto sia_provider::is_directory(const std::string &api_path, bool &exists) const
     exists = false;
 
     json file_data{};
-    auto res{get_object_info(api_path + '/', file_data)};
+    auto res{get_object_info(std::string{api_path} + '/', file_data)};
     if (res == api_error::item_not_found) {
       if (create_directory_key(api_path) == api_error::success) {
         exists = true;
@@ -535,7 +536,7 @@ auto sia_provider::is_directory(const std::string &api_path, bool &exists) const
   return api_error::error;
 }
 
-auto sia_provider::is_file(const std::string &api_path, bool &exists) const
+auto sia_provider::is_file(std::string_view api_path, bool &exists) const
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
@@ -614,8 +615,8 @@ auto sia_provider::is_online() const -> bool {
 }
 
 void sia_provider::iterate_objects(
-    const std::string &api_path, const json &object_list,
-    std::function<void(const std::string &, bool, json)> handle_entry) const {
+    std::string_view api_path, const json &object_list,
+    std::function<void(std::string_view, bool, json)> handle_entry) const {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (not object_list.contains("objects")) {
@@ -659,15 +660,15 @@ void sia_provider::iterate_objects(
   }
 }
 
-auto sia_provider::read_file_bytes(const std::string &api_path,
-                                   std::size_t size, std::uint64_t offset,
+auto sia_provider::read_file_bytes(std::string_view api_path, std::size_t size,
+                                   std::uint64_t offset,
                                    data_buffer &read_buffer,
                                    stop_type &stop_requested) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
     curl::requests::http_get get{};
-    get.path = "/api/worker/object" + api_path;
+    get.path = fmt::format("/api/worker/object{}", api_path);
     get.query["bucket"] = get_sia_config().bucket;
     get.headers["accept"] = "application/octet-stream";
     get.range = {{
@@ -730,13 +731,13 @@ auto sia_provider::read_file_bytes(const std::string &api_path,
   return api_error::error;
 }
 
-auto sia_provider::remove_directory_impl(const std::string &api_path)
+auto sia_provider::remove_directory_impl(std::string_view api_path)
     -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   curl::requests::http_delete del{};
   del.allow_timeout = true;
-  del.path = "/api/bus/object" + api_path + "/";
+  del.path = fmt::format("/api/bus/object{}/", api_path);
   del.query["bucket"] = get_sia_config().bucket;
 
   std::string error_data;
@@ -767,12 +768,12 @@ auto sia_provider::remove_directory_impl(const std::string &api_path)
   return api_error::success;
 }
 
-auto sia_provider::remove_file_impl(const std::string &api_path) -> api_error {
+auto sia_provider::remove_file_impl(std::string_view api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   curl::requests::http_delete del{};
   del.allow_timeout = true;
-  del.path = "/api/bus/object" + api_path;
+  del.path = fmt::format("/api/bus/object{}", api_path);
   del.query["bucket"] = get_sia_config().bucket;
 
   std::string error_data;
@@ -804,8 +805,8 @@ auto sia_provider::remove_file_impl(const std::string &api_path) -> api_error {
   return api_error::success;
 }
 
-auto sia_provider::rename_file(const std::string &from_api_path,
-                               const std::string &to_api_path) -> api_error {
+auto sia_provider::rename_file(std::string_view from_api_path,
+                               std::string_view to_api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -895,13 +896,13 @@ void sia_provider::stop() {
                                                    "sia_provider");
 }
 
-auto sia_provider::upload_file_impl(const std::string &api_path,
-                                    const std::string &source_path,
+auto sia_provider::upload_file_impl(std::string_view api_path,
+                                    std::string_view source_path,
                                     stop_type &stop_requested) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   curl::requests::http_put_file put_file{};
-  put_file.path = "/api/worker/object" + api_path;
+  put_file.path = fmt::format("/api/worker/object{}", api_path);
   put_file.query["bucket"] = get_sia_config().bucket;
   put_file.headers["content-type"] = "application/octet-stream";
   put_file.source_path = source_path;
diff --git a/repertory/librepertory/src/rpc/client/client.cpp b/repertory/librepertory/src/rpc/client/client.cpp
index 7e0d8120..fef5b65a 100644
--- a/repertory/librepertory/src/rpc/client/client.cpp
+++ b/repertory/librepertory/src/rpc/client/client.cpp
@@ -83,12 +83,12 @@ auto client::get_config() const -> rpc_response {
   };
 }
 
-auto client::get_config_value_by_name(const std::string &name) const
+auto client::get_config_value_by_name(std::string_view name) const
     -> rpc_response {
   auto base_url =
       "http://" + host_info_.host + ":" + std::to_string(host_info_.port);
 
-  httplib::Params params{{"name", name}};
+  httplib::Params params{{"name", std::string{name}}};
   httplib::Client cli{base_url};
   cli.set_basic_auth(host_info_.user,
                      rpc::create_password_hash(host_info_.password));
@@ -114,12 +114,12 @@ auto client::get_config_value_by_name(const std::string &name) const
   };
 }
 
-auto client::get_directory_items(const std::string &api_path) const
+auto client::get_directory_items(std::string_view api_path) const
     -> rpc_response {
   auto base_url =
       "http://" + host_info_.host + ":" + std::to_string(host_info_.port);
 
-  httplib::Params params{{"api_path", api_path}};
+  httplib::Params params{{"api_path", std::string{api_path}}};
   httplib::Client cli{base_url};
   cli.set_basic_auth(host_info_.user,
                      rpc::create_password_hash(host_info_.password));
@@ -144,11 +144,11 @@ auto client::get_directory_items(const std::string &api_path) const
   };
 }
 
-auto client::get_item_info(const std::string &api_path) const -> rpc_response {
+auto client::get_item_info(std::string_view api_path) const -> rpc_response {
   auto base_url =
       "http://" + host_info_.host + ":" + std::to_string(host_info_.port);
 
-  httplib::Params params{{"api_path", api_path}};
+  httplib::Params params{{"api_path", std::string{api_path}}};
   httplib::Client cli{base_url};
   cli.set_basic_auth(host_info_.user,
                      rpc::create_password_hash(host_info_.password));
@@ -229,11 +229,11 @@ auto client::get_pinned_files() const -> rpc_response {
   };
 }
 
-auto client::pin_file(const std::string &api_path) const -> rpc_response {
+auto client::pin_file(std::string_view api_path) const -> rpc_response {
   auto base_url =
       "http://" + host_info_.host + ":" + std::to_string(host_info_.port);
 
-  httplib::Params params{{"api_path", api_path}};
+  httplib::Params params{{"api_path", std::string{api_path}}};
   httplib::Client cli{base_url};
   cli.set_basic_auth(host_info_.user,
                      rpc::create_password_hash(host_info_.password));
@@ -258,11 +258,11 @@ auto client::pin_file(const std::string &api_path) const -> rpc_response {
   };
 }
 
-auto client::pinned_status(const std::string &api_path) const -> rpc_response {
+auto client::pinned_status(std::string_view api_path) const -> rpc_response {
   auto base_url =
       "http://" + host_info_.host + ":" + std::to_string(host_info_.port);
 
-  httplib::Params params{{"api_path", api_path}};
+  httplib::Params params{{"api_path", std::string{api_path}}};
   httplib::Client cli{base_url};
   cli.set_basic_auth(host_info_.user,
                      rpc::create_password_hash(host_info_.password));
@@ -287,15 +287,15 @@ auto client::pinned_status(const std::string &api_path) const -> rpc_response {
   };
 }
 
-auto client::set_config_value_by_name(const std::string &name,
-                                      const std::string &value) const
+auto client::set_config_value_by_name(std::string_view name,
+                                      std::string_view value) const
     -> rpc_response {
   auto base_url =
       "http://" + host_info_.host + ":" + std::to_string(host_info_.port);
 
   httplib::Params params{
-      {"name", name},
-      {"value", value},
+      {"name", std::string{name}},
+      {"value", std::string{value}},
   };
 
   httplib::Client cli{base_url};
@@ -351,11 +351,11 @@ auto client::unmount() const -> rpc_response {
   };
 }
 
-auto client::unpin_file(const std::string &api_path) const -> rpc_response {
+auto client::unpin_file(std::string_view api_path) const -> rpc_response {
   auto base_url =
       "http://" + host_info_.host + ":" + std::to_string(host_info_.port);
 
-  httplib::Params params{{"api_path", api_path}};
+  httplib::Params params{{"api_path", std::string{api_path}}};
   httplib::Client cli{base_url};
   cli.set_basic_auth(host_info_.user,
                      rpc::create_password_hash(host_info_.password));
diff --git a/repertory/librepertory/src/types/repertory.cpp b/repertory/librepertory/src/types/repertory.cpp
index 895529c4..f22fc787 100644
--- a/repertory/librepertory/src/types/repertory.cpp
+++ b/repertory/librepertory/src/types/repertory.cpp
@@ -71,14 +71,15 @@ auto clean_json_value(std::string_view name, std::string_view data)
   return std::string{data};
 }
 
-auto database_type_from_string(std::string type, database_type default_type)
-    -> database_type {
-  type = utils::string::to_lower(utils::string::trim(type));
-  if (type == "rocksdb") {
+auto database_type_from_string(std::string_view type,
+                               database_type default_type) -> database_type {
+  auto type_lower =
+      utils::string::to_lower(utils::string::trim_copy(std::string{type}));
+  if (type_lower == "rocksdb") {
     return database_type::rocksdb;
   }
 
-  if (type == "sqlite") {
+  if (type_lower == "sqlite") {
     return database_type::sqlite;
   }
 
@@ -96,18 +97,19 @@ auto database_type_to_string(const database_type &type) -> std::string {
   }
 }
 
-auto download_type_from_string(std::string type, download_type default_type)
-    -> download_type {
-  type = utils::string::to_lower(utils::string::trim(type));
-  if (type == "default") {
+auto download_type_from_string(std::string_view type,
+                               download_type default_type) -> download_type {
+  auto type_lower =
+      utils::string::to_lower(utils::string::trim_copy(std::string{type}));
+  if (type_lower == "default") {
     return download_type::default_;
   }
 
-  if (type == "direct") {
+  if (type_lower == "direct") {
     return download_type::direct;
   }
 
-  if (type == "ring_buffer") {
+  if (type_lower == "ring_buffer") {
     return download_type::ring_buffer;
   }
 
@@ -127,30 +129,31 @@ auto download_type_to_string(const download_type &type) -> std::string {
   }
 }
 
-auto event_level_from_string(std::string level, event_level default_level)
+auto event_level_from_string(std::string_view type, event_level default_level)
     -> event_level {
-  level = utils::string::to_lower(level);
-  if (level == "critical" || level == "event_level::critical") {
+  auto type_lower =
+      utils::string::to_lower(utils::string::trim_copy(std::string{type}));
+  if (type_lower == "critical" || type_lower == "event_level::critical") {
     return event_level::critical;
   }
 
-  if (level == "debug" || level == "event_level::debug") {
+  if (type_lower == "debug" || type_lower == "event_level::debug") {
     return event_level::debug;
   }
 
-  if (level == "warn" || level == "event_level::warn") {
+  if (type_lower == "warn" || type_lower == "event_level::warn") {
     return event_level::warn;
   }
 
-  if (level == "info" || level == "event_level::info") {
+  if (type_lower == "info" || type_lower == "event_level::info") {
     return event_level::info;
   }
 
-  if (level == "error" || level == "event_level::error") {
+  if (type_lower == "error" || type_lower == "event_level::error") {
     return event_level::error;
   }
 
-  if (level == "trace" || level == "event_level::trace") {
+  if (type_lower == "trace" || type_lower == "event_level::trace") {
     return event_level::trace;
   }
 
@@ -175,6 +178,7 @@ auto event_level_to_string(event_level level) -> std::string {
     return "info";
   }
 }
+
 static const std::unordered_map<api_error, std::string> LOOKUP = {
     {api_error::success, "success"},
     {api_error::access_denied, "access_denied"},
@@ -242,7 +246,8 @@ auto api_error_to_string(api_error error) -> const std::string & {
 
 auto provider_type_from_string(std::string_view type,
                                provider_type default_type) -> provider_type {
-  auto type_lower = utils::string::to_lower(std::string{type});
+  auto type_lower =
+      utils::string::to_lower(utils::string::trim_copy(std::string{type}));
   if (type_lower == "encrypt") {
     return provider_type::encrypt;
   }
diff --git a/repertory/librepertory/src/utils/cli_utils.cpp b/repertory/librepertory/src/utils/cli_utils.cpp
index 33aca67b..3fb06330 100644
--- a/repertory/librepertory/src/utils/cli_utils.cpp
+++ b/repertory/librepertory/src/utils/cli_utils.cpp
@@ -31,12 +31,10 @@
 
 namespace repertory::utils::cli {
 void get_api_authentication_data(std::string &user, std::string &password,
-                                 std::uint16_t &port, provider_type prov,
-                                 const std::string &data_directory) {
-  const auto cfg_file_path = utils::path::combine(
-      data_directory.empty() ? app_config::default_data_directory(prov)
-                             : data_directory,
-      {"config.json"});
+                                 std::uint16_t &port,
+                                 std::string_view data_directory) {
+  const auto cfg_file_path =
+      utils::path::combine(data_directory, {"config.json"});
 
   json data;
   const auto success = utils::retry_action([&]() -> bool {
@@ -67,7 +65,7 @@ void get_api_authentication_data(std::string &user, std::string &password,
   return provider_type::sia;
 }
 
-auto has_option(std::vector<const char *> args, const std::string &option_name)
+auto has_option(std::vector<const char *> args, std::string_view option_name)
     -> bool {
   return std::ranges::find_if(args, [&option_name](auto &&value) -> bool {
            return option_name == value;
@@ -78,9 +76,8 @@ auto has_option(std::vector<const char *> args, const option &opt) -> bool {
   return has_option(args, opt.at(0U)) || has_option(args, opt.at(1U));
 }
 
-auto parse_option(std::vector<const char *> args,
-                  const std::string &option_name, std::uint8_t count)
-    -> std::vector<std::string> {
+auto parse_option(std::vector<const char *> args, std::string_view option_name,
+                  std::uint8_t count) -> std::vector<std::string> {
   std::vector<std::string> ret;
   auto found{false};
   for (std::size_t idx{0U}; not found && (idx < args.size()); idx++) {
diff --git a/repertory/librepertory/src/utils/file_utils.cpp b/repertory/librepertory/src/utils/file_utils.cpp
index c6e23d26..e1dc7f62 100644
--- a/repertory/librepertory/src/utils/file_utils.cpp
+++ b/repertory/librepertory/src/utils/file_utils.cpp
@@ -99,17 +99,17 @@ auto get_directory_files(std::string_view path, bool oldest_first,
 
     closedir(root);
 
-    const auto add_to_lookup = [&](const std::string &lookup_path) {
-      if (lookup.find(lookup_path) == lookup.end()) {
+    const auto add_to_lookup = [&](std::string_view lookup_path) {
+      if (lookup.find(std::string{lookup_path}) == lookup.end()) {
         struct stat u_stat{};
-        stat(lookup_path.c_str(), &u_stat);
+        stat(std::string{lookup_path}.c_str(), &u_stat);
 #if defined(__APPLE__)
-        lookup[lookup_path] =
+        lookup[std::string{lookup_path}] =
             (static_cast<std::uint64_t>(u_stat.st_mtimespec.tv_sec) *
              utils::time::NANOS_PER_SECOND) +
             static_cast<std::uint64_t>(u_stat.st_mtimespec.tv_nsec);
 #else  // !defined(__APPLE__)
-        lookup[lookup_path] =
+        lookup[std::string{lookup_path}] =
             (static_cast<std::uint64_t>(u_stat.st_mtim.tv_sec) *
              utils::time::NANOS_PER_SECOND) +
             static_cast<std::uint64_t>(u_stat.st_mtim.tv_nsec);
@@ -128,10 +128,10 @@ auto get_directory_files(std::string_view path, bool oldest_first,
   return ret;
 }
 
-auto read_file_lines(const std::string &path) -> std::vector<std::string> {
+auto read_file_lines(std::string_view path) -> std::vector<std::string> {
   std::vector<std::string> ret;
   if (utils::file::file(path).exists()) {
-    std::ifstream stream(path);
+    std::ifstream stream(std::string{path});
     std::string current_line;
     while (not stream.eof() && std::getline(stream, current_line)) {
       ret.emplace_back(utils::string::right_trim(current_line, '\r'));
@@ -142,7 +142,7 @@ auto read_file_lines(const std::string &path) -> std::vector<std::string> {
   return ret;
 }
 
-auto reset_modified_time(const std::string &path) -> bool {
+auto reset_modified_time(std::string_view path) -> bool {
   auto ret{false};
 #if defined(_WIN32)
   SYSTEMTIME st{};
@@ -151,7 +151,7 @@ auto reset_modified_time(const std::string &path) -> bool {
   FILETIME ft{};
   if ((ret = !!::SystemTimeToFileTime(&st, &ft))) {
     auto handle = ::CreateFileA(
-        path.c_str(), FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
+        std::string{path}.c_str(), FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
         FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
         OPEN_EXISTING, 0, nullptr);
     if ((ret = (handle != INVALID_HANDLE_VALUE))) {
@@ -160,7 +160,7 @@ auto reset_modified_time(const std::string &path) -> bool {
     }
   }
 #else  // !defined(_WIN32)
-  auto desc = open(path.c_str(), O_RDWR);
+  auto desc = open(std::string{path}.c_str(), O_RDWR);
   ret = (desc != -1);
   if (ret) {
     ret = futimens(desc, nullptr) == 0;
diff --git a/repertory/librepertory/src/utils/polling.cpp b/repertory/librepertory/src/utils/polling.cpp
index 572a9bf5..295da206 100644
--- a/repertory/librepertory/src/utils/polling.cpp
+++ b/repertory/librepertory/src/utils/polling.cpp
@@ -97,9 +97,9 @@ auto polling::get_stop_requested() const -> bool {
   return stop_requested_ || app_config::get_stop_requested();
 }
 
-void polling::remove_callback(const std::string &name) {
+void polling::remove_callback(std::string_view name) {
   mutex_lock lock(mutex_);
-  items_.erase(name);
+  items_.erase(std::string{name});
 }
 
 void polling::set_callback(const polling_item &item) {
diff --git a/repertory/librepertory/src/utils/utils.cpp b/repertory/librepertory/src/utils/utils.cpp
index 8aed1dbf..d148965b 100644
--- a/repertory/librepertory/src/utils/utils.cpp
+++ b/repertory/librepertory/src/utils/utils.cpp
@@ -46,7 +46,7 @@ void calculate_allocation_size(bool directory, std::uint64_t file_size,
 }
 
 auto create_rocksdb(
-    const app_config &cfg, const std::string &name,
+    const app_config &cfg, std::string_view name,
     const std::vector<rocksdb::ColumnFamilyDescriptor> &families,
     std::vector<rocksdb::ColumnFamilyHandle *> &handles, bool clear)
     -> std::unique_ptr<rocksdb::TransactionDB> {
@@ -60,8 +60,9 @@ auto create_rocksdb(
 
   auto path = utils::path::combine(db_dir, {name});
   if (clear && not utils::file::directory{path}.remove_recursively()) {
-    utils::error::raise_error(function_name,
-                              "failed to remove " + name + " db|" + path);
+    utils::error::raise_error(
+        function_name,
+        fmt::format("failed to remove|name|{}|path|{}", name, path));
   }
 
   rocksdb::Options options{};
diff --git a/repertory/repertory/include/cli/actions.hpp b/repertory/repertory/include/cli/actions.hpp
index c9f6af33..7a7424af 100644
--- a/repertory/repertory/include/cli/actions.hpp
+++ b/repertory/repertory/include/cli/actions.hpp
@@ -47,8 +47,8 @@
 
 namespace repertory::cli::actions {
 using action = std::function<exit_code(
-    std::vector<const char *>, const std::string &, provider_type,
-    const std::string &, std::string, std::string)>;
+    std::vector<const char *>, std::string_view, provider_type,
+    std::string_view, std::string, std::string)>;
 
 struct option_hasher {
   auto operator()(const utils::cli::option &opt) const -> std::size_t {
@@ -122,8 +122,8 @@ inline const std::unordered_map<utils::cli::option, action, option_hasher>
 
 [[nodiscard]] inline auto
 perform_action(const utils::cli::option &opt, std::vector<const char *> args,
-               const std::string &data_directory, provider_type prov,
-               const std::string &unique_id, std::string user,
+               std::string_view data_directory, provider_type prov,
+               std::string_view unique_id, std::string user,
                std::string password) -> exit_code {
   if (utils::cli::has_option(args, opt)) {
     if (option_actions.contains(opt)) {
diff --git a/repertory/repertory/include/cli/check_version.hpp b/repertory/repertory/include/cli/check_version.hpp
index 92c3d91c..e693c6e8 100644
--- a/repertory/repertory/include/cli/check_version.hpp
+++ b/repertory/repertory/include/cli/check_version.hpp
@@ -29,10 +29,10 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-check_version(const std::string &data_directory, provider_type prov,
-              const std::string &remote_host, std::uint16_t remote_port)
+check_version(std::string_view data_directory, provider_type prov,
+              std::string_view remote_host, std::uint16_t remote_port)
     -> exit_code {
-  auto ret = cli::check_data_directory(data_directory, prov);
+  auto ret = cli::check_data_directory(data_directory);
   if (ret != exit_code::success) {
     return ret;
   }
diff --git a/repertory/repertory/include/cli/common.hpp b/repertory/repertory/include/cli/common.hpp
index fee53a96..d6ecbbb5 100644
--- a/repertory/repertory/include/cli/common.hpp
+++ b/repertory/repertory/include/cli/common.hpp
@@ -73,13 +73,10 @@ namespace repertory::cli {
   return code;
 }
 
-[[nodiscard]] inline auto check_data_directory(std::string_view data_directory,
-                                               provider_type prov)
+[[nodiscard]] inline auto check_data_directory(std::string_view data_directory)
     -> exit_code {
-  auto full_directory = data_directory.empty()
-                            ? app_config::default_data_directory(prov)
-                            : utils::path::absolute(data_directory);
-  if (not utils::file::directory{full_directory}.exists()) {
+  if (not utils::file::directory{utils::path::absolute(data_directory)}
+              .exists()) {
     return handle_error(exit_code::mount_not_found, "failed: mount not found");
   }
 
diff --git a/repertory/repertory/include/cli/display_config.hpp b/repertory/repertory/include/cli/display_config.hpp
index 846e065b..03e69b64 100644
--- a/repertory/repertory/include/cli/display_config.hpp
+++ b/repertory/repertory/include/cli/display_config.hpp
@@ -26,12 +26,12 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto display_config(std::vector<const char *> /* args */,
-                                         const std::string &data_directory,
+                                         std::string_view data_directory,
                                          provider_type prov,
-                                         const std::string &unique_id,
+                                         std::string_view unique_id,
                                          std::string user, std::string password)
     -> exit_code {
-  auto ret = cli::check_data_directory(data_directory, prov);
+  auto ret = cli::check_data_directory(data_directory);
   if (ret != exit_code::success) {
     return ret;
   }
@@ -46,7 +46,7 @@ namespace repertory::cli::actions {
 
   if (lock_res == lock_result::locked) {
     auto port = app_config::default_api_port(prov);
-    utils::cli::get_api_authentication_data(user, password, port, prov,
+    utils::cli::get_api_authentication_data(user, password, port,
                                             data_directory);
     auto response = client({
                                .host = "localhost",
diff --git a/repertory/repertory/include/cli/drive_information.hpp b/repertory/repertory/include/cli/drive_information.hpp
index 3fe267f6..283737c1 100644
--- a/repertory/repertory/include/cli/drive_information.hpp
+++ b/repertory/repertory/include/cli/drive_information.hpp
@@ -27,14 +27,14 @@
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
 drive_information(std::vector<const char *> /* args */,
-                  const std::string &data_directory, provider_type prov,
-                  const std::string &unique_id, std::string user,
+                  std::string_view data_directory, provider_type prov,
+                  std::string_view unique_id, std::string user,
                   std::string password) -> exit_code {
   lock_data lock(data_directory, prov, unique_id);
   auto lock_res = lock.grab_lock(1U);
   if (lock_res == lock_result::locked) {
     auto port = app_config::default_api_port(prov);
-    utils::cli::get_api_authentication_data(user, password, port, prov,
+    utils::cli::get_api_authentication_data(user, password, port,
                                             data_directory);
     auto response = client({
                                .host = "localhost",
diff --git a/repertory/repertory/include/cli/get.hpp b/repertory/repertory/include/cli/get.hpp
index e5bddfab..73e1a55d 100644
--- a/repertory/repertory/include/cli/get.hpp
+++ b/repertory/repertory/include/cli/get.hpp
@@ -26,11 +26,11 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto get(std::vector<const char *> args,
-                              const std::string &data_directory,
-                              provider_type prov, const std::string &unique_id,
+                              std::string_view data_directory,
+                              provider_type prov, std::string_view unique_id,
                               std::string user, std::string password)
     -> exit_code {
-  auto ret = cli::check_data_directory(data_directory, prov);
+  auto ret = cli::check_data_directory(data_directory);
   if (ret != exit_code::success) {
     return ret;
   }
@@ -56,7 +56,7 @@ namespace repertory::cli::actions {
 
   if (lock_res == lock_result::locked) {
     auto port = app_config::default_api_port(prov);
-    utils::cli::get_api_authentication_data(user, password, port, prov,
+    utils::cli::get_api_authentication_data(user, password, port,
                                             data_directory);
     auto response = client({
                                .host = "localhost",
diff --git a/repertory/repertory/include/cli/get_directory_items.hpp b/repertory/repertory/include/cli/get_directory_items.hpp
index a93fc06c..e5d733d7 100644
--- a/repertory/repertory/include/cli/get_directory_items.hpp
+++ b/repertory/repertory/include/cli/get_directory_items.hpp
@@ -27,8 +27,8 @@
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
 get_directory_items(std::vector<const char *> args,
-                    const std::string &data_directory, provider_type prov,
-                    const std::string & /* unique_id */, std::string user,
+                    std::string_view data_directory, provider_type prov,
+                    std::string_view /* unique_id */, std::string user,
                     std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
@@ -38,8 +38,7 @@ get_directory_items(std::vector<const char *> args,
   }
 
   auto port = app_config::default_api_port(prov);
-  utils::cli::get_api_authentication_data(user, password, port, prov,
-                                          data_directory);
+  utils::cli::get_api_authentication_data(user, password, port, data_directory);
   auto response = client({
                              .host = "localhost",
                              .password = password,
diff --git a/repertory/repertory/include/cli/get_item_info.hpp b/repertory/repertory/include/cli/get_item_info.hpp
index 0cefb175..9c30a1c6 100644
--- a/repertory/repertory/include/cli/get_item_info.hpp
+++ b/repertory/repertory/include/cli/get_item_info.hpp
@@ -26,8 +26,8 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-get_item_info(std::vector<const char *> args, const std::string &data_directory,
-              provider_type prov, const std::string & /* unique_id */,
+get_item_info(std::vector<const char *> args, std::string_view data_directory,
+              provider_type prov, std::string_view /* unique_id */,
               std::string user, std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
@@ -37,8 +37,7 @@ get_item_info(std::vector<const char *> args, const std::string &data_directory,
   }
 
   auto port = app_config::default_api_port(prov);
-  utils::cli::get_api_authentication_data(user, password, port, prov,
-                                          data_directory);
+  utils::cli::get_api_authentication_data(user, password, port, data_directory);
   auto response = client({
                              .host = "localhost",
                              .password = password,
diff --git a/repertory/repertory/include/cli/get_pinned_files.hpp b/repertory/repertory/include/cli/get_pinned_files.hpp
index ef1b4873..0f7b68e1 100644
--- a/repertory/repertory/include/cli/get_pinned_files.hpp
+++ b/repertory/repertory/include/cli/get_pinned_files.hpp
@@ -26,14 +26,13 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto get_pinned_files(std::vector<const char *> /* args */,
-                                           const std::string &data_directory,
+                                           std::string_view data_directory,
                                            provider_type prov,
-                                           const std::string & /* unique_id */,
+                                           std::string_view /* unique_id */,
                                            std::string user,
                                            std::string password) -> exit_code {
   auto port = app_config::default_api_port(prov);
-  utils::cli::get_api_authentication_data(user, password, port, prov,
-                                          data_directory);
+  utils::cli::get_api_authentication_data(user, password, port, data_directory);
   auto response = client({
                              .host = "localhost",
                              .password = password,
diff --git a/repertory/repertory/include/cli/mount.hpp b/repertory/repertory/include/cli/mount.hpp
index 74840c0f..70141bf0 100644
--- a/repertory/repertory/include/cli/mount.hpp
+++ b/repertory/repertory/include/cli/mount.hpp
@@ -28,8 +28,8 @@
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
 mount(std::vector<const char *> args, std::string data_directory,
-      int &mount_result, provider_type prov, const std::string &remote_host,
-      std::uint16_t remote_port, const std::string &unique_id) -> exit_code {
+      int &mount_result, provider_type prov, std::string_view remote_host,
+      std::uint16_t remote_port, std::string_view unique_id) -> exit_code {
   std::vector<std::string> orig_args;
   args.reserve(args.size());
   for (const auto *arg : args) {
@@ -39,7 +39,7 @@ mount(std::vector<const char *> args, std::string data_directory,
   auto has_gc_option =
       utils::cli::has_option(args, utils::cli::options::generate_config_option);
   if (has_gc_option) {
-    auto res = cli::check_data_directory(data_directory, prov);
+    auto res = cli::check_data_directory(data_directory);
     if (res != exit_code::success) {
       return res;
     }
@@ -129,9 +129,9 @@ mount(std::vector<const char *> args, std::string data_directory,
   std::cout << "Initializing " << app_config::get_provider_display_name(prov)
             << (unique_id.empty() ? ""
                 : (prov == provider_type::remote)
-                    ? " [" + remote_host + ':' + std::to_string(remote_port) +
-                          ']'
-                    : " [" + unique_id + ']')
+                    ? " [" + std::string{remote_host} + ':' +
+                          std::to_string(remote_port) + ']'
+                    : " [" + std::string{unique_id} + ']')
             << " Drive" << std::endl;
   if (prov == provider_type::remote) {
     try {
diff --git a/repertory/repertory/include/cli/open_files.hpp b/repertory/repertory/include/cli/open_files.hpp
index feaa7503..cce3499a 100644
--- a/repertory/repertory/include/cli/open_files.hpp
+++ b/repertory/repertory/include/cli/open_files.hpp
@@ -27,8 +27,8 @@
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
 open_files(std::vector<const char *> /* args */,
-           const std::string &data_directory, provider_type prov,
-           const std::string &unique_id, std::string user, std::string password)
+           std::string_view data_directory, provider_type prov,
+           std::string_view unique_id, std::string user, std::string password)
     -> exit_code {
   lock_data lock(data_directory, prov, unique_id);
   auto lock_res = lock.grab_lock(1U);
@@ -40,8 +40,7 @@ open_files(std::vector<const char *> /* args */,
   }
 
   auto port = app_config::default_api_port(prov);
-  utils::cli::get_api_authentication_data(user, password, port, prov,
-                                          data_directory);
+  utils::cli::get_api_authentication_data(user, password, port, data_directory);
   auto response = client({
                              .host = "localhost",
                              .password = password,
diff --git a/repertory/repertory/include/cli/pin_file.hpp b/repertory/repertory/include/cli/pin_file.hpp
index c5c7becc..c9aa0921 100644
--- a/repertory/repertory/include/cli/pin_file.hpp
+++ b/repertory/repertory/include/cli/pin_file.hpp
@@ -26,9 +26,9 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-pin_file(std::vector<const char *> args, const std::string &data_directory,
-         provider_type prov, const std::string & /* unique_id */,
-         std::string user, std::string password) -> exit_code {
+pin_file(std::vector<const char *> args, std::string_view data_directory,
+         provider_type prov, std::string_view /* unique_id */, std::string user,
+         std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
       args, repertory::utils::cli::options::pin_file_option, data);
@@ -37,8 +37,7 @@ pin_file(std::vector<const char *> args, const std::string &data_directory,
   }
 
   auto port = app_config::default_api_port(prov);
-  utils::cli::get_api_authentication_data(user, password, port, prov,
-                                          data_directory);
+  utils::cli::get_api_authentication_data(user, password, port, data_directory);
   auto response = client({
                              .host = "localhost",
                              .password = password,
diff --git a/repertory/repertory/include/cli/pinned_status.hpp b/repertory/repertory/include/cli/pinned_status.hpp
index c54a1f74..e7628467 100644
--- a/repertory/repertory/include/cli/pinned_status.hpp
+++ b/repertory/repertory/include/cli/pinned_status.hpp
@@ -26,8 +26,8 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-pinned_status(std::vector<const char *> args, const std::string &data_directory,
-              provider_type prov, const std::string & /*unique_id*/,
+pinned_status(std::vector<const char *> args, std::string_view data_directory,
+              provider_type prov, std::string_view /* unique_id */,
               std::string user, std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
@@ -37,8 +37,7 @@ pinned_status(std::vector<const char *> args, const std::string &data_directory,
   }
 
   auto port = app_config::default_api_port(prov);
-  utils::cli::get_api_authentication_data(user, password, port, prov,
-                                          data_directory);
+  utils::cli::get_api_authentication_data(user, password, port, data_directory);
   auto response = client({
                              .host = "localhost",
                              .password = password,
diff --git a/repertory/repertory/include/cli/remove.hpp b/repertory/repertory/include/cli/remove.hpp
index fc538cbd..3807b30c 100644
--- a/repertory/repertory/include/cli/remove.hpp
+++ b/repertory/repertory/include/cli/remove.hpp
@@ -27,11 +27,12 @@
 #include "utils/time.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto
-remove(std::vector<const char *> /* args */, const std::string &data_directory,
-       provider_type prov, const std::string &unique_id, std::string /* user */,
-       std::string /* password */) -> exit_code {
-  auto ret = cli::check_data_directory(data_directory, prov);
+[[nodiscard]] inline auto remove(std::vector<const char *> /* args */,
+                                 std::string_view data_directory,
+                                 provider_type prov, std::string_view unique_id,
+                                 std::string /* user */,
+                                 std::string /* password */) -> exit_code {
+  auto ret = cli::check_data_directory(data_directory);
   if (ret != exit_code::success) {
     return ret;
   }
diff --git a/repertory/repertory/include/cli/set.hpp b/repertory/repertory/include/cli/set.hpp
index 3c0a4204..23e3bcf2 100644
--- a/repertory/repertory/include/cli/set.hpp
+++ b/repertory/repertory/include/cli/set.hpp
@@ -26,11 +26,11 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto set(std::vector<const char *> args,
-                              const std::string &data_directory,
-                              provider_type prov, const std::string &unique_id,
+                              std::string_view data_directory,
+                              provider_type prov, std::string_view unique_id,
                               std::string user, std::string password)
     -> exit_code {
-  auto ret = cli::check_data_directory(data_directory, prov);
+  auto ret = cli::check_data_directory(data_directory);
   if (ret != exit_code::success) {
     return ret;
   }
@@ -60,7 +60,7 @@ namespace repertory::cli::actions {
 
   if (lock_res == lock_result::locked) {
     auto port = app_config::default_api_port(prov);
-    utils::cli::get_api_authentication_data(user, password, port, prov,
+    utils::cli::get_api_authentication_data(user, password, port,
                                             data_directory);
     auto response = client({
                                .host = "localhost",
diff --git a/repertory/repertory/include/cli/status.hpp b/repertory/repertory/include/cli/status.hpp
index d0a7896f..8a95cd85 100644
--- a/repertory/repertory/include/cli/status.hpp
+++ b/repertory/repertory/include/cli/status.hpp
@@ -25,11 +25,12 @@
 #include "cli/common.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto
-status(std::vector<const char *> /* args */, const std::string &data_directory,
-       provider_type prov, const std::string &unique_id, std::string /* user */,
-       std::string /* password */) -> exit_code {
-  auto ret = cli::check_data_directory(data_directory, prov);
+[[nodiscard]] inline auto status(std::vector<const char *> /* args */,
+                                 std::string_view data_directory,
+                                 provider_type prov, std::string_view unique_id,
+                                 std::string /* user */,
+                                 std::string /* password */) -> exit_code {
+  auto ret = cli::check_data_directory(data_directory);
   if (ret != exit_code::success) {
     return ret;
   }
diff --git a/repertory/repertory/include/cli/test.hpp b/repertory/repertory/include/cli/test.hpp
index 13baf6e5..83e3455d 100644
--- a/repertory/repertory/include/cli/test.hpp
+++ b/repertory/repertory/include/cli/test.hpp
@@ -26,10 +26,10 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-test(std::vector<const char *> /* args */, const std::string &data_directory,
-     provider_type prov, const std::string & /*unique_id*/,
-     std::string /*user*/, std::string /*password*/) -> exit_code {
-  auto ret = cli::check_data_directory(data_directory, prov);
+test(std::vector<const char *> /* args */, std::string_view data_directory,
+     provider_type prov, std::string_view /* unique_id */, std::string /*user*/,
+     std::string /*password*/) -> exit_code {
+  auto ret = cli::check_data_directory(data_directory);
   if (ret != exit_code::success) {
     return ret;
   }
diff --git a/repertory/repertory/include/cli/unmount.hpp b/repertory/repertory/include/cli/unmount.hpp
index 5aa00756..6f454f14 100644
--- a/repertory/repertory/include/cli/unmount.hpp
+++ b/repertory/repertory/include/cli/unmount.hpp
@@ -26,14 +26,13 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-unmount(std::vector<const char *> /* args */, const std::string &data_directory,
-        provider_type prov, const std::string & /* unique_id */,
-        std::string user, std::string password) -> exit_code {
+unmount(std::vector<const char *> /* args */, std::string_view data_directory,
+        provider_type prov, std::string_view /* unique_id */, std::string user,
+        std::string password) -> exit_code {
   constexpr const std::uint8_t retry_count{30U};
 
   auto port{app_config::default_api_port(prov)};
-  utils::cli::get_api_authentication_data(user, password, port, prov,
-                                          data_directory);
+  utils::cli::get_api_authentication_data(user, password, port, data_directory);
   auto response = client({
                              .host = "localhost",
                              .password = password,
diff --git a/repertory/repertory/include/cli/unpin_file.hpp b/repertory/repertory/include/cli/unpin_file.hpp
index bdd921b5..2de8034e 100644
--- a/repertory/repertory/include/cli/unpin_file.hpp
+++ b/repertory/repertory/include/cli/unpin_file.hpp
@@ -26,8 +26,8 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-unpin_file(std::vector<const char *> args, const std::string &data_directory,
-           provider_type prov, const std::string & /*unique_id*/,
+unpin_file(std::vector<const char *> args, std::string_view data_directory,
+           provider_type prov, std::string_view /* unique_id */,
            std::string user, std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
@@ -37,8 +37,7 @@ unpin_file(std::vector<const char *> args, const std::string &data_directory,
   }
 
   auto port = app_config::default_api_port(prov);
-  utils::cli::get_api_authentication_data(user, password, port, prov,
-                                          data_directory);
+  utils::cli::get_api_authentication_data(user, password, port, data_directory);
   auto response = client({
                              .host = "localhost",
                              .password = password,
diff --git a/repertory/repertory/include/ui/ui_server.hpp b/repertory/repertory/include/ui/ui_server.hpp
index 61a994f8..0d489988 100644
--- a/repertory/repertory/include/ui/ui_server.hpp
+++ b/repertory/repertory/include/ui/ui_server.hpp
@@ -135,7 +135,7 @@ private:
       -> std::vector<std::string>;
 
   [[nodiscard]] auto mount(provider_type prov, std::string_view name,
-                           const std::string &location) -> bool;
+                           std::string_view location) -> bool;
 
   void notify_and_unlock(unique_mutex_lock &nonce_lock);
 
diff --git a/repertory/repertory/src/ui/ui_server.cpp b/repertory/repertory/src/ui/ui_server.cpp
index 3e1cb9cc..fa188014 100644
--- a/repertory/repertory/src/ui/ui_server.cpp
+++ b/repertory/repertory/src/ui/ui_server.cpp
@@ -840,7 +840,7 @@ auto ui_server::launch_process(provider_type prov, std::string_view name,
 }
 
 auto ui_server::mount(provider_type prov, std::string_view name,
-                      const std::string &location) -> bool {
+                      std::string_view location) -> bool {
 #if defined(_WIN32)
   if (utils::file::directory{location}.exists()) {
 #else  // !defined(_WIN32)
@@ -856,7 +856,7 @@ auto ui_server::mount(provider_type prov, std::string_view name,
   static std::mutex mount_mtx;
   mutex_lock nonce_lock(mount_mtx);
 
-  launch_process(prov, name, {location}, true);
+  launch_process(prov, name, {std::string{location}}, true);
   return true;
 }
 
diff --git a/repertory/repertory_test/include/fixtures/drive_fixture.hpp b/repertory/repertory_test/include/fixtures/drive_fixture.hpp
index 81660233..7efcf431 100644
--- a/repertory/repertory_test/include/fixtures/drive_fixture.hpp
+++ b/repertory/repertory_test/include/fixtures/drive_fixture.hpp
@@ -129,13 +129,13 @@ struct platform_ops {
 #endif // !defined(_WIN32)
   }
 
-  static auto build_cmd(const std::string &args_joined,
+  static auto build_cmd(std::string_view args_joined,
                         [[maybe_unused]] bool is_mount) -> std::string {
 #if defined(_WIN32)
     if (is_mount) {
-      return "start .\\repertory.exe -f " + args_joined;
+      return "start .\\repertory.exe -f " + std::string{args_joined};
     }
-    return ".\\repertory.exe " + args_joined;
+    return ".\\repertory.exe " + std::string{args_joined};
 #else // !defined(_WIN32)
 #if defined(__APPLE__)
     constexpr std::string_view repertory_bin =
@@ -143,12 +143,12 @@ struct platform_ops {
 #else  // !defined(__APPLE__)
     constexpr std::string_view repertory_bin = "./repertory ";
 #endif // defined(__APPLE__)
-    return std::string(repertory_bin) + args_joined;
+    return std::string(repertory_bin) + std::string{args_joined};
 #endif // defined(_WIN32)
   }
 
   static void execute_mount(std::vector<std::string> args_without_location,
-                            const std::string &location) {
+                            std::string_view location) {
     ensure_process_cwd();
     args_without_location.emplace_back(location);
 
@@ -162,7 +162,7 @@ struct platform_ops {
   }
 
   static void execute_unmount(std::vector<std::string> args_without_unmount,
-                              [[maybe_unused]] const std::string &location) {
+                              [[maybe_unused]] std::string_view location) {
     ensure_process_cwd();
     args_without_unmount.emplace_back("-unmount");
 
@@ -206,16 +206,16 @@ protected:
   static void SetUpTestCase() {
     current_directory = std::filesystem::current_path();
 
-    const auto make_test_dir = [](const std::string &suite,
-                                  const std::string &sub) -> std::string {
+    const auto make_test_dir = [](std::string_view suite,
+                                  std::string_view sub) -> std::string {
       return utils::path::combine(test::get_test_output_dir(), {
                                                                    suite,
                                                                    sub,
                                                                });
     };
 
-    const auto make_cfg_dir = [](const std::string &root,
-                                 const std::string &name) -> std::string {
+    const auto make_cfg_dir = [](std::string_view root,
+                                 std::string_view name) -> std::string {
       auto cfg = utils::path::combine(root, {name});
       EXPECT_TRUE(utils::file::directory(cfg).create_directory());
       return cfg;
@@ -501,9 +501,9 @@ public:
     EXPECT_FALSE(utils::file::directory(file_path).exists());
   }
 
-  static void unlink_root_file(const std::string &file_path) {
+  static void unlink_root_file(std::string_view file_path) {
     auto api_path = utils::path::create_api_path(
-        utils::path::strip_to_file_name(file_path));
+        utils::path::strip_to_file_name(std::string{file_path}));
 
     [[maybe_unused]] auto res =
         meta->set_item_meta(api_path, {
@@ -515,14 +515,14 @@ public:
     unlink_file_and_test(file_path);
   }
 
-  static void overwrite_text(const std::string &path, const std::string &data) {
-    int desc = ::open(path.c_str(), O_WRONLY | O_TRUNC);
+  static void overwrite_text(std::string_view path, std::string_view data) {
+    int desc = ::open(std::string{path}.c_str(), O_WRONLY | O_TRUNC);
     ASSERT_NE(desc, -1);
     write_all(desc, data);
     ::close(desc);
   }
 
-  static void write_all(int desc, const std::string &data) {
+  static void write_all(int desc, std::string_view data) {
     std::size_t off{0U};
     while (off < data.size()) {
       auto written = ::write(desc, &data.at(off), data.length() - off);
@@ -531,8 +531,8 @@ public:
     }
   }
 
-  static auto slurp(const std::string &path) -> std::string {
-    int desc = ::open(path.c_str(), O_RDONLY);
+  static auto slurp(std::string_view path) -> std::string {
+    int desc = ::open(std::string{path}.c_str(), O_RDONLY);
     if (desc == -1) {
       return {};
     }
@@ -557,9 +557,9 @@ public:
     return out;
   }
 
-  [[nodiscard]] static auto stat_size(const std::string &path) -> off_t {
+  [[nodiscard]] static auto stat_size(std::string_view path) -> off_t {
     struct stat st_unix{};
-    int res = ::stat(path.c_str(), &st_unix);
+    int res = ::stat(std::string{path}.c_str(), &st_unix);
     EXPECT_EQ(0, res) << "stat(" << path
                       << ") failed: " << std::strerror(errno);
     return st_unix.st_size;
diff --git a/repertory/repertory_test/include/fixtures/providers_fixture.hpp b/repertory/repertory_test/include/fixtures/providers_fixture.hpp
index 2ca78e5f..fea401fc 100644
--- a/repertory/repertory_test/include/fixtures/providers_fixture.hpp
+++ b/repertory/repertory_test/include/fixtures/providers_fixture.hpp
@@ -218,11 +218,11 @@ protected:
     }
   }
 
-  static void create_directory(const std::string &api_path) {
+  static void create_directory(std::string_view api_path) {
     auto date = utils::time::get_time_now();
-    auto meta = create_meta_attributes(date, 1U, date + 1U, date + 2U, true,
-                                       getgid(), "", 0700, date + 3U, 2U, 0U,
-                                       api_path + "_src", getuid(), date + 4U);
+    auto meta = create_meta_attributes(
+        date, 1U, date + 1U, date + 2U, true, getgid(), "", 0700, date + 3U, 2U,
+        0U, std::string{api_path} + "_src", getuid(), date + 4U);
     EXPECT_EQ(api_error::success, provider->create_directory(api_path, meta));
 
     bool exists{};
@@ -249,7 +249,7 @@ protected:
     EXPECT_EQ(date + 4U, utils::string::to_uint64(meta2[META_WRITTEN]));
   }
 
-  static void create_file(const std::string &api_path) {
+  static void create_file(std::string_view api_path) {
     auto source_path = test::generate_test_file_name("providers_test");
 
     auto date = utils::time::get_time_now();
@@ -304,7 +304,7 @@ protected:
   }
 
   [[nodiscard]] static auto
-  pinned_includes_api_path(const auto &pinned, const std::string &expected_path)
+  pinned_includes_api_path(const auto &pinned, std::string_view expected_path)
       -> bool {
     return std::ranges::any_of(pinned,
                                [&expected_path](auto &&api_path) -> bool {
diff --git a/repertory/repertory_test/include/mocks/mock_fuse_drive.hpp b/repertory/repertory_test/include/mocks/mock_fuse_drive.hpp
index 8f649186..837e9547 100644
--- a/repertory/repertory_test/include/mocks/mock_fuse_drive.hpp
+++ b/repertory/repertory_test/include/mocks/mock_fuse_drive.hpp
@@ -44,21 +44,20 @@ private:
   std::unordered_map<std::string, api_meta_map> meta_;
 
 public:
-  auto check_owner(const std::string &) const -> api_error override {
+  auto check_owner(std::string_view) const -> api_error override {
     return api_error::success;
   }
 
-  auto check_parent_access(const std::string &, int) const
-      -> api_error override {
+  auto check_parent_access(std::string_view, int) const -> api_error override {
     return api_error::success;
   }
 
-  auto get_directory_item_count(const std::string &) const
+  auto get_directory_item_count(std::string_view) const
       -> std::uint64_t override {
     return 1;
   }
 
-  auto get_directory_items(const std::string &) const
+  auto get_directory_items(std::string_view) const
       -> directory_item_list override {
     directory_item_list list{};
 
@@ -80,19 +79,20 @@ public:
     return list;
   }
 
-  auto get_file_size(const std::string &) const -> std::uint64_t override {
+  auto get_file_size(std::string_view) const -> std::uint64_t override {
     return 0U;
   }
 
-  auto get_item_meta(const std::string &api_path, api_meta_map &meta) const
+  auto get_item_meta(std::string_view api_path, api_meta_map &meta) const
       -> api_error override {
-    meta = const_cast<mock_fuse_drive *>(this)->meta_[api_path];
+    meta = const_cast<mock_fuse_drive *>(this)->meta_[std::string{api_path}];
     return api_error::success;
   }
 
-  auto get_item_meta(const std::string &api_path, const std::string &name,
+  auto get_item_meta(std::string_view api_path, std::string_view name,
                      std::string &value) const -> api_error override {
-    value = const_cast<mock_fuse_drive *>(this)->meta_[api_path][name];
+    value = const_cast<mock_fuse_drive *>(this)
+                ->meta_[std::string{api_path}][std::string{name}];
     if (value.empty()) {
       value = "0";
     }
@@ -114,8 +114,8 @@ public:
     volume_label = "TestVolumeLabel";
   }
 
-  auto rename_directory(const std::string &from_api_path,
-                        const std::string &to_api_path) -> int override {
+  auto rename_directory(std::string_view from_api_path,
+                        std::string_view to_api_path) -> int override {
     const auto from_file_path =
         utils::path::combine(mount_location_, {from_api_path});
     const auto to_file_path =
@@ -123,9 +123,8 @@ public:
     return rename(from_file_path.c_str(), to_file_path.c_str());
   }
 
-  auto rename_file(const std::string &from_api_path,
-                   const std::string &to_api_path, bool overwrite)
-      -> int override {
+  auto rename_file(std::string_view from_api_path, std::string_view to_api_path,
+                   bool overwrite) -> int override {
     const auto from_file_path =
         utils::path::combine(mount_location_, {from_api_path});
     const auto to_file_path =
@@ -144,19 +143,17 @@ public:
     return rename(from_file_path.c_str(), to_file_path.c_str());
   }
 
-  auto is_processing(const std::string &) const -> bool override {
-    return false;
+  auto is_processing(std::string_view) const -> bool override { return false; }
+
+  void set_item_meta(std::string_view api_path, std::string_view key,
+                     std::string_view value) override {
+    meta_[std::string{api_path}][std::string{key}] = value;
   }
 
-  void set_item_meta(const std::string &api_path, const std::string &key,
-                     const std::string &value) override {
-    meta_[api_path][key] = value;
-  }
-
-  void set_item_meta(const std::string &api_path,
+  void set_item_meta(std::string_view api_path,
                      const api_meta_map &meta) override {
     for (const auto &[key, value] : meta) {
-      meta_[api_path][key] = value;
+      meta_[std::string{api_path}][key] = value;
     }
   }
 };
diff --git a/repertory/repertory_test/include/mocks/mock_open_file.hpp b/repertory/repertory_test/include/mocks/mock_open_file.hpp
index f65d78be..6b889365 100644
--- a/repertory/repertory_test/include/mocks/mock_open_file.hpp
+++ b/repertory/repertory_test/include/mocks/mock_open_file.hpp
@@ -103,7 +103,7 @@ public:
 
   MOCK_METHOD(api_error, resize, (std::uint64_t new_file_size), (override));
 
-  MOCK_METHOD(void, set_api_path, (const std::string &api_path), (override));
+  MOCK_METHOD(void, set_api_path, (std::string_view api_path), (override));
 
   MOCK_METHOD(void, set_unlinked, (bool value), (override));
 
diff --git a/repertory/repertory_test/include/mocks/mock_provider.hpp b/repertory/repertory_test/include/mocks/mock_provider.hpp
index 563e45ce..c85fd079 100644
--- a/repertory/repertory_test/include/mocks/mock_provider.hpp
+++ b/repertory/repertory_test/include/mocks/mock_provider.hpp
@@ -41,55 +41,54 @@ public:
               (const, override));
 
   MOCK_METHOD(api_error, create_directory,
-              (const std::string &api_path, api_meta_map &meta), (override));
+              (std::string_view api_path, api_meta_map &meta), (override));
 
   MOCK_METHOD(api_error, create_directory_clone_source_meta,
-              (const std::string &source_api_path, const std::string &api_path),
+              (std::string_view source_api_path, std::string_view api_path),
               (override));
 
   MOCK_METHOD(api_error, create_file,
-              (const std::string &api_path, api_meta_map &meta), (override));
+              (std::string_view api_path, api_meta_map &meta), (override));
 
   MOCK_METHOD(api_error, get_api_path_from_source,
-              (const std::string &source_path, std::string &api_path),
+              (std::string_view source_path, std::string &api_path),
               (const, override));
 
   MOCK_METHOD(std::uint64_t, get_directory_item_count,
-              (const std::string &api_path), (const, override));
+              (std::string_view api_path), (const, override));
 
   MOCK_METHOD(api_error, get_directory_item,
-              (const std::string &api_path, directory_item &item),
+              (std::string_view api_path, directory_item &item),
               (const, override));
 
   MOCK_METHOD(api_error, get_directory_items,
-              (const std::string &api_path, directory_item_list &list),
+              (std::string_view api_path, directory_item_list &list),
               (const, override));
 
-  MOCK_METHOD(api_error, get_file,
-              (const std::string &api_path, api_file &file), (const, override));
+  MOCK_METHOD(api_error, get_file, (std::string_view api_path, api_file &file),
+              (const, override));
 
   MOCK_METHOD(api_error, get_file_list,
               (api_file_list & list, std::string &marker), (const, override));
 
   MOCK_METHOD(api_error, get_file_size,
-              (const std::string &api_path, std::uint64_t &file_size),
+              (std::string_view api_path, std::uint64_t &file_size),
               (const, override));
 
   MOCK_METHOD(api_error, get_filesystem_item,
-              (const std::string &api_path, bool directory,
-               filesystem_item &fsi),
+              (std::string_view api_path, bool directory, filesystem_item &fsi),
               (const, override));
 
   MOCK_METHOD(api_error, get_filesystem_item_from_source_path,
-              (const std::string &source_path, filesystem_item &fsi),
+              (std::string_view source_path, filesystem_item &fsi),
               (const, override));
 
   MOCK_METHOD(api_error, get_item_meta,
-              (const std::string &api_path, api_meta_map &meta),
+              (std::string_view api_path, api_meta_map &meta),
               (const, override));
 
   MOCK_METHOD(api_error, get_item_meta,
-              (const std::string &api_path, const std::string &key,
+              (std::string_view api_path, std::string_view key,
                std::string &value),
               (const, override));
 
@@ -107,9 +106,9 @@ public:
   MOCK_METHOD(bool, is_read_only, (), (const, override));
 
   MOCK_METHOD(api_error, is_directory,
-              (const std::string &api_path, bool &exists), (const, override));
+              (std::string_view api_path, bool &exists), (const, override));
 
-  MOCK_METHOD(api_error, is_file, (const std::string &api_path, bool &exists),
+  MOCK_METHOD(api_error, is_file, (std::string_view api_path, bool &exists),
               (const, override));
 
   MOCK_METHOD(bool, is_online, (), (const, override));
@@ -117,32 +116,29 @@ public:
   bool is_rename_supported() const override { return allow_rename_; }
 
   MOCK_METHOD(api_error, read_file_bytes,
-              (const std::string &path, std::size_t size, std::uint64_t offset,
+              (std::string_view path, std::size_t size, std::uint64_t offset,
                data_buffer &data, stop_type &stop_requested),
               (override));
 
-  MOCK_METHOD(api_error, remove_directory, (const std::string &api_path),
+  MOCK_METHOD(api_error, remove_directory, (std::string_view api_path),
               (override));
 
-  MOCK_METHOD(api_error, remove_file, (const std::string &api_path),
-              (override));
+  MOCK_METHOD(api_error, remove_file, (std::string_view api_path), (override));
 
   MOCK_METHOD(api_error, remove_item_meta,
-              (const std::string &api_path, const std::string &key),
-              (override));
+              (std::string_view api_path, std::string_view key), (override));
 
   MOCK_METHOD(api_error, rename_file,
-              (const std::string &from_api_path,
-               const std::string &to_api_path),
+              (std::string_view from_api_path, std::string_view to_api_path),
               (override));
 
   MOCK_METHOD(api_error, set_item_meta,
-              (const std::string &api_path, const std::string &key,
-               const std::string &value),
+              (std::string_view api_path, std::string_view key,
+               std::string_view value),
               (override));
 
   MOCK_METHOD(api_error, set_item_meta,
-              (const std::string &api_path, api_meta_map meta), (override));
+              (std::string_view api_path, api_meta_map meta), (override));
 
   MOCK_METHOD(bool, start,
               (api_item_added_callback api_item_added, i_file_manager *fm),
@@ -151,7 +147,7 @@ public:
   MOCK_METHOD(void, stop, (), (override));
 
   MOCK_METHOD(api_error, upload_file,
-              (const std::string &api_path, const std::string &source_path,
+              (std::string_view api_path, std::string_view source_path,
                stop_type &stop_requested),
               (override));
 };
diff --git a/repertory/repertory_test/include/mocks/mock_upload_manager.hpp b/repertory/repertory_test/include/mocks/mock_upload_manager.hpp
index 4ab7671e..91471e48 100644
--- a/repertory/repertory_test/include/mocks/mock_upload_manager.hpp
+++ b/repertory/repertory_test/include/mocks/mock_upload_manager.hpp
@@ -32,10 +32,10 @@ public:
   MOCK_METHOD(void, queue_upload, (const i_open_file &o), (override));
 
   MOCK_METHOD(void, remove_resume,
-              (const std::string &api_path, const std::string &source_path),
+              (std::string_view api_path, std::string_view source_path),
               (override));
 
-  MOCK_METHOD(void, remove_upload, (const std::string &api_path), (override));
+  MOCK_METHOD(void, remove_upload, (std::string_view api_path), (override));
 
   MOCK_METHOD(void, store_resume, (const i_open_file &o), (override));
 };
diff --git a/repertory/repertory_test/include/mocks/mock_winfsp_drive.hpp b/repertory/repertory_test/include/mocks/mock_winfsp_drive.hpp
index b6604f32..c14ce48c 100644
--- a/repertory/repertory_test/include/mocks/mock_winfsp_drive.hpp
+++ b/repertory/repertory_test/include/mocks/mock_winfsp_drive.hpp
@@ -43,12 +43,12 @@ private:
 
 public:
   [[nodiscard]] auto
-  get_directory_item_count(const std::string & /*api_path*/) const
+  get_directory_item_count(std::string_view /*api_path*/) const
       -> std::uint64_t override {
     return 1;
   }
 
-  [[nodiscard]] auto get_directory_items(const std::string & /*api_path*/) const
+  [[nodiscard]] auto get_directory_items(std::string_view /*api_path*/) const
       -> directory_item_list override {
     directory_item_list list{};
 
@@ -69,18 +69,17 @@ public:
     return list;
   }
 
-  [[nodiscard]] auto get_file_size(const std::string & /*api_path*/) const
+  [[nodiscard]] auto get_file_size(std::string_view /*api_path*/) const
       -> std::uint64_t override {
     return 0;
   }
 
-  auto get_item_meta(const std::string & /*api_path*/,
+  auto get_item_meta(std::string_view /*api_path*/,
                      api_meta_map & /* meta */) const -> api_error override {
     return api_error::error;
   }
 
-  auto get_item_meta(const std::string & /*api_path*/,
-                     const std::string & /*name*/,
+  auto get_item_meta(std::string_view /*api_path*/, std::string_view /*name*/,
                      std::string & /*value*/) const -> api_error override {
     return api_error::error;
   }
@@ -135,7 +134,7 @@ public:
     volume_label = "TestVolumeLabel";
   }
 
-  auto populate_file_info(const std::string &api_path,
+  auto populate_file_info(std::string_view api_path,
                           remote::file_info &r_info) const
       -> api_error override {
     auto file_path = utils::path::combine(mount_location_, {api_path});
diff --git a/repertory/repertory_test/include/utils/event_capture.hpp b/repertory/repertory_test/include/utils/event_capture.hpp
index 7030039f..63db5eec 100644
--- a/repertory/repertory_test/include/utils/event_capture.hpp
+++ b/repertory/repertory_test/include/utils/event_capture.hpp
@@ -88,7 +88,7 @@ public:
     lock.unlock();
   }
 
-  [[nodiscard]] auto wait_for_event(const std::string &event_name) -> bool {
+  [[nodiscard]] auto wait_for_event(std::string_view event_name) -> bool {
     auto missing = true;
     const auto start_time = std::chrono::system_clock::now();
 
diff --git a/repertory/repertory_test/src/app_config_test.cpp b/repertory/repertory_test/src/app_config_test.cpp
index 699b14c5..8a9688aa 100644
--- a/repertory/repertory_test/src/app_config_test.cpp
+++ b/repertory/repertory_test/src/app_config_test.cpp
@@ -197,8 +197,8 @@ static void defaults_tests(const json &json_data, provider_type prov) {
 
 template <typename get_t, typename set_t, typename val_t>
 static void test_getter_setter(app_config &cfg, get_t getter, set_t setter,
-                               val_t val1, val_t val2, const std::string &key,
-                               const std::string &val_str) {
+                               val_t val1, val_t val2, std::string_view key,
+                               std::string_view val_str) {
   (cfg.*setter)(val1);
   ASSERT_TRUE((cfg.*getter)() == val1);
 
@@ -209,7 +209,8 @@ static void test_getter_setter(app_config &cfg, get_t getter, set_t setter,
     return;
   }
 
-  EXPECT_STREQ(val_str.c_str(), cfg.set_value_by_name(key, val_str).c_str());
+  EXPECT_STREQ(std::string{val_str}.c_str(),
+               cfg.set_value_by_name(key, val_str).c_str());
 }
 
 static void common_tests(app_config &config, provider_type prov) {
diff --git a/repertory/repertory_test/src/direct_open_file_test.cpp b/repertory/repertory_test/src/direct_open_file_test.cpp
index e2fa7d62..4dcdaf39 100644
--- a/repertory/repertory_test/src/direct_open_file_test.cpp
+++ b/repertory/repertory_test/src/direct_open_file_test.cpp
@@ -45,7 +45,7 @@ TEST_F(direct_open_file_test, read_full_file) {
   auto test_buffer = build_test_buffer(source_file);
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([test_buffer](const std::string &, std::size_t size,
+      .WillRepeatedly([test_buffer](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
         if (stop_requested) {
@@ -113,7 +113,7 @@ TEST_F(direct_open_file_test, read_full_file_in_reverse) {
   auto test_buffer = build_test_buffer(source_file);
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([test_buffer](const std::string &, std::size_t size,
+      .WillRepeatedly([test_buffer](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
         if (stop_requested) {
@@ -179,7 +179,7 @@ TEST_F(direct_open_file_test, read_full_file_in_partial_chunks) {
   auto test_buffer = build_test_buffer(source_file);
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([test_buffer](const std::string &, std::size_t size,
+      .WillRepeatedly([test_buffer](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
         if (stop_requested) {
@@ -242,7 +242,7 @@ TEST_F(direct_open_file_test, read_full_file_in_partial_chunks_in_reverse) {
   auto test_buffer = build_test_buffer(source_file);
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([test_buffer](const std::string &, std::size_t size,
+      .WillRepeatedly([test_buffer](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
         if (stop_requested) {
@@ -313,7 +313,7 @@ TEST_F(direct_open_file_test, clamp_read_past_eof_returns_remaining_only) {
   auto test_buffer = build_test_buffer(source_file);
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([test_buffer](const std::string &, std::size_t size,
+      .WillRepeatedly([test_buffer](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
         if (stop_requested) {
@@ -382,7 +382,7 @@ TEST_F(direct_open_file_test, cross_boundary_small_read_is_correct) {
   auto test_buffer = build_test_buffer(source_file);
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([test_buffer](const std::string &, std::size_t size,
+      .WillRepeatedly([test_buffer](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
         if (stop_requested) {
@@ -430,7 +430,7 @@ TEST_F(direct_open_file_test, random_seek_pattern_reads_match_source) {
   auto test_buffer = build_test_buffer(source_file);
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([test_buffer](const std::string &, std::size_t size,
+      .WillRepeatedly([test_buffer](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
         if (stop_requested) {
@@ -496,7 +496,7 @@ TEST_F(direct_open_file_test, provider_error_is_propagated) {
   bool fail_once{true};
   EXPECT_CALL(provider, read_file_bytes)
       .WillRepeatedly(
-          [test_buffer, &fail_once](const std::string &, std::size_t size,
+          [test_buffer, &fail_once](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
             if (stop_requested) {
@@ -546,7 +546,7 @@ TEST_F(direct_open_file_test, tiny_file_smaller_than_chunk) {
   auto test_buffer = build_test_buffer(source_file);
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([test_buffer](const std::string &, std::size_t size,
+      .WillRepeatedly([test_buffer](std::string_view, std::size_t size,
                                     std::uint64_t offset, data_buffer &data,
                                     stop_type &stop_requested) -> api_error {
         if (stop_requested) {
diff --git a/repertory/repertory_test/src/file_manager_test.cpp b/repertory/repertory_test/src/file_manager_test.cpp
index 1569c63b..70c87b6d 100644
--- a/repertory/repertory_test/src/file_manager_test.cpp
+++ b/repertory/repertory_test/src/file_manager_test.cpp
@@ -162,9 +162,9 @@ TEST_F(file_manager_test, can_create_and_close_file) {
     EXPECT_CALL(mp, create_file("/test_create.txt", meta))
         .WillOnce(Return(api_error::success));
     EXPECT_CALL(mp, get_filesystem_item)
-        .WillOnce([&meta](const std::string &api_path, bool directory,
+        .WillOnce([&meta](std::string_view api_path, bool directory,
                           filesystem_item &fsi) -> api_error {
-          EXPECT_STREQ("/test_create.txt", api_path.c_str());
+          EXPECT_STREQ("/test_create.txt", std::string{api_path}.c_str());
           EXPECT_FALSE(directory);
           fsi.api_path = api_path;
           fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -268,9 +268,9 @@ TEST_F(file_manager_test, can_open_and_close_file) {
     EXPECT_CALL(mp, create_file).Times(0U);
 
     EXPECT_CALL(mp, get_filesystem_item)
-        .WillOnce([&meta](const std::string &api_path, bool directory,
+        .WillOnce([&meta](std::string_view api_path, bool directory,
                           filesystem_item &fsi) -> api_error {
-          EXPECT_STREQ("/test_open.txt", api_path.c_str());
+          EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
           EXPECT_FALSE(directory);
           fsi.api_path = api_path;
           fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -363,9 +363,9 @@ TEST_F(file_manager_test, can_open_and_close_multiple_handles_for_same_file) {
     EXPECT_CALL(mp, create_file).Times(0U);
 
     EXPECT_CALL(mp, get_filesystem_item)
-        .WillOnce([&meta](const std::string &api_path, bool directory,
+        .WillOnce([&meta](std::string_view api_path, bool directory,
                           filesystem_item &fsi) -> api_error {
-          EXPECT_STREQ("/test_open.txt", api_path.c_str());
+          EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
           EXPECT_FALSE(directory);
           fsi.api_path = api_path;
           fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -441,9 +441,10 @@ TEST_F(file_manager_test,
       test::create_random_file(utils::string::to_uint64(meta[META_SIZE]));
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillRepeatedly([&meta](const std::string &api_path, bool directory,
+      .WillRepeatedly([&meta](std::string_view api_path, bool directory,
                               filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_write_partial_download.txt", api_path.c_str());
+        EXPECT_STREQ("/test_write_partial_download.txt",
+                     std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -454,9 +455,8 @@ TEST_F(file_manager_test,
       });
 
   EXPECT_CALL(mp, read_file_bytes)
-      .WillRepeatedly([&file](const std::string & /* api_path */,
-                              std::size_t size, std::uint64_t offset,
-                              data_buffer &data,
+      .WillRepeatedly([&file](std::string_view /* api_path */, std::size_t size,
+                              std::uint64_t offset, data_buffer &data,
                               stop_type &stop_requested) -> api_error {
         if (stop_requested) {
           return api_error::download_stopped;
@@ -489,13 +489,12 @@ TEST_F(file_manager_test,
 #endif
 
   EXPECT_CALL(mp, set_item_meta("/test_write_partial_download.txt", _))
-      .WillOnce(
-          [](const std::string &, const api_meta_map &meta2) -> api_error {
-            EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_CHANGED).empty()));
-            EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_MODIFIED).empty()));
-            EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_WRITTEN).empty()));
-            return api_error::success;
-          });
+      .WillOnce([](std::string_view, const api_meta_map &meta2) -> api_error {
+        EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_CHANGED).empty()));
+        EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_MODIFIED).empty()));
+        EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_WRITTEN).empty()));
+        return api_error::success;
+      });
   EXPECT_CALL(mp, upload_file).Times(0u);
 
   if (not open_file->is_write_supported()) {
@@ -597,9 +596,10 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) {
       test::create_random_file(utils::string::to_uint64(meta[META_SIZE]));
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillRepeatedly([&meta](const std::string &api_path, bool directory,
+      .WillRepeatedly([&meta](std::string_view api_path, bool directory,
                               filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_write_full_download.txt", api_path.c_str());
+        EXPECT_STREQ("/test_write_full_download.txt",
+                     std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -610,9 +610,8 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) {
       });
 
   EXPECT_CALL(mp, read_file_bytes)
-      .WillRepeatedly([&file](const std::string & /* api_path */,
-                              std::size_t size, std::uint64_t offset,
-                              data_buffer &data,
+      .WillRepeatedly([&file](std::string_view /* api_path */, std::size_t size,
+                              std::uint64_t offset, data_buffer &data,
                               stop_type & /* stop_requested */) -> api_error {
         std::size_t bytes_read{};
         data.resize(size);
@@ -633,13 +632,12 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) {
 #endif
 
   EXPECT_CALL(mp, set_item_meta("/test_write_full_download.txt", _))
-      .WillOnce(
-          [](const std::string &, const api_meta_map &meta2) -> api_error {
-            EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_CHANGED).empty()));
-            EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_MODIFIED).empty()));
-            EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_WRITTEN).empty()));
-            return api_error::success;
-          });
+      .WillOnce([](std::string_view, const api_meta_map &meta2) -> api_error {
+        EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_CHANGED).empty()));
+        EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_MODIFIED).empty()));
+        EXPECT_NO_THROW(EXPECT_FALSE(meta2.at(META_WRITTEN).empty()));
+        return api_error::success;
+      });
 
   if (not open_file->is_write_supported()) {
     EXPECT_TRUE(mgr.get_open_file(handle, true, open_file));
@@ -709,9 +707,9 @@ TEST_F(file_manager_test, can_evict_file) {
     EXPECT_CALL(mp, create_file("/test_evict.txt", meta))
         .WillOnce(Return(api_error::success));
     EXPECT_CALL(mp, get_filesystem_item)
-        .WillRepeatedly([&meta](const std::string &api_path, bool directory,
+        .WillRepeatedly([&meta](std::string_view api_path, bool directory,
                                 filesystem_item &fsi) -> api_error {
-          EXPECT_STREQ("/test_evict.txt", api_path.c_str());
+          EXPECT_STREQ("/test_evict.txt", std::string{api_path}.c_str());
           EXPECT_FALSE(directory);
           fsi.api_path = api_path;
           fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -754,10 +752,10 @@ TEST_F(file_manager_test, can_evict_file) {
       [&mgr]() -> bool { return not mgr.is_processing("/test_evict.txt"); }));
 
   EXPECT_CALL(mp, get_item_meta(_, META_PINNED, _))
-      .WillOnce([](const std::string &api_path, const std::string &key,
+      .WillOnce([](std::string_view api_path, std::string_view key,
                    std::string &value) -> api_error {
-        EXPECT_STREQ("/test_evict.txt", api_path.c_str());
-        EXPECT_STREQ(META_PINNED.c_str(), key.c_str());
+        EXPECT_STREQ("/test_evict.txt", std::string{api_path}.c_str());
+        EXPECT_STREQ(META_PINNED.c_str(), std::string{key}.c_str());
         value = "0";
         return api_error::success;
       });
@@ -772,7 +770,7 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_pinned) {
   file_manager mgr(*cfg, mp);
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillRepeatedly([](const std::string &api_path, bool directory,
+      .WillRepeatedly([](std::string_view api_path, bool directory,
                          filesystem_item &fsi) -> api_error {
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -783,10 +781,10 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_pinned) {
       });
 
   EXPECT_CALL(mp, get_item_meta(_, META_PINNED, _))
-      .WillOnce([](const std::string &api_path, const std::string &key,
+      .WillOnce([](std::string_view api_path, std::string_view key,
                    std::string &value) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
-        EXPECT_STREQ(META_PINNED.c_str(), key.c_str());
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
+        EXPECT_STREQ(META_PINNED.c_str(), std::string{key}.c_str());
         value = "1";
         return api_error::success;
       });
@@ -805,9 +803,10 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_open) {
   file_manager mgr(*cfg, mp);
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
+
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -817,10 +816,10 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_open) {
       });
 
   EXPECT_CALL(mp, set_item_meta(_, _, _))
-      .WillOnce([](const std::string &api_path, const std::string &key,
-                   const std::string &value) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
-        EXPECT_STREQ(META_SOURCE.c_str(), key.c_str());
+      .WillOnce([](std::string_view api_path, std::string_view key,
+                   std::string_view value) -> api_error {
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
+        EXPECT_STREQ(META_SOURCE.c_str(), std::string{key}.c_str());
         EXPECT_FALSE(value.empty());
         return api_error::success;
       });
@@ -845,8 +844,7 @@ TEST_F(file_manager_test, evict_file_fails_if_unable_to_get_filesystem_item) {
   file_manager mgr(*cfg, mp);
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillRepeatedly([](const std::string & /* api_path */,
-                         bool /* directory */,
+      .WillRepeatedly([](std::string_view /* api_path */, bool /* directory */,
                          filesystem_item & /* fsi */) -> api_error {
         return api_error::error;
       });
@@ -859,7 +857,7 @@ TEST_F(file_manager_test, evict_file_fails_if_source_path_is_empty) {
   file_manager mgr(*cfg, mp);
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillRepeatedly([](const std::string &api_path, bool directory,
+      .WillRepeatedly([](std::string_view api_path, bool directory,
                          filesystem_item &fsi) -> api_error {
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -902,9 +900,9 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_uploading) {
     EXPECT_CALL(mp, create_file("/test_evict.txt", meta))
         .WillOnce(Return(api_error::success));
     EXPECT_CALL(mp, get_filesystem_item)
-        .WillRepeatedly([&meta](const std::string &api_path, bool directory,
+        .WillRepeatedly([&meta](std::string_view api_path, bool directory,
                                 filesystem_item &fsi) -> api_error {
-          EXPECT_STREQ("/test_evict.txt", api_path.c_str());
+          EXPECT_STREQ("/test_evict.txt", std::string{api_path}.c_str());
           EXPECT_FALSE(directory);
           fsi.api_path = api_path;
           fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -925,10 +923,9 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_uploading) {
         .Times(2)
         .WillRepeatedly(Return(api_error::success));
     EXPECT_CALL(mp, upload_file)
-        .WillOnce([](const std::string &api_path,
-                     const std::string &source_path2,
+        .WillOnce([](std::string_view api_path, std::string_view source_path2,
                      stop_type & /*stop_requested*/) -> api_error {
-          EXPECT_STREQ("/test_evict.txt", api_path.c_str());
+          EXPECT_STREQ("/test_evict.txt", std::string{api_path}.c_str());
           EXPECT_FALSE(source_path2.empty());
           std::this_thread::sleep_for(3s);
           return api_error::success;
@@ -984,9 +981,9 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_modified) {
   file_manager mgr(*cfg, mp);
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_evict.txt", api_path.c_str());
+        EXPECT_STREQ("/test_evict.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1022,9 +1019,9 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_not_complete) {
 
   file_manager mgr(*cfg, mp);
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_evict.txt", api_path.c_str());
+        EXPECT_STREQ("/test_evict.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
         fsi.api_path = api_path;
@@ -1061,9 +1058,9 @@ TEST_F(file_manager_test, can_get_directory_items) {
 
   file_manager mgr(*cfg, mp);
   EXPECT_CALL(mp, get_directory_items)
-      .WillOnce([](const std::string &api_path,
+      .WillOnce([](std::string_view api_path,
                    directory_item_list &list) -> api_error {
-        EXPECT_STREQ("/", api_path.c_str());
+        EXPECT_STREQ("/", std::string{api_path}.c_str());
         list.insert(list.begin(), directory_item{
                                       "..",
                                       "",
@@ -1172,9 +1169,9 @@ TEST_F(file_manager_test,
       });
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1248,9 +1245,9 @@ TEST_F(file_manager_test,
   EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("/test_open.src"));
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
                    filesystem_item & /*fsi*/) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         return api_error::error;
       });
@@ -1282,9 +1279,9 @@ TEST_F(file_manager_test, open_file_fails_if_provider_set_item_meta_fails) {
   EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("/test_open.src"));
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1325,9 +1322,9 @@ TEST_F(file_manager_test, open_file_creates_source_path_if_empty) {
   EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return(""));
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1337,10 +1334,10 @@ TEST_F(file_manager_test, open_file_creates_source_path_if_empty) {
       });
 
   EXPECT_CALL(mp, set_item_meta("/test_open.txt", _, _))
-      .WillOnce([](const std::string &api_path, const std::string &key,
-                   const std::string &value) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
-        EXPECT_STREQ(META_SOURCE.c_str(), key.c_str());
+      .WillOnce([](std::string_view api_path, std::string_view key,
+                   std::string_view value) -> api_error {
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
+        EXPECT_STREQ(META_SOURCE.c_str(), std::string{key}.c_str());
         EXPECT_FALSE(value.empty());
         return api_error::success;
       });
@@ -1378,9 +1375,9 @@ TEST_F(file_manager_test, open_file_first_file_handle_is_not_zero) {
   EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("/test_open.src"));
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_open.txt", api_path.c_str());
+        EXPECT_STREQ("/test_open.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1428,17 +1425,17 @@ TEST_F(file_manager_test, can_remove_file) {
   };
 
   EXPECT_CALL(mp, get_item_meta(_, _))
-      .WillOnce([&api_f](const std::string &api_path,
-                         api_meta_map &meta) -> api_error {
-        EXPECT_STREQ("/test_remove.txt", api_path.c_str());
-        meta = provider_meta_creator(false, api_f);
-        return api_error::success;
-      });
+      .WillOnce(
+          [&api_f](std::string_view api_path, api_meta_map &meta) -> api_error {
+            EXPECT_STREQ("/test_remove.txt", std::string{api_path}.c_str());
+            meta = provider_meta_creator(false, api_f);
+            return api_error::success;
+          });
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, bool directory,
+      .WillOnce([](std::string_view api_path, bool directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_remove.txt", api_path.c_str());
+        EXPECT_STREQ("/test_remove.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1509,9 +1506,10 @@ TEST_F(file_manager_test, file_is_closed_after_download_timeout) {
       source_path, 10, now + 4u);
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillRepeatedly([&meta](const std::string &api_path, bool directory,
+      .WillRepeatedly([&meta](std::string_view api_path, bool directory,
                               filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_download_timeout.txt", api_path.c_str());
+        EXPECT_STREQ("/test_download_timeout.txt",
+                     std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1524,7 +1522,7 @@ TEST_F(file_manager_test, file_is_closed_after_download_timeout) {
   event_capture capture({item_timeout::name});
 
   EXPECT_CALL(mp, read_file_bytes)
-      .WillRepeatedly([](const std::string & /* api_path */, std::size_t size,
+      .WillRepeatedly([](std::string_view /* api_path */, std::size_t size,
                          std::uint64_t offset, data_buffer &data,
                          stop_type &stop_requested) -> api_error {
         if (stop_requested) {
@@ -1578,9 +1576,9 @@ TEST_F(file_manager_test, remove_file_fails_if_file_does_not_exist) {
   file_manager mgr(*cfg, mp);
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, const bool &directory,
+      .WillOnce([](std::string_view api_path, const bool &directory,
                    filesystem_item & /*fsi*/) -> api_error {
-        EXPECT_STREQ("/test_remove.txt", api_path.c_str());
+        EXPECT_STREQ("/test_remove.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         return api_error::item_not_found;
       });
@@ -1595,9 +1593,9 @@ TEST_F(file_manager_test, remove_file_fails_if_provider_remove_file_fails) {
 
   EXPECT_CALL(mp, get_item_meta(_, _)).WillOnce(Return(api_error::success));
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, const bool &directory,
+      .WillOnce([](std::string_view api_path, const bool &directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_remove.txt", api_path.c_str());
+        EXPECT_STREQ("/test_remove.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1618,9 +1616,9 @@ TEST_F(file_manager_test, remove_file_fails_if_get_item_meta_fails) {
 
   EXPECT_CALL(mp, get_item_meta(_, _)).WillOnce(Return(api_error::error));
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillOnce([](const std::string &api_path, const bool &directory,
+      .WillOnce([](std::string_view api_path, const bool &directory,
                    filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_remove.txt", api_path.c_str());
+        EXPECT_STREQ("/test_remove.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1667,9 +1665,9 @@ TEST_F(file_manager_test,
       .WillOnce(Return(api_error::success));
 
   EXPECT_CALL(mp, get_filesystem_item)
-      .WillRepeatedly([&meta](const std::string &api_path, bool directory,
+      .WillRepeatedly([&meta](std::string_view api_path, bool directory,
                               filesystem_item &fsi) -> api_error {
-        EXPECT_STREQ("/test_create.txt", api_path.c_str());
+        EXPECT_STREQ("/test_create.txt", std::string{api_path}.c_str());
         EXPECT_FALSE(directory);
         fsi.api_path = api_path;
         fsi.api_parent = utils::path::get_parent_api_path(api_path);
@@ -1680,7 +1678,7 @@ TEST_F(file_manager_test,
       });
 
   EXPECT_CALL(mp, set_item_meta("/test_create.txt", _))
-      .WillOnce([](const std::string &,
+      .WillOnce([](std::string_view,
                    const api_meta_map &new_meta) -> api_error {
         EXPECT_EQ(utils::encryption::encrypting_reader::get_data_chunk_size() *
                       4UL,
diff --git a/repertory/repertory_test/src/fuse_drive_utimens_futimens_test.cpp b/repertory/repertory_test/src/fuse_drive_utimens_futimens_test.cpp
index faac1363..02bacd94 100644
--- a/repertory/repertory_test/src/fuse_drive_utimens_futimens_test.cpp
+++ b/repertory/repertory_test/src/fuse_drive_utimens_futimens_test.cpp
@@ -26,9 +26,9 @@
 using repertory::utils::time::NANOS_PER_SECOND;
 
 namespace {
-void get_times_ns(const std::string &path, long long &at_ns, long long &mt_ns) {
+void get_times_ns(std::string_view path, long long &at_ns, long long &mt_ns) {
   struct stat st_unix{};
-  ASSERT_EQ(0, ::stat(path.c_str(), &st_unix));
+  ASSERT_EQ(0, ::stat(std::string{path}.c_str(), &st_unix));
 
 #if defined(__APPLE__)
   at_ns = static_cast<long long>(st_unix.st_atimespec.tv_sec) *
diff --git a/repertory/repertory_test/src/open_file_test.cpp b/repertory/repertory_test/src/open_file_test.cpp
index 80343dc2..9d204169 100644
--- a/repertory/repertory_test/src/open_file_test.cpp
+++ b/repertory/repertory_test/src/open_file_test.cpp
@@ -67,12 +67,13 @@ std::atomic<std::size_t> open_file_test::inst{0U};
 
 static void test_closeable_open_file(const open_file &file, bool directory,
                                      api_error err, std::uint64_t size,
-                                     const std::string &source_path) {
+                                     std::string_view source_path) {
   EXPECT_EQ(directory, file.is_directory());
   EXPECT_EQ(err, file.get_api_error());
   EXPECT_EQ(std::size_t(0U), file.get_open_file_count());
   EXPECT_EQ(std::uint64_t(size), file.get_file_size());
-  EXPECT_STREQ(source_path.c_str(), file.get_source_path().c_str());
+  EXPECT_STREQ(std::string{source_path}.c_str(),
+               file.get_source_path().c_str());
   EXPECT_TRUE(file.can_close());
 }
 
@@ -100,7 +101,7 @@ TEST_F(open_file_test, properly_initializes_state_for_0_byte_file) {
 
   EXPECT_CALL(upload_mgr, remove_resume)
       .WillOnce(
-          [&fsi](const std::string &api_path, const std::string &source_path2) {
+          [&fsi](std::string_view api_path, std::string_view source_path2) {
             EXPECT_EQ(fsi.api_path, api_path);
             EXPECT_EQ(fsi.source_path, source_path2);
           });
@@ -125,7 +126,7 @@ TEST_F(open_file_test, properly_initializes_state_based_on_chunk_size) {
 
   EXPECT_CALL(upload_mgr, remove_resume)
       .WillOnce(
-          [&fsi](const std::string &api_path, const std::string &source_path2) {
+          [&fsi](std::string_view api_path, std::string_view source_path2) {
             EXPECT_EQ(fsi.api_path, api_path);
             EXPECT_EQ(fsi.source_path, source_path2);
           });
@@ -155,7 +156,7 @@ TEST_F(open_file_test, will_not_change_source_path_for_0_byte_file) {
 
   EXPECT_CALL(upload_mgr, remove_resume)
       .WillOnce(
-          [&fsi](const std::string &api_path, const std::string &source_path2) {
+          [&fsi](std::string_view api_path, std::string_view source_path2) {
             EXPECT_EQ(fsi.api_path, api_path);
             EXPECT_EQ(fsi.source_path, source_path2);
           });
@@ -182,15 +183,16 @@ TEST_F(open_file_test, will_change_source_path_if_file_size_is_greater_than_0) {
 
   EXPECT_CALL(upload_mgr, remove_resume)
       .WillOnce(
-          [&fsi](const std::string &api_path, const std::string &source_path2) {
+          [&fsi](std::string_view api_path, std::string_view source_path2) {
             EXPECT_EQ(fsi.api_path, api_path);
             EXPECT_EQ(fsi.source_path, source_path2);
           });
 
   EXPECT_CALL(provider, set_item_meta(fsi.api_path, META_SOURCE, _))
-      .WillOnce([&fsi](const std::string &, const std::string &,
-                       const std::string &source_path2) -> api_error {
-        EXPECT_STRNE(fsi.source_path.c_str(), source_path2.c_str());
+      .WillOnce([&fsi](std::string_view, std::string_view,
+                       std::string_view source_path2) -> api_error {
+        EXPECT_STRNE(fsi.source_path.c_str(),
+                     std::string{source_path2}.c_str());
         return api_error::success;
       });
 
@@ -219,7 +221,7 @@ TEST_F(open_file_test,
 
   EXPECT_CALL(upload_mgr, remove_resume)
       .WillOnce(
-          [&fsi](const std::string &api_path, const std::string &source_path2) {
+          [&fsi](std::string_view api_path, std::string_view source_path2) {
             EXPECT_EQ(fsi.api_path, api_path);
             EXPECT_EQ(fsi.source_path, source_path2);
           });
@@ -250,7 +252,7 @@ TEST_F(open_file_test, write_with_incomplete_download) {
                            test_chunk_size * 2u, source_path);
 
   EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
-      .WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
+      .WillOnce([](std::string_view, const api_meta_map &meta) -> api_error {
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_WRITTEN).empty()));
@@ -258,9 +260,8 @@ TEST_F(open_file_test, write_with_incomplete_download) {
       });
 
   EXPECT_CALL(provider, read_file_bytes)
-      .WillRepeatedly([&nf](const std::string & /* api_path */,
-                            std::size_t size, std::uint64_t offset,
-                            data_buffer &data,
+      .WillRepeatedly([&nf](std::string_view /* api_path */, std::size_t size,
+                            std::uint64_t offset, data_buffer &data,
                             stop_type &stop_requested) -> api_error {
         if (stop_requested) {
           return api_error::download_stopped;
@@ -282,7 +283,7 @@ TEST_F(open_file_test, write_with_incomplete_download) {
       });
 
   EXPECT_CALL(upload_mgr, remove_upload)
-      .WillOnce([&fsi](const std::string &api_path) {
+      .WillOnce([&fsi](std::string_view api_path) {
         EXPECT_EQ(fsi.api_path, api_path);
       });
 
@@ -342,7 +343,7 @@ TEST_F(open_file_test, write_new_file) {
   data_buffer data = {10, 9, 8};
 
   EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
-      .WillOnce([&data](const std::string &,
+      .WillOnce([&data](std::string_view,
                         const api_meta_map &meta) -> api_error {
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
@@ -351,7 +352,7 @@ TEST_F(open_file_test, write_new_file) {
         EXPECT_EQ(data.size(), utils::string::to_size_t(meta.at(META_SIZE)));
         return api_error::success;
       })
-      .WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
+      .WillOnce([](std::string_view, const api_meta_map &meta) -> api_error {
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_WRITTEN).empty()));
@@ -359,7 +360,7 @@ TEST_F(open_file_test, write_new_file) {
       });
 
   EXPECT_CALL(upload_mgr, remove_upload)
-      .WillOnce([&fsi](const std::string &api_path) {
+      .WillOnce([&fsi](std::string_view api_path) {
         EXPECT_EQ(fsi.api_path, api_path);
       });
 
@@ -414,7 +415,7 @@ TEST_F(open_file_test, write_new_file_multiple_chunks) {
   data_buffer data = {10, 9, 8};
 
   EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
-      .WillOnce([&data](const std::string &,
+      .WillOnce([&data](std::string_view,
                         const api_meta_map &meta) -> api_error {
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
@@ -423,14 +424,14 @@ TEST_F(open_file_test, write_new_file_multiple_chunks) {
         EXPECT_EQ(data.size(), utils::string::to_size_t(meta.at(META_SIZE)));
         return api_error::success;
       })
-      .WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
+      .WillOnce([](std::string_view, const api_meta_map &meta) -> api_error {
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_WRITTEN).empty()));
         return api_error::success;
       })
       .WillOnce(
-          [&data](const std::string &, const api_meta_map &meta) -> api_error {
+          [&data](std::string_view, const api_meta_map &meta) -> api_error {
             EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
             EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
             EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_SIZE).empty()));
@@ -439,7 +440,7 @@ TEST_F(open_file_test, write_new_file_multiple_chunks) {
                       utils::string::to_size_t(meta.at(META_SIZE)));
             return api_error::success;
           })
-      .WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
+      .WillOnce([](std::string_view, const api_meta_map &meta) -> api_error {
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_WRITTEN).empty()));
@@ -447,7 +448,7 @@ TEST_F(open_file_test, write_new_file_multiple_chunks) {
       });
 
   EXPECT_CALL(upload_mgr, remove_upload)
-      .WillOnce([&fsi](const std::string &api_path) {
+      .WillOnce([&fsi](std::string_view api_path) {
         EXPECT_EQ(fsi.api_path, api_path);
       });
 
@@ -504,7 +505,7 @@ TEST_F(open_file_test, resize_file_to_0_bytes) {
   test_closeable_open_file(file, false, api_error::success, fsi.size,
                            source_path);
   EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
-      .WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
+      .WillOnce([](std::string_view, const api_meta_map &meta) -> api_error {
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_SIZE).empty()));
@@ -515,7 +516,7 @@ TEST_F(open_file_test, resize_file_to_0_bytes) {
       });
 
   EXPECT_CALL(upload_mgr, remove_upload)
-      .WillOnce([&fsi](const std ::string &api_path) {
+      .WillOnce([&fsi](std::string_view api_path) {
         EXPECT_EQ(fsi.api_path, api_path);
       });
 
@@ -563,7 +564,7 @@ TEST_F(open_file_test, resize_file_by_full_chunk) {
   test_closeable_open_file(file, false, api_error::success, fsi.size,
                            source_path);
   EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
-      .WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
+      .WillOnce([](std::string_view, const api_meta_map &meta) -> api_error {
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
         EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_SIZE).empty()));
@@ -574,7 +575,7 @@ TEST_F(open_file_test, resize_file_by_full_chunk) {
       });
 
   EXPECT_CALL(upload_mgr, remove_upload)
-      .WillOnce([&fsi](const std::string &api_path) {
+      .WillOnce([&fsi](std::string_view api_path) {
         EXPECT_EQ(fsi.api_path, api_path);
       });
 
@@ -625,7 +626,7 @@ TEST_F(open_file_test, can_add_handle) {
       .WillOnce(Return(api_error::success));
   EXPECT_CALL(upload_mgr, remove_resume)
       .WillOnce(
-          [&fsi](const std::string &api_path, const std::string &source_path2) {
+          [&fsi](std::string_view api_path, std::string_view source_path2) {
             EXPECT_EQ(fsi.api_path, api_path);
             EXPECT_EQ(fsi.source_path, source_path2);
           });
@@ -682,7 +683,7 @@ TEST_F(open_file_test, can_remove_handle) {
 
   EXPECT_CALL(upload_mgr, remove_resume)
       .WillOnce(
-          [&fsi](const std::string &api_path, const std::string &source_path2) {
+          [&fsi](std::string_view api_path, std::string_view source_path2) {
             EXPECT_EQ(fsi.api_path, api_path);
             EXPECT_EQ(fsi.source_path, source_path2);
           });
diff --git a/repertory/repertory_test/src/packet_client_test.cpp b/repertory/repertory_test/src/packet_client_test.cpp
index ac1d5bca..e16c3ea8 100644
--- a/repertory/repertory_test/src/packet_client_test.cpp
+++ b/repertory/repertory_test/src/packet_client_test.cpp
@@ -36,10 +36,10 @@ public:
                      std::uint8_t pool_size = 2)
       : server_(std::make_unique<packet_server>(
             port, std::move(token), pool_size,
-            [](const std::string & /*client_id*/) {},
+            [](std::string_view /*client_id*/) {},
             [](std::uint32_t /*service_flags_in*/,
-               const std::string & /*client_id*/, std::uint64_t /*thread_id*/,
-               const std::string &method, packet * /*request*/,
+               std::string_view /*client_id*/, std::uint64_t /*thread_id*/,
+               std::string_view method, packet * /*request*/,
                packet & /*response*/,
                packet_server::message_complete_callback done) {
               if (method == "ping") {
@@ -53,7 +53,7 @@ private:
   std::unique_ptr<packet_server> server_;
 };
 
-inline auto make_cfg(std::uint16_t port, const std::string &token)
+inline auto make_cfg(std::uint16_t port, std::string_view token)
     -> remote::remote_config {
   remote::remote_config cfg{};
   cfg.host_name_or_ip = "127.0.0.1";
@@ -129,9 +129,9 @@ TEST(packet_client_test, pooled_connection_reused_on_second_send) {
 
   packet_server server{
       port, token, 2U,
-      [&close_count](const std::string & /*client_id*/) { ++close_count; },
-      [](std::uint32_t /*service_flags_in*/, const std::string & /*client_id*/,
-         std::uint64_t /*thread_id*/, const std::string &method,
+      [&close_count](std::string_view /*client_id*/) { ++close_count; },
+      [](std::uint32_t /*service_flags_in*/, std::string_view /*client_id*/,
+         std::uint64_t /*thread_id*/, std::string_view method,
          packet * /*request*/, packet & /*response*/,
          packet_server::message_complete_callback done) {
         if (method == "ping") {
diff --git a/repertory/repertory_test/src/ring_buffer_open_file_test.cpp b/repertory/repertory_test/src/ring_buffer_open_file_test.cpp
index fe953519..0a125de7 100644
--- a/repertory/repertory_test/src/ring_buffer_open_file_test.cpp
+++ b/repertory/repertory_test/src/ring_buffer_open_file_test.cpp
@@ -323,7 +323,7 @@ TEST_F(ring_buffer_open_file_test, read_full_file) {
 
   std::mutex read_mtx;
   EXPECT_CALL(mp, read_file_bytes)
-      .WillRepeatedly([&read_mtx, &nf](const std::string & /* api_path */,
+      .WillRepeatedly([&read_mtx, &nf](std::string_view /* api_path */,
                                        std::size_t size, std::uint64_t offset,
                                        data_buffer &data,
                                        stop_type &stop_requested) -> api_error {
@@ -389,7 +389,7 @@ TEST_F(ring_buffer_open_file_test, read_full_file_in_reverse) {
 
   std::mutex read_mtx;
   EXPECT_CALL(mp, read_file_bytes)
-      .WillRepeatedly([&read_mtx, &nf](const std::string & /* api_path */,
+      .WillRepeatedly([&read_mtx, &nf](std::string_view /* api_path */,
                                        std::size_t size, std::uint64_t offset,
                                        data_buffer &data,
                                        stop_type &stop_requested) -> api_error {
@@ -455,7 +455,7 @@ TEST_F(ring_buffer_open_file_test, read_full_file_in_partial_chunks) {
 
   std::mutex read_mtx;
   EXPECT_CALL(mp, read_file_bytes)
-      .WillRepeatedly([&read_mtx, &nf](const std::string & /* api_path */,
+      .WillRepeatedly([&read_mtx, &nf](std::string_view /* api_path */,
                                        std::size_t size, std::uint64_t offset,
                                        data_buffer &data,
                                        stop_type &stop_requested) -> api_error {
@@ -523,7 +523,7 @@ TEST_F(ring_buffer_open_file_test,
 
   std::mutex read_mtx;
   EXPECT_CALL(mp, read_file_bytes)
-      .WillRepeatedly([&read_mtx, &nf](const std::string & /* api_path */,
+      .WillRepeatedly([&read_mtx, &nf](std::string_view /* api_path */,
                                        std::size_t size, std::uint64_t offset,
                                        data_buffer &data,
                                        stop_type &stop_requested) -> api_error {
diff --git a/repertory/repertory_test/src/upload_test.cpp b/repertory/repertory_test/src/upload_test.cpp
index c4b72b3b..b23fb6d3 100644
--- a/repertory/repertory_test/src/upload_test.cpp
+++ b/repertory/repertory_test/src/upload_test.cpp
@@ -55,7 +55,7 @@ TEST(upload_test, can_upload_a_valid_file) {
       });
 
   EXPECT_CALL(mock_prov, upload_file(fsi.api_path, fsi.source_path, _))
-      .WillOnce([](const std::string &, const std::string &,
+      .WillOnce([](std::string_view, std::string_view,
                    stop_type &stop_requested) -> api_error {
         EXPECT_FALSE(stop_requested);
         return api_error::success;
@@ -100,7 +100,7 @@ TEST(upload_test, can_cancel_upload) {
   std::condition_variable notify;
 
   EXPECT_CALL(mock_provider, upload_file(fsi.api_path, fsi.source_path, _))
-      .WillOnce([&notify, &mtx](const std::string &, const std::string &,
+      .WillOnce([&notify, &mtx](std::string_view, std::string_view,
                                 stop_type &stop_requested) -> api_error {
         EXPECT_FALSE(stop_requested);
 
@@ -161,7 +161,7 @@ TEST(upload_test, can_stop_upload) {
       });
 
   EXPECT_CALL(mock_provider, upload_file(fsi.api_path, fsi.source_path, _))
-      .WillOnce([](const std::string &, const std::string &,
+      .WillOnce([](std::string_view, std::string_view,
                    stop_type &stop_requested) -> api_error {
         std::this_thread::sleep_for(3s);
         EXPECT_TRUE(stop_requested);