Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@components/core/src/clp_s/timestamp_parser/TimestampParser.cpp`:
- Around line 946-951: The current code in TimestampParser.cpp creates a
temporary std::string via std::to_string(value) before appending padding and the
value to buffer; replace that allocation by formatting the integer directly into
a small stack char array using std::to_chars (include <charconv>), compute
digits written, compute num_padding_characters as before, then call
buffer.append(num_padding_characters, padding_character) and buffer.append(ptr,
ptr + digits_written) instead of using value_str—target the block that declares
value, length, padding_character and the buffer appends to eliminate the heap
allocation.
- Around line 936-953: The function append_positive_left_padded_integer
currently takes an int which causes implicit narrowing at call sites; change the
parameter type of value from int to int64_t in both the function declaration and
the function definition (append_positive_left_padded_integer) so it accepts
int64_t (matching extract_absolute_subsecond_nanoseconds()/epochtime_t and
chrono .count() results); ensure any includes for <cstdint> are present and
update any forward declarations or prototypes to the new signature so callers no
longer perform narrowing conversions.

---

Outside diff comments:
In `@components/core/src/clp_s/timestamp_parser/TimestampParser.cpp`:
- Around line 751-773: Extract the repeated logic that builds a 9-digit
left-padded nanoseconds string, trims trailing zeros, validates not-all-zero,
and appends to the output into a small helper (e.g.,
formatOrAppendFractionalNanoseconds or appendTrimmedSubseconds) and call it from
the 'T' branch in TimestampParser::... (the date-time marshal case) and from the
numeric marshal case; the helper should accept the nanoseconds value (from
time_of_day.subseconds().count() or equivalent) plus a reference to the buffer
(or return a string and an ErrorCode) and must reproduce the current behavior:
pad to 9 digits, strip trailing '0's, return
ErrorCode::IncompatibleTimestampPattern when all digits are zero, and otherwise
append the trimmed substring to the buffer so both code paths use the same
implementation.

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@components/core/src/clp_s/timestamp_parser/TimestampParser.cpp`:
- Around line 309-314: The declaration of append_positive_left_padded_integer
currently takes an int which causes implicit narrowing at call sites that pass
long long/int64_t; change the parameter type from int to int64_t in the function
declaration and the corresponding definition
(append_positive_left_padded_integer) so callers (chrono .count(),
extract_absolute_subsecond_nanoseconds, epochtime_t, etc.) no longer narrow;
keep the same validation inside the function that checks value >= 0 and no other
behavior changes are required—update any matching forward declarations or
overloads to use int64_t as well.
- Around line 936-953: The function append_positive_left_padded_integer
currently uses std::to_string which heap-allocates; change it to use
std::to_chars writing into a stack-local std::array<char,20> (sized for int64_t)
and compute the digit count from the returned ptr to avoid allocations. Keep the
negative check, optionally change the parameter from int to int64_t (and adjust
checks) so the buffer size is safe, compute num_padding_characters from the
digit count, then append the padding and the digit range to buffer via
buffer.append(pointer, count). Ensure error handling remains the same and return
success().

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@components/core/src/clp_s/timestamp_parser/TimestampParser.cpp`:
- Around line 879-885: Remove the stray blank line in the call to
append_positive_left_padded_integer wrapped by YSTDLIB_ERROR_HANDLING_TRYV so
the argument list is contiguous (match the style used in
marshal_date_time_timestamp); specifically, edit the call that passes
subsecond_nanoseconds, 9, '0', subsecond_nanoseconds_str to remove the empty
line between subsecond_nanoseconds and 9 so the macro invocation and its
arguments are formatted consistently.
- Around line 879-885: Remove the stray empty line inside the argument list of
the append_positive_left_padded_integer call in the 'T' case of
marshal_numeric_timestamp: locate the call to
append_positive_left_padded_integer with symbols subsecond_nanoseconds, 9, '0',
and subsecond_nanoseconds_str and ensure there is no blank line between the
first argument (subsecond_nanoseconds) and the next argument (9) so the argument
list matches the formatting used in marshal_date_time_timestamp.
- Around line 957-959: The current early return uses a std::error_code named err
(created from ec) which yields std::generic_category; instead return the project
ErrorCode type using the appropriate ErrorCodeEnum value used elsewhere in this
file (replace "return err;" with "return
ErrorCode{ErrorCodeEnum::<appropriate_enum>}" so the error belongs to the
project's category), and remove the now-unnecessary `#include` <system_error>;
locate the occurrence in TimestampParser.cpp around the to_chars handling where
err is declared and mirror the enum choice used by other returns in this file.
- Around line 957-959: The code currently returns a std::error_code (err) which
uses std::generic_category; replace that with the project-specific ErrorCode so
the returned error belongs to the project's category. In the block with
variables ec/err (the to_chars failure path), map the std::error_code to the
appropriate ErrorCode by returning ErrorCode{ErrorCodeEnum::<appropriate_enum>}
(pick the closest existing enum such as
ParseError/InvalidTimestamp/UnexpectedFailure used elsewhere in this file)
instead of returning err, so all error returns in TimestampParser.cpp use the
project ErrorCode type and category.

---

Duplicate comments:
In `@components/core/src/clp_s/timestamp_parser/TimestampParser.cpp`:
- Around line 311-312: The function append_positive_left_padded_integer
currently takes an int (append_positive_left_padded_integer(int value,...))
which causes implicit narrowing when callers pass long long/int64_t
(chrono.count(), epochtime_t, extract_absolute_subsecond_nanoseconds); change
the parameter type to a wider integer (e.g., long long or int64_t) in both the
declaration and definition of append_positive_left_padded_integer and adjust any
internal arithmetic/formatting to use that wider type so callers no longer
perform narrowing conversions (no other semantic changes required).
- Around line 311-312: The function append_positive_left_padded_integer
currently takes an int but is called with int64_t/long long values (e.g.,
time_of_day.hours/minutes/seconds/subseconds().count() and
extract_absolute_subsecond_nanoseconds results), causing implicit narrowing;
change the parameter type of append_positive_left_padded_integer to a 64-bit
signed type (e.g., int64_t or long long) and update any related local
temporaries accordingly, then add explicit range checks/assertions to ensure the
value fits the expected digit width before doing any narrowing/static_cast to
int for digit extraction or buffer indexing; locate the function by name
append_positive_left_padded_integer and adjust callers only if they rely on
overload ambiguity.
- Line 951: The use of the GCC-only typeof in the declaration of
value_str_buffer should be replaced with standard C++ decltype: update the array
type expression in the line that defines std::array<char,
std::numeric_limits<typeof(value)>::digits10 + 1> value_str_buffer{} to use
std::numeric_limits<decltype(value)>::digits10 + 1 instead; ensure the change
targets the value_str_buffer declaration in TimestampParser.cpp so the code
remains portable and compiles with non-GCC compilers.
- Line 951: The declaration of value_str_buffer uses the non-standard GCC
extension typeof; replace typeof(value) with the standard C++ decltype by
changing the expression to use std::numeric_limits<decltype(value)>::digits10 +
1 so value_str_buffer is declared as std::array<char,
std::numeric_limits<decltype(value)>::digits10 + 1> value_str_buffer{}; (update
the line in TimestampParser.cpp where value_str_buffer is defined).

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@components/core/src/clp_s/timestamp_parser/TimestampParser.cpp`:
- Around line 942-947: Change the append_positive_left_padded_integer function
signature to accept a 64-bit integer type (e.g., int64_t) instead of int to
avoid implicit narrowing at its call sites (calls that pass
time_of_day.hours().count(), .minutes().count(), .seconds().count(),
.subseconds().count(), and extract_absolute_subsecond_nanoseconds which return
long long/int64_t). Update the parameter type in the function
declaration/definition (append_positive_left_padded_integer) and any internal
uses to the new int64_t type so callers no longer trigger narrowing or
-Wconversion warnings.
- Around line 880-886: Remove the stray blank line inside the
YSTDLIB_ERROR_HANDLING_TRYV call to append_positive_left_padded_integer: ensure
the arguments (subsecond_nanoseconds, 9, '0', subsecond_nanoseconds_str) are
adjacent as in the marshal_date_time_timestamp example; update the call using
the same argument formatting so the macro invocation and parameters
(append_positive_left_padded_integer, subsecond_nanoseconds, 9, '0',
subsecond_nanoseconds_str) have no extra blank line between them.
- Around line 958-960: The current code returns a std::error_code created from
ec (std::generic_category) which is inconsistent with the project's ErrorCode;
replace the `if (auto const err{std::make_error_code(ec)}; err) { return err; }`
branch to return the project's ErrorCode type instead (e.g., `return
ErrorCode{ErrorCodeEnum::...}`) using the same ErrorCodeEnum value used for
other to_chars/parse failures in this file (look for existing `return
ErrorCode{ErrorCodeEnum::...}` usages in TimestampParser.cpp to pick the correct
enum variant), and remove the now-unnecessary `#include <system_error>`.
- Line 952: Replace the non-standard GCC extension typeof with the standard C++
decltype for the numeric_limits instantiation: change the array declaration that
references std::numeric_limits<typeof(value)>::digits10 to use
std::numeric_limits<decltype(value)>::digits10 (i.e., update the expression in
the std::array<> template parameter for value_str_buffer in
TimestampParser.cpp).