Update

src/vamp_zero/app.cpp

@@ -166,7 +166,7 @@ auto load_initial_state(vamp_zero::config const &config) -> std::expected<vamp_z
     return std::unexpected(practice.error());
   }
   auto state = vamp_zero::app_state{
-    .catalog = std::make_shared<vamp_zero::catalogue const>(vamp_zero::catalogue{
+    .catalog = std::make_shared<vamp_zero::catalog const>(vamp_zero::catalog{
       .performance = std::move(*performance),
       .practice = std::move(*practice),
     }),
@@ -204,7 +204,7 @@ auto validate_score_pages(boost::asio::any_io_executor executor, vamp_zero::conf
   co_return std::expected<void, modulus::error>{};
 }
 
-auto validate_catalogue(boost::asio::any_io_executor executor, vamp_zero::config const &config, vamp_zero::catalogue const &catalog) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
+auto validate_catalog(boost::asio::any_io_executor executor, vamp_zero::config const &config, vamp_zero::catalog const &catalog) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
   for (auto const &part : catalog.performance.parts) {
     auto reference = vamp_zero::score_reference{.category = vamp_zero::score_category::PERFORMANCE, .id = part.id};
     auto valid = co_await validate_score_pages(executor, config, std::move(reference));
@@ -261,9 +261,9 @@ auto probe_runtime_directory(vamp_zero::config const &config) -> std::expected<v
   return {};
 }
 
-auto check_readiness(vamp_zero::config const &config, vamp_zero::catalogue const &catalog) -> std::expected<void, modulus::error> {
+auto check_readiness(vamp_zero::config const &config, vamp_zero::catalog const &catalog) -> std::expected<void, modulus::error> {
   auto io = boost::asio::io_context{};
-  auto future = boost::asio::co_spawn(io, validate_catalogue(io.get_executor(), config, catalog), boost::asio::use_future);
+  auto future = boost::asio::co_spawn(io, validate_catalog(io.get_executor(), config, catalog), boost::asio::use_future);
   io.run();
   auto valid = future.get();
   if (!valid) {

src/vamp_zero/database.cpp

@@ -25,7 +25,7 @@
 namespace {
 
 constexpr auto application_id = std::int64_t{0x56414D50};
-constexpr auto catalogue_schema_version = std::int64_t{3};
+constexpr auto catalog_schema_version = std::int64_t{3};
 
 auto connection_config(vamp_zero::database_config const &config) -> noto::connection_config {
   auto result = noto::file_connection_config(config.path, "product-vamp");
@@ -40,17 +40,17 @@ auto text_value(noto::sqlite_value const &value) -> std::string {
   return text == nullptr ? std::string{} : *text;
 }
 
-auto close_catalogue_query(noto::connection &connection, noto::statement &statement, std::expected<void, modulus::error> status) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
+auto close_catalog_query(noto::connection &connection, noto::statement &statement, std::expected<void, modulus::error> status) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
   auto finalized = co_await statement.async_finalize();
   if (!finalized) {
-    modulus::log_error("catalogue query finalization failed: " + finalized.error().describe());
+    modulus::log_error("catalog query finalization failed: " + finalized.error().describe());
     if (status) {
       status = std::unexpected(finalized.error());
     }
   }
   auto closed = co_await connection.async_close();
   if (!closed) {
-    modulus::log_error("catalogue connection close failed: " + closed.error().describe());
+    modulus::log_error("catalog connection close failed: " + closed.error().describe());
     if (status) {
       status = std::unexpected(closed.error());
     }
@@ -60,7 +60,7 @@ auto close_catalogue_query(noto::connection &connection, noto::statement &statem
 
 auto resolve_source_path(std::string const &assets_path, std::string const &source) -> std::expected<std::string, modulus::error> {
   auto fail = [] {
-    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "unsafe catalogue asset path; rebuild or reinstall Product Vamp"));
+    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "unsafe catalog asset path; rebuild or reinstall Product Vamp"));
   };
   auto relative = std::filesystem::path{source};
   if (source.empty() || source.find('\0') != std::string::npos || source.find('\\') != std::string::npos ||
@@ -94,23 +94,23 @@ auto count_value(noto::sqlite_value const &value) -> std::size_t {
 auto vamp_zero::async_validate_database(boost::asio::any_io_executor executor, vamp_zero::database_config config, std::bool_t integrity) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
   auto error = std::error_code{};
   if (!std::filesystem::is_regular_file(config.path, error) || error) {
-    co_return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "catalogue is missing or unreadable: " + config.path + "; rebuild or reinstall Product Vamp"));
+    co_return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "catalog is missing or unreadable: " + config.path + "; rebuild or reinstall Product Vamp"));
   }
   auto connection = noto::connection{executor, connection_config(config)};
   auto connected = co_await connection.async_connect();
   if (!connected) {
-    co_return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "cannot open catalogue: " + config.path + "; rebuild or reinstall Product Vamp: " + connected.error().describe()));
+    co_return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "cannot open catalog: " + config.path + "; rebuild or reinstall Product Vamp: " + connected.error().describe()));
   }
   auto application = co_await connection.async_application_id();
   auto version = co_await connection.async_user_version();
   auto status = std::expected<void, modulus::error>{};
-  if (!application || !version || *application != application_id || *version != catalogue_schema_version) {
-    status = std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "invalid or incompatible catalogue: " + config.path + "; rebuild or reinstall Product Vamp"));
+  if (!application || !version || *application != application_id || *version != catalog_schema_version) {
+    status = std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "invalid or incompatible catalog: " + config.path + "; rebuild or reinstall Product Vamp"));
   }
   if (status && integrity) {
     auto checked = co_await connection.async_execute("PRAGMA quick_check(1)");
     if (!checked || checked->rows.size() != 1U || checked->rows[0].size() != 1U || text_value(checked->rows[0][0]) != "ok") {
-      status = std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "corrupt catalogue: " + config.path + "; rebuild or reinstall Product Vamp"));
+      status = std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "corrupt catalog: " + config.path + "; rebuild or reinstall Product Vamp"));
     }
   }
   auto closed = co_await connection.async_close();
@@ -169,7 +169,7 @@ auto vamp_zero::async_load_performance_library(boost::asio::any_io_executor exec
       .total_pages = count_value(row[7]),
     });
   }
-  auto closed = co_await close_catalogue_query(connection, *selected, std::move(status));
+  auto closed = co_await close_catalog_query(connection, *selected, std::move(status));
   if (!closed) {
     co_return std::unexpected(closed.error());
   }
@@ -230,7 +230,7 @@ auto vamp_zero::async_load_practice_library(boost::asio::any_io_executor executo
       .parts = {std::move(practice_part)},
     });
   }
-  auto closed = co_await close_catalogue_query(connection, *selected, std::move(status));
+  auto closed = co_await close_catalog_query(connection, *selected, std::move(status));
   if (!closed) {
     co_return std::unexpected(closed.error());
   }
@@ -272,7 +272,7 @@ auto vamp_zero::async_load_score(boost::asio::any_io_executor executor, vamp_zer
   if (!result) {
     status = std::unexpected(result.error());
   }
-  auto closed = co_await close_catalogue_query(connection, *selected, std::move(status));
+  auto closed = co_await close_catalog_query(connection, *selected, std::move(status));
   if (!closed) {
     co_return std::unexpected(closed.error());
   }

src/vamp_zero/page_control.cpp

@@ -67,7 +67,7 @@ auto decrease_bpm(vamp_zero::audio_state &audio) -> void {
 
 auto clamp_state(vamp_zero::app_state state) -> vamp_zero::app_state {
   if (!state.catalog) {
-    state.catalog = vamp_zero::empty_catalogue();
+    state.catalog = vamp_zero::empty_catalog();
   }
   state.audio = clamp_audio_state(state.audio);
   state.selected_main_menu_index = std::min(state.selected_main_menu_index, main_menu_count - 1U);
@@ -469,7 +469,7 @@ auto vamp_zero::remote_display_text(vamp_zero::app_state const &state) -> std::s
 
 auto vamp_zero::validate_app_state(vamp_zero::app_state const &state) -> std::expected<void, modulus::error> {
   if (!state.catalog) {
-    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "catalogue is missing"));
+    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "catalog is missing"));
   }
   if (state.selected_main_menu_index >= main_menu_count) {
     return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "selected main menu index is out of range"));

src/vamp_zero/portal.cpp

@@ -124,7 +124,7 @@ auto vamp_zero::control_state::set_observer(std::function<void(vamp_zero::app_st
   observer_ = std::move(observer);
 }
 
-auto vamp_zero::control_state::finish_playback(std::uint64_t session, std::string error, std::shared_ptr<vamp_zero::catalogue const> catalog) -> void {
+auto vamp_zero::control_state::finish_playback(std::uint64_t session, std::string error, std::shared_ptr<vamp_zero::catalog const> catalog) -> void {
   auto observer = std::function<void(vamp_zero::app_state)>{};
   auto updated = vamp_zero::app_state{};
   {

src/vamp_zero/score_loader.cpp

@@ -75,7 +75,7 @@ struct vamp_zero::score_loader::state : std::enable_shared_from_this<state> {
   std::function<boost::asio::awaitable<std::expected<vamp_zero::score_document, modulus::error>>(vamp_zero::score_reference)> load;
   std::function<void()> completed;
   std::mutex mutex{};
-  std::shared_ptr<vamp_zero::catalogue const> catalog{};
+  std::shared_ptr<vamp_zero::catalog const> catalog{};
   std::optional<vamp_zero::score_reference> reference{};
   vamp_zero::score_load_state value{};
   std::uint64_t generation{};
@@ -90,7 +90,7 @@ vamp_zero::score_loader::~score_loader() {
   stop();
 }
 
-auto vamp_zero::score_loader::select(std::shared_ptr<vamp_zero::catalogue const> catalog, std::optional<vamp_zero::score_reference> reference) -> void {
+auto vamp_zero::score_loader::select(std::shared_ptr<vamp_zero::catalog const> catalog, std::optional<vamp_zero::score_reference> reference) -> void {
   auto lock = std::scoped_lock{state_->mutex};
   if (!catalog) {
     reference.reset();

src/vamp_zero/types.cpp

@@ -4,8 +4,8 @@
 #include <vector>
 
 
-auto vamp_zero::empty_catalogue() -> std::shared_ptr<vamp_zero::catalogue const> const & {
-  static auto const empty = std::make_shared<vamp_zero::catalogue const>();
+auto vamp_zero::empty_catalog() -> std::shared_ptr<vamp_zero::catalog const> const & {
+  static auto const empty = std::make_shared<vamp_zero::catalog const>();
   return empty;
 }
 

src/vamp_zero/ui.cpp

@@ -402,7 +402,7 @@ auto vamp_zero::zero_ui::publish(vamp_zero::ui_state state) -> std::expected<voi
   {
     auto lock = std::scoped_lock{runtime_->mutex_};
     if (!state.app.catalog) {
-      state.app.catalog = vamp_zero::empty_catalogue();
+      state.app.catalog = vamp_zero::empty_catalog();
     }
     score_loader_->select(state.app.catalog, vamp_zero::selected_score_reference(state.app));
     runtime_->state_ = std::move(state);