pi-usereq 0.48.0 → 0.50.0

package/tests/fixtures_attended_results/project/find.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ <PROJECT_BASE>/src/fixture_c.c | c\n- @brief Comprehensive C language test fixture for parser validation.\n- @details Covers structs, unions, enums, function pointers, inline functions,\npreprocessor directives, bitfields, variadic functions, and complex\ntypedef chains that stress-test regex-based parsing.\n\n### IMPORT: `\"myheader.h\"`\n> Lines: 14-14\n```\n#include \"myheader.h\"\n```\n\n### IMPORT: `<stdarg.h>`\n> Lines: 15-15\n```\n#include <stdarg.h>\n```\n\n### IMPORT: `<stdio.h>`\n> Lines: 16-16\n```\n#include <stdio.h>\n```\n\n### IMPORT: `<stdlib.h>`\n> Lines: 17-17\n```\n#include <stdlib.h>\n```\n\n### IMPORT: `<string.h>`\n> Lines: 18-18\n```\n#include <string.h>\n```\n\n### VARIABLE: `i_val`\n> Signature: `int i_val`\n> Lines: 85-85\n- @brief Payload can hold either an integer or float value. */\n```\nint i_val;\n```\n\n### VARIABLE: `f_val`\n> Signature: `float f_val`\n> Lines: 86-86\n```\nfloat f_val;\n```\n\n### FUNCTION: `int`\n> Signature: `typedef int (*comparator_fn)(const void *a, const void *b)`\n> Lines: 124-142\n- @brief Function pointer type for generic comparison callbacks.\n- @brief Unary transform callback operating on a single integer.\n- @param a Pointer to first element.\n- @param b Pointer to second element.\n- @return Negative if a<b, zero if equal, positive if a>b.\n```\ntypedef int (*comparator_fn)(const void *a, const void *b);\ntypedef int (*transform_fn)(int value);\ntypedef struct {\nconst char *name;\ncomparator_fn handler;\nint priority;\n} callback_entry_t;\n```\n\n### FUNCTION: `int`\n> Signature: `typedef int (*transform_fn)(int value)`\n> Lines: 130-142\n- @brief Unary transform callback operating on a single integer.\n```\ntypedef int (*transform_fn)(int value);\ntypedef struct {\nconst char *name;\ncomparator_fn handler;\nint priority;\n} callback_entry_t;\n```\n\n### VARIABLE: `counter`\n> Signature: `static int counter = 0`\n> Lines: 147-147\n- @brief Module-scoped invocation counter, not visible externally. */\n```\nstatic int counter = 0;\n```\n\n### VARIABLE: `error_buffer`\n> Signature: `static char error_buffer[256] = {0}`\n> Lines: 150-150\n- @brief Global error message buffer shared across translation unit. */\n```\nstatic char error_buffer[256] = {0};\n```\n\n### FUNCTION: `min_val`\n> Signature: `static inline int min_val(int a, int b) { return a < b ? a : b; }`\n> Lines: 160-160\n- @brief Compute the minimum of two integers.\n- @param a First integer.\n- @param b Second integer.\n- @return The smaller of a and b.\n```\nstatic inline int min_val(int a, int b) { return a < b ? a : b; }\n```\n\n### FUNCTION: `greet`\n> Signature: `void greet(const char *name)`\n> Lines: 168-174\n- @brief Print a greeting message to stdout.\n- @param name The recipient name; must not be NULL.\n```\nvoid greet(const char *name) {\nif (name == NULL) {\nreturn;\n}\nprintf(\"Hello %s\\n\", name);\n}\n```\n\n### FUNCTION: `main`\n> Signature: `int main(int argc, char **argv)`\n> Lines: 182-190\n- @brief Application entry point.\n- @param argc Argument count from the OS.\n- @param argv Argument vector; argv[0] is the program name.\n- @return Exit code: 0 on success, 1 on error.\n```\nint main(int argc, char **argv) {\nif (argc < 2) {\nfprintf(stderr, \"Usage: %s <name>\\n\", argv[0]);\nreturn 1;\n}\ngreet(argv[1]);\nreturn 0;\n}\n```\n\n### FUNCTION: `sum_ints`\n> Signature: `int sum_ints(int count, ...)`\n> Lines: 200-210\n- @brief Compute the sum of a variable number of integers.\n- @param count Number of integer arguments that follow.\n- @param ... Variable integer arguments to sum.\n- @return The cumulative sum of all provided integers.\n```\nint sum_ints(int count, ...) {\nva_list ap;\nva_start(ap, count);\nint total = 0;\nfor (int i = 0; i < count; i++) {\ntotal += va_arg(ap, int);\n}\nva_end(ap);\nreturn total;\n}\n```\n\n### VARIABLE: `total`\n> Signature: `int total = 0`\n> Lines: 203-203\n```\nint total = 0;\n```\n\n### FUNCTION: `apply_transform`\n> Signature: `void apply_transform(int *arr, size_t len, transform_fn fn)`\n> Lines: 220-225\n- @brief Apply a transform function to every element in an array.\n- @param arr Array of integers to transform in-place.\n- @param len Number of elements in arr.\n- @param fn Transform callback applied to each element.\n```\nvoid apply_transform(int *arr, size_t len, transform_fn fn) {\nfor (size_t i = 0; i < len; i++) {\narr[i] = fn(arr[i]);\n}\n}\n```\n\n### FUNCTION: `factorial`\n> Signature: `unsigned long factorial(unsigned int n)`\n> Lines: 234-241\n- @brief Compute factorial recursively.\n- @param n Non-negative integer input.\n- @return n! or 1 when n <= 1.\n```\nunsigned long factorial(unsigned int n) {\nif (n <= 1) {\nreturn 1;\n}\nreturn n * factorial(n - 1);\n}\n```\n\n### FUNCTION: `fast_copy`\n> Signature: `static void fast_copy(void *restrict dest, const void *restrict src, size_t n)`\n> Lines: 251-253\n- @brief Copy bytes between non-overlapping buffers.\n- @param dest Destination buffer (restrict-qualified).\n- @param src Source buffer (restrict-qualified).\n- @param n Number of bytes to copy.\n```\nstatic void fast_copy(void *restrict dest, const void *restrict src, size_t n) {\nmemcpy(dest, src, n);\n}\n```\n\n### FUNCTION: `read_volatile`\n> Signature: `static int read_volatile(volatile int *reg) { return *reg; }`\n> Lines: 260-260\n- @brief Read a hardware register marked volatile.\n- @param reg Pointer to the memory-mapped register.\n- @return The current 32-bit register value.\n```\nstatic int read_volatile(volatile int *reg) { return *reg; }\n```\n\n### FUNCTION: `sum_fixed`\n> Signature: `int sum_fixed(int arr[static 10])`\n> Lines: 269-275\n- @brief Sum elements of a fixed-size array.\n- @param arr Array with at least 10 elements (compiler hint via static 10).\n- @return The sum of the first 10 elements.\n```\nint sum_fixed(int arr[static 10]) {\nint s = 0;\nfor (int i = 0; i < 10; i++) {\ns += arr[i];\n}\nreturn s;\n}\n```\n\n### VARIABLE: `s`\n> Signature: `int s = 0`\n> Lines: 270-270\n```\nint s = 0;\n```\n\n### VARIABLE: `x`\n> Signature: `int x`\n> Lines: 279-279\n```\nint x;\n```\n\n### VARIABLE: `y`\n> Signature: `int y`\n> Lines: 280-280\n```\nint y;\n```\n\n### VARIABLE: `a11`\n> Signature: `int a11`\n> Lines: 283-283\n```\nint a11;\n```\n\n### VARIABLE: `a22`\n> Signature: `int a22`\n> Lines: 284-284\n```\nint a22;\n```\n\n### VARIABLE: `i`\n> Signature: `int i`\n> Lines: 291-291\n```\nint i;\n```\n\n### VARIABLE: `f`\n> Signature: `float f`\n> Lines: 292-292\n```\nfloat f;\n```\n\n### VARIABLE: `l`\n> Signature: `long l`\n> Lines: 296-296\n```\nlong l;\n```\n\n### VARIABLE: `s`\n> Signature: `int s`\n> Lines: 299-299\n```\nint s;\n```\n\n### VARIABLE: `c`\n> Signature: `char c`\n> Lines: 300-300\n```\nchar c;\n```\n\n### VARIABLE: `x`\n> Signature: `int x`\n> Lines: 303-303\n```\nint x;\n```\n\n### VARIABLE: `y`\n> Signature: `int y`\n> Lines: 304-304\n```\nint y;\n```\n\n### FUNCTION: `req_cover_c_1`\n> Signature: `int req_cover_c_1(int value) { return value + 1; }`\n> Lines: 319-319\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nint req_cover_c_1(int value) { return value + 1; }\n```\n\n### FUNCTION: `req_cover_c_2`\n> Signature: `int req_cover_c_2(int value) { return value + 2; }`\n> Lines: 328-328\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nint req_cover_c_2(int value) { return value + 2; }\n```\n\n### FUNCTION: `req_cover_c_3`\n> Signature: `int req_cover_c_3(int value) { return value + 3; }`\n> Lines: 337-337\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nint req_cover_c_3(int value) { return value + 3; }\n```\n\n### FUNCTION: `req_cover_c_4`\n> Signature: `int req_cover_c_4(int value) { return value + 4; }`\n> Lines: 346-346\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nint req_cover_c_4(int value) { return value + 4; }\n```\n\n### FUNCTION: `req_cover_c_5`\n> Signature: `int req_cover_c_5(int value) { return value + 5; }`\n> Lines: 355-355\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nint req_cover_c_5(int value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_cpp.cpp | cpp\n- @brief Comprehensive C++ test fixture for parser stress-testing.\n- @details Covers templates, SFINAE, constexpr, lambdas, concepts, CRTP,\noperator overloading, move semantics, nested namespaces, and\nmodern C++20/23 constructs.\n\n### IMPORT: `<concepts>`\n> Lines: 13-13\n```\n#include <concepts>\n```\n\n### IMPORT: `<functional>`\n> Lines: 14-14\n```\n#include <functional>\n```\n\n### IMPORT: `<iostream>`\n> Lines: 15-15\n```\n#include <iostream>\n```\n\n### IMPORT: `<memory>`\n> Lines: 16-16\n```\n#include <memory>\n```\n\n### IMPORT: `<optional>`\n> Lines: 17-17\n```\n#include <optional>\n```\n\n### IMPORT: `<string>`\n> Lines: 18-18\n```\n#include <string>\n```\n\n### IMPORT: `<vector>`\n> Lines: 19-19\n```\n#include <vector>\n```\n\n### CLASS: `Container`\n> Signature: `template <Printable T> class Container`\n> Lines: 55-110\n- @brief Generic container with RAII semantics.\n@tparam T Element type; must satisfy Printable concept.\n- @brief Stored value of type T.\n```\ntemplate <Printable T> class Container {\npublic:\nT value;\nexplicit Container(T v) : value(std::move(v)) {}\nContainer(const Container &other) = default;\nContainer(Container &&other) noexcept = default;\nContainer &operator=(const Container &other) = default;\nContainer &operator=(Container &&other) noexcept = default;\n~Container() = default;\nfriend std::ostream &operator<<(std::ostream &os, const Container &c) {\nreturn os << c.value;\n}\nbool operator==(const Container &other) const { return value == other.value; }\n};\n```\n\n### FUNCTION: `r`\n> Signature: `explicit Container(T v) : value(std::move(v)) {}`\n> Lines: 63-63\n- @brief Construct container with an initial value.\n- @param v The value to store.\n```\nexplicit Container(T v) : value(std::move(v)) {}\n```\n\n### FUNCTION: `r`\n> Signature: `Container(const Container &other) = default`\n> Lines: 69-102\n- @brief Copy constructor performs deep copy.\n- @brief Move constructor transfers ownership.\n- @param other Source container to copy from.\n- @param other Source container; left in valid but unspecified state.\n```\nContainer(const Container &other) = default;\nContainer(Container &&other) noexcept = default;\nContainer &operator=(const Container &other) = default;\nContainer &operator=(Container &&other) noexcept = default;\n~Container() = default;\nfriend std::ostream &operator<<(std::ostream &os, const Container &c) {\nreturn os << c.value;\n}\n```\n\n### FUNCTION: `r`\n> Signature: `Container(Container &&other) noexcept = default`\n> Lines: 75-102\n- @brief Move constructor transfers ownership.\n- @brief Copy assignment operator.\n- @param other Source container; left in valid but unspecified state.\n- @param other Source container.\n- @return Reference to this container.\n```\nContainer(Container &&other) noexcept = default;\nContainer &operator=(const Container &other) = default;\nContainer &operator=(Container &&other) noexcept = default;\n~Container() = default;\nfriend std::ostream &operator<<(std::ostream &os, const Container &c) {\nreturn os << c.value;\n}\n```\n\n### FUNCTION: `dist_sq`\n> Signature: `constexpr double dist_sq(const Point &other) const`\n> Lines: 127-132\n- @brief Compute Euclidean distance squared to another point.\n- @param other Target point.\n- @return Distance squared (avoids sqrt overhead).\n```\nconstexpr double dist_sq(const Point &other) const {\ndouble dx = x - other.x;\ndouble dy = y - other.y;\nreturn dx * dx + dy * dy;\n}\n```\n\n### CLASS: `Cloneable`\n> Signature: `template <typename Derived> class Cloneable`\n> Lines: 175-185\n- @brief CRTP base providing a polymorphic clone method.\n@tparam Derived The concrete class inheriting this base.\n- @brief Create a heap-allocated copy of the derived object.\n- @return Unique pointer to the cloned instance.\n```\ntemplate <typename Derived> class Cloneable {\npublic:\nstd::unique_ptr<Derived> clone() const {\nreturn std::make_unique<Derived>(static_cast<const Derived &>(*this));\n}\n};\n```\n\n### CLASS: `Base`\n> Signature: `class Base`\n> Lines: 193-201\n- @brief Abstract base with a pure virtual method.\n- @brief Identify the concrete type at runtime.\n- @return A non-owning string literal naming the type.\n```\nclass Base {\npublic:\nvirtual const char *type_name() const = 0;\nvirtual ~Base() = default;\n};\n```\n\n### FUNCTION: `type_name`\n> Signature: `virtual const char *type_name() const = 0`\n> Lines: 199-207\n- @brief Identify the concrete type at runtime.\n- @return A non-owning string literal naming the type.\n```\nvirtual const char *type_name() const = 0;\nvirtual ~Base() = default;\n};\nclass DerivedA : public virtual Base {\n```\n\n### CLASS: `DerivedA`\n> Signature: `class DerivedA : public virtual Base`\n> Lines: 207-210\n- @brief First concrete implementation of Base.\n```\nclass DerivedA : public virtual Base {\npublic:\nconst char *type_name() const override { return \"DerivedA\"; }\n};\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"DerivedA\"; }`\n> Lines: 209-209\n```\nconst char *type_name() const override { return \"DerivedA\"; }\n```\n\n### CLASS: `DerivedB`\n> Signature: `class DerivedB : public virtual Base`\n> Lines: 216-219\n- @brief Second concrete implementation for diamond inheritance testing.\n```\nclass DerivedB : public virtual Base {\npublic:\nconst char *type_name() const override { return \"DerivedB\"; }\n};\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"DerivedB\"; }`\n> Lines: 218-218\n```\nconst char *type_name() const override { return \"DerivedB\"; }\n```\n\n### CLASS: `Diamond`\n> Signature: `class Diamond : public DerivedA, public DerivedB`\n> Lines: 225-228\n- @brief Diamond inheritance: inherits from both DerivedA and DerivedB.\n```\nclass Diamond : public DerivedA, public DerivedB {\npublic:\nconst char *type_name() const override { return \"Diamond\"; }\n};\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"Diamond\"; }`\n> Lines: 227-227\n```\nconst char *type_name() const override { return \"Diamond\"; }\n```\n\n### FUNCTION: `f`\n> Signature: `if (pos == std::string::npos)`\n> Lines: 251-254\n- @brief Parse a key=value string into its components.\n- @param input String in \"key=value\" format.\n- @return Pair of key and value; empty strings if malformed.\n```\nif (pos == std::string::npos) {\nreturn {\"\", \"\"};\n}\n```\n\n### FUNCTION: `greet`\n> Signature: `void greet(std::string name) { std::cout << \"Hello, \" << name << \"\\n\"; }`\n> Lines: 264-264\n- @brief Greet a person by name on stdout.\n- @param name The person's name to display.\n```\nvoid greet(std::string name) { std::cout << \"Hello, \" << name << \"\\n\"; }\n```\n\n### FUNCTION: `main`\n> Signature: `int main()`\n> Lines: 270-275\n- @brief Program entry point.\n- @return 0 on success.\n```\nint main() {\nauto [key, val] = parse_kv(\"lang=cpp\");\ngreet(key);\nreturn 0;\n}\n```\n\n### FUNCTION: `t`\n> Signature: `greet(key)`\n> Lines: 273-284\n```\ngreet(key);\nreturn 0;\n}\nconstexpr auto square = [](auto x) { return x * x; };\n```\n\n### FUNCTION: `format_int`\n> Signature: `inline std::string format_int(int v) { return std::to_string(v); }`\n> Lines: 295-295\n- @brief Internal helper formatting integers to strings.\n- @param v The integer to format.\n- @return Formatted string representation.\n```\ninline std::string format_int(int v) { return std::to_string(v); }\n```\n\n### FUNCTION: `std::to_string`\n> Signature: `return std::to_string(value)`\n> Lines: 310-318\n- @brief SFINAE-enabled serialize function for Numeric types.\n@tparam T Numeric type.\n- @brief Overload for string serialization (identity transform).\n- @param value The numeric value to serialize.\n- @param value The string to serialize.\n- @return String representation of the value.\n- @return The input string unchanged.\n```\nreturn std::to_string(value);\n}\ninline std::string serialize(const std::string &value) { return value; }\n```\n\n### FUNCTION: `serialize`\n> Signature: `inline std::string serialize(const std::string &value) { return value; }`\n> Lines: 318-318\n- @brief Overload for string serialization (identity transform).\n- @param value The string to serialize.\n- @return The input string unchanged.\n```\ninline std::string serialize(const std::string &value) { return value; }\n```\n\n### FUNCTION: `add_one`\n> Signature: `inline int add_one(int v) { return v + 1; }`\n> Lines: 344-344\n```\ninline int add_one(int v) { return v + 1; }\n```\n\n### FUNCTION: `ping`\n> Signature: `inline int ping() { return 1; }`\n> Lines: 347-347\n```\ninline int ping() { return 1; }\n```\n\n### FUNCTION: `pong`\n> Signature: `inline int pong() { return 2; }`\n> Lines: 350-350\n```\ninline int pong() { return 2; }\n```\n\n### FUNCTION: `req_cover_cpp_1`\n> Signature: `int req_cover_cpp_1(int value) { return value + 1; }`\n> Lines: 366-366\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nint req_cover_cpp_1(int value) { return value + 1; }\n```\n\n### FUNCTION: `req_cover_cpp_2`\n> Signature: `int req_cover_cpp_2(int value) { return value + 2; }`\n> Lines: 375-375\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nint req_cover_cpp_2(int value) { return value + 2; }\n```\n\n### FUNCTION: `req_cover_cpp_3`\n> Signature: `int req_cover_cpp_3(int value) { return value + 3; }`\n> Lines: 384-384\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nint req_cover_cpp_3(int value) { return value + 3; }\n```\n\n### FUNCTION: `req_cover_cpp_4`\n> Signature: `int req_cover_cpp_4(int value) { return value + 4; }`\n> Lines: 393-393\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nint req_cover_cpp_4(int value) { return value + 4; }\n```\n\n### FUNCTION: `req_cover_cpp_5`\n> Signature: `int req_cover_cpp_5(int value) { return value + 5; }`\n> Lines: 402-402\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nint req_cover_cpp_5(int value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_csharp.cs | csharp\n\n### IMPORT: `System`\n> Lines: 9-9\n```\nusing System;\n```\n\n### IMPORT: `System.Collections.Generic`\n> Lines: 10-10\n```\nusing System.Collections.Generic;\n```\n\n### IMPORT: `System.Linq`\n> Lines: 11-11\n```\nusing System.Linq;\n```\n\n### IMPORT: `System.Threading.Tasks`\n> Lines: 12-12\n```\nusing System.Threading.Tasks;\n```\n\n### IMPORT: `System.Threading`\n> Lines: 13-13\n```\nusing System.Threading;\n```\n\n### DECORATOR: `AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)`\n> Lines: 39-39\n```\n[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]\n```\n\n### CLASS: `AuditableAttribute`\n> Signature: `public class AuditableAttribute : Attribute`\n> Lines: 40-43\n```\npublic class AuditableAttribute : Attribute {\npublic int Level { get; set; } = 1;\n}\n```\n\n### DECORATOR: `Serializable`\n> Lines: 51-51\n```\n[Serializable]\n```\n\n### DECORATOR: `Auditable(Level = 2)`\n> Lines: 52-52\n```\n[Auditable(Level = 2)]\n```\n\n### CLASS: `Person`\n> Signature: `public class Person : IComparable<Person>, IDisposable`\n> Lines: 53-172\n```\npublic class Person : IComparable<Person>, IDisposable {\npublic const int MAX_AGE = 150;\nprivate static int _instanceCount = 0;\nprivate string _name;\npublic string Name {\nget => _name;\nset {\nif (string.IsNullOrWhiteSpace(value))\nthrow new ArgumentException(\"Name cannot be empty\");\n_name = value;\n}\n}\npublic int Age { get; init; }\npublic string? Email { get; set; }\npublic Guid Id { get; } = Guid.NewGuid();\npublic event DataChangedHandler? OnDataChanged;\npublic Person(string name, int age) {\n_name = name;\nAge = age;\nInterlocked.Increment(ref _instanceCount);\n}\npublic void Greet() {\nOnDataChanged?.Invoke(this, $\"Greeted {Name}\");\nConsole.WriteLine($\"Hello, {Name}!\");\n}\npublic static async Task<string> FetchAsync(CancellationToken token = default) {\nawait Task.Delay(100, token);\nreturn \"data\";\n}\npublic int CompareTo(Person? other) {\nif (other is null) return 1;\nreturn Age.CompareTo(other.Age);\n}\npublic void Dispose() {\nInterlocked.Decrement(ref _instanceCount);\nGC.SuppressFinalize(this);\n}\npublic object? this[string propertyName] {\nget {\nreturn propertyName switch {\n\"Name\" => Name,\n\"Age\" => Age,\n\"Email\" => Email,\n_ => null,\n};\n}\n}\npublic void Deconstruct(out string name, out int age) {\nname = Name;\nage = Age;\n}\npublic static int GetInstanceCount() => _instanceCount;\n}\n```\n\n### FUNCTION: `Person`\n> Signature: `public Person(string name, int age)`\n> Lines: 97-101\n- @brief Construct a new Person with name and age.\n- @details Initializes backing fields and updates instance counters.\n- @param name Display name (required).\n- @param age Age in years (must be 0..MAX_AGE).\n- @return Constructed Person instance.\n```\npublic Person(string name, int age) {\n_name = name;\nAge = age;\nInterlocked.Increment(ref _instanceCount);\n}\n```\n\n### FUNCTION: `Greet`\n> Signature: `public void Greet()`\n> Lines: 106-110\n```\npublic void Greet() {\nOnDataChanged?.Invoke(this, $\"Greeted {Name}\");\nConsole.WriteLine($\"Hello, {Name}!\");\n}\n```\n\n### FUNCTION: `FetchAsync`\n> Signature: `public static async Task<string> FetchAsync(CancellationToken token = default)`\n> Lines: 117-120\n- @brief Fetch person data asynchronously with cancellation support.\n- @details Waits asynchronously and returns a deterministic payload.\n- @details Supports cancellation through token propagation.\n- @param token Cancellation token for cooperative cancellation.\n- @return Formatted data string.\n```\npublic static async Task<string> FetchAsync(CancellationToken token = default) {\nawait Task.Delay(100, token);\nreturn \"data\";\n}\n```\n\n### FUNCTION: `CompareTo`\n> Signature: `public int CompareTo(Person? other)`\n> Lines: 127-130\n- @brief Compare persons by age for sorting.\n- @details Implements IComparable ordering semantics.\n- @details Null values are ordered after non-null instances.\n- @param other Person to compare with.\n- @return Comparison result: negative, zero, or positive.\n```\npublic int CompareTo(Person? other) {\nif (other is null) return 1;\nreturn Age.CompareTo(other.Age);\n}\n```\n\n### FUNCTION: `Dispose`\n> Signature: `public void Dispose()`\n> Lines: 135-139\n```\npublic void Dispose() {\nInterlocked.Decrement(ref _instanceCount);\nGC.SuppressFinalize(this);\n}\n```\n\n### FUNCTION: `Deconstruct`\n> Signature: `public void Deconstruct(out string name, out int age)`\n> Lines: 162-165\n```\npublic void Deconstruct(out string name, out int age) {\nname = Name;\nage = Age;\n}\n```\n\n### FUNCTION: `GetInstanceCount`\n> Signature: `public static int GetInstanceCount() => _instanceCount`\n> Lines: 171-179\n```\npublic static int GetInstanceCount() => _instanceCount;\n}\npublic interface IGreeter {\n```\n\n### FUNCTION: `SayHello`\n> Signature: `void SayHello(string name)`\n> Lines: 184-192\n```\nvoid SayHello(string name);\nvoid SayGoodbye(string name) {\nConsole.WriteLine($\"Goodbye, {name}\");\n}\n```\n\n### FUNCTION: `SayGoodbye`\n> Signature: `void SayGoodbye(string name)`\n> Lines: 190-192\n```\nvoid SayGoodbye(string name) {\nConsole.WriteLine($\"Goodbye, {name}\");\n}\n```\n\n### FUNCTION: `FindByIdAsync`\n> Signature: `Task<T?> FindByIdAsync(int id)`\n> Lines: 201-215\n```\nTask<T?> FindByIdAsync(int id);\nIAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\nTask<bool> SaveAsync(T entity);\n}\npublic readonly struct Point {\n```\n\n### FUNCTION: `GetAllAsync`\n> Signature: `IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default)`\n> Lines: 204-215\n```\nIAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\nTask<bool> SaveAsync(T entity);\n}\npublic readonly struct Point {\n```\n\n### FUNCTION: `SaveAsync`\n> Signature: `Task<bool> SaveAsync(T entity)`\n> Lines: 207-215\n```\nTask<bool> SaveAsync(T entity);\n}\npublic readonly struct Point {\n```\n\n### DECORATOR: `Flags`\n> Lines: 237-237\n```\n[Flags]\n```\n\n### FUNCTION: `ConfigEntry`\n> Signature: `public record ConfigEntry(string Key, string Value)`\n> Lines: 258-292\n```\npublic record ConfigEntry(string Key, string Value);\npublic record struct Vector2(double X, double Y);\npublic static class StringExtensions {\npublic static string Truncate(this string str, int maxLength) {\nif (str.Length <= maxLength) return str;\nreturn str[..maxLength] + \"...\";\n}\npublic static bool IsAscii(this string str) {\nreturn str.All(c => c < 128);\n}\n}\n```\n\n### CLASS: `StringExtensions`\n> Signature: `public static class StringExtensions`\n> Lines: 272-292\n```\npublic static class StringExtensions {\npublic static string Truncate(this string str, int maxLength) {\nif (str.Length <= maxLength) return str;\nreturn str[..maxLength] + \"...\";\n}\npublic static bool IsAscii(this string str) {\nreturn str.All(c => c < 128);\n}\n}\n```\n\n### FUNCTION: `Truncate`\n> Signature: `public static string Truncate(this string str, int maxLength)`\n> Lines: 279-282\n```\npublic static string Truncate(this string str, int maxLength) {\nif (str.Length <= maxLength) return str;\nreturn str[..maxLength] + \"...\";\n}\n```\n\n### FUNCTION: `IsAscii`\n> Signature: `public static bool IsAscii(this string str)`\n> Lines: 289-291\n```\npublic static bool IsAscii(this string str) {\nreturn str.All(c => c < 128);\n}\n```\n\n### CLASS: `SortedCollection`\n> Signature: `public class SortedCollection<T> where T : IComparable<T>`\n> Lines: 300-322\n```\npublic class SortedCollection<T> where T : IComparable<T> {\nprivate readonly List<T> _items = new();\npublic void Add(T item) {\nvar index = _items.BinarySearch(item);\nif (index < 0) index = ~index;\n_items.Insert(index, item);\n}\npublic IEnumerable<T> Where(Func<T, bool> predicate) {\nreturn _items.Where(predicate);\n}\n}\n```\n\n### FUNCTION: `Add`\n> Signature: `public void Add(T item)`\n> Lines: 307-312\n```\npublic void Add(T item) {\nvar index = _items.BinarySearch(item);\nif (index < 0) index = ~index;\n_items.Insert(index, item);\n}\n```\n\n### FUNCTION: `Where`\n> Signature: `public IEnumerable<T> Where(Func<T, bool> predicate)`\n> Lines: 319-321\n```\npublic IEnumerable<T> Where(Func<T, bool> predicate) {\nreturn _items.Where(predicate);\n}\n```\n\n### CLASS: `PatternMatcher`\n> Signature: `public static class PatternMatcher`\n> Lines: 329-347\n```\npublic static class PatternMatcher {\npublic static string Describe(object? obj) {\nreturn obj switch {\nnull => \"null\",\nint i when i > 0 => $\"positive int: {i}\",\nint i => $\"non-positive int: {i}\",\nstring { Length: 0 } => \"empty string\",\nstring s => $\"string({s.Length}): {s}\",\nPerson { Age: >= 18 } p => $\"adult: {p.Name}\",\nPerson p => $\"minor: {p.Name}\",\n_ => $\"unknown: {obj.GetType().Name}\",\n};\n}\n}\n```\n\n### FUNCTION: `Describe`\n> Signature: `public static string Describe(object? obj)`\n> Lines: 335-346\n```\npublic static string Describe(object? obj) {\nreturn obj switch {\nnull => \"null\",\nint i when i > 0 => $\"positive int: {i}\",\nint i => $\"non-positive int: {i}\",\nstring { Length: 0 } => \"empty string\",\nstring s => $\"string({s.Length}): {s}\",\nPerson { Age: >= 18 } p => $\"adult: {p.Name}\",\nPerson p => $\"minor: {p.Name}\",\n_ => $\"unknown: {obj.GetType().Name}\",\n};\n}\n```\n\n### DECORATOR: `DebuggerDisplay(\"{Value}\")`\n> Lines: 367-367\n```\n[DebuggerDisplay(\"{Value}\")]\n```\n\n### CLASS: `ReqCoverCsharp`\n> Signature: `public static class ReqCoverCsharp`\n> Lines: 374-410\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n```\npublic static class ReqCoverCsharp {\npublic static int ReqCoverCsharp1(int value) { return value + 1; }\npublic static int ReqCoverCsharp2(int value) { return value + 2; }\npublic static int ReqCoverCsharp3(int value) { return value + 3; }\npublic static int ReqCoverCsharp4(int value) { return value + 4; }\npublic static int ReqCoverCsharp5(int value) { return value + 5; }\n}\n```\n\n### FUNCTION: `ReqCoverCsharp1`\n> Signature: `public static int ReqCoverCsharp1(int value) { return value + 1; }`\n> Lines: 380-380\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\npublic static int ReqCoverCsharp1(int value) { return value + 1; }\n```\n\n### FUNCTION: `ReqCoverCsharp2`\n> Signature: `public static int ReqCoverCsharp2(int value) { return value + 2; }`\n> Lines: 387-387\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\npublic static int ReqCoverCsharp2(int value) { return value + 2; }\n```\n\n### FUNCTION: `ReqCoverCsharp3`\n> Signature: `public static int ReqCoverCsharp3(int value) { return value + 3; }`\n> Lines: 394-394\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\npublic static int ReqCoverCsharp3(int value) { return value + 3; }\n```\n\n### FUNCTION: `ReqCoverCsharp4`\n> Signature: `public static int ReqCoverCsharp4(int value) { return value + 4; }`\n> Lines: 401-401\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\npublic static int ReqCoverCsharp4(int value) { return value + 4; }\n```\n\n### FUNCTION: `ReqCoverCsharp5`\n> Signature: `public static int ReqCoverCsharp5(int value) { return value + 5; }`\n> Lines: 408-408\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\npublic static int ReqCoverCsharp5(int value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_elixir.ex | elixir\n\n### IMPORT: `GenServer`\n> Lines: 18-18\n```\n  use GenServer\n```\n\n### IMPORT: `Enum`\n> Lines: 19-19\n```\n  import Enum\n```\n\n### IMPORT: `MyApp.Config`\n> Lines: 20-20\n```\n  alias MyApp.Config\n```\n\n### IMPORT: `MyApp.Server.State`\n> Lines: 21-21\n```\n  alias MyApp.Server.State\n```\n\n### IMPORT: `Logger`\n> Lines: 22-22\n```\n  require Logger\n```\n\n### FUNCTION: `start_link`\n> Signature: `def start_link(opts) do`\n> Lines: 66-69\n```\n  def start_link(opts) do\n    name = Keyword.get(opts, :name, \"default\")\n    GenServer.start_link(__MODULE__, opts, name: via_tuple(name))\n  end\n```\n\n### FUNCTION: `add_item`\n> Signature: `def add_item(server, item) do`\n> Lines: 79-81\n```\n  def add_item(server, item) do\n    GenServer.call(server, {:add_item, item})\n  end\n```\n\n### FUNCTION: `get_items`\n> Signature: `def get_items(server) do`\n> Lines: 90-92\n```\n  def get_items(server) do\n    GenServer.call(server, :get_items)\n  end\n```\n\n### FUNCTION: `notify`\n> Signature: `def notify(server, event) do`\n> Lines: 102-104\n```\n  def notify(server, event) do\n    GenServer.cast(server, {:notify, event})\n  end\n```\n\n### FUNCTION: `via_tuple`\n> Signature: `defp via_tuple(name) do`\n> Lines: 111-113\n- @brief Generate a via-tuple for process registration.\n- @param name The server name.\n- @return Via-tuple for Registry lookup.\n```\n  defp via_tuple(name) do\n    {:via, Registry, {MyApp.Registry, name}}\n  end\n```\n\n### FUNCTION: `init`\n> Signature: `def init(opts) do`\n> Lines: 118-131\n```\n  def init(opts) do\n    name = Keyword.fetch!(opts, :name)\n    port = Keyword.get(opts, :port, 4000)\n    state = %__MODULE__{\n      name: name,\n      port: port,\n      started_at: DateTime.utc_now()\n    }\n    Logger.info(\"Server #{name} started on port #{port}\")\n    {:ok, state}\n  end\n```\n\n### FUNCTION: `handle_call`\n> Signature: `def handle_call({:add_item, item}, _from, state) do`\n> Lines: 134-142\n```\n  def handle_call({:add_item, item}, _from, state) do\n    if length(state.items) >= @max_items do\n      {:reply, {:error, :capacity_exceeded}, state}\n    else\n      new_state = %{state | items: [item | state.items]}\n      {:reply, :ok, new_state}\n    end\n  end\n```\n\n### FUNCTION: `handle_call`\n> Signature: `def handle_call(:get_items, _from, state) do`\n> Lines: 145-147\n```\n  def handle_call(:get_items, _from, state) do\n    {:reply, Enum.reverse(state.items), state}\n  end\n```\n\n### FUNCTION: `handle_cast`\n> Signature: `def handle_cast({:notify, event}, state) do`\n> Lines: 150-153\n```\n  def handle_cast({:notify, event}, state) do\n    Logger.debug(\"Received event: #{inspect(event)}\")\n    {:noreply, state}\n  end\n```\n\n### FUNCTION: `handle_info`\n> Signature: `def handle_info(:timeout, state) do`\n> Lines: 156-159\n```\n  def handle_info(:timeout, state) do\n    Logger.warn(\"Server #{state.name} timed out\")\n    {:noreply, state}\n  end\n```\n\n### FUNCTION: `handle_internal`\n> Signature: `defp handle_internal(state) do`\n> Lines: 164-168\n- @brief Handle internal state cleanup and maintenance.\n- @param state Current server state.\n- @return Updated state with pruned items.\n```\n  defp handle_internal(state) do\n    pruned = Enum.take(state.items, @max_items)\n    %{state | items: pruned}\n  end\n```\n\n### FUNCTION: `my_macro`\n> Signature: `defmacro my_macro(expr) do`\n> Lines: 176-182\n```\n  defmacro my_macro(expr) do\n    quote do\n      result = unquote(expr)\n      Logger.debug(\"Macro result: #{inspect(result)}\")\n      result\n    end\n  end\n```\n\n### FUNCTION: `print`\n> Signature: `def print(data)`\n> Lines: 199-200\n```\n  def print(data)\nend\n```\n\n### FUNCTION: `print`\n> Signature: `def print(server) do`\n> Lines: 211-213\n```\n  def print(server) do\n    \"Server(#{server.name}:#{server.port})\"\n  end\n```\n\n### FUNCTION: `print`\n> Signature: `def print(str) do`\n> Lines: 217-219\n```\n  def print(str) do\n    \"String(#{str})\"\n  end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_integer(value) and value > 0, do: :positive`\n> Lines: 237-258\n```\n  def classify(value) when is_integer(value) and value > 0, do: :positive\n  def classify(value) when is_integer(value) and value < 0, do: :negative\n  def classify(0), do: :zero\n  def classify(value) when is_binary(value), do: :string\n  def classify(value) when is_list(value), do: :list\n  def classify(_), do: :unknown\n  @doc \"\"\"\n  Process a list using pipe operator for data transformation.\n  @param items List of strings to process.\n  @return Sorted list of unique uppercase strings.\n  \"\"\"\n  @spec process_list(list(String.t())) :: list(String.t())\n  def process_list(items) do\n    items\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.upcase/1)\n    |> Enum.uniq()\n    |> Enum.sort()\n  end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_integer(value) and value < 0, do: :negative`\n> Lines: 238-258\n```\n  def classify(value) when is_integer(value) and value < 0, do: :negative\n  def classify(0), do: :zero\n  def classify(value) when is_binary(value), do: :string\n  def classify(value) when is_list(value), do: :list\n  def classify(_), do: :unknown\n  @doc \"\"\"\n  Process a list using pipe operator for data transformation.\n  @param items List of strings to process.\n  @return Sorted list of unique uppercase strings.\n  \"\"\"\n  @spec process_list(list(String.t())) :: list(String.t())\n  def process_list(items) do\n    items\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.upcase/1)\n    |> Enum.uniq()\n    |> Enum.sort()\n  end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(0), do: :zero`\n> Lines: 239-258\n```\n  def classify(0), do: :zero\n  def classify(value) when is_binary(value), do: :string\n  def classify(value) when is_list(value), do: :list\n  def classify(_), do: :unknown\n  @doc \"\"\"\n  Process a list using pipe operator for data transformation.\n  @param items List of strings to process.\n  @return Sorted list of unique uppercase strings.\n  \"\"\"\n  @spec process_list(list(String.t())) :: list(String.t())\n  def process_list(items) do\n    items\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.upcase/1)\n    |> Enum.uniq()\n    |> Enum.sort()\n  end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_binary(value), do: :string`\n> Lines: 240-258\n```\n  def classify(value) when is_binary(value), do: :string\n  def classify(value) when is_list(value), do: :list\n  def classify(_), do: :unknown\n  @doc \"\"\"\n  Process a list using pipe operator for data transformation.\n  @param items List of strings to process.\n  @return Sorted list of unique uppercase strings.\n  \"\"\"\n  @spec process_list(list(String.t())) :: list(String.t())\n  def process_list(items) do\n    items\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.upcase/1)\n    |> Enum.uniq()\n    |> Enum.sort()\n  end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_list(value), do: :list`\n> Lines: 241-258\n```\n  def classify(value) when is_list(value), do: :list\n  def classify(_), do: :unknown\n  @doc \"\"\"\n  Process a list using pipe operator for data transformation.\n  @param items List of strings to process.\n  @return Sorted list of unique uppercase strings.\n  \"\"\"\n  @spec process_list(list(String.t())) :: list(String.t())\n  def process_list(items) do\n    items\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.upcase/1)\n    |> Enum.uniq()\n    |> Enum.sort()\n  end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(_), do: :unknown`\n> Lines: 242-258\n```\n  def classify(_), do: :unknown\n  @doc \"\"\"\n  Process a list using pipe operator for data transformation.\n  @param items List of strings to process.\n  @return Sorted list of unique uppercase strings.\n  \"\"\"\n  @spec process_list(list(String.t())) :: list(String.t())\n  def process_list(items) do\n    items\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.upcase/1)\n    |> Enum.uniq()\n    |> Enum.sort()\n  end\n```\n\n### FUNCTION: `process_list`\n> Signature: `def process_list(items) do`\n> Lines: 251-258\n```\n  def process_list(items) do\n    items\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.upcase/1)\n    |> Enum.uniq()\n    |> Enum.sort()\n  end\n```\n\n### FUNCTION: `pythagorean_triples`\n> Signature: `def pythagorean_triples(range) do`\n> Lines: 267-274\n```\n  def pythagorean_triples(range) do\n    for a <- 1..range,\n        b <- a..range,\n        c <- b..range,\n        a * a + b * b == c * c do\n      {a, b, c}\n    end\n  end\n```\n\n### FUNCTION: `safe_divide`\n> Signature: `def safe_divide(_, 0), do: {:error, :division_by_zero}`\n> Lines: 284-296\n```\n  def safe_divide(_, 0), do: {:error, :division_by_zero}\n  def safe_divide(a, b), do: {:ok, a / b}\n  @doc \"\"\"\n  Recursively compute factorial with guard clause.\n  @param n Non-negative integer.\n  @return Factorial of n.\n  \"\"\"\n  @spec factorial(non_neg_integer()) :: pos_integer()\n  def factorial(0), do: 1\n  def factorial(n) when n > 0, do: n * factorial(n - 1)\nend\n```\n\n### FUNCTION: `safe_divide`\n> Signature: `def safe_divide(a, b), do: {:ok, a / b}`\n> Lines: 285-296\n```\n  def safe_divide(a, b), do: {:ok, a / b}\n  @doc \"\"\"\n  Recursively compute factorial with guard clause.\n  @param n Non-negative integer.\n  @return Factorial of n.\n  \"\"\"\n  @spec factorial(non_neg_integer()) :: pos_integer()\n  def factorial(0), do: 1\n  def factorial(n) when n > 0, do: n * factorial(n - 1)\nend\n```\n\n### FUNCTION: `factorial`\n> Signature: `def factorial(0), do: 1`\n> Lines: 294-296\n```\n  def factorial(0), do: 1\n  def factorial(n) when n > 0, do: n * factorial(n - 1)\nend\n```\n\n### FUNCTION: `factorial`\n> Signature: `def factorial(n) when n > 0, do: n * factorial(n - 1)`\n> Lines: 295-296\n```\n  def factorial(n) when n > 0, do: n * factorial(n - 1)\nend\n```\n\n### FUNCTION: `audit`\n> Signature: `def audit(data)`\n> Lines: 340-341\n```\n  def audit(data)\nend\n```\n\n### FUNCTION: `render`\n> Signature: `def render(data)`\n> Lines: 344-345\n```\n  def render(data)\nend\n```\n\n### FUNCTION: `parse`\n> Signature: `def parse(data)`\n> Lines: 348-349\n```\n  def parse(data)\nend\n```\n\n### FUNCTION: `validate`\n> Signature: `def validate(data)`\n> Lines: 352-353\n```\n  def validate(data)\nend\n```\n\n### FUNCTION: `audit`\n> Signature: `def audit(data), do: data`\n> Lines: 356-357\n```\n  def audit(data), do: data\nend\n```\n\n### FUNCTION: `render`\n> Signature: `def render(data), do: data`\n> Lines: 360-361\n```\n  def render(data), do: data\nend\n```\n\n### FUNCTION: `parse`\n> Signature: `def parse(data), do: data`\n> Lines: 364-365\n```\n  def parse(data), do: data\nend\n```\n\n### FUNCTION: `validate`\n> Signature: `def validate(data), do: data`\n> Lines: 368-369\n```\n  def validate(data), do: data\nend\n```\n\n### FUNCTION: `req_cover_elixir_1`\n> Signature: `def req_cover_elixir_1(value), do: value + 1`\n> Lines: 378-408\n- @brief Coverage helper construct 1.\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n  def req_cover_elixir_1(value), do: value + 1\n  def req_cover_elixir_2(value), do: value + 2\n  def req_cover_elixir_3(value), do: value + 3\n  def req_cover_elixir_4(value), do: value + 4\n  def req_cover_elixir_5(value), do: value + 5\nend\n```\n\n### FUNCTION: `req_cover_elixir_2`\n> Signature: `def req_cover_elixir_2(value), do: value + 2`\n> Lines: 385-408\n- @brief Coverage helper construct 2.\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n  def req_cover_elixir_2(value), do: value + 2\n  def req_cover_elixir_3(value), do: value + 3\n  def req_cover_elixir_4(value), do: value + 4\n  def req_cover_elixir_5(value), do: value + 5\nend\n```\n\n### FUNCTION: `req_cover_elixir_3`\n> Signature: `def req_cover_elixir_3(value), do: value + 3`\n> Lines: 392-408\n- @brief Coverage helper construct 3.\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n  def req_cover_elixir_3(value), do: value + 3\n  def req_cover_elixir_4(value), do: value + 4\n  def req_cover_elixir_5(value), do: value + 5\nend\n```\n\n### FUNCTION: `req_cover_elixir_4`\n> Signature: `def req_cover_elixir_4(value), do: value + 4`\n> Lines: 399-408\n- @brief Coverage helper construct 4.\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n  def req_cover_elixir_4(value), do: value + 4\n  def req_cover_elixir_5(value), do: value + 5\nend\n```\n\n### FUNCTION: `req_cover_elixir_5`\n> Signature: `def req_cover_elixir_5(value), do: value + 5`\n> Lines: 406-408\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n  def req_cover_elixir_5(value), do: value + 5\nend\n```\n\n@@@ <PROJECT_BASE>/src/fixture_go.go | go\n\n### IMPORT: `(`\n> Lines: 14-14\n```\nimport (\n```\n\n### FUNCTION: `main`\n> Signature: `func main()`\n> Lines: 111-113\n```\nfunc main() {\n\tfmt.Println(\"hello\")\n}\n```\n\n### FUNCTION: `init`\n> Signature: `func init()`\n> Lines: 116-119\n```\nfunc init() {\n\tglobalVar = 1\n}\n```\n\n### FUNCTION: `Divide`\n> Signature: `func Divide(a, b int) (int, int, error)`\n> Lines: 180-185\n- @param a Dividend.\n- @param b Divisor; must not be zero.\n- @return Quotient and remainder, or error if b is zero.\n```\nfunc Divide(a, b int) (int, int, error) {\n\tif b == 0 {\n\t\treturn 0, 0, fmt.Errorf(\"division by zero\")\n\t}\n\treturn a / b, a % b, nil\n}\n```\n\n### FUNCTION: `ParseConfig`\n> Signature: `func ParseConfig(input string) (host string, port int, err error)`\n> Lines: 192-200\n- @param input Configuration string in \"host:port\" format.\n- @return Named host and port values, or error.\n```\nfunc ParseConfig(input string) (host string, port int, err error) {\n\t_, scanErr := fmt.Sscanf(input, \"%s:%d\", &host, &port)\n\tif scanErr != nil {\n\t\terr = scanErr\n\t\treturn\n\t}\n\treturn\n}\n```\n\n### FUNCTION: `Counter`\n> Signature: `func Counter() func() int`\n> Lines: 206-213\n- @return Closure yielding successive integer counts.\n```\nfunc Counter() func() int {\n\tcount := 0\n\treturn func() int {\n\t\tcount++\n\t\treturn count\n\t}\n}\n```\n\n### FUNCTION: `FanOut`\n> Signature: `func FanOut(items []string, workers int) <-chan string`\n> Lines: 221-243\n- @param items Slice of strings to process.\n- @param workers Number of concurrent worker goroutines.\n- @return Channel delivering processed results.\n```\nfunc FanOut(items []string, workers int) <-chan string {\n\tresults := make(chan string, len(items))\n\tvar wg sync.WaitGroup\n\tfor i := 0; i < workers; i++ {\n\t\twg.Add(1)\n\t\tgo func(id int) {\n\t\t\tdefer wg.Done()\n\t\t\tfor _, item := range items {\n\t\t\t\tresults <- fmt.Sprintf(\"[%d] %s\", id, item)\n\t\t\t}\n\t\t}(i)\n\t}\n\tgo func() {\n\t\twg.Wait()\n\t\tclose(results)\n\t}()\n\treturn results\n}\n```\n\n### FUNCTION: `Describe`\n> Signature: `func Describe(v interface{}) string`\n> Lines: 250-266\n- @param v Any value to describe.\n- @return Human-readable type description.\n```\nfunc Describe(v interface{}) string {\n\tswitch val := v.(type) {\n\tcase int:\n\t\treturn fmt.Sprintf(\"int: %d\", val)\n\tcase string:\n\t\treturn fmt.Sprintf(\"string: %q\", val)\n\tcase bool:\n\t\tif val {\n\t\t\treturn \"bool: true\"\n\t\t}\n\t\treturn \"bool: false\"\n\tcase nil:\n\t\treturn \"nil\"\n\tdefault:\n\t\treturn fmt.Sprintf(\"unknown: %T\", val)\n\t}\n}\n```\n\n### FUNCTION: `SafeExecute`\n> Signature: `func SafeExecute(fn func()) (err error)`\n> Lines: 273-282\n- @param fn The function to execute safely.\n- @return Error if fn panicked, nil otherwise.\n```\nfunc SafeExecute(fn func()) (err error) {\n\tdefer func() {\n\t\tif r := recover(); r != nil {\n\t\t\terr = fmt.Errorf(\"panic: %v\", r)\n\t\t}\n\t}()\n\tfn()\n\treturn nil\n}\n```\n\n### IMPORT: `\"os\"`\n> Lines: 289-289\n```\nimport \"os\"\n```\n\n### IMPORT: `\"time\"`\n> Lines: 290-290\n```\nimport \"time\"\n```\n\n### IMPORT: `\"strings\"`\n> Lines: 291-291\n```\nimport \"strings\"\n```\n\n### IMPORT: `\"bytes\"`\n> Lines: 292-292\n```\nimport \"bytes\"\n```\n\n### FUNCTION: `reqCoverGo1`\n> Signature: `func reqCoverGo1(value int) int { return value + 1 }`\n> Lines: 311-311\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfunc reqCoverGo1(value int) int { return value + 1 }\n```\n\n### FUNCTION: `reqCoverGo2`\n> Signature: `func reqCoverGo2(value int) int { return value + 2 }`\n> Lines: 318-318\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfunc reqCoverGo2(value int) int { return value + 2 }\n```\n\n### FUNCTION: `reqCoverGo3`\n> Signature: `func reqCoverGo3(value int) int { return value + 3 }`\n> Lines: 325-325\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfunc reqCoverGo3(value int) int { return value + 3 }\n```\n\n### FUNCTION: `reqCoverGo4`\n> Signature: `func reqCoverGo4(value int) int { return value + 4 }`\n> Lines: 332-332\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfunc reqCoverGo4(value int) int { return value + 4 }\n```\n\n### FUNCTION: `reqCoverGo5`\n> Signature: `func reqCoverGo5(value int) int { return value + 5 }`\n> Lines: 339-339\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfunc reqCoverGo5(value int) int { return value + 5 }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_haskell.hs | haskell\n\n### IMPORT: `Data.List (sort, nub, intercalate)`\n> Lines: 22-22\n```\nimport Data.List (sort, nub, intercalate)\n```\n\n### IMPORT: `Data.Maybe (fromMaybe, isJust)`\n> Lines: 23-23\n```\nimport Data.Maybe (fromMaybe, isJust)\n```\n\n### IMPORT: `Data.Map as Map`\n> Lines: 24-24\n```\nimport qualified Data.Map as Map\n```\n\n### IMPORT: `Control.Monad (when, unless, forM_)`\n> Lines: 25-25\n```\nimport Control.Monad (when, unless, forM_)\n```\n\n### CLASS: `Printable`\n> Signature: `class Printable a where`\n> Lines: 72-79\n```\nclass Printable a where\n  printIt :: a -> String\n  debugPrint :: a -> String\n  debugPrint x = \"Debug: \" ++ printIt x\n```\n\n### CLASS: `Serializable`\n> Signature: `class Serializable a where`\n> Lines: 81-84\n```\nclass Serializable a where\n  serialize :: a -> [(String, String)]\n```\n\n### FUNCTION: `greet`\n> Signature: `greet :: String -> String`\n> Lines: 112-112\n```\ngreet :: String -> String\n```\n\n### FUNCTION: `safeDiv`\n> Signature: `safeDiv :: Double -> Double -> Maybe Double`\n> Lines: 117-117\n```\nsafeDiv :: Double -> Double -> Maybe Double\n```\n\n### FUNCTION: `eval`\n> Signature: `eval :: Expr -> Double`\n> Lines: 123-123\n```\neval :: Expr -> Double\n```\n\n### FUNCTION: `processList`\n> Signature: `processList :: [Int] -> [Int]`\n> Lines: 131-131\n```\nprocessList :: [Int] -> [Int]\n```\n\n### FUNCTION: `fibonacci`\n> Signature: `fibonacci :: Int -> Integer`\n> Lines: 143-143\n```\nfibonacci :: Int -> Integer\n```\n\n### FUNCTION: `insertTree`\n> Signature: `insertTree :: (Ord a) => a -> Tree a -> Tree a`\n> Lines: 155-155\n```\ninsertTree :: (Ord a) => a -> Tree a -> Tree a\n```\n\n### FUNCTION: `foldTree`\n> Signature: `foldTree :: (b -> a -> b) -> b -> Tree a -> b`\n> Lines: 164-164\n```\nfoldTree :: (b -> a -> b) -> b -> Tree a -> b\n```\n\n### FUNCTION: `lookupConfig`\n> Signature: `lookupConfig :: Config -> String -> Int -> Int`\n> Lines: 173-173\n```\nlookupConfig :: Config -> String -> Int -> Int\n```\n\n### FUNCTION: `applyN`\n> Signature: `applyN :: Int -> Transform a -> a -> a`\n> Lines: 178-178\n```\napplyN :: Int -> Transform a -> a -> a\n```\n\n### FUNCTION: `formatPersons`\n> Signature: `formatPersons :: (Printable a) => [a] -> String`\n> Lines: 184-184\n```\nformatPersons :: (Printable a) => [a] -> String\n```\n\n### FUNCTION: `safeCompute`\n> Signature: `safeCompute :: Double -> Double -> Double -> Maybe Double`\n> Lines: 189-189\n```\nsafeCompute :: Double -> Double -> Double -> Maybe Double\n```\n\n### IMPORT: `Data.Set as Set`\n> Lines: 201-201\n```\nimport qualified Data.Set as Set\n```\n\n### CLASS: `Renderable`\n> Signature: `class Renderable a where`\n> Lines: 204-204\n```\nclass Renderable a where\n```\n\n### CLASS: `Parsable`\n> Signature: `class Parsable a where`\n> Lines: 205-205\n```\nclass Parsable a where\n```\n\n### CLASS: `Executable`\n> Signature: `class Executable a where`\n> Lines: 206-206\n```\nclass Executable a where\n```\n\n### FUNCTION: `reqCoverHaskell1`\n> Signature: `reqCoverHaskell1 :: Int -> Int`\n> Lines: 215-215\n- @brief Coverage helper construct 1.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n--\n- @param value Input value for helper construct 1.\n--\n- @return Output value for helper construct 1.\n```\nreqCoverHaskell1 :: Int -> Int\n```\n\n### FUNCTION: `reqCoverHaskell2`\n> Signature: `reqCoverHaskell2 :: Int -> Int`\n> Lines: 223-223\n- @brief Coverage helper construct 2.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n--\n- @param value Input value for helper construct 2.\n--\n- @return Output value for helper construct 2.\n```\nreqCoverHaskell2 :: Int -> Int\n```\n\n### FUNCTION: `reqCoverHaskell3`\n> Signature: `reqCoverHaskell3 :: Int -> Int`\n> Lines: 231-231\n- @brief Coverage helper construct 3.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n--\n- @param value Input value for helper construct 3.\n--\n- @return Output value for helper construct 3.\n```\nreqCoverHaskell3 :: Int -> Int\n```\n\n### FUNCTION: `reqCoverHaskell4`\n> Signature: `reqCoverHaskell4 :: Int -> Int`\n> Lines: 239-239\n- @brief Coverage helper construct 4.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n--\n- @param value Input value for helper construct 4.\n--\n- @return Output value for helper construct 4.\n```\nreqCoverHaskell4 :: Int -> Int\n```\n\n### FUNCTION: `reqCoverHaskell5`\n> Signature: `reqCoverHaskell5 :: Int -> Int`\n> Lines: 247-247\n- @brief Coverage helper construct 5.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n--\n- @param value Input value for helper construct 5.\n--\n- @return Output value for helper construct 5.\n```\nreqCoverHaskell5 :: Int -> Int\n```\n\n@@@ <PROJECT_BASE>/src/fixture_java.java | java\n- @brief Comprehensive Java test fixture for parser validation.\n- @details Covers generics with wildcards, sealed classes, records, inner classes,\nanonymous classes, lambdas, method references, switch expressions,\ntry-with-resources, annotations, and default interface methods.\n\n### IMPORT: `java.util.List`\n> Lines: 13-13\n```\nimport java.util.List;\n```\n\n### IMPORT: `java.util.Map`\n> Lines: 14-14\n```\nimport java.util.Map;\n```\n\n### IMPORT: `java.util.Optional`\n> Lines: 15-15\n```\nimport java.util.Optional;\n```\n\n### IMPORT: `java.util.function.Function`\n> Lines: 16-16\n```\nimport java.util.function.Function;\n```\n\n### IMPORT: `java.util.function.Predicate`\n> Lines: 17-17\n```\nimport java.util.function.Predicate;\n```\n\n### IMPORT: `java.util.stream.Collectors`\n> Lines: 18-18\n```\nimport java.util.stream.Collectors;\n```\n\n### IMPORT: `java.lang.Math.PI`\n> Lines: 19-19\n```\nimport static java.lang.Math.PI;\n```\n\n### DECORATOR: `interface`\n> Lines: 27-27\n- @brief Marks a method as requiring authentication before invocation.\n- @param role The minimum role level required for access.\n```\n@interface RequiresAuth {\n```\n\n### FUNCTION: `role`\n> Signature: `String role() default \"user\"`\n> Lines: 28-39\n```\nString role() default \"user\";\n}\n@SuppressWarnings(\"unchecked\")\npublic class MyClass<T extends Comparable<T>> {\n```\n\n### DECORATOR: `SuppressWarnings(\"unchecked\")`\n> Lines: 38-38\n- @brief Primary class demonstrating various Java constructs.\n- @param <T> Generic type parameter for flexible data handling.\n```\n@SuppressWarnings(\"unchecked\")\n```\n\n### CLASS: `MyClass`\n> Signature: `public class MyClass<T extends Comparable<T>>`\n> Lines: 39-165\n- @brief Maximum buffer size constant.\n```\npublic class MyClass<T extends Comparable<T>> {\npublic static final int MAX_SIZE = 100;\nprivate List<T> items;\npublic MyClass(List<T> items) {\nthis.items = items;\n}\npublic void greet(String name) {\nif (name == null) {\nreturn;\n}\nSystem.out.println(\"Hello, \" + name);\n}\nprivate static String helper() {\nreturn \"ok\";\n}\npublic Optional<T> findFirst(Predicate<T> predicate) {\nfor (T item : items) {\nif (predicate.test(item)) {\nreturn Optional.of(item);\n}\n}\nreturn Optional.empty();\n}\npublic <R> List<R> map(Function<T, R> mapper) {\nreturn items.stream()\n.map(mapper)\n.collect(Collectors.toList());\n}\npublic double sumWildcard(List<? extends Number> source) {\ndouble total = 0.0;\nfor (Number n : source) {\ntotal += n.doubleValue();\n}\nreturn total;\n}\npublic class Builder {\nprivate List<T> pending;\npublic Builder add(T item) {\npending.add(item);\nreturn this;\n}\npublic MyClass<T> build() {\nreturn new MyClass<>(pending);\n}\n}\npublic static class Config {\npublic final String key;\npublic final Object value;\npublic Config(String key, Object value) {\nthis.key = key;\nthis.value = value;\n}\n}\n}\n```\n\n### FUNCTION: `MyClass`\n> Signature: `public MyClass(List<T> items)`\n> Lines: 51-53\n- @brief Construct MyClass with an initial item list.\n- @param items The starting collection of items.\n```\npublic MyClass(List<T> items) {\nthis.items = items;\n}\n```\n\n### FUNCTION: `greet`\n> Signature: `public void greet(String name)`\n> Lines: 59-65\n- @brief Greet a person by name on standard output.\n- @param name The person's name; must not be null.\n```\npublic void greet(String name) {\nif (name == null) {\nreturn;\n}\nSystem.out.println(\"Hello, \" + name);\n}\n```\n\n### FUNCTION: `helper`\n> Signature: `private static String helper()`\n> Lines: 71-73\n- @brief Helper method returning a status string.\n- @return Always returns \"ok\".\n```\nprivate static String helper() {\nreturn \"ok\";\n}\n```\n\n### FUNCTION: `findFirst`\n> Signature: `public Optional<T> findFirst(Predicate<T> predicate)`\n> Lines: 80-88\n- @brief Find the first item matching a predicate.\n- @param predicate Filter condition for items.\n- @return Optional containing the first match, or empty.\n```\npublic Optional<T> findFirst(Predicate<T> predicate) {\nfor (T item : items) {\nif (predicate.test(item)) {\nreturn Optional.of(item);\n}\n}\nreturn Optional.empty();\n}\n```\n\n### FUNCTION: `map`\n> Signature: `public <R> List<R> map(Function<T, R> mapper)`\n> Lines: 96-100\n- @brief Transform all items using a mapping function.\n- @param <R> The result type after transformation.\n- @param mapper Function to apply to each item.\n- @return List of transformed results.\n```\npublic <R> List<R> map(Function<T, R> mapper) {\nreturn items.stream()\n.map(mapper)\n.collect(Collectors.toList());\n}\n```\n\n### FUNCTION: `sumWildcard`\n> Signature: `public double sumWildcard(List<? extends Number> source)`\n> Lines: 107-113\n- @brief Process items with a wildcard-bounded list.\n- @param source List of items extending Number.\n- @return Sum of all numeric values as double.\n```\npublic double sumWildcard(List<? extends Number> source) {\ndouble total = 0.0;\nfor (Number n : source) {\ntotal += n.doubleValue();\n}\nreturn total;\n}\n```\n\n### CLASS: `Builder`\n> Signature: `public class Builder`\n> Lines: 121-141\n- @brief Inner builder class for constructing MyClass instances.\n- @brief Add an item to the builder.\n- @param item Item to include in the built instance.\n- @return This builder for chaining.\n```\npublic class Builder {\nprivate List<T> pending;\npublic Builder add(T item) {\npending.add(item);\nreturn this;\n}\npublic MyClass<T> build() {\nreturn new MyClass<>(pending);\n}\n}\n```\n\n### FUNCTION: `add`\n> Signature: `public Builder add(T item)`\n> Lines: 129-132\n- @brief Add an item to the builder.\n- @param item Item to include in the built instance.\n- @return This builder for chaining.\n```\npublic Builder add(T item) {\npending.add(item);\nreturn this;\n}\n```\n\n### FUNCTION: `build`\n> Signature: `public MyClass<T> build()`\n> Lines: 138-140\n- @brief Finalize and create the MyClass instance.\n- @return A new MyClass populated with accumulated items.\n```\npublic MyClass<T> build() {\nreturn new MyClass<>(pending);\n}\n```\n\n### CLASS: `Config`\n> Signature: `public static class Config`\n> Lines: 149-164\n- @brief Static configuration holder with validation.\n- @brief Configuration key string.\n- @brief Configuration value.\n```\npublic static class Config {\npublic final String key;\npublic final Object value;\npublic Config(String key, Object value) {\nthis.key = key;\nthis.value = value;\n}\n}\n```\n\n### FUNCTION: `Config`\n> Signature: `public Config(String key, Object value)`\n> Lines: 160-163\n- @brief Construct a Config entry.\n- @param key The configuration key.\n- @param value The associated value.\n```\npublic Config(String key, Object value) {\nthis.key = key;\nthis.value = value;\n}\n```\n\n### FUNCTION: `sayHello`\n> Signature: `void sayHello(String name)`\n> Lines: 178-186\n- @brief Perform a greeting to the named person.\n- @brief Default farewell method with implementation.\n- @param name Recipient of the greeting.\n- @param name Person to bid farewell.\n```\nvoid sayHello(String name);\ndefault void sayGoodbye(String name) {\nSystem.out.println(\"Goodbye, \" + name);\n}\n```\n\n### FUNCTION: `simple`\n> Signature: `static Greeter simple()`\n> Lines: 192-195\n- @brief Static factory creating a simple Greeter.\n- @return A Greeter that prints to stdout.\n```\nstatic Greeter simple() {\nreturn name -> System.out.println(\"Hi, \" + name);\n}\n```\n\n### FUNCTION: `getHex`\n> Signature: `public String getHex()`\n> Lines: 227-229\n- @brief Get the hex code of this color.\n- @return Hex string including '#' prefix.\n```\npublic String getHex() {\nreturn hex;\n}\n```\n\n### FUNCTION: `Point`\n> Signature: `public record Point(double x, double y)`\n> Lines: 240-261\n- @brief Immutable 2D coordinate record.\n- @brief Compact constructor validating coordinates.\n- @param x Horizontal coordinate.\n- @param y Vertical coordinate.\n- @throws IllegalArgumentException If either coordinate is NaN.\n```\npublic record Point(double x, double y) {\npublic Point {\nif (Double.isNaN(x) || Double.isNaN(y)) {\nthrow new IllegalArgumentException(\"NaN coordinates\");\n}\n}\npublic double distanceTo(Point other) {\ndouble dx = this.x - other.x;\ndouble dy = this.y - other.y;\nreturn Math.sqrt(dx * dx + dy * dy);\n}\n}\n```\n\n### FUNCTION: `distanceTo`\n> Signature: `public double distanceTo(Point other)`\n> Lines: 256-260\n- @brief Compute distance to another point.\n- @param other Target point.\n- @return Euclidean distance.\n```\npublic double distanceTo(Point other) {\ndouble dx = this.x - other.x;\ndouble dy = this.y - other.y;\nreturn Math.sqrt(dx * dx + dy * dy);\n}\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 274-276\n- @brief Compute the area of this shape.\n- @return Area as a double; subclasses provide implementation.\n```\npublic double area() {\nreturn 0.0;\n}\n```\n\n### CLASS: `Circle`\n> Signature: `public final class Circle extends Shape`\n> Lines: 284-304\n- @brief Circle shape with radius-based area computation.\n- @brief Radius of the circle.\n```\npublic final class Circle extends Shape {\nprivate final double radius;\npublic Circle(double radius) {\nthis.radius = radius;\n}\n@Override\npublic double area() {\nreturn PI * radius * radius;\n}\n}\n```\n\n### FUNCTION: `Circle`\n> Signature: `public Circle(double radius)`\n> Lines: 292-294\n- @brief Construct a circle with a given radius.\n- @param radius Non-negative radius value.\n```\npublic Circle(double radius) {\nthis.radius = radius;\n}\n```\n\n### DECORATOR: `Override`\n> Lines: 300-300\n- @brief Compute circle area using π×r².\n- @return The area of the circle.\n```\n@Override\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 301-303\n```\npublic double area() {\nreturn PI * radius * radius;\n}\n```\n\n### CLASS: `Rectangle`\n> Signature: `public final class Rectangle extends Shape`\n> Lines: 311-324\n- @brief Rectangle shape with width and height.\n```\npublic final class Rectangle extends Shape {\nprivate final double width;\nprivate final double height;\npublic Rectangle(double width, double height) {\nthis.width = width;\nthis.height = height;\n}\n@Override\npublic double area() {\nreturn width * height;\n}\n}\n```\n\n### FUNCTION: `Rectangle`\n> Signature: `public Rectangle(double width, double height)`\n> Lines: 315-318\n```\npublic Rectangle(double width, double height) {\nthis.width = width;\nthis.height = height;\n}\n```\n\n### DECORATOR: `Override`\n> Lines: 320-320\n```\n@Override\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 321-323\n```\npublic double area() {\nreturn width * height;\n}\n```\n\n### CLASS: `Evaluator`\n> Signature: `public class Evaluator`\n> Lines: 332-361\n- @brief Demonstrates switch expressions and try-with-resources.\n- @brief Describe a shape using pattern matching switch expression.\n- @param shape The shape to describe.\n- @return Human-readable description string.\n```\npublic class Evaluator {\npublic static String describe(Shape shape) {\nreturn switch (shape) {\ncase Circle c -> \"Circle with radius \" + c.area();\ncase Rectangle r -> \"Rectangle with area \" + r.area();\ndefault -> \"Unknown shape\";\n};\n}\n@RequiresAuth(role = \"admin\")\npublic static String readFile(String path) throws java.io.IOException {\ntry (var reader = new java.io.BufferedReader(new java.io.FileReader(path))) {\nreturn reader.lines().collect(Collectors.joining(\"\\n\"));\n}\n}\n}\n```\n\n### FUNCTION: `describe`\n> Signature: `public static String describe(Shape shape)`\n> Lines: 339-346\n- @brief Describe a shape using pattern matching switch expression.\n- @param shape The shape to describe.\n- @return Human-readable description string.\n```\npublic static String describe(Shape shape) {\nreturn switch (shape) {\ncase Circle c -> \"Circle with radius \" + c.area();\ncase Rectangle r -> \"Rectangle with area \" + r.area();\ndefault -> \"Unknown shape\";\n};\n}\n```\n\n### FUNCTION: `switch`\n> Signature: `return switch (shape)`\n> Lines: 341-345\n```\nreturn switch (shape) {\ncase Circle c -> \"Circle with radius \" + c.area();\ncase Rectangle r -> \"Rectangle with area \" + r.area();\ndefault -> \"Unknown shape\";\n};\n```\n\n### DECORATOR: `RequiresAuth(role = \"admin\")`\n> Lines: 354-354\n- @brief Read a file safely with try-with-resources.\n- @param path File system path to read.\n- @return File contents as a string.\n- @throws java.io.IOException If the file cannot be read.\n```\n@RequiresAuth(role = \"admin\")\n```\n\n### FUNCTION: `readFile`\n> Signature: `public static String readFile(String path) throws java.io.IOException`\n> Lines: 355-360\n```\npublic static String readFile(String path) throws java.io.IOException {\ntry (var reader = new java.io.BufferedReader(new java.io.FileReader(path))) {\nreturn reader.lines().collect(Collectors.joining(\"\\n\"));\n}\n}\n```\n\n### DECORATOR: `Trace`\n> Lines: 380-380\n```\n@Trace\n```\n\n### CLASS: `ReqCoverJava`\n> Signature: `class ReqCoverJava`\n> Lines: 383-429\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nclass ReqCoverJava {\nstatic int reqCoverJava1(int value) { return value + 1; }\nstatic int reqCoverJava2(int value) { return value + 2; }\nstatic int reqCoverJava3(int value) { return value + 3; }\nstatic int reqCoverJava4(int value) { return value + 4; }\nstatic int reqCoverJava5(int value) { return value + 5; }\n}\n```\n\n### FUNCTION: `reqCoverJava1`\n> Signature: `static int reqCoverJava1(int value) { return value + 1; }`\n> Lines: 391-391\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nstatic int reqCoverJava1(int value) { return value + 1; }\n```\n\n### FUNCTION: `reqCoverJava2`\n> Signature: `static int reqCoverJava2(int value) { return value + 2; }`\n> Lines: 400-400\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nstatic int reqCoverJava2(int value) { return value + 2; }\n```\n\n### FUNCTION: `reqCoverJava3`\n> Signature: `static int reqCoverJava3(int value) { return value + 3; }`\n> Lines: 409-409\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nstatic int reqCoverJava3(int value) { return value + 3; }\n```\n\n### FUNCTION: `reqCoverJava4`\n> Signature: `static int reqCoverJava4(int value) { return value + 4; }`\n> Lines: 418-418\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nstatic int reqCoverJava4(int value) { return value + 4; }\n```\n\n### FUNCTION: `reqCoverJava5`\n> Signature: `static int reqCoverJava5(int value) { return value + 5; }`\n> Lines: 427-427\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nstatic int reqCoverJava5(int value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_javascript.js | javascript\n- @brief Comprehensive JavaScript test fixture for parser validation.\n- @details Covers classes with private fields, generators, async generators,\nproxies, symbols, IIFE, dynamic imports, destructuring, computed\nproperties, and chained promise patterns.\n\n### IMPORT: `React from 'react';`\n> Lines: 11-11\n```\nimport React from 'react';\n```\n\n### IMPORT: `{ useState, useEffect } from 'react';`\n> Lines: 12-12\n```\nimport { useState, useEffect } from 'react';\n```\n\n### CLASS: `MyComponent`\n> Signature: `class MyComponent`\n> Lines: 20-66\n- @brief React-like component with private fields and static initialization.\n- @brief Private instance counter, not accessible outside the class.\n```\nclass MyComponent {\n#instanceId;\nstatic #registry = new Map();\nstatic {\nconsole.log('MyComponent class loaded');\n}\nconstructor(id = 0) {\nthis.#instanceId = id;\nMyComponent.#registry.set(id, this);\n}\nrender() {\nreturn null;\n}\ngetId() {\nreturn this.#instanceId;\n}\nstatic has(id) {\nreturn MyComponent.#registry.has(id);\n}\n}\n```\n\n### CLASS: `EnhancedComponent`\n> Signature: `class EnhancedComponent extends MyComponent`\n> Lines: 75-93\n- @brief Extended component with lifecycle hooks.\n- @brief Override render to return a div element.\n- @return {Object} A simple virtual DOM node.\n```\nclass EnhancedComponent extends MyComponent {\nrender() {\nsuper.render();\nreturn { type: 'div', children: [] };\n}\ncomponentDidMount() {\nconsole.log('mounted');\n}\n}\n```\n\n### FUNCTION: `greet`\n> Signature: `function greet(name)`\n> Lines: 103-105\n- @brief Greet a person by name.\n- @param {string} name The person's name.\n- @return {string} Greeting message.\n```\nfunction greet(name) {\nreturn \"Hello \" + name;\n}\n```\n\n### FUNCTION: `fetchData`\n> Signature: `async function fetchData()`\n> Lines: 112-115\n- @brief Fetch data from the API endpoint asynchronously.\n- @return {Promise<Response>} The fetch response promise.\n```\nasync function fetchData() {\nreturn await fetch('/api');\n}\n```\n\n### FUNCTION: `handler`\n> Signature: `const handler = (event) =>`\n> Lines: 122-126\n- @brief Event handler arrow function for UI events.\n- @param {Event} event The DOM event object.\n```\nconst handler = (event) => {\nevent.preventDefault();\nconsole.log(event.type);\n};\n```\n\n### FUNCTION: `processItems`\n> Signature: `const processItems = ({ items, count }) =>`\n> Lines: 134-136\n- @brief Arrow function with destructuring parameter.\n- @param {{ items: Array, count: number }} param0 Destructured config.\n- @return {Array} Processed item list.\n```\nconst processItems = ({ items, count }) => {\nreturn items.slice(0, count).map(i => i.toUpperCase());\n};\n```\n\n### FUNCTION: `idGenerator`\n> Signature: `function* idGenerator()`\n> Lines: 164-170\n- @brief Infinite generator producing sequential integer IDs.\n@yields {number} The next unique ID.\n```\nfunction* idGenerator() {\nlet id = 0;\nwhile (true) {\nyield id++;\n}\n}\n```\n\n### FUNCTION: `rangeGenerator`\n> Signature: `function* rangeGenerator(start, end)`\n> Lines: 179-183\n- @brief Generator yielding integers in a bounded range.\n- @param {number} start Inclusive lower bound.\n- @param {number} end Exclusive upper bound.\n@yields {number} Each integer from start to end-1.\n```\nfunction* rangeGenerator(start, end) {\nfor (let i = start; i < end; i++) {\nyield i;\n}\n}\n```\n\n### FUNCTION: `asyncDataStream`\n> Signature: `async function* asyncDataStream(url)`\n> Lines: 194-206\n- @brief Asynchronously yield paginated API results.\n- @param {string} url Base URL for pagination.\n@yields {Object} Each page's parsed JSON data.\n```\nasync function* asyncDataStream(url) {\nlet page = 0;\nwhile (true) {\nconst response = await fetch(`${url}?page=${page}`);\nconst data = await response.json();\nif (data.length === 0) {\nreturn;\n}\nyield data;\npage++;\n}\n}\n```\n\n### FUNCTION: `initResult`\n> Signature: `const initResult = (() =>`\n> Lines: 213-217\n- @brief Immediately invoked function expression for module initialization.\n```\nconst initResult = (() => {\nconst config = { debug: false };\nreturn Object.freeze(config);\n})();\n```\n\n### FUNCTION: `createProxy`\n> Signature: `function createProxy(target)`\n> Lines: 227-240\n- @brief Create a logging proxy around any target object.\n- @param {Object} target The object to wrap with proxy traps.\n- @return {Proxy} Proxied object that logs property access.\n```\nfunction createProxy(target) {\nreturn new Proxy(target, {\nget(obj, prop) {\nconsole.log(`Access: ${String(prop)}`);\nreturn Reflect.get(obj, prop);\n},\nset(obj, prop, value) {\nconsole.log(`Set: ${String(prop)} = ${value}`);\nreturn Reflect.set(obj, prop, value);\n},\n});\n}\n```\n\n### FUNCTION: `buildDynamic`\n> Signature: `function buildDynamic(prefix)`\n> Lines: 250-258\n- @brief Build an object with computed property keys.\n- @param {string} prefix Key prefix for dynamic properties.\n- @return {Object} Object with dynamically named properties.\n```\nfunction buildDynamic(prefix) {\nreturn {\n[`${prefix}_name`]: 'value',\n[`${prefix}_id`]: 42,\n[Symbol.toPrimitive](hint) {\nreturn hint === 'string' ? prefix : 0;\n},\n};\n}\n```\n\n### FUNCTION: `fetchAndProcess`\n> Signature: `function fetchAndProcess(url)`\n> Lines: 268-280\n- @brief Demonstrate chained promise pattern with error recovery.\n- @param {string} url The resource URL to fetch.\n- @return {Promise<Object>} Processed data or fallback on error.\n```\nfunction fetchAndProcess(url) {\nreturn fetch(url)\n.then(res => res.json())\n.then(data => {\nreturn { ...data, processed: true };\n})\n.catch(err => {\nconsole.error(err);\nreturn { error: true, processed: false };\n});\n}\n```\n\n### FUNCTION: `configureApp`\n> Signature: `function configureApp({ host = 'localhost', port = 3000, db: { url: dbUrl = 'sqlite://' } = {} } = {})`\n> Lines: 290-292\n- @brief Configure application with deep destructuring defaults.\n- @param {Object} options Configuration object with nested defaults.\n- @return {Object} Resolved configuration.\n```\nfunction configureApp({ host = 'localhost', port = 3000, db: { url: dbUrl = 'sqlite://' } = {} } = {}) {\nreturn { host, port, dbUrl };\n}\n```\n\n### FUNCTION: `setPrivate`\n> Signature: `function setPrivate(obj, data)`\n> Lines: 310-312\n- @brief Store private data associated with an object.\n- @param {Object} obj The key object.\n- @param {*} data The private data to associate.\n```\nfunction setPrivate(obj, data) {\n_privateState.set(obj, data);\n}\n```\n\n### FUNCTION: `loadPlugin`\n> Signature: `async function loadPlugin(name)`\n> Lines: 322-326\n- @brief Dynamically import a module at runtime.\n- @param {string} name Module specifier to import.\n- @return {Promise<Module>} The loaded module namespace.\n```\nasync function loadPlugin(name) {\nconst mod = await import(`./${name}.js`);\nreturn mod;\n}\n```\n\n### IMPORT: `fs from 'fs';`\n> Lines: 329-329\n```\nimport fs from 'fs';\n```\n\n### IMPORT: `path from 'path';`\n> Lines: 330-330\n```\nimport path from 'path';\n```\n\n### IMPORT: `url from 'url';`\n> Lines: 331-331\n```\nimport url from 'url';\n```\n\n### CLASS: `ExtraService`\n> Signature: `export class ExtraService { constructor() { this.ready = true; } }`\n> Lines: 332-332\n```\nexport class ExtraService { constructor() { this.ready = true; } }\n```\n\n### CLASS: `HelperComponent`\n> Signature: `class HelperComponent { render() { return null; } }`\n> Lines: 333-333\n```\nclass HelperComponent { render() { return null; } }\n```\n\n### CLASS: `WidgetFactory`\n> Signature: `export default class WidgetFactory { create() { return {}; } }`\n> Lines: 334-334\n```\nexport default class WidgetFactory { create() { return {}; } }\n```\n\n### FUNCTION: `reqCoverJs1`\n> Signature: `function reqCoverJs1(value) { return value + 1; }`\n> Lines: 353-353\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfunction reqCoverJs1(value) { return value + 1; }\n```\n\n### FUNCTION: `reqCoverJs2`\n> Signature: `function reqCoverJs2(value) { return value + 2; }`\n> Lines: 360-360\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfunction reqCoverJs2(value) { return value + 2; }\n```\n\n### FUNCTION: `reqCoverJs3`\n> Signature: `function reqCoverJs3(value) { return value + 3; }`\n> Lines: 367-367\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfunction reqCoverJs3(value) { return value + 3; }\n```\n\n### FUNCTION: `reqCoverJs4`\n> Signature: `function reqCoverJs4(value) { return value + 4; }`\n> Lines: 374-374\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfunction reqCoverJs4(value) { return value + 4; }\n```\n\n### FUNCTION: `reqCoverJs5`\n> Signature: `function reqCoverJs5(value) { return value + 5; }`\n> Lines: 381-381\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfunction reqCoverJs5(value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_kotlin.kt | kotlin\n- @brief Comprehensive Kotlin test fixture for parser validation.\n- @details Covers extension functions, inline/reified generics, DSL builders,\ndelegation, coroutine scope, destructuring, sealed interfaces,\nvalue classes, operator overloading, and lateinit.\n\n### IMPORT: `kotlin.collections.List`\n> Lines: 11-11\n```\nimport kotlin.collections.List\n```\n\n### IMPORT: `kotlinx.coroutines.flow.Flow`\n> Lines: 12-12\n```\nimport kotlinx.coroutines.flow.Flow\n```\n\n### IMPORT: `kotlinx.coroutines.flow.flow`\n> Lines: 13-13\n```\nimport kotlinx.coroutines.flow.flow\n```\n\n### DECORATOR: `Deprecated`\n> Lines: 18-18\n- @brief Marks a class or function as deprecated with migration path. */\n```\n@Deprecated(\"Use UserV2 instead\", replaceWith = ReplaceWith(\"UserV2\"))\n```\n\n### CLASS: `User`\n> Signature: `data class User(val name: String, val age: Int = 0)`\n> Lines: 19-61\n```\ndata class User(val name: String, val age: Int = 0)\nsealed class Result<out T> {\ndata class Success<T>(val value: T) : Result<T>()\ndata class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\nobject Loading : Result<Nothing>()\nfun <R> map(transform: (T) -> R): Result<R> = when (this) {\nis Success -> Success(transform(value))\nis Error -> Error(message, cause)\nis Loading -> Loading\n}\n}\n```\n\n### CLASS: `Result`\n> Signature: `sealed class Result<out T>`\n> Lines: 28-61\n- @brief Sealed class representing success/failure outcomes.\n@tparam T The success value type.\n- @brief Successful outcome holding a value.\n- @param value The result data.\n```\nsealed class Result<out T> {\ndata class Success<T>(val value: T) : Result<T>()\ndata class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\nobject Loading : Result<Nothing>()\nfun <R> map(transform: (T) -> R): Result<R> = when (this) {\nis Success -> Success(transform(value))\nis Error -> Error(message, cause)\nis Loading -> Loading\n}\n}\n```\n\n### CLASS: `Success`\n> Signature: `data class Success<T>(val value: T) : Result<T>()`\n> Lines: 34-60\n- @brief Successful outcome holding a value.\n- @brief Failed outcome holding an error message.\n- @param value The result data.\n- @param message Description of the failure.\n- @param cause Optional underlying exception.\n```\ndata class Success<T>(val value: T) : Result<T>()\ndata class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\nobject Loading : Result<Nothing>()\nfun <R> map(transform: (T) -> R): Result<R> = when (this) {\nis Success -> Success(transform(value))\nis Error -> Error(message, cause)\nis Loading -> Loading\n}\n```\n\n### CLASS: `Error`\n> Signature: `data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()`\n> Lines: 42-60\n- @brief Failed outcome holding an error message.\n- @brief Singleton state representing an in-progress operation.\n- @param message Description of the failure.\n- @param cause Optional underlying exception.\n```\ndata class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\nobject Loading : Result<Nothing>()\nfun <R> map(transform: (T) -> R): Result<R> = when (this) {\nis Success -> Success(transform(value))\nis Error -> Error(message, cause)\nis Loading -> Loading\n}\n```\n\n### FUNCTION: `map`\n> Signature: `fun <R> map(transform: (T) -> R): Result<R> = when (this)`\n> Lines: 56-60\n- @brief Map the success value using a transform function.\n@tparam R The target type after transformation.\n- @param transform Function converting T to R.\n- @return Transformed Result or original error/loading state.\n```\nfun <R> map(transform: (T) -> R): Result<R> = when (this) {\nis Success -> Success(transform(value))\nis Error -> Error(message, cause)\nis Loading -> Loading\n}\n```\n\n### FUNCTION: `findById`\n> Signature: `fun findById(id: Int): T?`\n> Lines: 76-96\n- @brief Find an entity by its unique identifier.\n- @brief Persist an entity.\n- @param id Entity ID.\n- @param entity The entity to save.\n- @return The entity or null if not found.\n- @return True if save succeeded.\n```\nfun findById(id: Int): T?\nfun save(entity: T): Boolean\nfun findAll(): Flow<T>\n}\nsealed interface Identifiable {\n```\n\n### FUNCTION: `save`\n> Signature: `fun save(entity: T): Boolean`\n> Lines: 83-96\n- @brief Persist an entity.\n- @brief Retrieve all entities as a Flow stream.\n- @param entity The entity to save.\n- @return True if save succeeded.\n- @return Flow emitting all stored entities.\n```\nfun save(entity: T): Boolean\nfun findAll(): Flow<T>\n}\nsealed interface Identifiable {\n```\n\n### FUNCTION: `findAll`\n> Signature: `fun findAll(): Flow<T>`\n> Lines: 89-96\n- @brief Retrieve all entities as a Flow stream.\n- @brief Sealed interface requiring an ID property.\n- @return Flow emitting all stored entities.\n```\nfun findAll(): Flow<T>\n}\nsealed interface Identifiable {\n```\n\n### FUNCTION: `fromHex`\n> Signature: `fun fromHex(hex: String): Color? = values().find { it.hex == hex }`\n> Lines: 121-121\n- @brief Parse a color from its hex string.\n- @param hex Hex color code including '#' prefix.\n- @return Matching Color or null.\n```\nfun fromHex(hex: String): Color? = values().find { it.hex == hex }\n```\n\n### CLASS: `Entity`\n> Signature: `data class Entity(`\n> Lines: 134-155\n- @brief Data class combining Identifiable with named properties.\n- @param id Unique identifier.\n- @param name Entity display name.\n- @param status Current lifecycle status.\n```\ndata class Entity(\noverride val id: Int,\nval name: String,\nval status: String = \"active\",\n) : Identifiable\n@JvmInline\nvalue class EmailAddress(val value: String) {\ninit {\nrequire(value.contains('@')) { \"Invalid email: $value\" }\n}\nval domain: String get() = value.substringAfter('@')\n}\n```\n\n### DECORATOR: `JvmInline`\n> Lines: 147-147\n- @brief Inline value class wrapping a validated email string.\n- @param value The raw email address string.\n```\n@JvmInline\n```\n\n### FUNCTION: `greet`\n> Signature: `fun greet(name: String): String`\n> Lines: 165-167\n- @brief Greet a person by name.\n- @param name The person's name.\n- @return Greeting message string.\n```\nfun greet(name: String): String {\nreturn \"Hello $name\"\n}\n```\n\n### FUNCTION: `fetchData`\n> Signature: `suspend fun fetchData(): String`\n> Lines: 174-177\n- @brief Suspend function simulating async data retrieval.\n- @return Retrieved data as a string.\n```\nsuspend fun fetchData(): String {\nreturn \"data\"\n}\n```\n\n### FUNCTION: `processItems`\n> Signature: `fun processItems(items: List<String>, transform: (String) -> String): List<String>`\n> Lines: 186-188\n- @brief Higher-order function with trailing lambda syntax.\n- @param items List of strings to process.\n- @param transform Function applied to each item.\n- @return List of transformed results.\n```\nfun processItems(items: List<String>, transform: (String) -> String): List<String> {\nreturn items.map(transform)\n}\n```\n\n### CLASS: `Vector2`\n> Signature: `data class Vector2(val x: Double, val y: Double)`\n> Lines: 229-249\n- @brief 2D vector with operator overloading for arithmetic.\n- @brief Add two vectors component-wise.\n- @param x Horizontal component.\n- @param y Vertical component.\n- @param other The vector to add.\n- @return Resulting sum vector.\n```\ndata class Vector2(val x: Double, val y: Double) {\noperator fun plus(other: Vector2) = Vector2(x + other.x, y + other.y)\noperator fun unaryMinus() = Vector2(-x, -y)\noperator fun times(other: Vector2) = x * other.x + y * other.y\n}\n```\n\n### VARIABLE: `counter`\n> Signature: `var counter = 0`\n> Lines: 257-257\n- @brief Mutable package-level counter. */\n```\nvar counter = 0\n```\n\n### FUNCTION: `set`\n> Signature: `fun set(key: String, value: Any)`\n> Lines: 274-276\n- @brief Store a configuration value.\n- @param key Configuration key.\n- @param value Configuration value.\n```\nfun set(key: String, value: Any) {\nconfig[key] = value\n}\n```\n\n### DECORATOR: `Suppress`\n> Lines: 284-284\n- @brief Retrieve a typed configuration value.\n@tparam T Expected value type.\n- @param key Configuration key.\n- @return The value cast to T, or null.\n```\n@Suppress(\"UNCHECKED_CAST\")\n```\n\n### FUNCTION: `get`\n> Signature: `fun <T> get(key: String): T? = config[key] as? T`\n> Lines: 285-292\n- @brief Companion object pattern for factory construction.\n```\nfun <T> get(key: String): T? = config[key] as? T\n}\ncompanion object Factory {\n```\n\n### CLASS: `DelegatingList`\n> Signature: `class DelegatingList<T>(private val inner: MutableList<T>) : List<T> by inner`\n> Lines: 303-316\n- @brief List implementation delegating to an inner mutable list.\n@tparam T Element type.\n- @brief Count of accesses to the delegated list.\n- @param inner The backing list.\n```\nclass DelegatingList<T>(private val inner: MutableList<T>) : List<T> by inner {\nvar accessCount = 0\nprivate set\noverride val size: Int\nget() {\naccessCount++\nreturn inner.size\n}\n}\n```\n\n### VARIABLE: `accessCount`\n> Signature: `var accessCount = 0`\n> Lines: 305-305\n- @brief Count of accesses to the delegated list. */\n```\nvar accessCount = 0\n```\n\n### CLASS: `Service`\n> Signature: `class Service`\n> Lines: 324-339\n- @brief Service class demonstrating lateinit and lazy initialization.\n- @brief Late-initialized dependency, set after construction.\n```\nclass Service {\nlateinit var dependency: Repository<Entity>\nval resource: String by lazy {\n\"expensive_resource\"\n}\nfun isReady(): Boolean = ::dependency.isInitialized\n}\n```\n\n### FUNCTION: `isReady`\n> Signature: `fun isReady(): Boolean = ::dependency.isInitialized`\n> Lines: 338-347\n- @brief Check if the dependency has been initialized.\n- @return True if dependency is set.\n```\nfun isReady(): Boolean = ::dependency.isInitialized\n}\nclass HtmlBuilder {\n```\n\n### CLASS: `HtmlBuilder`\n> Signature: `class HtmlBuilder`\n> Lines: 347-373\n- @brief Simple DSL for building HTML strings.\n- @brief Add a div element with content from a lambda.\n- @param block Lambda providing the div content.\n```\nclass HtmlBuilder {\nprivate val elements = mutableListOf<String>()\nfun div(block: HtmlBuilder.() -> Unit) {\nval inner = HtmlBuilder()\ninner.block()\nelements.add(\"<div>${inner.build()}</div>\")\n}\nfun text(text: String) {\nelements.add(text)\n}\nfun build(): String = elements.joinToString(\"\")\n}\n```\n\n### FUNCTION: `div`\n> Signature: `fun div(block: HtmlBuilder.() -> Unit)`\n> Lines: 354-358\n- @brief Add a div element with content from a lambda.\n- @param block Lambda providing the div content.\n```\nfun div(block: HtmlBuilder.() -> Unit) {\nval inner = HtmlBuilder()\ninner.block()\nelements.add(\"<div>${inner.build()}</div>\")\n}\n```\n\n### FUNCTION: `text`\n> Signature: `fun text(text: String)`\n> Lines: 364-366\n- @brief Add a text node.\n- @param text The text content.\n```\nfun text(text: String) {\nelements.add(text)\n}\n```\n\n### FUNCTION: `build`\n> Signature: `fun build(): String = elements.joinToString(\"\")`\n> Lines: 372-381\n- @brief Build the accumulated HTML string.\n- @brief DSL entry point for building HTML content.\n- @param block Builder lambda receiving HtmlBuilder scope.\n- @return Concatenated HTML output.\n- @return Complete HTML string.\n```\nfun build(): String = elements.joinToString(\"\")\n}\nfun html(block: HtmlBuilder.() -> Unit): String {\n```\n\n### FUNCTION: `html`\n> Signature: `fun html(block: HtmlBuilder.() -> Unit): String`\n> Lines: 381-385\n- @brief DSL entry point for building HTML content.\n- @param block Builder lambda receiving HtmlBuilder scope.\n- @return Complete HTML string.\n```\nfun html(block: HtmlBuilder.() -> Unit): String {\nval builder = HtmlBuilder()\nbuilder.block()\nreturn builder.build()\n}\n```\n\n### IMPORT: `kotlin.math.max`\n> Lines: 388-388\n```\nimport kotlin.math.max\n```\n\n### IMPORT: `kotlin.math.min`\n> Lines: 389-389\n```\nimport kotlin.math.min\n```\n\n### DECORATOR: `Synchronized`\n> Lines: 398-398\n```\n@Synchronized\n```\n\n### DECORATOR: `PublishedApi`\n> Lines: 399-399\n```\n@PublishedApi\n```\n\n### VARIABLE: `retries`\n> Signature: `var retries = 0`\n> Lines: 401-401\n```\nvar retries = 0\n```\n\n### VARIABLE: `attempts`\n> Signature: `var attempts = 0`\n> Lines: 402-402\n```\nvar attempts = 0\n```\n\n### VARIABLE: `state`\n> Signature: `var state = \"idle\"`\n> Lines: 403-403\n```\nvar state = \"idle\"\n```\n\n### FUNCTION: `reqCoverKotlin1`\n> Signature: `fun reqCoverKotlin1(value: Int): Int = value + 1`\n> Lines: 413-413\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfun reqCoverKotlin1(value: Int): Int = value + 1\n```\n\n### FUNCTION: `reqCoverKotlin2`\n> Signature: `fun reqCoverKotlin2(value: Int): Int = value + 2`\n> Lines: 422-422\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfun reqCoverKotlin2(value: Int): Int = value + 2\n```\n\n### FUNCTION: `reqCoverKotlin3`\n> Signature: `fun reqCoverKotlin3(value: Int): Int = value + 3`\n> Lines: 431-431\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfun reqCoverKotlin3(value: Int): Int = value + 3\n```\n\n### FUNCTION: `reqCoverKotlin4`\n> Signature: `fun reqCoverKotlin4(value: Int): Int = value + 4`\n> Lines: 440-440\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfun reqCoverKotlin4(value: Int): Int = value + 4\n```\n\n### FUNCTION: `reqCoverKotlin5`\n> Signature: `fun reqCoverKotlin5(value: Int): Int = value + 5`\n> Lines: 449-449\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfun reqCoverKotlin5(value: Int): Int = value + 5\n```\n\n@@@ <PROJECT_BASE>/src/fixture_lua.lua | lua\n\n### FUNCTION: `globalFunc`\n> Signature: `function globalFunc(x)`\n> Lines: 14-16\n- @param x number The input value.\n---\n- @return number The input incremented by one.\n```\nfunction globalFunc(x)\nreturn x + 1\nend\n```\n\n### FUNCTION: `localFunc`\n> Signature: `local function localFunc(y)`\n> Lines: 22-28\n```\nlocal function localFunc(y)\nif type(y) ~= \"number\" then\nerror(\"expected number, got \" .. type(y))\nend\nreturn y * 2\nend\n```\n\n### FUNCTION: `sumAll`\n> Signature: `local function sumAll(...)`\n> Lines: 33-41\n- @param ... number Variable number of numeric arguments.\n---\n- @return number Sum of all provided values.\n```\nlocal function sumAll(...)\nlocal total = 0\nlocal args = {...}\nfor _, v in ipairs(args) do\ntotal = total + v\nend\nreturn total\nend\n```\n\n### VARIABLE: `total`\n> Signature: `local total = 0`\n> Lines: 34-34\n```\nlocal total = 0\n```\n\n### VARIABLE: `args`\n> Signature: `local args = {...}`\n> Lines: 35-35\n```\nlocal args = {...}\n```\n\n### VARIABLE: `myVar`\n> Signature: `local myVar = 42`\n> Lines: 46-46\n- @brief Module-level constant for retry limits.\n```\nlocal myVar = 42\n```\n\n### VARIABLE: `config`\n> Signature: `local config =`\n> Lines: 49-49\n- @brief Configuration table with default settings.\n```\nlocal config = {\n```\n\n### FUNCTION: `handler`\n> Signature: `local handler = function(event)`\n> Lines: 59-66\n- @param event table Event object containing type and data fields.\n```\nlocal handler = function(event)\nif event.type == \"click\" then\nprint(\"clicked at \" .. event.x .. \",\" .. event.y)\nelse\nprint(\"event: \" .. event.type)\nend\nend\n```\n\n### VARIABLE: `MyModule`\n> Signature: `local MyModule = {}`\n> Lines: 72-72\n- @brief Table-based module using method syntax.\n```\nlocal MyModule = {}\n```\n\n### FUNCTION: `MyModule.new`\n> Signature: `function MyModule.new(name)`\n> Lines: 78-83\n- @param name string Instance identifier.\n---\n- @return table New MyModule instance.\n```\nfunction MyModule.new(name)\nlocal self = setmetatable({}, MyModule)\nself.name = name\nself._items = {}\nreturn self\nend\n```\n\n### VARIABLE: `self`\n> Signature: `local self = setmetatable({}, MyModule)`\n> Lines: 79-79\n```\nlocal self = setmetatable({}, MyModule)\n```\n\n### FUNCTION: `MyModule.method`\n> Signature: `MyModule.method = function(self)`\n> Lines: 88-90\n- @param self table The MyModule instance.\n---\n- @return string The instance name.\n```\nMyModule.method = function(self)\nreturn self.name\nend\n```\n\n### FUNCTION: `MyModule:addItem`\n> Signature: `function MyModule:addItem(item)`\n> Lines: 94-97\n- @param item any The item to store.\n```\nfunction MyModule:addItem(item)\ntable.insert(self._items, item)\nend\n```\n\n### FUNCTION: `MyModule:count`\n> Signature: `function MyModule:count()`\n> Lines: 101-103\n- @return number Number of items.\n```\nfunction MyModule:count()\nreturn #self._items\nend\n```\n\n### VARIABLE: `Animal`\n> Signature: `local Animal = {}`\n> Lines: 109-109\n- @brief Base class using metatables for inheritance.\n```\nlocal Animal = {}\n```\n\n### FUNCTION: `Animal.new`\n> Signature: `function Animal.new(species)`\n> Lines: 115-119\n- @param species string The animal's species.\n---\n- @return table New Animal instance.\n```\nfunction Animal.new(species)\nlocal self = setmetatable({}, Animal)\nself.species = species\nreturn self\nend\n```\n\n### VARIABLE: `self`\n> Signature: `local self = setmetatable({}, Animal)`\n> Lines: 116-116\n```\nlocal self = setmetatable({}, Animal)\n```\n\n### FUNCTION: `Animal:speak`\n> Signature: `function Animal:speak()`\n> Lines: 123-125\n- @return string Sound description.\n```\nfunction Animal:speak()\nreturn self.species .. \" says ...\"\nend\n```\n\n### VARIABLE: `Dog`\n> Signature: `local Dog = setmetatable({}, { __index = Animal })`\n> Lines: 129-129\n- @brief Dog subclass inheriting from Animal.\n```\nlocal Dog = setmetatable({}, { __index = Animal })\n```\n\n### FUNCTION: `Dog.new`\n> Signature: `function Dog.new(name)`\n> Lines: 135-140\n- @param name string The dog's name.\n---\n- @return table New Dog instance.\n```\nfunction Dog.new(name)\nlocal self = Animal.new(\"Dog\")\nsetmetatable(self, Dog)\nself.dogName = name\nreturn self\nend\n```\n\n### VARIABLE: `self`\n> Signature: `local self = Animal.new(\"Dog\")`\n> Lines: 136-136\n```\nlocal self = Animal.new(\"Dog\")\n```\n\n### FUNCTION: `Dog:speak`\n> Signature: `function Dog:speak()`\n> Lines: 144-146\n- @return string The dog's vocalization.\n```\nfunction Dog:speak()\nreturn self.dogName .. \" says Woof!\"\nend\n```\n\n### FUNCTION: `makeCounter`\n> Signature: `local function makeCounter(step)`\n> Lines: 153-160\n- @param step number Increment amount per call.\n---\n- @return function Closure returning successive counts.\n```\nlocal function makeCounter(step)\nlocal count = 0\nreturn function()\ncount = count + step\nreturn count\nend\nend\n```\n\n### VARIABLE: `count`\n> Signature: `local count = 0`\n> Lines: 154-154\n```\nlocal count = 0\n```\n\n### FUNCTION: `fibonacci`\n> Signature: `local function fibonacci(limit)`\n> Lines: 167-176\n- @param limit number Maximum number of values to yield.\n---\n- @return function Coroutine wrap function.\n```\nlocal function fibonacci(limit)\nreturn coroutine.wrap(function()\nlocal a, b = 0, 1\nfor _ = 1, limit do\ncoroutine.yield(a)\na, b = b, a + b\nend\nend)\nend\n```\n\n### FUNCTION: `safeCall`\n> Signature: `local function safeCall(fn, ...)`\n> Lines: 184-192\n- @param fn function The function to execute.\n---\n- @param ... any Arguments to pass to fn.\n---\n- @return boolean, any Success flag and result or error message.\n```\nlocal function safeCall(fn, ...)\nlocal ok, result = pcall(fn, ...)\nif not ok then\nprint(\"Error: \" .. tostring(result))\nreturn false, nil\nend\nreturn true, result\nend\n```\n\n### VARIABLE: `mixedTable`\n> Signature: `local mixedTable =`\n> Lines: 197-197\n- @brief Complex table demonstrating all key types.\n```\nlocal mixedTable = {\n```\n\n### FUNCTION: `range`\n> Signature: `local function range(from, to)`\n> Lines: 219-228\n- @param from number Start of range (inclusive).\n---\n- @param to number End of range (inclusive).\n---\n- @return function Iterator function.\n```\nlocal function range(from, to)\nlocal i = from - 1\nreturn function()\ni = i + 1\nif i <= to then\nreturn i\nend\nend\nend\n```\n\n### VARIABLE: `i`\n> Signature: `local i = from - 1`\n> Lines: 220-220\n```\nlocal i = from - 1\n```\n\n### FUNCTION: `req_cover_lua_1`\n> Signature: `function req_cover_lua_1(value)`\n> Lines: 236-238\n- @brief Coverage helper construct 1.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n--\n- @param value Input value for helper construct 1.\n--\n- @return Output value for helper construct 1.\n```\nfunction req_cover_lua_1(value)\nreturn value + 1\nend\n```\n\n### FUNCTION: `req_cover_lua_2`\n> Signature: `function req_cover_lua_2(value)`\n> Lines: 245-247\n- @brief Coverage helper construct 2.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n--\n- @param value Input value for helper construct 2.\n--\n- @return Output value for helper construct 2.\n```\nfunction req_cover_lua_2(value)\nreturn value + 2\nend\n```\n\n### FUNCTION: `req_cover_lua_3`\n> Signature: `function req_cover_lua_3(value)`\n> Lines: 254-256\n- @brief Coverage helper construct 3.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n--\n- @param value Input value for helper construct 3.\n--\n- @return Output value for helper construct 3.\n```\nfunction req_cover_lua_3(value)\nreturn value + 3\nend\n```\n\n### FUNCTION: `req_cover_lua_4`\n> Signature: `function req_cover_lua_4(value)`\n> Lines: 263-265\n- @brief Coverage helper construct 4.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n--\n- @param value Input value for helper construct 4.\n--\n- @return Output value for helper construct 4.\n```\nfunction req_cover_lua_4(value)\nreturn value + 4\nend\n```\n\n### FUNCTION: `req_cover_lua_5`\n> Signature: `function req_cover_lua_5(value)`\n> Lines: 272-274\n- @brief Coverage helper construct 5.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n--\n- @param value Input value for helper construct 5.\n--\n- @return Output value for helper construct 5.\n```\nfunction req_cover_lua_5(value)\nreturn value + 5\nend\n```\n\n@@@ <PROJECT_BASE>/src/fixture_perl.pl | perl\n\n### IMPORT: `strict`\n> Lines: 18-18\n```\nuse strict;\n```\n\n### IMPORT: `warnings`\n> Lines: 19-19\n```\nuse warnings;\n```\n\n### IMPORT: `Carp qw(croak confess)`\n> Lines: 20-20\n```\nuse Carp qw(croak confess);\n```\n\n### IMPORT: `Exporter`\n> Lines: 21-21\n```\nrequire Exporter;\n```\n\n### FUNCTION: `new`\n> Signature: `sub new`\n> Lines: 48-48\n- @brief Create a new MyPackage instance.\n- @param class The class name (implicit first argument).\n- @param %args Named arguments: name (required), age (optional).\n- @return Blessed hashref instance.\n=cut\n```\nsub new {\n```\n\n### FUNCTION: `name`\n> Signature: `sub name`\n> Lines: 62-62\n- @brief Accessor for the name attribute.\n- @return The instance name string.\n```\nsub name {\n```\n\n### FUNCTION: `is_valid`\n> Signature: `sub is_valid`\n> Lines: 74-74\n- @brief Check if the instance is in a valid state.\n- @return 1 if valid, 0 otherwise.\n```\nsub is_valid {\n```\n\n### FUNCTION: `greet`\n> Signature: `sub greet`\n> Lines: 83-83\n- @brief Print a greeting to stdout.\n- @param $name The person's name.\n```\nsub greet {\n```\n\n### FUNCTION: `process`\n> Signature: `sub process`\n> Lines: 95-95\n- @brief Process data and return result.\n- @return 1 indicating success.\n```\nsub process {\n```\n\n### FUNCTION: `format_output`\n> Signature: `sub format_output`\n> Lines: 102-102\n- @brief Format output depending on context (list vs scalar).\n- @param @items List of items to format.\n- @return In list context: formatted items. In scalar: count.\n```\nsub format_output {\n```\n\n### FUNCTION: `helper`\n> Signature: `sub helper`\n> Lines: 115-115\n- @brief Standalone helper for internal use.\n- @return Always returns \"ok\".\n```\nsub helper {\n```\n\n### FUNCTION: `extract_emails`\n> Signature: `sub extract_emails`\n> Lines: 124-124\n- @brief Extract all email addresses from text.\n- @param $text Input text to scan.\n- @return List of matched email addresses.\n```\nsub extract_emails {\n```\n\n### FUNCTION: `replace_all`\n> Signature: `sub replace_all`\n> Lines: 139-139\n- @brief Replace all occurrences of a pattern in text.\n- @param $text Input text.\n- @param $pattern Regex pattern to find.\n- @param $replacement Replacement string.\n- @return Modified text with substitutions applied.\n```\nsub replace_all {\n```\n\n### FUNCTION: `make_multiplier`\n> Signature: `sub make_multiplier`\n> Lines: 150-150\n- @brief Create a multiplier closure.\n- @param $factor The multiplication factor.\n- @return Coderef that multiplies its argument by factor.\n```\nsub make_multiplier {\n```\n\n### FUNCTION: `dispatch`\n> Signature: `sub dispatch`\n> Lines: 178-178\n```\nsub dispatch {\n```\n\n### FUNCTION: `generate_template`\n> Signature: `sub generate_template`\n> Lines: 190-190\n- @brief Generate a template string using a here-document.\n- @param $name Name to insert into the template.\n- @return Formatted multi-line string.\n```\nsub generate_template {\n```\n\n### FUNCTION: `AUTOLOAD`\n> Signature: `sub AUTOLOAD`\n> Lines: 210-210\n- @brief Handle undefined method calls dynamically.\n- @details Methods named get_* return the corresponding attribute.\n- @param @args Arguments passed to the auto-loaded method.\n- @return The attribute value or undef.\n```\nsub AUTOLOAD {\n```\n\n### FUNCTION: `safe_execute`\n> Signature: `sub safe_execute`\n> Lines: 230-230\n- @brief Execute a block with error trapping.\n- @param $code Coderef to execute.\n- @return Result of execution or undef on error.\n```\nsub safe_execute {\n```\n\n### IMPORT: `lib 'lib'`\n> Lines: 257-257\n```\nuse lib 'lib';\n```\n\n### FUNCTION: `req_cover_perl_1`\n> Signature: `sub req_cover_perl_1`\n> Lines: 265-265\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nsub req_cover_perl_1 {\n```\n\n### FUNCTION: `req_cover_perl_2`\n> Signature: `sub req_cover_perl_2`\n> Lines: 275-275\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nsub req_cover_perl_2 {\n```\n\n### FUNCTION: `req_cover_perl_3`\n> Signature: `sub req_cover_perl_3`\n> Lines: 285-285\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nsub req_cover_perl_3 {\n```\n\n### FUNCTION: `req_cover_perl_4`\n> Signature: `sub req_cover_perl_4`\n> Lines: 295-295\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nsub req_cover_perl_4 {\n```\n\n### FUNCTION: `req_cover_perl_5`\n> Signature: `sub req_cover_perl_5`\n> Lines: 305-305\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nsub req_cover_perl_5 {\n```\n\n@@@ <PROJECT_BASE>/src/fixture_php.php | php\n- @brief Comprehensive PHP test fixture for parser validation.\n- @details Covers enums with methods, union/intersection types, readonly\nproperties, constructor promotion, arrow functions, match expressions,\nfirst-class callables, attributes, fibers, and named arguments.\n\n### IMPORT: `App\\Contracts\\Repository`\n> Lines: 14-14\n```\nuse App\\Contracts\\Repository;\n```\n\n### IMPORT: `App\\Events\\{ModelCreated, ModelDeleted}`\n> Lines: 15-15\n```\nuse App\\Events\\{ModelCreated, ModelDeleted};\n```\n\n### IMPORT: `Psr\\Log\\LoggerInterface`\n> Lines: 16-16\n```\nuse Psr\\Log\\LoggerInterface;\n```\n\n### IMPORT: `'config.php'`\n> Lines: 17-17\n```\nrequire_once 'config.php';\n```\n\n### FUNCTION: `isActive`\n> Signature: `public function isActive(): bool`\n> Lines: 45-47\n- @brief Check if the status represents an active state.\n- @return bool True if the entity is publicly visible.\n```\npublic function isActive(): bool {\nreturn $this === self::Published;\n}\n```\n\n### FUNCTION: `label`\n> Signature: `public function label(): string`\n> Lines: 53-59\n- @brief Get a human-readable label for display.\n- @return string Formatted status label.\n```\npublic function label(): string {\nreturn match($this) {\nself::Draft => 'Draft',\nself::Published => 'Published',\nself::Archived => 'Archived',\n};\n}\n```\n\n### CLASS: `BaseModel`\n> Signature: `abstract class BaseModel`\n> Lines: 69-111\n- @brief Abstract base model with common persistence operations.\n- @brief Construct a model with promoted properties.\n- @details Uses constructor promotion for compact field declaration.\n- @param int $id Unique identifier (readonly after construction).\n- @param \\DateTimeImmutable $createdAt Timestamp of creation.\n```\nabstract class BaseModel {\npublic function __construct(\npublic readonly int $id,\npublic readonly \\DateTimeImmutable $createdAt = new \\DateTimeImmutable(),\n) {}\npublic function save(): bool {\nif (!$this->validate()) {\nreturn false;\n}\nreturn true;\n}\nabstract protected function validate(): bool;\nprivate static function validateConstraints(): bool {\nreturn true;\n}\nabstract public function toArray(): array;\n}\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 75-78\n- @brief Construct a model with promoted properties.\n- @param int $id Unique identifier (readonly after construction).\n- @param \\DateTimeImmutable $createdAt Timestamp of creation.\n```\npublic function __construct(\npublic readonly int $id,\npublic readonly \\DateTimeImmutable $createdAt = new \\DateTimeImmutable(),\n) {}\n```\n\n### FUNCTION: `save`\n> Signature: `public function save(): bool`\n> Lines: 84-90\n- @brief Persist the model to the data store.\n- @return bool True if save succeeded.\n```\npublic function save(): bool {\nif (!$this->validate()) {\nreturn false;\n}\nreturn true;\n}\n```\n\n### FUNCTION: `validateConstraints`\n> Signature: `private static function validateConstraints(): bool`\n> Lines: 102-104\n- @brief Internal validation helper with type narrowing.\n- @return bool True if entity passes all constraint checks.\n```\nprivate static function validateConstraints(): bool {\nreturn true;\n}\n```\n\n### CLASS: `User`\n> Signature: `final class User extends BaseModel`\n> Lines: 120-179\n- @brief Concrete user entity with union and intersection types.\n- @brief User's display name.\n```\nfinal class User extends BaseModel {\nprivate string $name;\nprivate ?string $email;\npublic function __construct(\nint $id,\nstring $name,\n?string $email = null,\n) {\nparent::__construct($id);\n$this->name = $name;\n$this->email = $email;\n}\npublic function getName(): string {\nreturn $this->name;\n}\npublic function getIdentifier(): string|int {\nreturn $this->email ?? $this->id;\n}\nprotected function validate(): bool {\nreturn strlen($this->name) > 0;\n}\npublic function toArray(): array {\nreturn [\n'id' => $this->id,\n'name' => $this->name,\n'email' => $this->email,\n];\n}\n}\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 133-141\n- @brief Construct a User with promoted and explicit properties.\n- @param int $id Unique user ID.\n- @param string $name Display name.\n- @param string|null $email Optional email address.\n```\npublic function __construct(\nint $id,\nstring $name,\n?string $email = null,\n) {\nparent::__construct($id);\n$this->name = $name;\n$this->email = $email;\n}\n```\n\n### FUNCTION: `getName`\n> Signature: `public function getName(): string`\n> Lines: 147-149\n- @brief Get the user's display name.\n- @return string The user name.\n```\npublic function getName(): string {\nreturn $this->name;\n}\n```\n\n### FUNCTION: `getIdentifier`\n> Signature: `public function getIdentifier(): string|int`\n> Lines: 155-158\n- @brief Get a value that may be string or int.\n- @return string|int The identifier in either format.\n```\npublic function getIdentifier(): string|int {\nreturn $this->email ?? $this->id;\n}\n```\n\n### FUNCTION: `validate`\n> Signature: `protected function validate(): bool`\n> Lines: 164-166\n- @brief Validate user-specific constraints.\n- @return bool True if name is non-empty.\n```\nprotected function validate(): bool {\nreturn strlen($this->name) > 0;\n}\n```\n\n### FUNCTION: `toArray`\n> Signature: `public function toArray(): array`\n> Lines: 172-178\n- @brief Serialize user to array.\n- @return array<string, mixed> User data array.\n```\npublic function toArray(): array {\nreturn [\n'id' => $this->id,\n'name' => $this->name,\n'email' => $this->email,\n];\n}\n```\n\n### FUNCTION: `findAll`\n> Signature: `public function findAll(): iterable`\n> Lines: 192-215\n- @brief Retrieve all entities.\n- @brief Find a single entity by ID.\n- @param int $id Entity identifier.\n- @return iterable<BaseModel> Collection of models.\n- @return BaseModel|null The found entity or null.\n```\npublic function findAll(): iterable;\npublic function findById(int $id): ?BaseModel;\npublic function count(array $criteria = []): int;\n}\ntrait Cacheable {\n```\n\n### FUNCTION: `findById`\n> Signature: `public function findById(int $id): ?BaseModel`\n> Lines: 199-215\n- @brief Find a single entity by ID.\n- @brief Count entities matching a filter.\n- @param int $id Entity identifier.\n- @param array<string, mixed> $criteria Filter criteria.\n- @return BaseModel|null The found entity or null.\n- @return int Number of matching entities.\n```\npublic function findById(int $id): ?BaseModel;\npublic function count(array $criteria = []): int;\n}\ntrait Cacheable {\n```\n\n### FUNCTION: `count`\n> Signature: `public function count(array $criteria = []): int`\n> Lines: 206-215\n- @brief Count entities matching a filter.\n- @param array<string, mixed> $criteria Filter criteria.\n- @return int Number of matching entities.\n```\npublic function count(array $criteria = []): int;\n}\ntrait Cacheable {\n```\n\n### FUNCTION: `cache`\n> Signature: `public function cache(): bool`\n> Lines: 223-226\n- @brief Store the current object in cache.\n- @return bool True if caching succeeded.\n```\npublic function cache(): bool {\nreturn true;\n}\n```\n\n### FUNCTION: `invalidateCache`\n> Signature: `public function invalidateCache(): void`\n> Lines: 232-234\n- @brief Invalidate the cached version of this object.\n- @return void\n```\npublic function invalidateCache(): void {\n}\n```\n\n### FUNCTION: `softDelete`\n> Signature: `public function softDelete(): void`\n> Lines: 255-257\n- @brief Mark the entity as soft-deleted.\n- @return void\n```\npublic function softDelete(): void {\n$this->deletedAt = new \\DateTimeImmutable();\n}\n```\n\n### FUNCTION: `isDeleted`\n> Signature: `public function isDeleted(): bool`\n> Lines: 263-265\n- @brief Check if the entity is currently deleted.\n- @return bool True if soft-deleted.\n```\npublic function isDeleted(): bool {\nreturn $this->deletedAt !== null;\n}\n```\n\n### CLASS: `CachedUser`\n> Signature: `final class CachedUser extends User`\n> Lines: 275-286\n- @brief User entity with caching and soft-delete capabilities.\n```\nfinal class CachedUser extends User {\nuse Cacheable;\nuse SoftDeletable;\npublic function cacheKey(): string {\nreturn \"user:{$this->id}\";\n}\n}\n```\n\n### IMPORT: `Cacheable`\n> Lines: 276-276\n```\nuse Cacheable;\n```\n\n### IMPORT: `SoftDeletable`\n> Lines: 277-277\n```\nuse SoftDeletable;\n```\n\n### FUNCTION: `cacheKey`\n> Signature: `public function cacheKey(): string`\n> Lines: 283-285\n- @brief Generate a unique cache key for this user.\n- @return string Cache key in format \"user:{id}\".\n```\npublic function cacheKey(): string {\nreturn \"user:{$this->id}\";\n}\n```\n\n### CLASS: `Route`\n> Signature: `class Route`\n> Lines: 295-305\n- @brief PHP attribute for annotating controller methods with routes.\n- @brief Define a route attribute.\n- @param string $path URL path pattern.\n- @param string $method HTTP method (GET, POST, etc.).\n```\nclass Route {\npublic function __construct(\npublic readonly string $path,\npublic readonly string $method = 'GET',\n) {}\n}\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 301-304\n- @brief Define a route attribute.\n- @param string $path URL path pattern.\n- @param string $method HTTP method (GET, POST, etc.).\n```\npublic function __construct(\npublic readonly string $path,\npublic readonly string $method = 'GET',\n) {}\n```\n\n### FUNCTION: `helper`\n> Signature: `function helper(): bool`\n> Lines: 314-316\n- @brief Standalone helper returning a boolean result.\n- @return bool Always returns true.\n```\nfunction helper(): bool {\nreturn true;\n}\n```\n\n### FUNCTION: `processData`\n> Signature: `function processData(mixed $data): string`\n> Lines: 324-333\n- @brief Process data using match expression for type dispatching.\n- @param mixed $data Input data of any type.\n- @return string Description of the processed data.\n```\nfunction processData(mixed $data): string {\nreturn match(true) {\nis_string($data) => \"string: \" . strlen($data),\nis_int($data) => \"int: $data\",\nis_array($data) => \"array: \" . count($data),\n$data instanceof BaseModel => \"model: \" . $data->id,\ndefault => \"unknown\",\n};\n}\n```\n\n### FUNCTION: `applyTransform`\n> Signature: `function applyTransform(array $items, callable $fn): array`\n> Lines: 342-344\n- @brief Higher-order function using arrow function syntax.\n- @param array<int> $items Array of integers.\n- @param callable(int): int $fn Transform function.\n- @return array<int> Transformed array.\n```\nfunction applyTransform(array $items, callable $fn): array {\nreturn array_map(fn(int $x): int => $fn($x), $items);\n}\n```\n\n### FUNCTION: `createMultiplier`\n> Signature: `function createMultiplier(int $factor): \\Closure`\n> Lines: 352-355\n- @brief Create a closure that multiplies its argument.\n- @param int $factor The multiplication factor.\n- @return \\Closure(int): int A multiplier closure.\n```\nfunction createMultiplier(int $factor): \\Closure {\nreturn fn(int $x): int => $x * $factor;\n}\n```\n\n### FUNCTION: `readFileContent`\n> Signature: `function readFileContent(string $path): string|false`\n> Lines: 363-368\n- @brief Read file contents with comprehensive error handling.\n- @param string $path File system path.\n- @return string|false File contents or false on failure.\n```\nfunction readFileContent(string $path): string|false {\nif (!file_exists($path)) {\nreturn false;\n}\nreturn file_get_contents($path);\n}\n```\n\n### CLASS: `ApiClient`\n> Signature: `final class ApiClient {}`\n> Lines: 385-385\n```\nfinal class ApiClient {}\n```\n\n### FUNCTION: `req_cover_php_1`\n> Signature: `function req_cover_php_1(int $value): int { return $value + 1; }`\n> Lines: 395-395\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfunction req_cover_php_1(int $value): int { return $value + 1; }\n```\n\n### FUNCTION: `req_cover_php_2`\n> Signature: `function req_cover_php_2(int $value): int { return $value + 2; }`\n> Lines: 404-404\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfunction req_cover_php_2(int $value): int { return $value + 2; }\n```\n\n### FUNCTION: `req_cover_php_3`\n> Signature: `function req_cover_php_3(int $value): int { return $value + 3; }`\n> Lines: 413-413\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfunction req_cover_php_3(int $value): int { return $value + 3; }\n```\n\n### FUNCTION: `req_cover_php_4`\n> Signature: `function req_cover_php_4(int $value): int { return $value + 4; }`\n> Lines: 422-422\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfunction req_cover_php_4(int $value): int { return $value + 4; }\n```\n\n### FUNCTION: `req_cover_php_5`\n> Signature: `function req_cover_php_5(int $value): int { return $value + 5; }`\n> Lines: 431-431\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfunction req_cover_php_5(int $value): int { return $value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_python.py | python\n- @brief Comprehensive Python test fixture for parser validation.\n- @details Covers classes, protocols, decorators, generators, async functions, and rich Doxygen-tagged constructs used to validate extraction workflows and deterministic parser behavior.\n\n### IMPORT: `asyncio  #!< @brief Async IO support. @details Used for async test fixtures. # noqa: F401`\n> Lines: 7-7\n- @brief Async IO support.\n- @details Used for async test fixtures. # noqa: F401\n```\nimport asyncio\n```\n\n### IMPORT: `os  #!< @brief OS interface module. @details Provides OS-dependent functionality. # noqa: F401`\n> Lines: 8-8\n- @brief OS interface module.\n- @details Provides OS-dependent functionality. # noqa: F401\n```\nimport os\n```\n\n### IMPORT: `sys  #!< @brief System-specific parameters. @see sys.exit() for exit handling.`\n> Lines: 9-9\n- @brief System-specific parameters.\n- @see sys.exit() for exit handling.\n```\nimport sys\n```\n\n### IMPORT: `Path  #!< @brief Object-oriented filesystem paths. @note Preferred over os.path. # noqa: F401`\n> Lines: 10-10\n- @brief Object-oriented filesystem paths.\n- @note Preferred over os.path. # noqa: F401\n```\nfrom pathlib import Path\n```\n\n### IMPORT: `(`\n> Lines: 11-11\n```\nfrom typing import (\n```\n\n### IMPORT: `dataclass, field`\n> Lines: 15-15\n```\nfrom dataclasses import dataclass, field\n```\n\n### IMPORT: `ABC, abstractmethod`\n> Lines: 16-16\n```\nfrom abc import ABC, abstractmethod\n```\n\n### IMPORT: `contextmanager`\n> Lines: 17-17\n```\nfrom contextlib import contextmanager\n```\n\n### VARIABLE: `MAX_RETRIES`\n> Signature: `MAX_RETRIES = 3  #!< @brief Maximum retry attempts. @details Applied to network operations. @warning Tune per use case. @satisfies retry-policy`\n> Lines: 19-19\n- @brief Maximum retry attempts.\n- @details Applied to network operations.\n- @warning Tune per use case.\n- @satisfies retry-policy\n```\nMAX_RETRIES = 3\n```\n\n### VARIABLE: `DEFAULT_TIMEOUT`\n> Signature: `DEFAULT_TIMEOUT = 30.0  #!< @brief Default timeout in seconds. @note For I/O operations.`\n> Lines: 20-20\n- @brief Default timeout in seconds.\n- @note For I/O operations.\n```\nDEFAULT_TIMEOUT = 30.0\n```\n\n### DECORATOR: `dataclass`\n> Lines: 26-26\n```\n@dataclass(slots=True)\n```\n\n### CLASS: `Config`\n> Signature: `class Config`\n> Lines: 27-61\n- @brief Stores key-value pairs with optional default fallback.\n- @details Dataclass-based configuration with validation.\n- @note Immutable after creation when frozen=True is used.\n- @see __post_init__() for validation logic.\n```\nclass Config:\n    name: str\n    values: Dict[str, str] = field(default_factory=dict)\n    debug: bool = False\n    def get(self, key: str, default: str = \"\") -> str:\n        if key in self.values:\n            return self.values[key]\n        return default\n    def __post_init__(self) -> None:\n        if not self.name.strip():\n            raise ValueError(\"Config name cannot be empty\")\n```\n\n### FUNCTION: `get`\n> Signature: `def get(self, key: str, default: str = \"\") -> str`\n> Lines: 39-51\n- @brief Stores key-value pairs with optional default fallback.\n- @details Dataclass-based configuration with validation.\n- @param key The configuration key to look up.\n- @param default Fallback value if key is missing.\n- @return The configuration value or default.\n- @note Immutable after creation when frozen=True is used.\n- @see __post_init__() for validation logic.\n```\n    def get(self, key: str, default: str = \"\") -> str:\n        if key in self.values:\n            return self.values[key]\n        return default\n```\n\n### FUNCTION: `__post_init__`\n> Signature: `def __post_init__(self) -> None`\n> Lines: 52-61\n- @brief Ensures name is non-empty and normalizes values. @raises ValueError If name is empty or whitespace.\n```\n    def __post_init__(self) -> None:\n        if not self.name.strip():\n            raise ValueError(\"Config name cannot be empty\")\n```\n\n### CLASS: `MyClass`\n> Signature: `class MyClass`\n> Lines: 62-167\n- @brief Base class demonstrating various Python constructs.\n- @details Includes nested classes, properties, and static methods.\n```\nclass MyClass:\n    class InnerHelper:\n        def __init__(self, tag: str):\n            self.tag = tag\n        def describe(self) -> str:\n            return f\"Helper({self.tag})\"\n    def __init__(self, name: str, retries: int = MAX_RETRIES):\n        self._name = name\n        self._retries = retries\n        self._call_count = 0\n    @property\n    def name(self) -> str:\n        return self._name\n    @name.setter\n    def name(self, value: str) -> None:\n        if not value:\n            raise ValueError(\"Name cannot be empty\")\n        self._name = value\n    @staticmethod\n    def create_default() -> \"MyClass\":\n        return MyClass(\"default\")\n    @classmethod\n    def from_dict(cls, data: dict) -> \"MyClass\":\n        return cls(\n            name=data[\"name\"],\n            retries=data.get(\"retries\", MAX_RETRIES),\n        )\n    def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]:\n        self._call_count += 1\n        for item in items:\n            if not item.strip():\n                continue\n            if verbose:\n                print(f\"Processing: {item}\")\n            return item if len(item) > 1 else item.upper()\n        return None\n    def compute(self, x: int, y: int) -> int:\n        return (x + y) if (x > 0 and y > 0) else abs(x - y)\n```\n\n### CLASS: `InnerHelper`\n> Signature: `class InnerHelper`\n> Lines: 69-87\n- @brief Base class demonstrating various Python constructs.\n- @brief Handles auxiliary computations within MyClass scope.\n- @details Includes nested classes, properties, and static methods.\n```\n    class InnerHelper:\n        def __init__(self, tag: str):\n            self.tag = tag\n        def describe(self) -> str:\n            return f\"Helper({self.tag})\"\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self, tag: str)`\n> Lines: 74-80\n- @brief Handles auxiliary computations within MyClass scope.\n- @param tag Short label for categorization.\n```\n        def __init__(self, tag: str):\n            self.tag = tag\n```\n\n### FUNCTION: `describe`\n> Signature: `def describe(self) -> str`\n> Lines: 81-87\n- @return String combining class name and tag.\n```\n        def describe(self) -> str:\n            return f\"Helper({self.tag})\"\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self, name: str, retries: int = MAX_RETRIES)`\n> Lines: 88-98\n- @param name Identifier for this instance.\n- @param retries Maximum retry attempts; defaults to MAX_RETRIES.\n```\n    def __init__(self, name: str, retries: int = MAX_RETRIES):\n        self._name = name\n        self._retries = retries\n        self._call_count = 0\n```\n\n### DECORATOR: `property`\n> Lines: 99-99\n```\n    @property\n```\n\n### FUNCTION: `name`\n> Signature: `def name(self) -> str`\n> Lines: 100-106\n- @return The name string set during initialization.\n```\n    def name(self) -> str:\n        return self._name\n```\n\n### DECORATOR: `name.setter`\n> Lines: 107-107\n```\n    @name.setter\n```\n\n### FUNCTION: `name`\n> Signature: `def name(self, value: str) -> None`\n> Lines: 108-117\n- @param value New name; must be non-empty. @raises ValueError If value is empty.\n```\n    def name(self, value: str) -> None:\n        if not value:\n            raise ValueError(\"Name cannot be empty\")\n        self._name = value\n```\n\n### DECORATOR: `staticmethod`\n> Lines: 118-118\n```\n    @staticmethod\n```\n\n### FUNCTION: `create_default`\n> Signature: `def create_default() -> \"MyClass\"`\n> Lines: 119-125\n- @return A new MyClass instance with name='default'.\n```\n    def create_default() -> \"MyClass\":\n        return MyClass(\"default\")\n```\n\n### DECORATOR: `classmethod`\n> Lines: 126-126\n```\n    @classmethod\n```\n\n### FUNCTION: `from_dict`\n> Signature: `def from_dict(cls, data: dict) -> \"MyClass\"`\n> Lines: 127-138\n- @param data Dictionary with 'name' and optional 'retries' keys.\n- @return A new instance populated from data. @raises KeyError If 'name' key is missing.\n```\n    def from_dict(cls, data: dict) -> \"MyClass\":\n        return cls(\n            name=data[\"name\"],\n            retries=data.get(\"retries\", MAX_RETRIES),\n        )\n```\n\n### FUNCTION: `process`\n> Signature: `def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]`\n> Lines: 139-156\n- @param items List of strings to process sequentially.\n- @param verbose Enable detailed logging when True.\n- @return The first valid item found or None if all are empty.\n```\n    def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]:\n        self._call_count += 1\n        for item in items:\n            if not item.strip():\n                continue\n            if verbose:\n                print(f\"Processing: {item}\")\n            return item if len(item) > 1 else item.upper()\n        return None\n```\n\n### FUNCTION: `compute`\n> Signature: `def compute(self, x: int, y: int) -> int`\n> Lines: 157-167\n- @param x First operand.\n- @param y Second operand.\n- @return Sum if both positive, difference otherwise.\n```\n    def compute(self, x: int, y: int) -> int:\n        return (x + y) if (x > 0 and y > 0) else abs(x - y)\n```\n\n### CLASS: `AbstractProcessor`\n> Signature: `class AbstractProcessor(ABC)`\n> Lines: 168-196\n- @brief Defines the interface that concrete processors must implement.\n- @details ABC-based interface with abstract methods.\n- @note Subclasses must implement execute() and execute_async().\n- @see ConcreteProcessor for a working implementation.\n- @sa ABC documentation for abstract base class patterns.\n```\nclass AbstractProcessor(ABC):\n    @abstractmethod\n    def execute(self, data: bytes) -> bool:\n        ...\n    @abstractmethod\n    async def execute_async(self, data: bytes) -> bool:\n        ...\n```\n\n### DECORATOR: `abstractmethod`\n> Lines: 178-178\n- @brief Defines the interface that concrete processors must implement.\n- @details ABC-based interface with abstract methods.\n- @note Subclasses must implement execute() and execute_async().\n- @see ConcreteProcessor for a working implementation.\n- @sa ABC documentation for abstract base class patterns.\n```\n    @abstractmethod\n```\n\n### FUNCTION: `execute`\n> Signature: `def execute(self, data: bytes) -> bool`\n> Lines: 179-186\n- @param data The raw input bytes to process.\n- @return True if processing succeeded, False otherwise.\n```\n    def execute(self, data: bytes) -> bool:\n        ...\n```\n\n### DECORATOR: `abstractmethod`\n> Lines: 187-187\n```\n    @abstractmethod\n```\n\n### FUNCTION: `execute_async`\n> Signature: `async def execute_async(self, data: bytes) -> bool`\n> Lines: 188-196\n- @param data The raw input bytes to process.\n- @return True if processing succeeded.\n```\n    async def execute_async(self, data: bytes) -> bool:\n        ...\n```\n\n### CLASS: `ConcreteProcessor`\n> Signature: `class ConcreteProcessor(AbstractProcessor)`\n> Lines: 197-231\n- @brief Processes byte data by decoding and validating content.\n- @details Implements synchronous and async execute methods.\n- @note Thread-safe for read operations.\n- @see AbstractProcessor for interface definition.\n```\nclass ConcreteProcessor(AbstractProcessor):\n    def execute(self, data: bytes) -> bool:\n        try:\n            text = data.decode(\"utf-8\")\n            return bool(text.strip())\n        except UnicodeDecodeError:\n            return False\n        finally:\n            pass\n    async def execute_async(self, data: bytes) -> bool:\n        return self.execute(data)\n```\n\n### FUNCTION: `execute`\n> Signature: `def execute(self, data: bytes) -> bool`\n> Lines: 206-222\n- @brief Processes byte data by decoding and validating content.\n- @details Implements synchronous and async execute methods.\n- @param data Raw bytes, expected UTF-8 encoded text.\n- @return True if decoding and validation succeed. @raises UnicodeDecodeError Propagated if data is not valid UTF-8.\n- @note Thread-safe for read operations.\n- @see AbstractProcessor for interface definition.\n```\n    def execute(self, data: bytes) -> bool:\n        try:\n            text = data.decode(\"utf-8\")\n            return bool(text.strip())\n        except UnicodeDecodeError:\n            return False\n        finally:\n            pass\n```\n\n### FUNCTION: `execute_async`\n> Signature: `async def execute_async(self, data: bytes) -> bool`\n> Lines: 223-231\n- @param data Raw bytes to process asynchronously.\n- @return True if valid content found.\n```\n    async def execute_async(self, data: bytes) -> bool:\n        return self.execute(data)\n```\n\n### CLASS: `GenericContainer`\n> Signature: `class GenericContainer(Generic[T])`\n> Lines: 232-271\n- @brief Type-safe collection with iteration and lookup support.\n- @details Generic collection with find and iteration. @tparam T The element type stored in this container.\n- @note Implements __iter__ for iteration protocol.\n- @see typing.Generic for generics documentation.\n```\nclass GenericContainer(Generic[T]):\n    def __init__(self) -> None:\n        self._items: List[T] = []\n    def add(self, item: T) -> None:\n        self._items.append(item)\n    def __iter__(self) -> Iterator[T]:\n        yield from self._items\n    def find(self, predicate) -> Optional[T]:\n        for item in self._items:\n            if predicate(item):\n                return item\n        return None\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self) -> None`\n> Lines: 242-245\n- @brief Type-safe collection with iteration and lookup support.\n- @details Generic collection with find and iteration.\n@tparam T The element type stored in this container.\n- @note Implements __iter__ for iteration protocol.\n- @see typing.Generic for generics documentation.\n```\n    def __init__(self) -> None:\n        self._items: List[T] = []\n```\n\n### FUNCTION: `add`\n> Signature: `def add(self, item: T) -> None`\n> Lines: 246-252\n- @param item Element of type T to add.\n```\n    def add(self, item: T) -> None:\n        self._items.append(item)\n```\n\n### FUNCTION: `__iter__`\n> Signature: `def __iter__(self) -> Iterator[T]`\n> Lines: 253-259\n- @return Iterator yielding items of type T.\n```\n    def __iter__(self) -> Iterator[T]:\n        yield from self._items\n```\n\n### FUNCTION: `find`\n> Signature: `def find(self, predicate) -> Optional[T]`\n> Lines: 260-271\n- @param predicate Callable accepting T and returning bool.\n- @return The first matching item or None.\n```\n    def find(self, predicate) -> Optional[T]:\n        for item in self._items:\n            if predicate(item):\n                return item\n        return None\n```\n\n### CLASS: `Renderable`\n> Signature: `class Renderable(Protocol)`\n> Lines: 272-285\n- @brief Structural typing interface for render-capable objects.\n```\nclass Renderable(Protocol):\n    def render(self) -> str:\n        ...\n```\n\n### FUNCTION: `render`\n> Signature: `def render(self) -> str`\n> Lines: 278-285\n- @brief Structural typing interface for render-capable objects.\n- @return Rendered string output.\n```\n    def render(self) -> str:\n        ...\n```\n\n### DECORATOR: `property`\n> Lines: 286-286\n```\n@property\n```\n\n### FUNCTION: `regular_function`\n> Signature: `def regular_function(x: int) -> int`\n> Lines: 287-295\n- @param x Input integer value.\n- @return The input value unchanged.\n```\ndef regular_function(x: int) -> int:\n    return x\n```\n\n### FUNCTION: `function_with_walrus`\n> Signature: `def function_with_walrus(data: List[int]) -> Optional[int]`\n> Lines: 296-307\n- @param data List of integers to scan.\n- @return The first value greater than 10, or None.\n```\ndef function_with_walrus(data: List[int]) -> Optional[int]:\n    if (n := next((x for x in data if x > 10), None)) is not None:\n        return n\n    return None\n```\n\n### FUNCTION: `multi_return_paths`\n> Signature: `def multi_return_paths(value: int) -> Union[str, int, None]`\n> Lines: 308-325\n- @param value Integer selector for branching logic.\n- @return A string, integer, or None depending on value.\n```\ndef multi_return_paths(value: int) -> Union[str, int, None]:\n    match value:\n        case 0:\n            return \"zero\"\n        case n if n < 0:\n            return abs(n)\n        case n if n > 100:\n            return None\n        case _:\n            return str(value)\n```\n\n### FUNCTION: `generator_function`\n> Signature: `def generator_function(limit: int) -> Iterator[int]`\n> Lines: 326-336\n- @param limit Upper bound (exclusive) for generation. @yield Squared integers from 0 to limit-1.\n```\ndef generator_function(limit: int) -> Iterator[int]:\n    for i in range(limit):\n        yield i * i\n```\n\n### FUNCTION: `async_generator`\n> Signature: `async def async_generator(items: List[str]) -> AsyncIterator[str]`\n> Lines: 337-347\n- @param items Source strings to process. @yield Upper-cased non-empty strings.\n```\nasync def async_generator(items: List[str]) -> AsyncIterator[str]:\n    for item in items:\n        if item.strip():\n            yield item.upper()\n```\n\n### DECORATOR: `contextmanager`\n> Lines: 348-348\n- @brief Context manager decorator.\n- @see contextlib.contextmanager\n```\n@contextmanager\n```\n\n### FUNCTION: `managed_resource`\n> Signature: `def managed_resource(path: str)`\n> Lines: 349-362\n- @param path File system path to the resource. @yield The opened file handle. @raises IOError If the resource cannot be opened.\n```\ndef managed_resource(path: str):\n    f = open(path, \"r\")\n    try:\n        yield f\n    finally:\n        f.close()\n```\n\n### FUNCTION: `closure_factory`\n> Signature: `def closure_factory(multiplier: int)`\n> Lines: 363-379\n- @param multiplier The fixed multiplier for the returned function.\n- @return A callable that multiplies input by multiplier.\n```\ndef closure_factory(multiplier: int):\n    def inner(x: int) -> int:\n        return x * multiplier\n    return inner\n```\n\n### FUNCTION: `inner`\n> Signature: `def inner(x: int) -> int`\n> Lines: 369-376\n- @param multiplier The fixed multiplier for the returned function.\n- @param x Value to multiply.\n- @return A callable that multiplies input by multiplier.\n- @return Product of x and the captured multiplier.\n```\n    def inner(x: int) -> int:\n        return x * multiplier\n```\n\n### FUNCTION: `uses_unpacking`\n> Signature: `def uses_unpacking(*args: int, **kwargs: str) -> Dict[str, Union[int, str]]`\n> Lines: 380-393\n- @param args Positional integer arguments.\n- @param kwargs Named string arguments.\n- @return Combined dictionary of all arguments.\n```\ndef uses_unpacking(*args: int, **kwargs: str) -> Dict[str, Union[int, str]]:\n    result: Dict[str, Union[int, str]] = {}\n    for i, val in enumerate(args):\n        result[f\"arg_{i}\"] = val\n    result.update(kwargs)\n    return result\n```\n\n### VARIABLE: `EVEN_SQUARES`\n> Signature: `EVEN_SQUARES = [x ** 2 for x in range(20) if x % 2 == 0]`\n> Lines: 398-398\n```\nEVEN_SQUARES = [x ** 2 for x in range(20) if x % 2 == 0]\n```\n\n### FUNCTION: `async_function`\n> Signature: `async def async_function()`\n> Lines: 401-408\n- @brief Minimal async function for testing async detection.\n```\nasync def async_function():\n    await asyncio.sleep(0)\n```\n\n### FUNCTION: `deeply_nested_logic`\n> Signature: `def deeply_nested_logic(matrix: List[List[int]]) -> int`\n> Lines: 409-429\n- @param matrix 2D list of integers.\n- @return Cumulative sum of positive even values.\n```\ndef deeply_nested_logic(matrix: List[List[int]]) -> int:\n    total = 0\n    for row in matrix:\n        for val in row:\n            if val > 0:\n                if val % 2 == 0:\n                    total += val\n                else:\n                    continue\n            else:\n                pass\n    return total\n```\n\n### FUNCTION: `exception_handling_example`\n> Signature: `def exception_handling_example(path: str) -> Optional[str]`\n> Lines: 430-453\n- @param path File path to attempt reading.\n- @return File contents or None on failure.\n```\ndef exception_handling_example(path: str) -> Optional[str]:\n    try:\n        with open(path, \"r\") as f:\n            content = f.read()\n        if not content:\n            raise ValueError(\"Empty file\")\n        return content\n    except FileNotFoundError:\n        return None\n    except (PermissionError, OSError) as e:\n        sys.exit(1)\n    except Exception:\n        raise\n    finally:\n        pass\n```\n\n### VARIABLE: `MAX_BATCH`\n> Signature: `MAX_BATCH = 64  # inline extension comment`\n> Lines: 455-455\n```\nMAX_BATCH = 64\n```\n\n### VARIABLE: `CACHE_LIMIT`\n> Signature: `CACHE_LIMIT = 128`\n> Lines: 457-457\n```\nCACHE_LIMIT = 128\n```\n\n### VARIABLE: `MAX_USERS`\n> Signature: `MAX_USERS = 500`\n> Lines: 459-459\n```\nMAX_USERS = 500\n```\n\n### FUNCTION: `req_cover_py_1`\n> Signature: `def req_cover_py_1(value: int) -> int`\n> Lines: 467-469\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\ndef req_cover_py_1(value: int) -> int:\n    return value + 1\n```\n\n### FUNCTION: `req_cover_py_2`\n> Signature: `def req_cover_py_2(value: int) -> int`\n> Lines: 475-477\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\ndef req_cover_py_2(value: int) -> int:\n    return value + 2\n```\n\n### FUNCTION: `req_cover_py_3`\n> Signature: `def req_cover_py_3(value: int) -> int`\n> Lines: 483-485\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\ndef req_cover_py_3(value: int) -> int:\n    return value + 3\n```\n\n### FUNCTION: `req_cover_py_4`\n> Signature: `def req_cover_py_4(value: int) -> int`\n> Lines: 491-493\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\ndef req_cover_py_4(value: int) -> int:\n    return value + 4\n```\n\n### FUNCTION: `req_cover_py_5`\n> Signature: `def req_cover_py_5(value: int) -> int`\n> Lines: 499-501\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\ndef req_cover_py_5(value: int) -> int:\n    return value + 5\n```\n\n@@@ <PROJECT_BASE>/src/fixture_ruby.rb | ruby\n\n### IMPORT: `'json'`\n> Lines: 10-10\n```\nrequire 'json'\n```\n\n### IMPORT: `'set'`\n> Lines: 11-11\n```\nrequire 'set'\n```\n\n### IMPORT: `'helper'`\n> Lines: 12-12\n```\nrequire_relative 'helper'\n```\n\n### DECORATOR: `:name, :age`\n> Lines: 20-20\n```\nattr_accessor :name, :age\n```\n\n### FUNCTION: `log`\n> Signature: `def log(message)`\n> Lines: 29-31\n- @brief Log a message to stdout with the class name prefix.\n- @param message [String] The message to log.\n```\ndef log(message)\nputs \"[#{self.class.name}] #{message}\"\nend\n```\n\n### FUNCTION: `log_error`\n> Signature: `def log_error(error)`\n> Lines: 35-38\n- @brief Log an error with backtrace information.\n- @param error [Exception] The exception to log.\n```\ndef log_error(error)\nputs \"[ERROR] #{error.message}\"\nputs error.backtrace.first(5).join(\"\\n\") if error.backtrace\nend\n```\n\n### CLASS: `MyClass`\n> Signature: `class MyClass`\n> Lines: 47-153\n```\nclass MyClass\ninclude Loggable\ninclude Comparable\nattr_accessor :name\nattr_reader :created_at\ndef initialize(name, **options)\n@name = name\n@options = options\n@created_at = Time.now\n@options[:retries] ||= MAX_RETRIES\nend\ndef self.create(attrs)\nnew(attrs[:name], **attrs.except(:name))\nend\ndef self.bulk_create(names)\nnames.map { |n| new(n) }\nend\ndef valid?\n!@name.nil? && !@name.empty?\nend\ndef matches?(pattern)\nreturn false if @name.nil?\npattern.match?(@name)\nend\ndef <=>(other)\n@name <=> other.name\nend\ndef +(other)\nself.class.new(\"#{@name}+#{other.name}\")\nend\ndef to_s\n\"MyClass(#{@name})\"\nend\ndef method_missing(method, *args, &block)\nif method.to_s.start_with?('find_by_')\nfield = method.to_s.sub('find_by_', '')\n\"Finding by #{field}: #{args.first}\"\nelse\nsuper\nend\nend\ndef respond_to_missing?(method, include_private = false)\nmethod.to_s.start_with?('find_by_') || super\nend\nprotected\ndef internal_config\n@options.dup\nend\nprivate\ndef validate!\nraise \"Invalid name\" unless valid?\nend\nend\n```\n\n### DECORATOR: `:name`\n> Lines: 52-52\n- @brief Read/write accessor for the instance name.\n```\nattr_accessor :name\n```\n\n### DECORATOR: `:created_at`\n> Lines: 55-55\n- @brief Read-only accessor for the creation timestamp.\n```\nattr_reader :created_at\n```\n\n### FUNCTION: `initialize`\n> Signature: `def initialize(name, **options)`\n> Lines: 60-66\n- @brief Initialize a new MyClass instance.\n- @param name [String] The instance identifier.\n- @param options [Hash] Optional configuration hash.\n```\ndef initialize(name, **options)\n@name = name\n@options = options\n@created_at = Time.now\n@options[:retries] ||= MAX_RETRIES\nend\n```\n\n### FUNCTION: `create`\n> Signature: `def self.create(attrs)`\n> Lines: 71-73\n- @brief Factory method creating an instance from a hash.\n- @param attrs [Hash] Attribute hash with :name key required.\n- @return [MyClass] A new instance populated from attrs.\n```\ndef self.create(attrs)\nnew(attrs[:name], **attrs.except(:name))\nend\n```\n\n### FUNCTION: `bulk_create`\n> Signature: `def self.bulk_create(names)`\n> Lines: 78-80\n- @brief Build multiple instances from an array of names.\n- @param names [Array<String>] Names to create instances for.\n- @return [Array<MyClass>] Array of new instances.\n```\ndef self.bulk_create(names)\nnames.map { |n| new(n) }\nend\n```\n\n### FUNCTION: `valid?`\n> Signature: `def valid?`\n> Lines: 84-86\n- @brief Predicate checking if the instance is valid.\n- @return [Boolean] True if name is non-empty.\n```\ndef valid?\n!@name.nil? && !@name.empty?\nend\n```\n\n### FUNCTION: `matches?`\n> Signature: `def matches?(pattern)`\n> Lines: 91-94\n- @brief Check if name matches a pattern.\n- @param pattern [Regexp] Regular expression to test against.\n- @return [Boolean] True if name matches the pattern.\n```\ndef matches?(pattern)\nreturn false if @name.nil?\npattern.match?(@name)\nend\n```\n\n### FUNCTION: `to_s`\n> Signature: `def to_s`\n> Lines: 112-114\n- @brief Convert to string representation.\n- @return [String] Human-readable description.\n```\ndef to_s\n\"MyClass(#{@name})\"\nend\n```\n\n### FUNCTION: `method_missing`\n> Signature: `def method_missing(method, *args, &block)`\n> Lines: 121-128\n```\ndef method_missing(method, *args, &block)\nif method.to_s.start_with?('find_by_')\nfield = method.to_s.sub('find_by_', '')\n\"Finding by #{field}: #{args.first}\"\nelse\nsuper\nend\nend\n```\n\n### FUNCTION: `respond_to_missing?`\n> Signature: `def respond_to_missing?(method, include_private = false)`\n> Lines: 134-136\n- @brief Declare which dynamic methods respond_to? should recognize.\n- @param method [Symbol] The method name to check.\n- @param include_private [Boolean] Whether to include private methods.\n- @return [Boolean] True if the method is handled dynamically.\n```\ndef respond_to_missing?(method, include_private = false)\nmethod.to_s.start_with?('find_by_') || super\nend\n```\n\n### FUNCTION: `internal_config`\n> Signature: `def internal_config`\n> Lines: 142-144\n- @brief Protected helper for internal computations.\n- @return [Hash] Current options hash.\n```\ndef internal_config\n@options.dup\nend\n```\n\n### FUNCTION: `validate!`\n> Signature: `def validate!`\n> Lines: 150-152\n```\ndef validate!\nraise \"Invalid name\" unless valid?\nend\n```\n\n### CLASS: `SpecialClass`\n> Signature: `class SpecialClass < MyClass`\n> Lines: 160-174\n- @brief Specialized subclass with additional behavior.\n- @brief Initialize with a priority level.\n- @param name [String] Instance name.\n- @param priority [Integer] Processing priority (lower = first).\n```\nclass SpecialClass < MyClass\ndef initialize(name, priority: 0, **options)\nsuper(name, **options)\n@priority = priority\nend\ndef to_s\n\"SpecialClass(#{@name}, pri=#{@priority})\"\nend\nend\n```\n\n### FUNCTION: `initialize`\n> Signature: `def initialize(name, priority: 0, **options)`\n> Lines: 164-167\n- @brief Initialize with a priority level.\n- @param name [String] Instance name.\n- @param priority [Integer] Processing priority (lower = first).\n```\ndef initialize(name, priority: 0, **options)\nsuper(name, **options)\n@priority = priority\nend\n```\n\n### FUNCTION: `to_s`\n> Signature: `def to_s`\n> Lines: 171-173\n- @brief Override to_s with priority information.\n- @return [String] Description including priority.\n```\ndef to_s\n\"SpecialClass(#{@name}, pri=#{@priority})\"\nend\n```\n\n### FUNCTION: `helper`\n> Signature: `def helper`\n> Lines: 183-185\n- @brief Module-level helper returning a boolean.\n- @return [Boolean] Always returns true.\n```\ndef helper\ntrue\nend\n```\n\n### FUNCTION: `process_with_block`\n> Signature: `def process_with_block(data)`\n> Lines: 191-197\n- @brief Process data with block yield pattern.\n- @param data [Object] Data to process.\n@yield [Object] Yields data for caller-defined processing.\n- @return [Object] The block's return value or data itself.\n```\ndef process_with_block(data)\nif block_given?\nyield(data)\nelse\ndata\nend\nend\n```\n\n### FUNCTION: `format_list`\n> Signature: `def self.format_list(items)`\n> Lines: 204-206\n- @brief Utility function accessible without mixing in.\n- @param items [Array] Items to format.\n- @return [String] Comma-separated formatted string.\n```\ndef self.format_list(items)\nitems.map(&:to_s).join(', ')\nend\n```\n\n### FUNCTION: `distance_from_origin`\n> Signature: `def distance_from_origin`\n> Lines: 216-218\n- @brief Compute the Euclidean distance from origin.\n- @return [Float] Distance from (0, 0).\n```\ndef distance_from_origin\nMath.sqrt(x**2 + y**2)\nend\n```\n\n### CLASS: `DynamicModel`\n> Signature: `class DynamicModel`\n> Lines: 225-238\n- @brief Demonstrates metaprogramming with define_method.\n- @brief Dynamically defined getter for #{field}.\n```\nclass DynamicModel\n%w[title body author].each do |field|\ndefine_method(field) do\ninstance_variable_get(\"@#{field}\")\nend\ndefine_method(\"#{field}=\") do |value|\ninstance_variable_set(\"@#{field}\", value)\nend\nend\nend\n```\n\n### FUNCTION: `with_retry`\n> Signature: `def with_retry(attempts: MAX_RETRIES)`\n> Lines: 255-268\n```\ndef with_retry(attempts: MAX_RETRIES)\ntries = 0\nbegin\ntries += 1\nyield\nrescue StandardError => e\nretry if tries < attempts\nraise \"Failed after #{attempts} attempts: #{e.message}\"\nensure\nputs \"Completed after #{tries} attempt(s)\"\nend\nend\n```\n\n### FUNCTION: `email?`\n> Signature: `def email?`\n> Lines: 278-280\n- @brief Check if the string is a valid email address.\n- @return [Boolean] True if string matches email pattern.\n```\ndef email?\nmatch?(/\\A[\\w+\\-.]+@[a-z\\d\\-]+(\\.[a-z\\d\\-]+)*\\.[a-z]+\\z/i)\nend\n```\n\n### CLASS: `ServiceObject`\n> Signature: `class ServiceObject; end # inline class comment`\n> Lines: 287-307\n```\nclass ServiceObject; end\nclass ReportBuilder; end\nmodule Metrics; end\nmodule Extras; end\nMAX_LIMIT = 100\nAPI_VERSION = \"v2\"\nCACHE_SIZE = 1024\nattr_writer :token\nattr_reader :state\nrequire 'yaml'\nrequire 'logger'\ndef req_cover_ruby_1(value)\nvalue + 1\nend\n```\n\n### CLASS: `ReportBuilder`\n> Signature: `class ReportBuilder; end`\n> Lines: 288-307\n```\nclass ReportBuilder; end\nmodule Metrics; end\nmodule Extras; end\nMAX_LIMIT = 100\nAPI_VERSION = \"v2\"\nCACHE_SIZE = 1024\nattr_writer :token\nattr_reader :state\nrequire 'yaml'\nrequire 'logger'\ndef req_cover_ruby_1(value)\nvalue + 1\nend\n```\n\n### DECORATOR: `:token`\n> Lines: 294-294\n```\nattr_writer :token\n```\n\n### DECORATOR: `:state`\n> Lines: 295-295\n```\nattr_reader :state\n```\n\n### IMPORT: `'yaml'`\n> Lines: 296-296\n```\nrequire 'yaml'\n```\n\n### IMPORT: `'logger'`\n> Lines: 297-297\n```\nrequire 'logger'\n```\n\n### FUNCTION: `req_cover_ruby_1`\n> Signature: `def req_cover_ruby_1(value)`\n> Lines: 305-307\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\ndef req_cover_ruby_1(value)\nvalue + 1\nend\n```\n\n### FUNCTION: `req_cover_ruby_2`\n> Signature: `def req_cover_ruby_2(value)`\n> Lines: 314-316\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\ndef req_cover_ruby_2(value)\nvalue + 2\nend\n```\n\n### FUNCTION: `req_cover_ruby_3`\n> Signature: `def req_cover_ruby_3(value)`\n> Lines: 323-325\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\ndef req_cover_ruby_3(value)\nvalue + 3\nend\n```\n\n### FUNCTION: `req_cover_ruby_4`\n> Signature: `def req_cover_ruby_4(value)`\n> Lines: 332-334\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\ndef req_cover_ruby_4(value)\nvalue + 4\nend\n```\n\n### FUNCTION: `req_cover_ruby_5`\n> Signature: `def req_cover_ruby_5(value)`\n> Lines: 341-343\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\ndef req_cover_ruby_5(value)\nvalue + 5\nend\n```\n\n@@@ <PROJECT_BASE>/src/fixture_rust.rs | rust\n\n### IMPORT: `std::io`\n> Lines: 9-9\n```\nuse std::io;\n```\n\n### IMPORT: `std::collections::HashMap`\n> Lines: 10-10\n```\nuse std::collections::HashMap;\n```\n\n### IMPORT: `std::fmt::{self, Display, Formatter}`\n> Lines: 11-11\n```\nuse std::fmt::{self, Display, Formatter};\n```\n\n### IMPORT: `std::sync::{Arc, Mutex}`\n> Lines: 12-12\n```\nuse std::sync::{Arc, Mutex};\n```\n\n### DECORATOR: `derive(Debug, Clone, PartialEq)`\n> Lines: 19-19\n- @brief Holds a single i32 field with Debug/Clone derives.\n```\n#[derive(Debug, Clone, PartialEq)]\n```\n\n### DECORATOR: `derive(Debug)`\n> Lines: 29-29\n```\n#[derive(Debug)]\n```\n\n### FUNCTION: `do_work`\n> Signature: `fn do_work(&self)`\n> Lines: 67-78\n```\nfn do_work(&self);\nfn do_work_with_ctx(&self, ctx: &str) -> bool {\nprintln!(\"ctx: {}\", ctx);\nself.do_work();\ntrue\n}\n```\n\n### FUNCTION: `do_work_with_ctx`\n> Signature: `fn do_work_with_ctx(&self, ctx: &str) -> bool`\n> Lines: 73-78\n- @param ctx Contextual string passed to the implementation.\n- @return True if work completed successfully.\n```\nfn do_work_with_ctx(&self, ctx: &str) -> bool {\nprintln!(\"ctx: {}\", ctx);\nself.do_work();\ntrue\n}\n```\n\n### FUNCTION: `parse`\n> Signature: `fn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>`\n> Lines: 93-96\n- @param input Byte slice to parse.\n- @return Parsed output or an IO error.\n```\nfn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>;\n}\nimpl MyStruct {\n```\n\n### FUNCTION: `new`\n> Signature: `fn new() -> Self`\n> Lines: 100-102\n- @return A MyStruct with field initialized to 0.\n```\nfn new() -> Self {\nSelf { field: 0 }\n}\n```\n\n### FUNCTION: `with_value`\n> Signature: `pub fn with_value(val: i32) -> Self`\n> Lines: 108-110\n- @param val The initial field value.\n- @return A new MyStruct.\n```\npub fn with_value(val: i32) -> Self {\nSelf { field: val }\n}\n```\n\n### FUNCTION: `value`\n> Signature: `pub fn value(&self) -> i32`\n> Lines: 115-117\n- @return The stored integer.\n```\npub fn value(&self) -> i32 {\nself.field\n}\n```\n\n### FUNCTION: `try_update`\n> Signature: `pub fn try_update(&mut self, new_val: i32) -> Option<i32>`\n> Lines: 123-131\n- @param new_val New value to set.\n- @return Old value if updated, None if new_val equals current.\n```\npub fn try_update(&mut self, new_val: i32) -> Option<i32> {\nif new_val == self.field {\nreturn None;\n}\nlet old = self.field;\nself.field = new_val;\nSome(old)\n}\n```\n\n### FUNCTION: `do_work`\n> Signature: `fn do_work(&self)`\n> Lines: 136-138\n```\nfn do_work(&self) {\nprintln!(\"{:?}\", self);\n}\n```\n\n### FUNCTION: `fmt`\n> Signature: `fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result`\n> Lines: 146-148\n- @param f Formatter to write into.\n- @return fmt::Result indicating success or failure.\n```\nfn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\nwrite!(f, \"MyStruct({})\", self.field)\n}\n```\n\n### FUNCTION: `insert`\n> Signature: `pub fn insert(&mut self, key: K, value: V) -> Option<V>`\n> Lines: 163-165\n- @param key The lookup key.\n- @param value The value to associate with the key.\n- @return Previous value for this key, or None.\n```\npub fn insert(&mut self, key: K, value: V) -> Option<V> {\nself.inner.insert(key, value)\n}\n```\n\n### FUNCTION: `get_or_default`\n> Signature: `pub fn get_or_default(&self, key: &K) -> V`\n> Lines: 171-176\n- @param key The key to look up.\n- @return Cloned value if found, or the default for V.\n```\npub fn get_or_default(&self, key: &K) -> V {\nmatch self.inner.get(key) {\nSome(v) => v.clone(),\nNone => V::default(),\n}\n}\n```\n\n### FUNCTION: `my_function`\n> Signature: `pub fn my_function(input: Option<&str>) -> String`\n> Lines: 240-249\n- @param input Optional string to evaluate.\n- @return Processed string or a fallback default.\n```\npub fn my_function(input: Option<&str>) -> String {\nlet text = match input {\nSome(s) if !s.is_empty() => s,\nSome(_) => return String::from(\"empty\"),\nNone => return String::from(\"none\"),\n};\ntext.to_uppercase()\n}\n```\n\n### FUNCTION: `async_function`\n> Signature: `pub async fn async_function() -> String`\n> Lines: 254-257\n- @return A greeting string after async computation.\n```\npub async fn async_function() -> String {\nString::from(\"hello async\")\n}\n```\n\n### FUNCTION: `filter_with`\n> Signature: `pub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>`\n> Lines: 264-269\n- @param items Slice of integers to filter.\n- @param predicate Closure returning true for items to keep.\n- @return Vector of items passing the predicate.\n```\npub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>\nwhere\nF: Fn(&i32) -> bool,\n{\nitems.iter().copied().filter(|x| predicate(x)).collect()\n}\n```\n\n### FUNCTION: `create_worker`\n> Signature: `pub fn create_worker(use_struct: bool) -> Box<dyn MyTrait>`\n> Lines: 275-281\n- @param use_struct If true, returns MyStruct; otherwise panics.\n- @return A heap-allocated trait object implementing MyTrait.\n```\npub fn create_worker(use_struct: bool) -> Box<dyn MyTrait> {\nif use_struct {\nBox::new(MyStruct::new())\n} else {\npanic!(\"No alternative implementation available\");\n}\n}\n```\n\n### FUNCTION: `read_raw`\n> Signature: `pub unsafe fn read_raw(ptr: *const i32) -> i32`\n> Lines: 288-291\n- @param ptr Raw pointer to an i32 value.\n- @return The value pointed to by ptr.\n- @sa fety Caller must ensure ptr is valid and aligned.\n```\npub unsafe fn read_raw(ptr: *const i32) -> i32 {\n*ptr\n}\n```\n\n### FUNCTION: `ffi_double`\n> Signature: `pub extern \"C\" fn ffi_double(x: i32) -> i32`\n> Lines: 297-299\n- @param x Integer to double.\n- @return The input multiplied by 2.\n```\npub extern \"C\" fn ffi_double(x: i32) -> i32 {\nx * 2\n}\n```\n\n### FUNCTION: `describe_enum`\n> Signature: `pub fn describe_enum(val: &MyEnum) -> String`\n> Lines: 305-315\n- @param val An enum variant to match against.\n- @return A description string for the matched variant.\n```\npub fn describe_enum(val: &MyEnum) -> String {\nmatch val {\nMyEnum::A => String::from(\"unit\"),\nMyEnum::B(s) => format!(\"string: {}\", s),\nMyEnum::C { x, y } => {\nlet mag = ((x * x + y * y) as f64).sqrt();\nformat!(\"point({}, {}) mag={:.2}\", x, y, mag)\n}\n}\n}\n```\n\n### IMPORT: `std::time::Duration`\n> Lines: 318-318\n```\nuse std::time::Duration;\n```\n\n### DECORATOR: `inline`\n> Lines: 322-322\n```\n#[inline]\n```\n\n### DECORATOR: `allow(dead_code)`\n> Lines: 323-323\n```\n#[allow(dead_code)]\n```\n\n### DECORATOR: `cfg(test)`\n> Lines: 324-324\n```\n#[cfg(test)]\n```\n\n### FUNCTION: `req_cover_rust_1`\n> Signature: `fn req_cover_rust_1(value: i32) -> i32 { value + 1 }`\n> Lines: 350-350\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfn req_cover_rust_1(value: i32) -> i32 { value + 1 }\n```\n\n### FUNCTION: `req_cover_rust_2`\n> Signature: `fn req_cover_rust_2(value: i32) -> i32 { value + 2 }`\n> Lines: 357-357\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfn req_cover_rust_2(value: i32) -> i32 { value + 2 }\n```\n\n### FUNCTION: `req_cover_rust_3`\n> Signature: `fn req_cover_rust_3(value: i32) -> i32 { value + 3 }`\n> Lines: 364-364\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfn req_cover_rust_3(value: i32) -> i32 { value + 3 }\n```\n\n### FUNCTION: `req_cover_rust_4`\n> Signature: `fn req_cover_rust_4(value: i32) -> i32 { value + 4 }`\n> Lines: 371-371\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfn req_cover_rust_4(value: i32) -> i32 { value + 4 }\n```\n\n### FUNCTION: `req_cover_rust_5`\n> Signature: `fn req_cover_rust_5(value: i32) -> i32 { value + 5 }`\n> Lines: 378-378\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfn req_cover_rust_5(value: i32) -> i32 { value + 5 }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_scala.scala | scala\n- @brief Comprehensive Scala test fixture for parser validation.\n- @details Covers implicits/givens, pattern matching, higher-kinded types,\nself-types, variance, opaque types, extension methods, enums,\nfor comprehensions, and cake pattern.\n\n### IMPORT: `scala.collection.mutable`\n> Lines: 11-11\n```\nimport scala.collection.mutable\n```\n\n### IMPORT: `scala.concurrent.{Future, ExecutionContext}`\n> Lines: 12-12\n```\nimport scala.concurrent.{Future, ExecutionContext}\n```\n\n### IMPORT: `scala.util.{Try, Success, Failure}`\n> Lines: 13-13\n```\nimport scala.util.{Try, Success, Failure}\n```\n\n### CLASS: `Person`\n> Signature: `case class Person(name: String, age: Int)`\n> Lines: 23-35\n- @brief Immutable data class for person entities.\n- @brief Check if the person is an adult.\n- @param name Display name.\n- @param age Age in years; must be non-negative.\n- @return True if age >= 18.\n```\ncase class Person(name: String, age: Int) {\ndef isAdult: Boolean = age >= 18\ndef greet: String = s\"Hi, I'm $name, age $age\"\n}\n```\n\n### FUNCTION: `isAdult`\n> Signature: `def isAdult: Boolean = age >= 18`\n> Lines: 28-43\n- @brief Check if the person is an adult.\n- @brief Create a greeting string.\n- @return True if age >= 18.\n- @return Formatted greeting including name and age.\n```\ndef isAdult: Boolean = age >= 18\ndef greet: String = s\"Hi, I'm $name, age $age\"\n}\nsealed trait Shape {\n```\n\n### FUNCTION: `greet`\n> Signature: `def greet: String = s\"Hi, I'm $name, age $age\"`\n> Lines: 34-43\n- @brief Create a greeting string.\n- @return Formatted greeting including name and age.\n```\ndef greet: String = s\"Hi, I'm $name, age $age\"\n}\nsealed trait Shape {\n```\n\n### FUNCTION: `area`\n> Signature: `def area: Double`\n> Lines: 48-56\n- @brief Compute the area of this shape.\n- @brief Circle shape with radius.\n- @param radius The circle's radius.\n- @return Area as a Double.\n```\ndef area: Double\n}\ncase class Circle(radius: Double) extends Shape {\n```\n\n### CLASS: `Circle`\n> Signature: `case class Circle(radius: Double) extends Shape`\n> Lines: 56-58\n- @brief Circle shape with radius.\n- @param radius The circle's radius.\n```\ncase class Circle(radius: Double) extends Shape {\noverride def area: Double = math.Pi * radius * radius\n}\n```\n\n### FUNCTION: `area`\n> Signature: `override def area: Double = math.Pi * radius * radius`\n> Lines: 57-66\n- @brief Rectangle shape with width and height.\n- @param width The rectangle's width.\n- @param height The rectangle's height.\n```\noverride def area: Double = math.Pi * radius * radius\n}\ncase class Rectangle(width: Double, height: Double) extends Shape {\n```\n\n### CLASS: `Rectangle`\n> Signature: `case class Rectangle(width: Double, height: Double) extends Shape`\n> Lines: 66-68\n- @brief Rectangle shape with width and height.\n- @param width The rectangle's width.\n- @param height The rectangle's height.\n```\ncase class Rectangle(width: Double, height: Double) extends Shape {\noverride def area: Double = width * height\n}\n```\n\n### FUNCTION: `area`\n> Signature: `override def area: Double = width * height`\n> Lines: 67-76\n```\noverride def area: Double = width * height\n}\nabstract class Animal {\n```\n\n### CLASS: `Animal`\n> Signature: `abstract class Animal`\n> Lines: 76-88\n- @brief Abstract base class for animals with sound production.\n- @brief The sound this animal makes.\n- @return Sound description string.\n```\nabstract class Animal {\ndef sound: String\ndef describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n}\n```\n\n### FUNCTION: `sound`\n> Signature: `def sound: String`\n> Lines: 81-87\n- @brief The sound this animal makes.\n- @brief Describe the animal including its sound.\n- @return Sound description string.\n- @return Formatted description string.\n```\ndef sound: String\ndef describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n```\n\n### FUNCTION: `describe`\n> Signature: `def describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"`\n> Lines: 87-87\n- @brief Describe the animal including its sound.\n- @return Formatted description string.\n```\ndef describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n```\n\n### FUNCTION: `draw`\n> Signature: `def draw(): Unit`\n> Lines: 101-109\n- @brief Draw the object as a string.\n- @brief Self-type trait requiring Drawable to be mixed in.\n- @details Demonstrates the cake pattern for dependency injection.\n- @return Rendered string representation.\n```\ndef draw(): Unit\n}\ntrait Logging { self: Drawable =>\n```\n\n### FUNCTION: `logAndDraw`\n> Signature: `def logAndDraw(): Unit =`\n> Lines: 113-116\n- @brief Log the drawing operation and then draw.\n```\ndef logAndDraw(): Unit = {\nprintln(\"About to draw\")\ndraw()\n}\n```\n\n### FUNCTION: `serialize`\n> Signature: `def serialize: Array[Byte]`\n> Lines: 128-137\n- @brief Serialize this object to bytes.\n- @return Byte array representation.\n```\ndef serialize: Array[Byte]\n}\nobject Main {\n```\n\n### FUNCTION: `main`\n> Signature: `def main(args: Array[String]): Unit =`\n> Lines: 142-147\n- @brief Application entry point.\n- @param args Command-line arguments.\n```\ndef main(args: Array[String]): Unit = {\nval people = List(Person(\"Alice\", 30), Person(\"Bob\", 17))\nval adults = people.filter(_.isAdult)\nadults.foreach(p => println(p.greet))\n}\n```\n\n### FUNCTION: `toString`\n> Signature: `override def toString: String = \"Main\"`\n> Lines: 153-179\n- @brief Override toString for Main object display.\n- @brief Mathematical constant pi.\n- @return String representation.\n```\noverride def toString: String = \"Main\"\nval pi = 3.14159265\nvar counter = 0\ntype StringList = List[String]\ntype Transformer[A] = A => A\ndef describeShape(shape: Shape): String = shape match {\ncase Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\ncase Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n}\n```\n\n### VARIABLE: `counter`\n> Signature: `var counter = 0`\n> Lines: 159-159\n- @brief Mutable counter for tracking operations. */\n```\nvar counter = 0\n```\n\n### FUNCTION: `describeShape`\n> Signature: `def describeShape(shape: Shape): String = shape match`\n> Lines: 176-179\n- @brief Describe a shape using exhaustive pattern matching.\n- @param shape The shape to describe.\n- @return Human-readable description with area.\n```\ndef describeShape(shape: Shape): String = shape match {\ncase Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\ncase Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n}\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(x: Int): String = x match`\n> Lines: 186-191\n- @brief Process a value with multiple match guards.\n- @param x Integer input to classify.\n- @return Classification string.\n```\ndef classify(x: Int): String = x match {\ncase 0 => \"zero\"\ncase n if n < 0 => \"negative\"\ncase n if n > 100 => \"large\"\ncase _ => \"positive\"\n}\n```\n\n### CLASS: `Config`\n> Signature: `class Config private (val entries: Map[String, String])`\n> Lines: 201-208\n- @brief Configuration holder with companion factory.\n- @brief Retrieve a value by key.\n- @param entries Key-value pairs.\n- @param key The configuration key.\n- @return Optional value.\n```\nclass Config private (val entries: Map[String, String]) {\ndef get(key: String): Option[String] = entries.get(key)\n}\n```\n\n### FUNCTION: `get`\n> Signature: `def get(key: String): Option[String] = entries.get(key)`\n> Lines: 207-214\n- @brief Retrieve a value by key.\n- @brief Companion object with factory methods for Config.\n- @param key The configuration key.\n- @return Optional value.\n```\ndef get(key: String): Option[String] = entries.get(key)\n}\nobject Config {\n```\n\n### FUNCTION: `apply`\n> Signature: `def apply(entries: (String, String)*): Config = new Config(entries.toMap)`\n> Lines: 220-236\n- @brief Create a Config from key-value pairs.\n- @brief Create an empty Config.\n- @param entries Variable number of key-value tuples.\n- @return A new Config instance.\n- @return Config with no entries.\n```\ndef apply(entries: (String, String)*): Config = new Config(entries.toMap)\ndef empty: Config = new Config(Map.empty)\n}\nclass Container[+A](val value: A) {\n```\n\n### FUNCTION: `empty`\n> Signature: `def empty: Config = new Config(Map.empty)`\n> Lines: 226-236\n- @brief Create an empty Config.\n- @return Config with no entries.\n```\ndef empty: Config = new Config(Map.empty)\n}\nclass Container[+A](val value: A) {\n```\n\n### CLASS: `Container`\n> Signature: `class Container[+A](val value: A)`\n> Lines: 236-252\n- @brief Covariant generic container.\n@tparam +A Element type (covariant).\n- @brief Map the contained value. @tparam B Target type.\n- @param f Transform function.\n- @return New Container with transformed value.\n```\nclass Container[+A](val value: A) {\ndef map[B](f: A => B): Container[B] = new Container(f(value))\ndef flatMap[B](f: A => Container[B]): Container[B] = f(value)\n}\n```\n\n### FUNCTION: `map`\n> Signature: `def map[B](f: A => B): Container[B] = new Container(f(value))`\n> Lines: 243-261\n- @brief Map the contained value.\n@tparam B Target type.\n- @brief Flat-map the contained value. @tparam B Target type.\n- @param f Transform function.\n- @param f Transform function returning a Container.\n- @return New Container with transformed value.\n- @return Flattened Container.\n```\ndef map[B](f: A => B): Container[B] = new Container(f(value))\ndef flatMap[B](f: A => Container[B]): Container[B] = f(value)\n}\nimplicit class RichInt(val n: Int) extends AnyVal {\n```\n\n### FUNCTION: `flatMap`\n> Signature: `def flatMap[B](f: A => Container[B]): Container[B] = f(value)`\n> Lines: 251-261\n- @brief Flat-map the contained value.\n@tparam B Target type.\n- @param f Transform function returning a Container.\n- @return Flattened Container.\n```\ndef flatMap[B](f: A => Container[B]): Container[B] = f(value)\n}\nimplicit class RichInt(val n: Int) extends AnyVal {\n```\n\n### FUNCTION: `isEven`\n> Signature: `def isEven: Boolean = n % 2 == 0`\n> Lines: 266-282\n- @brief Check if the number is even.\n- @brief Repeat a string n times.\n- @param s The string to repeat.\n- @return True if n is divisible by 2.\n- @return Concatenated result.\n```\ndef isEven: Boolean = n % 2 == 0\ndef times(s: String): String = s * n\n}\nobject ForCompExample {\n```\n\n### FUNCTION: `times`\n> Signature: `def times(s: String): String = s * n`\n> Lines: 273-282\n- @brief Repeat a string n times.\n- @param s The string to repeat.\n- @return Concatenated result.\n```\ndef times(s: String): String = s * n\n}\nobject ForCompExample {\n```\n\n### FUNCTION: `findPairs`\n> Signature: `def findPairs(range: Int, target: Int): List[(Int, Int)] =`\n> Lines: 289-295\n- @brief Compute all pairs of integers whose sum equals target.\n- @param range Upper bound of the search space.\n- @param target Desired sum.\n- @return List of pairs summing to target.\n```\ndef findPairs(range: Int, target: Int): List[(Int, Int)] = {\nfor {\nx <- (1 to range).toList\ny <- (x to range).toList\nif x + y == target\n} yield (x, y)\n}\n```\n\n### FUNCTION: `add`\n> Signature: `def add(a: Int)(b: Int): Int = a + b`\n> Lines: 311-351\n- @brief Curried addition function.\n- @brief Apply a function twice to an initial value. @tparam A Value type.\n- @param a First operand.\n- @param b Second operand.\n- @param f Function to apply.\n- @param x Initial value.\n- @return Sum of a and b.\n- @return Result of f(f(x)).\n```\ndef add(a: Int)(b: Int): Int = a + b\ndef twice[A](f: A => A)(x: A): A = f(f(x))\ndef compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n}\nimport scala.util.Random\nimport scala.concurrent.duration._\ntrait Runner\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\n```\n\n### FUNCTION: `twice`\n> Signature: `def twice[A](f: A => A)(x: A): A = f(f(x))`\n> Lines: 320-351\n- @brief Apply a function twice to an initial value.\n@tparam A Value type.\n- @brief Compose two functions left to right. @tparam A Input type. @tparam B Intermediate type. @tparam C Output type.\n- @param f Function to apply.\n- @param x Initial value.\n- @param f First function.\n- @param g Second function.\n- @return Result of f(f(x)).\n- @return Composed function.\n```\ndef twice[A](f: A => A)(x: A): A = f(f(x))\ndef compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n}\nimport scala.util.Random\nimport scala.concurrent.duration._\ntrait Runner\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\n```\n\n### FUNCTION: `compose`\n> Signature: `def compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))`\n> Lines: 331-351\n- @brief Compose two functions left to right.\n@tparam A Input type.\n@tparam B Intermediate type.\n@tparam C Output type.\n- @param f First function.\n- @param g Second function.\n- @return Composed function.\n```\ndef compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n}\nimport scala.util.Random\nimport scala.concurrent.duration._\ntrait Runner\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\n```\n\n### IMPORT: `scala.util.Random`\n> Lines: 335-335\n```\nimport scala.util.Random\n```\n\n### IMPORT: `scala.concurrent.duration._`\n> Lines: 336-336\n```\nimport scala.concurrent.duration._\n```\n\n### VARIABLE: `attempts`\n> Signature: `var attempts = 0`\n> Lines: 345-345\n```\nvar attempts = 0\n```\n\n### VARIABLE: `cursor`\n> Signature: `var cursor = 1`\n> Lines: 346-346\n```\nvar cursor = 1\n```\n\n### VARIABLE: `stage`\n> Signature: `var stage = \"init\"`\n> Lines: 347-347\n```\nvar stage = \"init\"\n```\n\n### VARIABLE: `status`\n> Signature: `var status = \"ready\"`\n> Lines: 348-348\n```\nvar status = \"ready\"\n```\n\n### FUNCTION: `reqCoverScala1`\n> Signature: `def reqCoverScala1(value: Int): Int = value + 1`\n> Lines: 359-359\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\ndef reqCoverScala1(value: Int): Int = value + 1\n```\n\n### FUNCTION: `reqCoverScala2`\n> Signature: `def reqCoverScala2(value: Int): Int = value + 2`\n> Lines: 368-368\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\ndef reqCoverScala2(value: Int): Int = value + 2\n```\n\n### FUNCTION: `reqCoverScala3`\n> Signature: `def reqCoverScala3(value: Int): Int = value + 3`\n> Lines: 377-377\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\ndef reqCoverScala3(value: Int): Int = value + 3\n```\n\n### FUNCTION: `reqCoverScala4`\n> Signature: `def reqCoverScala4(value: Int): Int = value + 4`\n> Lines: 386-386\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\ndef reqCoverScala4(value: Int): Int = value + 4\n```\n\n### FUNCTION: `reqCoverScala5`\n> Signature: `def reqCoverScala5(value: Int): Int = value + 5`\n> Lines: 395-395\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\ndef reqCoverScala5(value: Int): Int = value + 5\n```\n\n@@@ <PROJECT_BASE>/src/fixture_shell.sh | shell\n\n### VARIABLE: `MY_VAR`\n> Signature: `MY_VAR=\"hello\"`\n> Lines: 12-12\n- @brief Greeting message template.\n```\nMY_VAR=\"hello\"\n```\n\n### VARIABLE: `PATH_EXT`\n> Signature: `export PATH_EXT=\"/usr/local/bin\"`\n> Lines: 15-15\n- @brief Extended PATH including local binary directory.\n```\nexport PATH_EXT=\"/usr/local/bin\"\n```\n\n### VARIABLE: `MAX_COUNT`\n> Signature: `readonly MAX_COUNT=10`\n> Lines: 18-18\n- @brief Immutable maximum iteration counter.\n```\nreadonly MAX_COUNT=10\n```\n\n### VARIABLE: `BUILD_VERSION`\n> Signature: `declare -r BUILD_VERSION=\"1.0.0\"`\n> Lines: 21-21\n- @brief Build version set via declare.\n```\ndeclare -r BUILD_VERSION=\"1.0.0\"\n```\n\n### VARIABLE: `DEBUG_MODE`\n> Signature: `DEBUG_MODE=0`\n> Lines: 24-24\n- @brief Debug mode flag (0=off, 1=on).\n```\nDEBUG_MODE=0\n```\n\n### VARIABLE: `LANGUAGES`\n> Signature: `declare -a LANGUAGES=(\"python\" \"rust\" \"go\" \"java\" \"typescript\")`\n> Lines: 29-29\n- @brief Indexed array of supported languages.\n```\ndeclare -a LANGUAGES=(\"python\" \"rust\" \"go\" \"java\" \"typescript\")\n```\n\n### VARIABLE: `EXT_MAP`\n> Signature: `declare -A EXT_MAP=(`\n> Lines: 32-32\n- @brief Associative array mapping extensions to languages.\n```\ndeclare -A EXT_MAP=(\n```\n\n### FUNCTION: `greet`\n> Signature: `function greet()`\n> Lines: 44-44\n- @brief Greet a user by name on stdout.\n- @param $1 The user's name.\n```\nfunction greet() {\n```\n\n### FUNCTION: `cleanup`\n> Signature: `cleanup()`\n> Lines: 56-56\n- @brief Remove temporary files and directories.\n- @details Called by trap on EXIT for cleanup.\n```\ncleanup() {\n```\n\n### FUNCTION: `parse_args`\n> Signature: `parse_args()`\n> Lines: 68-68\n- @brief Parse command-line options using getopts.\n- @param $@ Command-line arguments.\n- @return Sets global variables based on parsed options.\n```\nparse_args() {\n```\n\n### VARIABLE: `VERBOSE`\n> Signature: `VERBOSE=1`\n> Lines: 74-74\n```\nVERBOSE=1\n```\n\n### VARIABLE: `DEBUG_MODE`\n> Signature: `DEBUG_MODE=1`\n> Lines: 78-78\n```\nDEBUG_MODE=1\n```\n\n### VARIABLE: `INPUT_FILE`\n> Signature: `INPUT_FILE=\"$OPTARG\"`\n> Lines: 82-82\n```\nINPUT_FILE=\"$OPTARG\"\n```\n\n### VARIABLE: `OUTPUT_FILE`\n> Signature: `OUTPUT_FILE=\"$OPTARG\"`\n> Lines: 86-86\n```\nOUTPUT_FILE=\"$OPTARG\"\n```\n\n### FUNCTION: `process_file`\n> Signature: `process_file()`\n> Lines: 105-105\n- @brief Process a file with error handling and logging.\n- @param $1 Path to the input file.\n- @param $2 Optional output path (defaults to stdout).\n- @return 0 on success, 1 on failure.\n```\nprocess_file() {\n```\n\n### FUNCTION: `retry_command`\n> Signature: `retry_command()`\n> Lines: 139-139\n- @brief Execute a command with retry logic.\n- @param $1 Maximum number of retry attempts.\n- @param $@ The command and arguments to execute.\n- @return Exit code of the final attempt.\n```\nretry_command() {\n```\n\n### FUNCTION: `log_message`\n> Signature: `log_message()`\n> Lines: 162-162\n- @brief Log a message with timestamp prefix.\n- @param $1 Log level (INFO, WARN, ERROR).\n- @param $@ Message text.\n```\nlog_message() {\n```\n\n### FUNCTION: `make_temp`\n> Signature: `make_temp()`\n> Lines: 172-172\n- @brief Generate a temporary file and return its path.\n- @return Path to the created temporary file.\n```\nmake_temp() {\n```\n\n### FUNCTION: `generate_config`\n> Signature: `generate_config()`\n> Lines: 189-189\n- @brief Generate a configuration file using heredoc.\n```\ngenerate_config() {\n```\n\n### FUNCTION: `factorial`\n> Signature: `factorial()`\n> Lines: 203-203\n- @brief Compute factorial iteratively.\n- @param $1 Non-negative integer.\n- @return Factorial result.\n```\nfactorial() {\n```\n\n### IMPORT: `./config.sh`\n> Lines: 218-218\n- @brief Load external configuration script if present.\n```\nsource ./config.sh\n```\n\n### IMPORT: `./env.sh`\n> Lines: 222-222\n```\nsource ./env.sh\n```\n\n### IMPORT: `./shared.sh`\n> Lines: 224-224\n```\nsource ./shared.sh\n```\n\n### IMPORT: `./runtime.sh`\n> Lines: 226-226\n```\nsource ./runtime.sh\n```\n\n### IMPORT: `./network.sh`\n> Lines: 228-228\n```\nsource ./network.sh\n```\n\n### FUNCTION: `req_cover_shell_1`\n> Signature: `req_cover_shell_1()`\n> Lines: 236-236\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nreq_cover_shell_1() {\n```\n\n### FUNCTION: `req_cover_shell_2`\n> Signature: `req_cover_shell_2()`\n> Lines: 245-245\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nreq_cover_shell_2() {\n```\n\n### FUNCTION: `req_cover_shell_3`\n> Signature: `req_cover_shell_3()`\n> Lines: 254-254\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nreq_cover_shell_3() {\n```\n\n### FUNCTION: `req_cover_shell_4`\n> Signature: `req_cover_shell_4()`\n> Lines: 263-263\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nreq_cover_shell_4() {\n```\n\n### FUNCTION: `req_cover_shell_5`\n> Signature: `req_cover_shell_5()`\n> Lines: 272-272\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nreq_cover_shell_5() {\n```\n\n@@@ <PROJECT_BASE>/src/fixture_swift.swift | swift\n\n### IMPORT: `Foundation`\n> Lines: 8-8\n```\nimport Foundation\n```\n\n### IMPORT: `Combine`\n> Lines: 9-9\n```\nimport Combine\n```\n\n### CLASS: `Animal`\n> Signature: `class Animal`\n> Lines: 16-58\n- @brief Base class with stored, computed, and observed properties.\n- @brief Species name identifier.\n```\nclass Animal {\nvar species: String\nvar legs: Int = 4 {\nwillSet {\nprint(\"Legs changing from \\(legs) to \\(newValue)\")\n}\ndidSet {\nif legs < 0 { legs = 0 }\n}\n}\nvar description: String {\nreturn \"\\(species) with \\(legs) legs\"\n}\ninit(species: String) {\nself.species = species\n}\nfunc speak() {\nprint(\"...\")\n}\nclass func createDefault() -> Animal {\nreturn Animal(species: \"Unknown\")\n}\ndeinit {\nprint(\"\\(species) deallocated\")\n}\n}\n```\n\n### VARIABLE: `species`\n> Signature: `var species: String`\n> Lines: 18-18\n- @brief Species name identifier.\n```\nvar species: String\n```\n\n### VARIABLE: `legs`\n> Signature: `var legs: Int = 4`\n> Lines: 21-21\n- @brief Number of legs; triggers a didSet observer on change.\n```\nvar legs: Int = 4 {\n```\n\n### VARIABLE: `description`\n> Signature: `var description: String`\n> Lines: 33-33\n- @brief Computed property returning a descriptive string.\n```\nvar description: String {\n```\n\n### FUNCTION: `speak`\n> Signature: `func speak()`\n> Lines: 44-46\n- @brief Produce a sound; subclasses should override.\n```\nfunc speak() {\nprint(\"...\")\n}\n```\n\n### CLASS: `func`\n> Signature: `class func createDefault() -> Animal`\n> Lines: 50-52\n- @brief Class method creating a generic instance.\n- @return An Animal with species \"Unknown\".\n```\nclass func createDefault() -> Animal {\nreturn Animal(species: \"Unknown\")\n}\n```\n\n### CLASS: `Dog`\n> Signature: `class Dog: Animal`\n> Lines: 63-78\n- @brief Concrete animal with dog-specific behavior.\n- @brief Dog's name.\n```\nclass Dog: Animal {\nlet name: String\ninit(name: String) {\nself.name = name\nsuper.init(species: \"Dog\")\n}\noverride func speak() {\nprint(\"\\(name) says: Woof!\")\n}\n}\n```\n\n### FUNCTION: `speak`\n> Signature: `override func speak()`\n> Lines: 75-77\n- @brief Override speak to produce dog-specific sound.\n```\noverride func speak() {\nprint(\"\\(name) says: Woof!\")\n}\n```\n\n### VARIABLE: `x`\n> Signature: `var x: Double = 0.0`\n> Lines: 86-86\n```\nvar x: Double = 0.0\n```\n\n### VARIABLE: `y`\n> Signature: `var y: Double = 0.0`\n> Lines: 87-87\n```\nvar y: Double = 0.0\n```\n\n### VARIABLE: `magnitude`\n> Signature: `var magnitude: Double`\n> Lines: 99-99\n- @brief Compute Euclidean distance from origin.\n- @return Distance as a Double.\n```\nvar magnitude: Double {\n```\n\n### VARIABLE: `data`\n> Signature: `private var data: [[Double]]`\n> Lines: 109-109\n- @brief Flat storage for matrix values.\n```\nprivate var data: [[Double]]\n```\n\n### VARIABLE: `opposite`\n> Signature: `var opposite: Direction`\n> Lines: 148-148\n- @brief Compute the opposite direction.\n- @return The direction 180 degrees from self.\n```\nvar opposite: Direction {\n```\n\n### FUNCTION: `map`\n> Signature: `func map<U>(_ transform: (T) -> U) -> AppResult<U>`\n> Lines: 171-178\n- @brief Map the success value using a transform closure.\n- @param transform Closure converting T to U.\n- @return A new AppResult with the transformed value.\n```\nfunc map<U>(_ transform: (T) -> U) -> AppResult<U> {\nswitch self {\ncase .success(let value):\nreturn .success(transform(value))\ncase .failure(let error):\nreturn .failure(error)\n}\n}\n```\n\n### FUNCTION: `draw`\n> Signature: `func draw() -> String`\n> Lines: 189-192\n- @brief Render the object to a string representation.\n- @brief Optional priority for render ordering.\n- @return Rendered string output.\n```\nfunc draw() -> String\nvar renderPriority: Int { get }\n```\n\n### VARIABLE: `renderPriority`\n> Signature: `var renderPriority: Int { get }`\n> Lines: 192-192\n- @brief Optional priority for render ordering.\n```\nvar renderPriority: Int { get }\n```\n\n### VARIABLE: `count`\n> Signature: `var count: Int { get }`\n> Lines: 207-207\n- @brief Number of elements in the container.\n```\nvar count: Int { get }\n```\n\n### VARIABLE: `renderPriority`\n> Signature: `var renderPriority: Int { return 0 }`\n> Lines: 214-214\n- @brief Default render priority for all Drawable conformants.\n```\nvar renderPriority: Int { return 0 }\n```\n\n### FUNCTION: `debugDraw`\n> Signature: `func debugDraw() -> String`\n> Lines: 218-220\n- @brief Debug draw with priority prefix.\n- @return String with priority and rendered content.\n```\nfunc debugDraw() -> String {\nreturn \"[\\(renderPriority)] \\(draw())\"\n}\n```\n\n### FUNCTION: `draw`\n> Signature: `func draw() -> String`\n> Lines: 229-231\n- @brief Render animal as a descriptive string.\n- @return Description of the animal.\n```\nfunc draw() -> String {\nreturn description\n}\n```\n\n### FUNCTION: `describe`\n> Signature: `func describe() -> String`\n> Lines: 235-237\n- @brief Describe the animal for UI display.\n- @return A formatted string suitable for labels.\n```\nfunc describe() -> String {\nreturn \"Animal: \\(species)\"\n}\n```\n\n### VARIABLE: `value`\n> Signature: `private var value: Value`\n> Lines: 253-253\n- @brief Current stored value.\n```\nprivate var value: Value\n```\n\n### VARIABLE: `wrappedValue`\n> Signature: `var wrappedValue: Value`\n> Lines: 256-256\n- @brief The wrapped value, clamped on set.\n```\nvar wrappedValue: Value {\n```\n\n### VARIABLE: `value`\n> Signature: `private var value: Int = 0`\n> Lines: 277-277\n- @brief Current count value.\n```\nprivate var value: Int = 0\n```\n\n### FUNCTION: `increment`\n> Signature: `func increment() -> Int`\n> Lines: 281-284\n- @brief Increment the counter and return the new value.\n- @return The incremented count.\n```\nfunc increment() -> Int {\nvalue += 1\nreturn value\n}\n```\n\n### FUNCTION: `reset`\n> Signature: `func reset()`\n> Lines: 287-289\n- @brief Reset the counter to zero.\n```\nfunc reset() {\nvalue = 0\n}\n```\n\n### FUNCTION: `greet`\n> Signature: `public func greet(name: String)`\n> Lines: 296-298\n- @brief Greet a person by name.\n- @param name The person's name.\n```\npublic func greet(name: String) {\nprint(\"Hello \\(name)\")\n}\n```\n\n### FUNCTION: `makeDrawable`\n> Signature: `func makeDrawable() -> some Drawable`\n> Lines: 302-304\n- @brief Build an opaque some-typed Drawable.\n- @return An opaque Drawable hiding the concrete type.\n```\nfunc makeDrawable() -> some Drawable {\nreturn Animal(species: \"Cat\")\n}\n```\n\n### FUNCTION: `contains`\n> Signature: `func contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable`\n> Lines: 311-313\n- @brief Generic function with where clause constraint.\n@tparam T Must be Equatable.\n- @param items Collection of items to search.\n- @param target The item to find.\n- @return True if target exists in items.\n```\nfunc contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable {\nreturn items.contains(target)\n}\n```\n\n### FUNCTION: `deferred`\n> Signature: `func deferred(_ action: @escaping () -> Void) -> () -> Void`\n> Lines: 318-323\n- @brief Higher-order function accepting an escaping closure.\n- @param action The closure to store for later execution.\n- @return A wrapper closure that invokes action.\n```\nfunc deferred(_ action: @escaping () -> Void) -> () -> Void {\nreturn {\naction()\n}\n}\n```\n\n### VARIABLE: `counter`\n> Signature: `private var counter = 0`\n> Lines: 331-331\n- @brief Module-scoped mutable counter with restricted access.\n```\nprivate var counter = 0\n```\n\n### VARIABLE: `config`\n> Signature: `var config: [String: Any] = [:]`\n> Lines: 335-335\n```\nvar config: [String: Any] = [:]\n```\n\n### IMPORT: `SwiftUI`\n> Lines: 342-342\n```\nimport SwiftUI\n```\n\n### IMPORT: `Combine`\n> Lines: 343-343\n```\nimport Combine\n```\n\n### IMPORT: `Foundation`\n> Lines: 344-344\n```\nimport Foundation\n```\n\n### IMPORT: `Dispatch`\n> Lines: 345-345\n```\nimport Dispatch\n```\n\n### IMPORT: `UIKit`\n> Lines: 346-346\n```\nimport UIKit\n```\n\n### CLASS: `ServiceController`\n> Signature: `class ServiceController {}`\n> Lines: 347-347\n```\nclass ServiceController {}\n```\n\n### CLASS: `CacheStore`\n> Signature: `final class CacheStore {}`\n> Lines: 348-348\n```\nfinal class CacheStore {}\n```\n\n### FUNCTION: `reqCoverSwift1`\n> Signature: `func reqCoverSwift1(_ value: Int) -> Int { value + 1 }`\n> Lines: 367-367\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfunc reqCoverSwift1(_ value: Int) -> Int { value + 1 }\n```\n\n### FUNCTION: `reqCoverSwift2`\n> Signature: `func reqCoverSwift2(_ value: Int) -> Int { value + 2 }`\n> Lines: 374-374\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfunc reqCoverSwift2(_ value: Int) -> Int { value + 2 }\n```\n\n### FUNCTION: `reqCoverSwift3`\n> Signature: `func reqCoverSwift3(_ value: Int) -> Int { value + 3 }`\n> Lines: 381-381\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfunc reqCoverSwift3(_ value: Int) -> Int { value + 3 }\n```\n\n### FUNCTION: `reqCoverSwift4`\n> Signature: `func reqCoverSwift4(_ value: Int) -> Int { value + 4 }`\n> Lines: 388-388\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfunc reqCoverSwift4(_ value: Int) -> Int { value + 4 }\n```\n\n### FUNCTION: `reqCoverSwift5`\n> Signature: `func reqCoverSwift5(_ value: Int) -> Int { value + 5 }`\n> Lines: 395-395\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfunc reqCoverSwift5(_ value: Int) -> Int { value + 5 }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_typescript.ts | typescript\n- @brief Comprehensive TypeScript test fixture for parser validation.\n- @details Covers conditional types, mapped types, template literal types,\nsatisfies operator, overload signatures, discriminated unions,\nmodule augmentation, decorators, generic constraints, and utility types.\n\n### IMPORT: `{ Component } from 'react';`\n> Lines: 10-10\n```\nimport { Component } from 'react';\n```\n\n### IMPORT: `type { ReactNode } from 'react';`\n> Lines: 11-11\n```\nimport type { ReactNode } from 'react';\n```\n\n### CLASS: `Base`\n> Signature: `export abstract class Base`\n> Lines: 122-139\n- @brief Abstract base class with template method pattern.\n- @brief Abstract render method to be implemented by subclasses.\n- @return void\n```\nexport abstract class Base {\nabstract render(): void;\nexecute(): void {\nconsole.log('before render');\nthis.render();\nconsole.log('after render');\n}\n}\n```\n\n### CLASS: `Derived`\n> Signature: `class Derived extends Base`\n> Lines: 148-161\n- @brief Concrete implementation with typed value storage.\n- @brief Stored numeric value.\n```\nclass Derived extends Base {\nvalue: number = 0;\nlabel?: string;\nrender(): void {\nconsole.log(this.value);\n}\n}\n```\n\n### CLASS: `TypedContainer`\n> Signature: `class TypedContainer<T extends Serializable>`\n> Lines: 168-201\n- @brief Generic container with constraint on Serializable.\n@tparam T Must implement Serializable interface.\n- @brief Internal array storage for items.\n```\nclass TypedContainer<T extends Serializable> {\nprivate items: T[] = [];\nadd(item: T): void {\nthis.items.push(item);\n}\ntoJSON(): string {\nreturn `[${this.items.map(i => i.toJSON()).join(',')}]`;\n}\nfind(predicate: (item: T) => boolean): T | undefined {\nfor (const item of this.items) {\nif (predicate(item)) {\nreturn item;\n}\n}\nreturn undefined;\n}\n}\n```\n\n### CLASS: `UserEntity`\n> Signature: `class UserEntity implements User, Serializable`\n> Lines: 210-228\n- @brief Full user entity implementing both User and Serializable.\n```\nclass UserEntity implements User, Serializable {\nreadonly id: string;\nname: string;\nage: number;\nconstructor(id: string, name: string, age: number) {\nthis.id = id;\nthis.name = name;\nthis.age = age;\n}\ntoJSON(): string {\nreturn JSON.stringify({ id: this.id, name: this.name, age: this.age });\n}\n}\n```\n\n### FUNCTION: `greet`\n> Signature: `export function greet(name: string): void`\n> Lines: 237-239\n- @brief Greet a person by name with type-safe parameter.\n- @param name The person's name to display.\n```\nexport function greet(name: string): void {\nconsole.log(`Hello, ${name}`);\n}\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: string): number`\n> Lines: 249-256\n- @brief Parse input with overloaded signatures for type safety.\n@overload Parse a string input into a number.\n@overload Parse a number input into a string.\n```\nfunction parse(input: string): number;\nfunction parse(input: number): string;\nfunction parse(input: string | number): string | number {\nif (typeof input === 'string') {\nreturn parseInt(input, 10);\n}\nreturn input.toString();\n}\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: number): string`\n> Lines: 250-256\n```\nfunction parse(input: number): string;\nfunction parse(input: string | number): string | number {\nif (typeof input === 'string') {\nreturn parseInt(input, 10);\n}\nreturn input.toString();\n}\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: string | number): string | number`\n> Lines: 251-256\n```\nfunction parse(input: string | number): string | number {\nif (typeof input === 'string') {\nreturn parseInt(input, 10);\n}\nreturn input.toString();\n}\n```\n\n### FUNCTION: `add`\n> Signature: `const add = (a: number): number => a + 1`\n> Lines: 266-277\n- @brief Add one to a number (arrow function syntax).\n- @brief Generic transform function with constraint. @tparam T Must have a toString method.\n- @param a The input number.\n- @param value Input value to transform.\n- @return The incremented value.\n- @return String representation of the value.\n```\nconst add = (a: number): number => a + 1;\nconst transform = <T extends { toString(): string }>(value: T): string => {\nreturn value.toString();\n};\n```\n\n### FUNCTION: `fetchEntity`\n> Signature: `async function fetchEntity<T>(url: string): Promise<T>`\n> Lines: 288-292\n- @brief Fetch and deserialize a typed entity from an API.\n@tparam T The expected response entity type.\n- @param url Endpoint URL.\n- @return Promise resolving to the typed entity.\n```\nasync function fetchEntity<T>(url: string): Promise<T> {\nconst response = await fetch(url);\nreturn response.json() as Promise<T>;\n}\n```\n\n### FUNCTION: `double`\n> Signature: `export function double(val: number): number`\n> Lines: 309-311\n- @brief Helper function scoped to namespace.\n- @param val Numeric input to double.\n- @return The doubled value.\n```\nexport function double(val: number): number {\nreturn val * 2;\n}\n```\n\n### DECORATOR: `Component`\n> Lines: 331-331\n- @brief Class using a decorator annotation.\n```\n@Component\n```\n\n### CLASS: `Decorated`\n> Signature: `class Decorated`\n> Lines: 332-335\n- @brief Template string for rendering.\n```\nclass Decorated {\ntemplate: string = '<div></div>';\n}\n```\n\n### FUNCTION: `isUser`\n> Signature: `function isUser(value: unknown): value is User`\n> Lines: 345-351\n- @brief Type guard narrowing unknown to User interface.\n- @param value Unknown input to validate.\n- @return True if value conforms to User shape.\n```\nfunction isUser(value: unknown): value is User {\nif (typeof value !== 'object' || value === null) {\nreturn false;\n}\nconst obj = value as Record<string, unknown>;\nreturn typeof obj.name === 'string' && typeof obj.age === 'number';\n}\n```\n\n### FUNCTION: `makeOptional`\n> Signature: `function makeOptional<T extends object>(obj: T): Partial<T>`\n> Lines: 373-375\n- @brief Convert all properties of an object to optional at runtime.\n@tparam T Source object type.\n- @param obj The source object.\n- @return A partial copy of the object.\n```\nfunction makeOptional<T extends object>(obj: T): Partial<T> {\nreturn { ...obj };\n}\n```\n\n### IMPORT: `{ Injectable } from 'inversify';`\n> Lines: 378-378\n```\nimport { Injectable } from 'inversify';\n```\n\n### IMPORT: `{ Observable } from 'rxjs';`\n> Lines: 379-379\n```\nimport { Observable } from 'rxjs';\n```\n\n### IMPORT: `{ FC } from 'react';`\n> Lines: 380-380\n```\nimport { FC } from 'react';\n```\n\n### DECORATOR: `injectable`\n> Lines: 381-381\n```\n@injectable\n```\n\n### DECORATOR: `sealed`\n> Lines: 382-382\n```\n@sealed\n```\n\n### DECORATOR: `track`\n> Lines: 383-383\n```\n@track\n```\n\n### DECORATOR: `memoized`\n> Lines: 384-384\n```\n@memoized\n```\n\n### FUNCTION: `reqCoverTs1`\n> Signature: `function reqCoverTs1(value: number): number { return value + 1; }`\n> Lines: 404-404\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfunction reqCoverTs1(value: number): number { return value + 1; }\n```\n\n### FUNCTION: `reqCoverTs2`\n> Signature: `function reqCoverTs2(value: number): number { return value + 2; }`\n> Lines: 411-411\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfunction reqCoverTs2(value: number): number { return value + 2; }\n```\n\n### FUNCTION: `reqCoverTs3`\n> Signature: `function reqCoverTs3(value: number): number { return value + 3; }`\n> Lines: 418-418\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfunction reqCoverTs3(value: number): number { return value + 3; }\n```\n\n### FUNCTION: `reqCoverTs4`\n> Signature: `function reqCoverTs4(value: number): number { return value + 4; }`\n> Lines: 425-425\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfunction reqCoverTs4(value: number): number { return value + 4; }\n```\n\n### FUNCTION: `reqCoverTs5`\n> Signature: `function reqCoverTs5(value: number): number { return value + 5; }`\n> Lines: 432-432\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfunction reqCoverTs5(value: number): number { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_zig.zig | zig\n\n### IMPORT: `std`\n> Lines: 7-7\n```\nconst std = @import(\"std\");\n```\n\n### IMPORT: `mem`\n> Lines: 8-8\n```\nconst mem = @import(\"std\").mem;\n```\n\n### FUNCTION: `main`\n> Signature: `pub fn main() void`\n> Lines: 14-16\n```\npub fn main() void {\nstd.debug.print(\"Hello\\n\", .{});\n}\n```\n\n### FUNCTION: `add`\n> Signature: `pub fn add(a: i32, b: i32) i32`\n> Lines: 22-24\n- @param a First operand.\n- @param b Second operand.\n- @return Sum of a and b.\n```\npub fn add(a: i32, b: i32) i32 {\nreturn a + b;\n}\n```\n\n### FUNCTION: `safeDivide`\n> Signature: `pub fn safeDivide(numerator: i32, denominator: i32) !i32`\n> Lines: 30-35\n- @param numerator The dividend.\n- @param denominator The divisor; must not be zero.\n- @return Quotient or error.DivisionByZero.\n```\npub fn safeDivide(numerator: i32, denominator: i32) !i32 {\nif (denominator == 0) {\nreturn error.DivisionByZero;\n}\nreturn @divTrunc(numerator, denominator);\n}\n```\n\n### FUNCTION: `max`\n> Signature: `pub fn max(comptime T: type, a: T, b: T) T`\n> Lines: 42-44\n- @param T The element type (comptime resolved).\n- @param a First value.\n- @param b Second value.\n- @return The larger of a and b.\n```\npub fn max(comptime T: type, a: T, b: T) T {\nreturn if (a > b) a else b;\n}\n```\n\n### FUNCTION: `indexOf`\n> Signature: `pub fn indexOf(comptime T: type, haystack: []const T, needle: T) ?usize`\n> Lines: 51-59\n- @param T Element type.\n- @param haystack Slice to search.\n- @param needle Value to find.\n- @return Index of needle or null if not found.\n```\npub fn indexOf(comptime T: type, haystack: []const T, needle: T) ?usize {\nfor (haystack, 0..) |item, i| {\nif (item == needle) {\nreturn i;\n}\n}\nreturn null;\n}\n```\n\n### FUNCTION: `comptimeConcat`\n> Signature: `pub fn comptimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8`\n> Lines: 65-67\n- @param a First string literal.\n- @param b Second string literal.\n- @return Concatenated string at compile time.\n```\npub fn comptimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8 {\nreturn a ++ b;\n}\n```\n\n### FUNCTION: `createBuffer`\n> Signature: `pub fn createBuffer(allocator: Allocator) ![]u8`\n> Lines: 72-78\n- @param allocator Memory allocator for buffer creation.\n- @return Allocated buffer or error.\n```\npub fn createBuffer(allocator: Allocator) ![]u8 {\nconst buf = try allocator.alloc(u8, 1024);\nerrdefer allocator.free(buf);\n@memset(buf, 0);\nreturn buf;\n}\n```\n\n### VARIABLE: `total`\n> Signature: `var total: f32 = 0.0`\n> Lines: 84-84\n- @param values Slice of floats to sum.\n- @return Sum of all elements.\n```\nvar total: f32 = 0.0;\n```\n\n### FUNCTION: `doubleValue`\n> Signature: `export fn doubleValue(x: i32) i32`\n> Lines: 94-96\n- @param x Value to double.\n- @return Input multiplied by two.\n```\nexport fn doubleValue(x: i32) i32 {\nreturn x * 2;\n}\n```\n\n### FUNCTION: `distSquared`\n> Signature: `pub fn distSquared(self: Point, other: Point) f64`\n> Lines: 110-114\n- @param self This point.\n- @param other Target point.\n- @return Distance squared (avoids sqrt).\n```\npub fn distSquared(self: Point, other: Point) f64 {\nconst dx = self.x - other.x;\nconst dy = self.y - other.y;\nreturn dx * dx + dy * dy;\n}\n```\n\n### FUNCTION: `origin`\n> Signature: `pub fn origin() Point`\n> Lines: 118-120\n- @return A zero-initialized Point.\n```\npub fn origin() Point {\nreturn .{ .x = 0.0, .y = 0.0 };\n}\n```\n\n### FUNCTION: `testing`\n> Signature: `pub fn testing() Config`\n> Lines: 141-143\n- @return Config with debug=true.\n```\npub fn testing() Config {\nreturn .{ .debug = true, .name = \"test\" };\n}\n```\n\n### FUNCTION: `toRgb`\n> Signature: `pub fn toRgb(self: Color) u32`\n> Lines: 157-163\n- @param self The color variant.\n- @return 24-bit RGB integer.\n```\npub fn toRgb(self: Color) u32 {\nreturn switch (self) {\n.red => 0xFF0000,\n.green => 0x00FF00,\n.blue => 0x0000FF,\n};\n}\n```\n\n### FUNCTION: `isOk`\n> Signature: `pub fn isOk(self: Result) bool`\n> Lines: 184-186\n- @param self The result to inspect.\n- @return True if variant is ok.\n```\npub fn isOk(self: Result) bool {\nreturn self == .ok;\n}\n```\n\n### VARIABLE: `global_state`\n> Signature: `pub var global_state: i32 = 0`\n> Lines: 202-202\n- @brief Global mutable state counter.\n```\npub var global_state: i32 = 0;\n```\n\n### VARIABLE: `x`\n> Signature: `var x: u32 = 1`\n> Lines: 206-206\n```\nvar x: u32 = 1;\n```\n\n### IMPORT: `io`\n> Lines: 243-243\n```\nconst io = @import(\"std\");\n```\n\n### IMPORT: `fs`\n> Lines: 244-244\n```\nconst fs = @import(\"std\");\n```\n\n### IMPORT: `mem`\n> Lines: 245-245\n```\nconst mem = @import(\"std\");\n```\n\n### IMPORT: `math`\n> Lines: 246-246\n```\nconst math = @import(\"std\");\n```\n\n### IMPORT: `json`\n> Lines: 247-247\n```\nconst json = @import(\"std\");\n```\n\n### VARIABLE: `retries`\n> Signature: `var retries: i32 = 0`\n> Lines: 256-256\n```\nvar retries: i32 = 0;\n```\n\n### VARIABLE: `pointer`\n> Signature: `var pointer: usize = 0`\n> Lines: 257-257\n```\nvar pointer: usize = 0;\n```\n\n### FUNCTION: `reqCoverZig1`\n> Signature: `fn reqCoverZig1(value: i32) i32 { return value + 1; }`\n> Lines: 265-265\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfn reqCoverZig1(value: i32) i32 { return value + 1; }\n```\n\n### FUNCTION: `reqCoverZig2`\n> Signature: `fn reqCoverZig2(value: i32) i32 { return value + 2; }`\n> Lines: 272-272\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfn reqCoverZig2(value: i32) i32 { return value + 2; }\n```\n\n### FUNCTION: `reqCoverZig3`\n> Signature: `fn reqCoverZig3(value: i32) i32 { return value + 3; }`\n> Lines: 279-279\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfn reqCoverZig3(value: i32) i32 { return value + 3; }\n```\n\n### FUNCTION: `reqCoverZig4`\n> Signature: `fn reqCoverZig4(value: i32) i32 { return value + 4; }`\n> Lines: 286-286\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfn reqCoverZig4(value: i32) i32 { return value + 4; }\n```\n\n### FUNCTION: `reqCoverZig5`\n> Signature: `fn reqCoverZig5(value: i32) i32 { return value + 5; }`\n> Lines: 293-293\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfn reqCoverZig5(value: i32) i32 { return value + 5; }\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/get-base-path.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "<PROJECT_BASE>\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/git-check-clean.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/git-check-dirty.json

@@ -1,5 +0,0 @@
-{
-  "code": 1,
-  "stdout": "",
-  "stderr": "ERROR: Git status unclear!\n"
-}

package/tests/fixtures_attended_results/project/git-path.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "<PROJECT_BASE>\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/git-wt-create-invalid.json

@@ -1,5 +0,0 @@
-{
-  "code": 1,
-  "stdout": "ERROR: Invalid worktree/branch name: bad name with spaces.\n",
-  "stderr": "ERROR: Invalid worktree/branch name: bad name with spaces.\n"
-}

package/tests/fixtures_attended_results/project/git-wt-create-valid.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/git-wt-delete-nonexistent.json

@@ -1,5 +0,0 @@
-{
-  "code": 1,
-  "stdout": "ERROR: Invalid worktree or branch name: nonexistent-wt-branch-xyz.\n",
-  "stderr": "ERROR: Invalid worktree or branch name: nonexistent-wt-branch-xyz.\n"
-}

package/tests/fixtures_attended_results/project/git-wt-delete-valid.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/git-wt-name.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "useReq-<PROJECT_NAME>-master-<TIMESTAMP>\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/static-check.json

@@ -1,5 +0,0 @@
-{
-  "code": 1,
-  "stdout": "# Static-Check(Command[false]): <PROJECT_BASE>/src/fixture_python.py\nResult: FAIL\nEvidence:\n\n\n",
-  "stderr": ""
-}