[2] docs: complete the parameter blocks that documented only some arguments

Review: missing doxygen params on some functions.

Resolution: the fifty-three blocks that named only some of their

parameters now name all of them.



Fifty-three functions carried a doxygen block that named some of their

parameters and silently omitted the rest, so the block read as complete

while leaving arguments unexplained. The cache record codecs were the

bulk of it: every encode documented its output record but not the value

it packed, and every decode the reverse.



Documents the missing parameters, and repairs several blocks whose text

had been reflowed into an unreadable state, including one that named a

parameter that no longer exists (valid_collectible_links took

collectibleDefinitions while the block still said collectibles).



Functions carrying no @param at all are left as they are. That is the

established convention for short helpers here, covering 42% of the

documented functions upstream, whereas partial blocks are 4% and read as

oversights rather than style.

Sunrise/src/client/content/items/packages/internal.h

@@ -154,6 +154,7 @@ void append_initial_plugs(const tables::items::Row& row,
  * @param source Located item index table and package reader state.
  * @param definitionIndex Native item index.
  * @param detail Receives the cached detail.
+ * @param item Receives the raw definition row the detail was built from.
  * @return True when the row is found and its definition blob reads.
  */
 [[nodiscard]] bool build_detail(const DetailSource& source,
@@ -298,7 +299,11 @@ void report_bucket_equipment_failure(const char* stage,
                                      std::size_t first,
                                      std::size_t second) noexcept;
 
-/** Reports the pass outcome once. @param published Rows published, or zero on failure. */
+/**
+ * Reports the pass outcome once.
+ * @param published Rows published, or zero on failure.
+ * @param reason Stage the pass reached, named in the line.
+ */
 void report(std::size_t published, const char* reason) noexcept;
 
 /**

Sunrise/src/client/content/items/packages/package_build_report.cpp

@@ -164,7 +164,11 @@ void report_bucket_equipment_failure(const char* stage,
     }
 }
 
-/** Reports the pass outcome once. @param published Rows published, or zero on failure. */
+/**
+ * Reports the pass outcome once.
+ * @param published Rows published, or zero on failure.
+ * @param reason Stage the pass reached, named in the line.
+ */
 void report(std::size_t published, const char* reason) noexcept {
     if (g_reported.exchange(true, std::memory_order_relaxed)) {
         return;

Sunrise/src/client/content/items/packages/package_subclass_build.cpp

@@ -42,7 +42,11 @@ constexpr std::size_t kSubclassSlot =
     return true;
 }
 
-/** @param rows Rows built so far. @return True when the candidate's key is already held. */
+/**
+ * @param rows Rows built so far.
+ * @param row Candidate whose key is tested against them.
+ * @return True when the candidate's key is already held.
+ */
 [[nodiscard]] bool held(std::span<const domain::Definition> rows,
                         const domain::Definition& row) noexcept {
     for (const domain::Definition& existing : rows) {

Sunrise/src/core/settings/parser.h

@@ -252,6 +252,7 @@ private:
     /**
      * Turns one authored input name into its input code.
      * @param name Key name, or one modifier and the key it prefixes joined by "+".
+     * @param output Receives the input code.
      * @return True when every part of the name is in the Client's input table.
      */
     [[nodiscard]] static bool input_code_value(std::string_view name,
@@ -338,6 +339,7 @@ private:
     /**
      * Turns a JSON level token into the logging enum.
      * @param name Borrowed level token.
+     * @param output Receives the logging level.
      * @return True when the token names a supported level.
      */
     [[nodiscard]] static bool level_value(std::string_view name, log::Level& output) noexcept;
@@ -350,6 +352,7 @@ private:
     /**
      * Maps one readable setting name to a Windows SDK virtual key.
      * @param name Lowercase settings key name.
+     * @param output Receives the Windows SDK virtual key.
      * @return True when the name is in the supported menu-key set.
      */
     [[nodiscard]] static bool ui_toggle_key_value(std::string_view name, UINT& output) noexcept;

Sunrise/src/middleware/content/packages/tables/item_appearance_reader.cpp

@@ -59,8 +59,7 @@ read(std::span<const std::byte> blob, std::size_t offset, Value& value) noexcept
 
 /**
  * Reads the gear-art index and every class-qualified arrangement the art block declares.
- * @param
- * definition Whole item definition bytes.
+ * @param definition Whole item definition bytes.
  * @param art Art block offset.
  * @param row Receives both art indices.
  */

Sunrise/src/middleware/content/packages/tables/item_definition_reader.cpp

@@ -84,6 +84,7 @@ void read_socket_entry_list(std::span<const std::byte> definition, Row& row) noe
  * Reads the optional equipment slot a definition declares.
  * @param definition Whole item definition bytes.
  * @param slot Receives the slot when the block is present and readable.
+ * @param raw Receives the unvalidated declared value, or -1 when the block is absent.
  */
 void read_equipment_slot(std::span<const std::byte> definition,
                          std::optional<std::int8_t>& slot,

Sunrise/src/middleware/datagen/character_record/appearance/character_appearance_render.cpp

@@ -27,6 +27,8 @@ struct Fold {
  * Records one material row, keeping insertion order and letting a later stage update a value.
  * A key arriving after 6 distinct keys are held can never reach the record, so it is dropped.
  * @param fold Ordered material keys.
+ * @param key Material key this row names.
+ * @param value Material value stored against that key.
  */
 void record(Fold& fold, std::int8_t key, std::uint16_t value) noexcept {
     for (std::size_t entry = 0; entry < fold.count; ++entry) {

Sunrise/src/middleware/datagen/character_record/appearance/internal.h

@@ -59,6 +59,7 @@ void apply_sentinels(layout::Appearance& appearance) noexcept;
 /**
  * Fills each equipped render row with its instance, definition, art and material pairs.
  * @param instances Resolved item instances belonging to one character.
+ * @param characterClass Class whose art rows are selected when a definition carries them.
  * @param appearance Appearance block receiving the render rows.
  * @return True when every instance addresses a render row.
  */

Sunrise/src/server/bap/encrypted/push/snapshot/family4_snapshot_preparer.cpp

@@ -23,8 +23,10 @@ namespace family4_datagen = middleware::datagen::family4;
 /**
  * Publishes the staged family metadata once every needed object is done.
  * @param subscription Family id the Client picked.
+ * @param objectCount Descriptors staged for this family.
  * @param compressedExtent Size of the used prefix of the sealed buffer.
  * @param reservation Cleanup extent carried over from any prior live snapshot.
+ * @param staged Descriptors and clear extents built by the caller.
  * @param output Gets the family snapshot only on success.
  * @return True when the staged descriptors pass the ownership check.
  */

Sunrise/src/server/bap/encrypted/push/snapshot/roster_snapshot.cpp

@@ -21,6 +21,7 @@ namespace character_record = middleware::datagen::character_record;
  * @param scratch Raw object storage owned by the lock.
  * @param account Account State read under the lock.
  * @param rawExtent First unused raw byte, advanced for every record.
+ * @param compressedExtent First unused sealed byte, advanced for every record.
  * @param staged Snapshot that takes one descriptor per character.
  * @param objectCount Descriptors already staged, advanced for every record.
  * @return True when every character is found and its record fits raw storage.

Sunrise/src/server/bap/encrypted/push/snapshot/snapshot.h

@@ -81,14 +81,17 @@ struct Prepared {
 
 /**
  * Builds the one-record Family-0 incremental that refreshes rendered equipment in place.
- * The
- * record is encoded from the prepared State after-image because the equipment transaction is
- * not
- * committed until both Family-4 and Family-0 frames fit.
- * @param replaceCharacterRecord Release
- * and recreate the same resident record so same-instance
- *        shader and ornament changes
- * rebuild the live-world render binding.
+ * The record is encoded from the prepared State after-image because the equipment transaction is
+ * not committed until both Family-4 and Family-0 frames fit.
+ * @param scratch Raw object storage owned by the lock.
+ * @param refresh Family-0 root, version, and resident the incremental is built against.
+ * @param afterCharacter Prepared State after-image the record is encoded from.
+ * @param characterIndex Position of that character in the account.
+ * @param nativeEquipmentSlot Native slot whose rendered item changed.
+ * @param replaceCharacterRecord Release and recreate the same resident record so same-instance
+ *        shader and ornament changes rebuild the live-world render binding.
+ * @param prepared Gets the descriptors and the scratch clear extent.
+ * @return True when the character resolves and every object fits raw storage.
  */
 [[nodiscard]] bool
 prepare_character_appearance_refresh(Scratch& scratch,

Sunrise/src/server/bap/encrypted/queuez/queuez_deferred_push.cpp

@@ -19,6 +19,7 @@ constexpr std::size_t kRepushReportLimit = 96;
 
 /**
  * Logs one delayed re-push with its framed size, so it can be compared to the first copy.
+ * @param stage Point in the deferred push the line reports.
  * @param bytes Framed size of the published notification.
  */
 void report_repush(const char* stage, std::size_t bytes) noexcept {

Sunrise/src/server/bap/encrypted/queuez/queuez_state_validation.h

@@ -47,6 +47,7 @@ namespace sunrise::server::bap::encrypted::queuez {
 /**
  * Decides whether one validated Family-3 subscription publishes a snapshot.
  * @param before Current queuez state owned by the peer.
+ * @param subscription Family selector the Client asked for.
  * @param publish Gets whether a svc-123 frame is needed.
  * @param after Gets the state published after the whole response transaction.
  * @return True when the selector belongs to the active post-change root, where that is needed.
@@ -78,13 +79,10 @@ namespace sunrise::server::bap::encrypted::queuez {
 
 /**
  * Stages one Family-4 version increment without changing its resident manifest.
- * @param
- * before Current queuez state owned by the peer.
- * @param characterSoid Selected character whose
- * equipment changed.
+ * @param before Current queuez state owned by the peer.
+ * @param characterSoid Selected character whose equipment changed.
  * @param swap Gets the checked version after-image and resident definition.
-
- * * @return True only when the named character object is resident in active Family 4.
+ * @return True only when the named character object is resident in active Family 4.
  */
 [[nodiscard]] bool stage_equipment_swap(const SessionState& before,
                                         std::uint64_t characterSoid,
@@ -120,8 +118,10 @@ namespace sunrise::server::bap::encrypted::queuez {
 /**
  * Stages one Family-4 version increment without changing its resident manifest.
  * @param before Current active peer state.
+ * @param accountSoid Account root the peer's family is rooted with.
  * @param characterSoid Selected resident character owning the changed item.
  * @param targetInstanceSoid Existing resident item-instance key to upsert.
+ * @param updatesAccount True when the account object rides the same increment.
  * @param socketPlug Gets the exact +1 version and item-instance schema id.
  * @return True when both the selected character and target instance are resident exactly once.
  */
@@ -136,14 +136,12 @@ namespace sunrise::server::bap::encrypted::queuez {
  * Stages one Family-4 increment that adds a new resident item and updates its character.
  *
  * @param before Current active peer state.
- * @param characterSoid Selected resident character
- * receiving the item.
- * @param acquiredInstanceSoid Fresh item-instance SOID absent from the
- * resident manifest.
- * @param acquisition Gets the exact +1 version and appended resident
- * after-image.
- * @return True when both schemas resolve and the manifest has one free resident
- * slot.
+ * @param accountSoid Account root the peer's family is rooted with.
+ * @param characterSoid Selected resident character receiving the item.
+ * @param acquiredInstanceSoid Fresh item-instance SOID absent from the resident manifest.
+ * @param updatesAccount True when the account object rides the same increment.
+ * @param acquisition Gets the exact +1 version and appended resident after-image.
+ * @return True when both schemas resolve and the manifest has one free resident slot.
  */
 [[nodiscard]] bool stage_item_acquisition(const SessionState& before,
                                           std::uint64_t accountSoid,
@@ -177,13 +175,12 @@ namespace sunrise::server::bap::encrypted::queuez {
  * Stages one Family-4 increment that removes an item resident and updates its character.
  *
  * @param before Current active peer state.
- * @param characterSoid Selected resident character
- * losing the item.
+ * @param accountSoid Account root the peer's family is rooted with.
+ * @param characterSoid Selected resident character losing the item.
  * @param dismantledInstanceSoid Existing item-instance SOID to release.
- *
+ * @param updatesAccount True when the account object rides the same increment.
  * @param dismantle Gets the exact +1 version and compacted resident after-image.
- * @return True
- * when both schemas and both named residents exist exactly once.
+ * @return True when both schemas and both named residents exist exactly once.
  */
 [[nodiscard]] bool stage_item_dismantle(const SessionState& before,
                                         std::uint64_t accountSoid,

Sunrise/src/server/bap/internal.h

@@ -103,6 +103,7 @@ namespace plaintext {
  * Handles plaintext bootstrap services, arms encryption after service 25, and routes the rest.
  * @param session Auth and nonce state owned by the connection.
  * @param scratch Transform buffers owned by the lock, kept off the Client thread stack.
+ * @param outer Parsed outer frame carrying the service id and its body.
  * @param response Whole-frame storage owned by the caller.
  * @param written Gets the encoded response size in bytes.
  * @return True when the service owes no reply, or its response is encoded.

Sunrise/src/state/build_data/cache/records/codec.h

@@ -5,124 +5,284 @@
 
 namespace sunrise::state::build_data::cache::records {
 
-/** @param record Receives the packed disk row. @return True when the row is valid. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the row is valid.
+ */
 [[nodiscard]] bool encode(const content::Definition& value, NamedRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const NamedRecord& record, content::Definition& value) noexcept;
 
-/** @param record Receives the packed disk row. @return Always true. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(const items::Definition& value, ItemRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const ItemRecord& record, items::Definition& value) noexcept;
 
-/** @param record Receives the packed disk row. @return Always true. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(const collectibles::Definition& value,
                           CollectibleRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return Always true. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return Always true.
+ */
 [[nodiscard]] bool decode(const CollectibleRecord& record,
                           collectibles::Definition& value) noexcept;
 
-/** Exact dense action-cost set codecs. */
+/**
+ * Exact dense action-cost set codec.
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the requirement count fits its fixed rows.
+ */
 [[nodiscard]] bool encode(const material_requirements::Definition& value,
                           MaterialRequirementSetRecord& record) noexcept;
+
+/**
+ * Exact dense action-cost set codec.
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the reserved field and every packed boolean are canonical.
+ */
 [[nodiscard]] bool decode(const MaterialRequirementSetRecord& record,
                           material_requirements::Definition& value) noexcept;
 
-/** @param record Receives the packed disk row. @return True when the state is a known one. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the state is a known one.
+ */
 [[nodiscard]] bool encode(const items::details::Definition& value,
                           ItemDetailRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the state byte is a known one. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the state byte is a known one.
+ */
 [[nodiscard]] bool decode(const ItemDetailRecord& record,
                           items::details::Definition& value) noexcept;
 
-/** Exact ordinary-socket rule codecs. */
+/**
+ * Exact ordinary-socket rule codec.
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the row's canonical padding is zero.
+ */
 [[nodiscard]] bool encode(const items::socket_plugs::Rule& value,
                           SocketPlugRuleRecord& record) noexcept;
+
+/**
+ * Exact ordinary-socket rule codec.
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the record's reserved byte is zero.
+ */
 [[nodiscard]] bool decode(const SocketPlugRuleRecord& record,
                           items::socket_plugs::Rule& value) noexcept;
 
-/** Deduplicated socket-pool range codecs. */
+/**
+ * Deduplicated socket-pool range codec.
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(const items::socket_plugs::Pool& value,
                           SocketPlugPoolRecord& record) noexcept;
+
+/**
+ * Deduplicated socket-pool range codec. Cross-row contiguity is checked at the domain boundary.
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return Always true.
+ */
 [[nodiscard]] bool decode(const SocketPlugPoolRecord& record,
                           items::socket_plugs::Pool& value) noexcept;
 
-/** Flat allowed-plug member codecs. */
+/**
+ * Flat allowed-plug member codec.
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(items::socket_plugs::Member value,
                           SocketPlugMemberRecord& record) noexcept;
+
+/**
+ * Flat allowed-plug member codec.
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return Always true.
+ */
 [[nodiscard]] bool decode(const SocketPlugMemberRecord& record,
                           items::socket_plugs::Member& value) noexcept;
 
-/** @param record Receives the packed disk row. @return Always true. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(const inventory::buckets::Descriptor& value,
                           InventoryBucketRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return Always true. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return Always true.
+ */
 [[nodiscard]] bool decode(const InventoryBucketRecord& record,
                           inventory::buckets::Descriptor& value) noexcept;
 
-/** @param record Receives the packed disk row. @return Always true. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(const socket_entry_lists::Definition& value,
                           SocketEntryListRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const SocketEntryListRecord& record,
                           socket_entry_lists::Definition& value) noexcept;
 
-/** @param record Receives the packed disk row. @return Always true. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(const socket_entry_lists::EntryTable& value,
                           SocketEntryTableRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const SocketEntryTableRecord& record,
                           socket_entry_lists::EntryTable& value) noexcept;
 
-/** @param record Receives the packed disk row. @return Always true. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(const abilities::Definition& value, AbilityBucketRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when every count is inside its limit. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when every count is inside its limit.
+ */
 [[nodiscard]] bool decode(const AbilityBucketRecord& record, abilities::Definition& value) noexcept;
 
-/** @param record Receives the packed disk row. @return Always true. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return Always true.
+ */
 [[nodiscard]] bool encode(const progressions::Definition& value,
                           ProgressionRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const ProgressionRecord& record,
                           progressions::Definition& value) noexcept;
 
-/** @param record Receives the packed disk row. @return True when the row is valid. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the row is valid.
+ */
 [[nodiscard]] bool encode(const scenarios::Definition& value, ScenarioRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const ScenarioRecord& record, scenarios::Definition& value) noexcept;
 
-/** @param record Receives the packed disk row. @return True when the row is valid. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the row is valid.
+ */
 [[nodiscard]] bool encode(const scenarios::RosterGroup& value, RosterGroupRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const RosterGroupRecord& record, scenarios::RosterGroup& value) noexcept;
 
-/** @param record Receives the packed disk row. @return True when the row is valid. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the row is valid.
+ */
 [[nodiscard]] bool encode(const hash_names::Name& value, HashNameRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const HashNameRecord& record, hash_names::Name& value) noexcept;
 
-/** @param record Receives the packed disk row. @return True when the row is valid. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the row is valid.
+ */
 [[nodiscard]] bool encode(const spawn_sets::Stem& value, SpawnStemRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const SpawnStemRecord& record, spawn_sets::Stem& value) noexcept;
 
-/** @param record Receives the packed disk row. @return True when the row is valid. */
+/**
+ * @param value Runtime row to pack.
+ * @param record Receives the packed disk row.
+ * @return True when the row is valid.
+ */
 [[nodiscard]] bool encode(const spawn_sets::NameHash& value, SpawnNameHashRecord& record) noexcept;
 
-/** @param value Receives the runtime row. @return True when the disk row is in standard form. */
+/**
+ * @param record Packed disk row.
+ * @param value Receives the runtime row.
+ * @return True when the disk row is in standard form.
+ */
 [[nodiscard]] bool decode(const SpawnNameHashRecord& record, spawn_sets::NameHash& value) noexcept;
 
 } // namespace sunrise::state::build_data::cache::records

Sunrise/src/state/build_data/cache/records/validation.h

@@ -40,10 +40,8 @@ valid_socket_plug_links(std::span<const items::socket_plugs::Rule> rules,
 
 /**
  * Checks every collectible item index against the complete dense item table.
- * @param
- * collectibles Complete dense collectible rows.
- * @param itemDefinitions Complete dense item
- * rows.
+ * @param collectibleDefinitions Complete dense collectible rows.
+ * @param itemDefinitions Complete dense item rows.
  * @return True when each row has its own ordinal and every available item link exists.
  */
 [[nodiscard]] bool

Sunrise/src/state/runtime/runtime.h

@@ -275,17 +275,14 @@ void shutdown() noexcept;
 
 /**
  * Prepares one installed equippable definition as a new selected-character inventory instance.
-
- * * Native-default sockets, a unique runtime SOID, and the selected character's current item level
-
- * * are used. Full loadout resolution is the authoritative bucket-capacity check.
  *
- * @param
- * definitionHash Installed item definition requested by the Client.
- * @param mutation Gets a
- * checked after-image without changing account State.
- * @return True when the item and every
- * existing loadout row resolve with one free native row.
+ * Native-default sockets, a unique runtime SOID, and the selected character's current item level
+ * are used. Full loadout resolution is the authoritative bucket-capacity check.
+ *
+ * @param collectibleIndex Collections row the Client pulled from.
+ * @param definitionHash Installed item definition requested by the Client.
+ * @param mutation Gets a checked after-image without changing account State.
+ * @return True when the item and every existing loadout row resolve with one free native row.
  */
 [[nodiscard]] bool prepare_item_acquisition(std::uint16_t collectibleIndex,
                                             std::uint32_t definitionHash,
@@ -297,13 +294,10 @@ void shutdown() noexcept;
 
 /**
  * Commits a prepared inventory insertion only while its selected character, existing loadout,
-
- * * and next inventory serial still match the prepare-time view.
+ * and next inventory serial still match the prepare-time view.
  *
- * @param mutation Prepared
- * mutation, always cleared before this function returns.
- * @return True when the insertion commits
- * atomically and leaves the whole account valid.
+ * @param mutation Prepared mutation, always cleared before this function returns.
+ * @return True when the insertion commits atomically and leaves the whole account valid.
  */
 [[nodiscard]] bool commit_item_acquisition(PendingItemAcquisition& mutation) noexcept;
 
@@ -313,6 +307,7 @@ void shutdown() noexcept;
  * An existing non-full stack is incremented. Otherwise a new dense State entry is appended only
  * when the installed profile bucket still owns a free native row.
  *
+ * @param collectibleIndex Collections row the Client pulled from.
  * @param definitionHash Installed stackable definition requested by the Client.
  * @param mutation Gets the checked profile before/after images without changing account State.
  * @return True when the definition belongs to the main profile array and one unit fits.

Sunrise/src/state/runtime/state_runtime.cpp

@@ -103,7 +103,11 @@ template <std::size_t Size>
     return account::valid(accountState);
 }
 
-/** Canonicalizes only profile rows which the installed socket UI materializes as action sources. */
+/**
+ * Canonicalizes only profile rows which the installed socket UI materializes as action sources.
+ * @param accountState Account canonicalized in place.
+ * @return True when every profile row canonicalizes.
+ */
 [[nodiscard]] bool canonicalize_profile_item_identities(AccountState& accountState) noexcept {
     if (!account::valid(accountState) || !build_data::socket_plug_rules_ready()) {
         return false;