style(core) - Minor style fixes. (#8)

## Description

Minor style fixes.

## Type of Change
- [ ] `feat` - New feature
- [ ] `fix` - Bug fix
- [ ] `docs` - Documentation update
- [x] `style` - Code style changes (formatting)
- [ ] `refactor` - Code refactoring
- [ ] `perf` - Performance improvement
- [ ] `test` - Test additions/fixes
- [ ] `build` - Build system changes
- [ ] `ci` - CI configuration changes

## Testing
- [ ] Unit tests added/updated
- [ ] Integration tests added/updated
- [ ] Manual testing performed
- [x] All tests pass locally

## Code Quality
- [x] Code follows the C++ Manual
- [x] No compiler warnings
- [x] Breaking changes documented (if any)
- [x] Documentation updated

## AI Policy Compliance
- [x] No AI-generated content
- [ ] Contains AI-generated code (disclosed and reviewed)

## Checklist
- [x] Branch is up-to-date with `main`
- [x] Commit messages follow conventional format
- [x] CI checks pass
- [x] Self-review completed

Author: raygoe

docs/contributing/ai-policy.md

@@ -154,7 +154,7 @@ auto result = some_complex_ai_generated_function_i_dont_understand();
 // ✅ Good: Understand and improve AI suggestions
 // AI suggested basic version, but I added error handling and
 // adapted to our std::error_code/std::expected pattern
-[[OAT_NODISCARD("Please remember to verify the std::expected result.")]]
+[[ION_NODISCARD("Please remember to verify the std::expected result.")]]
 std::expected<processed_data, std::error_code> process_data(buffer_view input) {
     if (input.empty()) {
         return std::unexpected(std::make_error_code(std::errc::bad_message));

docs/contributing/code-review.md

@@ -165,7 +165,7 @@ for (auto it = vec.begin(); it != vec.end(); it++) {
 - [ ] No naked `new`/`delete` - use `std::unique_ptr`
 - [ ] Factory functions return `std::expected<std::unique_ptr<T>, std::error_code>`
 - [ ] No exceptions escaping module boundaries
-- [ ] Proper `[[OAT_NODISCARD("...")]]
+- [ ] Proper `[[ION_NODISCARD("...")]]
 ` usage
 - [ ] Interface segregation (pure virtual interfaces)
 - [ ] No `std::shared_ptr` without justification

docs/development/README.md

@@ -157,7 +157,7 @@ class renderer_impl : public renderer_base {
 ```
 
 ### 4. **Explicit Error Handling**
-Every fallible operation returns `std::expected<T, std::error_code>` and is marked `[[OAT_NODISCARD("...")]]`.
+Every fallible operation returns `std::expected<T, std::error_code>` and is marked `[[ION_NODISCARD("...")]]`.
 
 ## Common Tasks
 

docs/development/cpp-manual.md

@@ -149,7 +149,7 @@ All runtime code SHALL use `std::expected` for error propagation. See API.3 for
 ```cpp
 // Example of catching an internal exception in a factory
 // static
-[[OAT_NODISCARD("Handle this result! Failure to do so is a bug.")]]
+[[ION_NODISCARD("Handle this result! Failure to do so is a bug.")]]
 std::expected<std::unique_ptr<my_object>, std::error_code> my_object::create(const std::string& config_data) {
     try {
         // my_object_impl constructor might throw on bad config_data
@@ -186,7 +186,7 @@ public:
     virtual ~my_object() = default;
 
     // Factory function
-    [[OAT_NODISCARD("Handle this result! Failure to do so is a bug.")]]
+    [[ION_NODISCARD("Handle this result! Failure to do so is a bug.")]]
     static std::expected<std::unique_ptr<my_object>, std::error_code> create(...);
 
 protected:
@@ -250,7 +250,7 @@ These layers establish strict boundaries crucial for maintainability, testabilit
 
 1.  **`[ Interface Layer ]`**
     *   **Location:** `include/oat/yourlib/...` (or similar public include path)
-    *   **Content:** Public headers defining abstract classes (interfaces), POD-like configuration structs, public enums (like `ErrorCode`), and factory function declarations (e.g., `static std::expected<std::unique_ptr<type_base>, std::error_code> create(...)`).
+    *   **Content:** Public headers defining abstract classes (interfaces), POD-like configuration structs, public enums (like `log_level`), and factory function declarations (e.g., `static std::expected<std::unique_ptr<type_base>, std::error_code> create(...)`).
     *   **Rule:** Interfaces expose **nothing private**. No implementation details, no private helper classes, no internal data structures. They define the "what," not the "how."
 
 2.  **`[ Implementation Layer ]`**
@@ -282,7 +282,7 @@ These layers establish strict boundaries crucial for maintainability, testabilit
 
             virtual void tick(uint64_t now_ns) = 0;
 
-            [[OAT_NODISCARD("Handle this result! Failure to do so is a bug.")]]
+            [[ION_NODISCARD("Handle this result! Failure to do so is a bug.")]]
             virtual std::expected<void, std::error_code> send_message(buffer_view payload) = 0;
             // ... other interface methods
         };
@@ -437,7 +437,7 @@ This convention enhances readability and consistency.
 | Private Implementation Source     | `snake_case_impl.cpp`| `session_manager_impl.cpp`  | `src/session_manager_impl.cpp`     |
 | Utility/Helper Header (Public)    | `snake_case.h`    | `buffer_utils.h`            | `include/oat/core/buffer_utils.h`  |
 | Utility/Helper Source (Private)   | `snake_case.cpp`  | `string_helpers.cpp`        | `src/string_helpers.cpp`           |
-| Test Source File                  | `PascalCaseTests.cpp` or `feature_tests.cpp` | `session_manager_tests.cpp`   | `tests/session_manager_tests.cpp`    |
+| Test Source File                  | `snake_cast_test.cpp` or `feature_tests.cpp` | `session_manager_tests.cpp`   | `tests/session_manager_tests.cpp`    |
 | Class / Struct / Enum Class       | `PascalCase`      | `session_manager`            | (Defined inside headers/sources)   |
 | Enum (C-style, if unavoidable)  | `ALL_CAPS_SNAKE`  | `MAX_CONNECTIONS`           | (Strongly prefer `enum class`)     |
 
@@ -556,16 +556,16 @@ private:
 ```cpp
 class data_processor {
 public:
-    [[OAT_NODISCARD("handle this result – failure to do so is a bug.")]]
-    static std::expected<std::unique_ptr<data_processor>, error>
+    [[ION_NODISCARD("handle this result – failure to do so is a bug.")]]
+    static std::expected<std::unique_ptr<data_processor>, std::error_code>
     create(config& cfg);                         // factory, still snake_case
 
     void submit_data(buffer_view data);
 
-    [[OAT_NODISCARD("handle this result – failure to do so is a bug.")]]
+    [[ION_NODISCARD("handle this result – failure to do so is a bug.")]]
     bool is_processing() const;
 
-    [[OAT_NODISCARD("handle this result – failure to do so is a bug.")]]
+    [[ION_NODISCARD("handle this result – failure to do so is a bug.")]]
     std::optional<result> get_result();
 
 private:
@@ -658,7 +658,7 @@ Strive to minimize the `#include` directives in your header files.
     // my_service.h
     #pragma once
     #include <memory> // For std::unique_ptr
-    #include <oat/core/error_code.h> // For ErrorCode, error (Tagged Enum Wrapper)
+    #include <oat/core/error.h> // for core_errc
     #include <oat/core/buffer_view.h> // For buffer_view
 
     // Forward declarations
@@ -768,7 +768,7 @@ public:
 
 class logger_factory {
 public:
-    [[OAT_NODISCARD("Handle this result! Failure to do so is a bug.")]]
+    [[ION_NODISCARD("Handle this result! Failure to do so is a bug.")]]
     virtual std::expected<std::unique_ptr<logger_base>, std::error_code> create_logger() = 0;
     virtual ~logger_factory() = default;
 };
@@ -791,7 +791,7 @@ public:
         stream_ << msg << '\n';
     }
 
-    [[OAT_NODISCARD("Handle this result! Failure to do so is a bug.")]]
+    [[ION_NODISCARD("Handle this result! Failure to do so is a bug.")]]
     static std::expected<std::unique_ptr<logger_base>, std::error_code> create(std::string_view path) {
         try {
             auto logger = std::unique_ptr<concrete_logger>(new concrete_logger(path));
@@ -831,7 +831,7 @@ private:
 
 class concrete_logger_factory : public logger_factory_base {
 public:
-    [[OAT_NODISCARD("Handle this result! Failure to do so is a bug.")]]
+    [[ION_NODISCARD("Handle this result! Failure to do so is a bug.")]]
     std::expected<std::unique_ptr<logger_base>, std::error_code> create_logger() override {
         return concrete_logger::create("log.txt");
     }
@@ -881,7 +881,7 @@ void reset_logger_factory() {
   class mock_logger : public logger_base { /* ... */ };
   class mock_logger_factory : public logger_factory_base {
   public:  
-      [[OAT_NODISCARD("Handle this result! Failure to do so is a bug.")]]
+      [[ION_NODISCARD("Handle this result! Failure to do so is a bug.")]]
       std::expected<std::unique_ptr<logger_base>, std::error_code> create_logger() override {
           return std::make_unique<mock_logger>();
       }
@@ -999,7 +999,7 @@ All public functions that can fail **shall**
 | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
 | **Return** `std::expected<T, std::error_code>` (or `std::expected<void, std::error_code>`).                                             | The value half (`T`) remains unconstrained; the error half is the *portable* C++11 struct whose layout is ABI-stable across DLLs. |
 | **Tag** every error code with a *module-local* strongly-typed `enum class`, then convert it to `std::error_code` via `make_error_code`. | Preserves type-safety at call sites while keeping one on-the-wire format.                                                         |
-| **Mark** every fallible API with `OAT_NODISCARD("…descriptive message…")`.                                                              | Forces callers to handle the result.                                                                                              |
+| **Mark** every fallible API with `ION_NODISCARD("…descriptive message…")`.                                                              | Forces callers to handle the result.                                                                                              |
 
 `bool`, sentinels, `nullptr`, raw integers, or `std::optional` **shall not** be used for error signalling. Exceptions remain an internal implementation detail; they do **not** cross public ABI boundaries.
 
@@ -1100,7 +1100,7 @@ static std::error_code to_net_error(std::error_code ec) noexcept {
 *Exported API*:
 
 ```cpp
-[[OAT_NODISCARD("check connect result")]]
+[[ION_NODISCARD("check connect result")]]
 std::expected<void, std::error_code> connect(socket s, address a)
 {
     if (::connect(s.fd(), …) == 0)  return {};
@@ -1118,21 +1118,21 @@ No caller ever sees `errno` or `DWORD`, only `oat::net::net_errc`.
 // oat/attributes.h
 #pragma once
 #if defined(__GNUC__) || defined(__clang__)
-#  define OAT_NODISCARD(msg) nodiscard(msg), gnu::warn_unused_result
+#  define ION_NODISCARD(msg) nodiscard(msg), gnu::warn_unused_result
 #elif defined(_MSC_VER)
-#  define OAT_NODISCARD(msg) nodiscard(msg)
+#  define ION_NODISCARD(msg) nodiscard(msg)
 #else
-#  define OAT_NODISCARD(msg) nodiscard
+#  define ION_NODISCARD(msg) nodiscard
 #endif
 ```
 
 *Usage examples*:
 
 ```cpp
-OAT_NODISCARD("handle the possible timeout")
+ION_NODISCARD("handle the possible timeout")
 std::expected<void, std::error_code> wait_for_ready(...);
 
-OAT_NODISCARD("did the asset actually load?")
+ION_NODISCARD("did the asset actually load?")
 std::expected<asset, std::error_code> load_asset(std::string_view path);
 ```
 
@@ -1168,7 +1168,7 @@ Each message explains *why* the caller shouldn’t ignore the value.
 * **Interoperable:** STL, Boost, gRPC and many third-party libraries already consume/produce `std::error_code`.
 * **Extensible:** each module owns its enum; no global registry or range reservation is required.
 * **Descriptive:** `message()` delivers human-readable text on demand; not stored unless logged.
-* **Enforced handling:** `OAT_NODISCARD` ensures the compiler reminds users to check every result.
+* **Enforced handling:** `ION_NODISCARD` ensures the compiler reminds users to check every result.
 
 Adhering to these rules yields clear, efficient, and portable error handling across all OAT C++ components.
 

docs/development/creating-apps.md

@@ -145,7 +145,7 @@ public:
     };
 
     // Factory
-    [[OAT_NODISCARD("Please make sure to handle the creation failure.")]]
+    [[ION_NODISCARD("Please make sure to handle the creation failure.")]]
     static std::expected<std::unique_ptr<application>, std::error_code> 
     create(const config& config);
 
@@ -158,7 +158,7 @@ public:
 private:
     application(const config& config);
 
-    [[OAT_NODISCARD("Please ensure to handle init failure.")]]
+    [[ION_NODISCARD("Please ensure to handle init failure.")]]
     std::expected<void, std::error_code> initialize();
 
     void update(float delta_time);

docs/development/creating-libraries.md

@@ -67,7 +67,7 @@ namespace ion::your_library {
 class your_type_base;
 
 // Factory function declaration
-[[OAT_NODISCARD("Please ensure that the result is valid.")]]
+[[ION_NODISCARD("Please ensure that the result is valid.")]]
 std::expected<std::unique_ptr<your_type_base>, std::error_code> 
 make_your_type(/* parameters */);
 
@@ -79,7 +79,7 @@ public:
     // Core functionality
     virtual void do_something() = 0;
 
-    [[OAT_NODISCARD("Please don't forget to check the result.")]]
+    [[ION_NODISCARD("Please don't forget to check the result.")]]
     virtual std::expected<int, std::error_code> compute_value() = 0;
 
     // No implementation details in interface!
@@ -106,7 +106,7 @@ namespace ion::your_library::detail {
 class your_type_impl final : public your_type_base {
 public:
     // Factory method
-    [[OAT_NODISCARD("Handle the result")]]
+    [[ION_NODISCARD("Handle the result")]]
     static std::expected<std::unique_ptr<your_type_impl>, std::error_code> 
     create(/* parameters */);
     
@@ -264,7 +264,7 @@ TEST_CASE("YourInterface basic operations", "[your_library]") {
     SECTION("Creation fails with invalid parameters") {
         auto result = make_your_interface(/* invalid params */);
         REQUIRE(!result.has_value());
-        REQUIRE(result.error().code() == ErrorCode::invalid_parameter);
+        REQUIRE(result.error() == core_errc::invalid_parameter);
     }
 
     SECTION("Operations work correctly") {
@@ -357,7 +357,7 @@ Any important implementation details...
 - ✅ Keep interfaces minimal and focused
 - ✅ Hide all implementation details
 - ✅ Use `std::expected` for all fallible operations
-- ✅ Mark functions `[[OAT_NODISCARD("...")]]` when appropriate
+- ✅ Mark functions `[[ION_NODISCARD("...")]]` when appropriate
 - ✅ Follow the dependency hierarchy strictly
 - ✅ Write comprehensive tests
 - ✅ Document the public API

docs/development/testing.md

@@ -54,7 +54,7 @@ TEST_CASE("Feature description", "[your_library]") {
 
         // Assert
         REQUIRE(!system.has_value());
-        REQUIRE(system.error().code() == ErrorCode::InvalidConfig);
+        REQUIRE(system.error() == core_errc::invalid_config);
     }
 }
 ```
@@ -88,22 +88,22 @@ TEST_CASE("Async operations complete correctly", "[async]") {
 ### Testing State Machines
 
 ```cpp
-TEST_CASE("State machine transitions", "[state]") {
-    auto machine = makeStateMachine();
+TEST_CASE("state machine transitions", "[state]") {
+    auto machine = make_state_machine();
     REQUIRE(machine.has_value());
 
     // Initial state
-    REQUIRE(machine.value()->getState() == State::Idle);
+    REQUIRE(machine.value()->get_state() == state::idle);
 
     // Valid transition
-    auto result = machine.value()->transition(Event::Start);
+    auto result = machine.value()->transition(event::start);
     REQUIRE(result.has_value());
-    REQUIRE(machine.value()->getState() == State::Running);
+    REQUIRE(machine.value()->get_state() == state::running);
 
     // Invalid transition
-    result = machine.value()->transition(Event::Start);
+    result = machine.value()->transition(event::start);
     REQUIRE(!result.has_value());
-    REQUIRE(result.error().code() == ErrorCode::InvalidTransition);
+    REQUIRE(result.error().code() == core_errc::InvalidTransition);
 }
 ```
 

libs/core/include/ion/core/buffer/buffer_base.h

@@ -11,31 +11,31 @@ class ION_CORE_API buffer_base {
 public:
     virtual ~buffer_base() = default;
 
-    [[OAT_NODISCARD("Handle resize result")]]
+    [[ION_NODISCARD("Handle resize result")]]
     virtual std::expected<void, std::error_code> resize(std::size_t bytes) = 0;
 
-    [[OAT_NODISCARD("Handle reserve result")]]
+    [[ION_NODISCARD("Handle reserve result")]]
     virtual std::expected<void, std::error_code> reserve(std::size_t bytes) = 0;
 
-    [[OAT_NODISCARD("Handle clear result")]]
+    [[ION_NODISCARD("Handle clear result")]]
     virtual std::expected<void, std::error_code> clear() = 0;
 
-    [[OAT_NODISCARD("Handle shrink result")]]
+    [[ION_NODISCARD("Handle shrink result")]]
     virtual std::expected<void, std::error_code> shrink_to_fit() = 0;
 
-    [[OAT_NODISCARD("Handle append result")]]
+    [[ION_NODISCARD("Handle append result")]]
     virtual std::expected<void, std::error_code> append(std::span<const std::byte> src) = 0;
 
-    [[OAT_NODISCARD("Handle view result")]]
+    [[ION_NODISCARD("Handle view result")]]
     virtual std::span<const std::byte> view() const noexcept = 0;
 
-    [[OAT_NODISCARD("Handle mutate result")]]
+    [[ION_NODISCARD("Handle mutate result")]]
     virtual std::span<      std::byte> mutate() noexcept      = 0;
 
-    [[OAT_NODISCARD("Handle size result")]]
+    [[ION_NODISCARD("Handle size result")]]
     virtual std::size_t size() const noexcept = 0;
 
-    [[OAT_NODISCARD("Handle capacity result")]]
+    [[ION_NODISCARD("Handle capacity result")]]
     virtual std::size_t capacity() const noexcept = 0;
 };
 

libs/core/include/ion/core/buffer/buffer_factory.h

@@ -8,13 +8,13 @@
 namespace ion::core {
 
 // Factory function to create a dynamic buffer with an optional initial capacity
-[[OAT_NODISCARD("Handle buffer creation result")]]
+[[ION_NODISCARD("Handle buffer creation result")]]
 ION_CORE_API std::expected<std::unique_ptr<buffer_base>, std::error_code>
 create_buffer(std::size_t initial_capacity = 0);
 
 // Factory function to create a static buffer with a fixed size
 template <std::size_t N>
-[[OAT_NODISCARD("Handle static buffer creation result")]]
+[[ION_NODISCARD("Handle static buffer creation result")]]
 std::expected<std::unique_ptr<buffer_base>, std::error_code>
 create_static_buffer() {
     return std::make_unique<detail::StaticBuffer<N>>();

libs/core/include/ion/core/logging/logger.h

@@ -28,7 +28,7 @@ class ION_CORE_API logger_base {
             std::vformat(fmt, std::make_format_args(std::forward<Args>(args)...)));
     }
 
-    [[OAT_NODISCARD("You should be actually checking this if you're bothering to call it.")]]
+    [[ION_NODISCARD("You should be actually checking this if you're bothering to call it.")]]
     virtual bool is_enabled(log_level level) const = 0;
 };