pi-usereq 0.48.0 → 0.50.0

package/tests/fixtures_attended_results/standalone/files-find/fixture_c.c.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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### MACRO: `MAX_SIZE`\n> Signature: `#define MAX_SIZE 100`\n> Lines: 22-22\n```\n#define MAX_SIZE 100\n```\n\n### MACRO: `CLAMP`\n> Signature: `#define CLAMP(val, lo, hi) ((val) < (lo) ? (lo) : ((val) > (hi) ? (hi) : (val)))`\n> Lines: 31-31\n- @brief Constrain value between lower and upper bounds.\n- @param val Value to clamp.\n- @param lo Minimum allowed value.\n- @param hi Maximum allowed value.\n```\n#define CLAMP(val, lo, hi) ((val) < (lo) ? (lo) : ((val) > (hi) ? (hi) : (val)))\n```\n\n### MACRO: `STRINGIFY`\n> Signature: `#define STRINGIFY(x) #x`\n> Lines: 34-34\n```\n#define STRINGIFY(x) #x\n```\n\n### MACRO: `CONCAT`\n> Signature: `#define CONCAT(a, b) a##b`\n> Lines: 40-40\n- @brief Token-pasting macro joining two identifiers.\n```\n#define CONCAT(a, b) a##b\n```\n\n### MACRO: `LOG`\n> Signature: `#define LOG(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)`\n> Lines: 43-43\n```\n#define LOG(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)\n```\n\n### MACRO: `LOG`\n> Signature: `#define LOG(fmt, ...) ((void)0)`\n> Lines: 45-45\n```\n#define LOG(fmt, ...) ((void)0)\n```\n\n### TYPEDEF: `my_int`\n> Signature: `typedef int my_int`\n> Lines: 51-51\n```\ntypedef int my_int;\n```\n\n### TYPEDEF: `byte_t`\n> Signature: `typedef unsigned char byte_t`\n> Lines: 54-54\n```\ntypedef unsigned char byte_t;\n```\n\n### STRUCT: `Point`\n> Signature: `struct Point`\n> Lines: 62-65\n- @brief 2D point with integer coordinates.\n- @brief Horizontal coordinate.\n- @brief Vertical coordinate.\n```\nstruct Point {\nint x;\nint y;\n};\n```\n\n### STRUCT: `PackedFlags`\n> Signature: `struct PackedFlags`\n> Lines: 71-76\n- @brief Bitfield struct testing parser handling of colon-separated widths.\n- @brief Read permission flag.\n- @brief Write permission flag.\n- @brief Execute permission flag.\n```\nstruct PackedFlags {\nunsigned int readable : 1;\nunsigned int writable : 1;\nunsigned int executable : 1;\nunsigned int reserved : 5;\n};\n```\n\n### STRUCT: `Node`\n> Signature: `struct Node`\n> Lines: 82-89\n- @brief Self-referential linked-list node with embedded anonymous union.\n- @brief Payload can hold either an integer or float value.\n```\nstruct Node {\nunion {\nint i_val;\nfloat f_val;\n} payload;\nstruct Node *next;\n};\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### UNION: `Data`\n> Signature: `union Data`\n> Lines: 97-101\n- @brief Discriminated union for multi-type storage.\n- @brief Integer interpretation.\n- @brief Float interpretation.\n- @brief Fixed-size string buffer.\n```\nunion Data {\nint i;\nfloat f;\nchar s[16];\n};\n```\n\n### ENUM: `Color`\n> Signature: `enum Color`\n> Lines: 109-113\n- @brief Primary color identifiers for rendering pipeline.\n- @brief Red channel.\n- @brief Green channel.\n- @brief Blue channel.\n```\nenum Color {\nRED,\nGREEN,\nBLUE\n};\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### STRUCT: `Vector2`\n> Signature: `struct Vector2`\n> Lines: 278-281\n```\nstruct Vector2 {\nint x;\nint y;\n};\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### STRUCT: `Matrix2`\n> Signature: `struct Matrix2`\n> Lines: 282-285\n```\nstruct Matrix2 {\nint a11;\nint a22;\n};\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### ENUM: `StatusCode`\n> Signature: `enum StatusCode { STATUS_OK, STATUS_ERR, STATUS_UNKNOWN }`\n> Lines: 286-286\n```\nenum StatusCode { STATUS_OK, STATUS_ERR, STATUS_UNKNOWN };\n```\n\n### ENUM: `LevelCode`\n> Signature: `enum LevelCode { LEVEL_LOW, LEVEL_MEDIUM, LEVEL_HIGH }`\n> Lines: 287-287\n```\nenum LevelCode { LEVEL_LOW, LEVEL_MEDIUM, LEVEL_HIGH };\n```\n\n### ENUM: `ModeCode`\n> Signature: `enum ModeCode { MODE_A, MODE_B }`\n> Lines: 288-288\n```\nenum ModeCode { MODE_A, MODE_B };\n```\n\n### ENUM: `FlagCode`\n> Signature: `enum FlagCode { FLAG_ON, FLAG_OFF }`\n> Lines: 289-289\n```\nenum FlagCode { FLAG_ON, FLAG_OFF };\n```\n\n### UNION: `NumberValue`\n> Signature: `union NumberValue`\n> Lines: 290-293\n```\nunion NumberValue {\nint i;\nfloat f;\n};\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### UNION: `PtrValue`\n> Signature: `union PtrValue`\n> Lines: 294-297\n```\nunion PtrValue {\nvoid *p;\nlong l;\n};\n```\n\n### VARIABLE: `l`\n> Signature: `long l`\n> Lines: 296-296\n```\nlong l;\n```\n\n### UNION: `StateValue`\n> Signature: `union StateValue`\n> Lines: 298-301\n```\nunion StateValue {\nint s;\nchar c;\n};\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### UNION: `PairValue`\n> Signature: `union PairValue`\n> Lines: 302-305\n```\nunion PairValue {\nint x;\nint y;\n};\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### TYPEDEF: `index_t`\n> Signature: `typedef long index_t`\n> Lines: 306-306\n```\ntypedef long index_t;\n```\n\n### TYPEDEF: `ratio_t`\n> Signature: `typedef float ratio_t`\n> Lines: 307-307\n```\ntypedef float ratio_t;\n```\n\n### STRUCT: `Point`\n> Signature: `typedef struct Point point_t`\n> Lines: 308-319\n```\ntypedef struct Point point_t;\ntypedef double score_t;\nint req_cover_c_1(int value) { return value + 1; }\n```\n\n### TYPEDEF: `score_t`\n> Signature: `typedef double score_t`\n> Lines: 309-309\n```\ntypedef double score_t;\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_cpp.cpp.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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### MACRO: `VERSION`\n> Signature: `#define VERSION 2`\n> Lines: 21-21\n```\n#define VERSION 2\n```\n\n### MACRO: `LIKELY`\n> Signature: `#define LIKELY(x) __builtin_expect(!!(x), 1)`\n> Lines: 24-24\n```\n#define LIKELY(x) __builtin_expect(!!(x), 1)\n```\n\n### NAMESPACE: `MyNS`\n> Signature: `namespace MyNS`\n> Lines: 28-299\n```\nnamespace MyNS {\ntemplate <typename T>\nconcept Printable = requires(std::ostream &os, T val) {\n{ os << val } -> std::same_as<std::ostream &>;\n};\ntemplate <typename T>\nconcept Numeric = std::integral<T> || std::floating_point<T>;\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};\nstruct Point {\ndouble x;\ndouble y;\nconstexpr double dist_sq(const Point &other) const {\ndouble dx = x - other.x;\ndouble dy = y - other.y;\nreturn dx * dx + dy * dy;\n}\nconstexpr Point operator+(const Point &rhs) const {\nreturn {x + rhs.x, y + rhs.y};\n}\n};\nenum class Direction {\nUp,\nDown,\nLeft,\nRight\n};\nusing StringVec = std::vector<std::string>;\ntypedef int my_int_t;\nusing Callback = std::function<void(int)>;\ntemplate <typename Derived> class Cloneable {\npublic:\nstd::unique_ptr<Derived> clone() const {\nreturn std::make_unique<Derived>(static_cast<const Derived &>(*this));\n}\n};\nclass Base {\npublic:\nvirtual const char *type_name() const = 0;\nvirtual ~Base() = default;\n};\nclass DerivedA : public virtual Base {\npublic:\nconst char *type_name() const override { return \"DerivedA\"; }\n};\nclass DerivedB : public virtual Base {\npublic:\nconst char *type_name() const override { return \"DerivedB\"; }\n};\nclass Diamond : public DerivedA, public DerivedB {\npublic:\nconst char *type_name() const override { return \"Diamond\"; }\n};\nconstexpr unsigned long long constexpr_factorial(unsigned int n) {\nreturn n <= 1 ? 1ULL : n * constexpr_factorial(n - 1);\n}\nstd::pair<std::string, std::string> parse_kv(const std::string &input) {\nauto pos = input.find('=');\nif (pos == std::string::npos) {\nreturn {\"\", \"\"};\n}\nreturn {input.substr(0, pos), input.substr(pos + 1)};\n}\nvoid greet(std::string name) { std::cout << \"Hello, \" << name << \"\\n\"; }\nint main() {\nauto [key, val] = parse_kv(\"lang=cpp\");\ngreet(key);\nreturn 0;\n}\nconstexpr auto square = [](auto x) { return x * x; };\nnamespace Inner::Detail {\ninline std::string format_int(int v) { return std::to_string(v); }\n}\n}\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### STRUCT: `Point`\n> Signature: `struct Point`\n> Lines: 118-142\n- @brief 2D coordinate with constexpr arithmetic support.\n- @brief X coordinate.\n- @brief Y coordinate.\n```\nstruct Point {\ndouble x;\ndouble y;\nconstexpr double dist_sq(const Point &other) const {\ndouble dx = x - other.x;\ndouble dy = y - other.y;\nreturn dx * dx + dy * dy;\n}\nconstexpr Point operator+(const Point &rhs) const {\nreturn {x + rhs.x, y + rhs.y};\n}\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### ENUM: `Direction`\n> Signature: `enum class Direction`\n> Lines: 150-155\n- @brief Cardinal movement directions with strong typing.\n- @brief Move upward.\n- @brief Move downward.\n- @brief Move left.\n```\nenum class Direction {\nUp,\nDown,\nLeft,\nRight\n};\n```\n\n### TYPE_ALIAS: `StringVec`\n> Signature: `using StringVec = std::vector<std::string>`\n> Lines: 160-160\n```\nusing StringVec = std::vector<std::string>;\n```\n\n### TYPE_ALIAS: `int`\n> Signature: `typedef int my_int_t`\n> Lines: 163-163\n```\ntypedef int my_int_t;\n```\n\n### TYPE_ALIAS: `Callback`\n> Signature: `using Callback = std::function<void(int)>`\n> Lines: 166-166\n```\nusing Callback = std::function<void(int)>;\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### NAMESPACE: `Inner`\n> Signature: `namespace Inner::Detail`\n> Lines: 288-297\n- @brief Internal helper formatting integers to strings.\n- @param v The integer to format.\n- @return Formatted string representation.\n```\nnamespace Inner::Detail {\ninline std::string format_int(int v) { return std::to_string(v); }\n}\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### STRUCT: `Pixel`\n> Signature: `struct Pixel`\n> Lines: 321-325\n```\nstruct Pixel {\nint r;\nint g;\nint b;\n};\n```\n\n### STRUCT: `Size`\n> Signature: `struct Size`\n> Lines: 326-329\n```\nstruct Size {\nint w;\nint h;\n};\n```\n\n### STRUCT: `Bounds`\n> Signature: `struct Bounds`\n> Lines: 330-335\n```\nstruct Bounds {\nint x;\nint y;\nint w;\nint h;\n};\n```\n\n### STRUCT: `Marker`\n> Signature: `struct Marker`\n> Lines: 336-338\n```\nstruct Marker {\nint id;\n};\n```\n\n### ENUM: `Mode`\n> Signature: `enum Mode { ModeA, ModeB }`\n> Lines: 339-339\n```\nenum Mode { ModeA, ModeB };\n```\n\n### ENUM: `State`\n> Signature: `enum State { StateIdle, StateBusy }`\n> Lines: 340-340\n```\nenum State { StateIdle, StateBusy };\n```\n\n### ENUM: `Grade`\n> Signature: `enum Grade { GradeA, GradeB }`\n> Lines: 341-341\n```\nenum Grade { GradeA, GradeB };\n```\n\n### ENUM: `Severity`\n> Signature: `enum Severity { SevLow, SevHigh }`\n> Lines: 342-342\n```\nenum Severity { SevLow, SevHigh };\n```\n\n### NAMESPACE: `extns`\n> Signature: `namespace extns`\n> Lines: 343-345\n```\nnamespace extns {\ninline int add_one(int v) { return v + 1; }\n}\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### NAMESPACE: `ext_alpha`\n> Signature: `namespace ext_alpha`\n> Lines: 346-348\n```\nnamespace ext_alpha {\ninline int ping() { return 1; }\n}\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### NAMESPACE: `ext_beta`\n> Signature: `namespace ext_beta`\n> Lines: 349-351\n```\nnamespace ext_beta {\ninline int pong() { return 2; }\n}\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### MACRO: `FEATURE_ALPHA`\n> Signature: `#define FEATURE_ALPHA 1`\n> Lines: 352-352\n```\n#define FEATURE_ALPHA 1\n```\n\n### MACRO: `FEATURE_BETA`\n> Signature: `#define FEATURE_BETA 2`\n> Lines: 353-353\n```\n#define FEATURE_BETA 2\n```\n\n### MACRO: `FEATURE_GAMMA`\n> Signature: `#define FEATURE_GAMMA 3`\n> Lines: 354-354\n```\n#define FEATURE_GAMMA 3\n```\n\n### TYPE_ALIAS: `NumberVec`\n> Signature: `using NumberVec = std::vector<int>`\n> Lines: 355-355\n```\nusing NumberVec = std::vector<int>;\n```\n\n### TYPE_ALIAS: `long`\n> Signature: `typedef long LongId`\n> Lines: 356-356\n```\ntypedef long LongId;\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_csharp.cs.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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### NAMESPACE: `MyApp`\n> Signature: `namespace MyApp`\n> Lines: 15-314\n```\nnamespace MyApp {\npublic delegate void DataChangedHandler(object sender, string data);\npublic delegate T Transform<T>(T value);\n[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]\npublic class AuditableAttribute : Attribute {\npublic int Level { get; set; } = 1;\n}\n[Serializable]\n[Auditable(Level = 2)]\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}\npublic interface IGreeter {\nvoid SayHello(string name);\nvoid SayGoodbye(string name) {\nConsole.WriteLine($\"Goodbye, {name}\");\n}\n}\npublic interface IRepository<T> where T : class, new() {\nTask<T?> FindByIdAsync(int id);\nIAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\nTask<bool> SaveAsync(T entity);\n}\npublic readonly struct Point {\npublic double X { get; init; }\npublic double Y { get; init; }\npublic static Point operator +(Point a, Point b) => new() { X = a.X + b.X, Y = a.Y + b.Y };\npublic double Magnitude => Math.Sqrt(X * X + Y * Y);\n}\n[Flags]\npublic enum Color {\nNone = 0,\nRed = 1,\nGreen = 2,\nBlue = 4,\nAll = Red | Green | Blue,\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}\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}\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### PROPERTY: `Level`\n> Signature: `public int Level { get; set; } = 1`\n> Lines: 42-42\n```\npublic int Level { get; set; } = 1;\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### CONSTANT: `MAX_AGE`\n> Signature: `public const int MAX_AGE = 150`\n> Lines: 55-55\n```\npublic const int MAX_AGE = 150;\n```\n\n### PROPERTY: `Name`\n> Signature: `public string Name`\n> Lines: 68-68\n```\npublic string Name {\n```\n\n### PROPERTY: `Age`\n> Signature: `public int Age { get; init; }`\n> Lines: 79-79\n```\npublic int Age { get; init; }\n```\n\n### PROPERTY: `Id`\n> Signature: `public Guid Id { get; } = Guid.NewGuid()`\n> Lines: 85-85\n```\npublic Guid Id { get; } = Guid.NewGuid();\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### INTERFACE: `IGreeter`\n> Signature: `public interface IGreeter`\n> Lines: 179-193\n```\npublic interface IGreeter {\nvoid SayHello(string name);\nvoid SayGoodbye(string name) {\nConsole.WriteLine($\"Goodbye, {name}\");\n}\n}\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### INTERFACE: `IRepository`\n> Signature: `public interface IRepository<T> where T : class, new()`\n> Lines: 199-208\n```\npublic interface IRepository<T> where T : class, new() {\nTask<T?> FindByIdAsync(int id);\nIAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\nTask<bool> SaveAsync(T entity);\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### STRUCT: `Point`\n> Signature: `public readonly struct Point`\n> Lines: 215-230\n```\npublic readonly struct Point {\npublic double X { get; init; }\npublic double Y { get; init; }\npublic static Point operator +(Point a, Point b) => new() { X = a.X + b.X, Y = a.Y + b.Y };\npublic double Magnitude => Math.Sqrt(X * X + Y * Y);\n}\n```\n\n### PROPERTY: `X`\n> Signature: `public double X { get; init; }`\n> Lines: 217-217\n```\npublic double X { get; init; }\n```\n\n### PROPERTY: `Y`\n> Signature: `public double Y { get; init; }`\n> Lines: 219-219\n```\npublic double Y { get; init; }\n```\n\n### DECORATOR: `Flags`\n> Lines: 237-237\n```\n[Flags]\n```\n\n### ENUM: `Color`\n> Signature: `public enum Color`\n> Lines: 238-249\n```\npublic enum Color {\nNone = 0,\nRed = 1,\nGreen = 2,\nBlue = 4,\nAll = Red | Green | Blue,\n}\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### NAMESPACE: `MyApp.Services`\n> Signature: `namespace MyApp.Services {}`\n> Lines: 352-352\n```\nnamespace MyApp.Services {}\n```\n\n### NAMESPACE: `MyApp.Core`\n> Signature: `namespace MyApp.Core {}`\n> Lines: 353-353\n```\nnamespace MyApp.Core {}\n```\n\n### NAMESPACE: `MyApp.Data`\n> Signature: `namespace MyApp.Data {}`\n> Lines: 354-354\n```\nnamespace MyApp.Data {}\n```\n\n### NAMESPACE: `MyApp.Api`\n> Signature: `namespace MyApp.Api {}`\n> Lines: 355-355\n```\nnamespace MyApp.Api {}\n```\n\n### INTERFACE: `ILogger`\n> Signature: `public interface ILogger {}`\n> Lines: 356-356\n```\npublic interface ILogger {}\n```\n\n### INTERFACE: `IParser`\n> Signature: `public interface IParser {}`\n> Lines: 357-357\n```\npublic interface IParser {}\n```\n\n### INTERFACE: `IRunner`\n> Signature: `public interface IRunner {}`\n> Lines: 358-358\n```\npublic interface IRunner {}\n```\n\n### ENUM: `ModeCs`\n> Signature: `public enum ModeCs { Fast, Safe }`\n> Lines: 359-359\n```\npublic enum ModeCs { Fast, Safe }\n```\n\n### ENUM: `PhaseCs`\n> Signature: `public enum PhaseCs { Init, Done }`\n> Lines: 360-360\n```\npublic enum PhaseCs { Init, Done }\n```\n\n### ENUM: `StateCs`\n> Signature: `public enum StateCs { Open, Closed }`\n> Lines: 361-361\n```\npublic enum StateCs { Open, Closed }\n```\n\n### ENUM: `SignalCs`\n> Signature: `public enum SignalCs { On, Off }`\n> Lines: 362-362\n```\npublic enum SignalCs { On, Off }\n```\n\n### STRUCT: `Size`\n> Signature: `public struct Size { public int W; public int H; }`\n> Lines: 363-363\n```\npublic struct Size { public int W; public int H; }\n```\n\n### STRUCT: `Vector`\n> Signature: `public readonly struct Vector { public readonly int X; public readonly int Y; }`\n> Lines: 364-364\n```\npublic readonly struct Vector { public readonly int X; public readonly int Y; }\n```\n\n### STRUCT: `Limits`\n> Signature: `public struct Limits { public int Max; }`\n> Lines: 365-365\n```\npublic struct Limits { public int Max; }\n```\n\n### STRUCT: `Cursor`\n> Signature: `public struct Cursor { public int Index; }`\n> Lines: 366-366\n```\npublic struct Cursor { public int Index; }\n```\n\n### DECORATOR: `DebuggerDisplay(\"{Value}\")`\n> Lines: 367-367\n```\n[DebuggerDisplay(\"{Value}\")]\n```\n\n### CONSTANT: `MIN_AGE`\n> Signature: `public const int MIN_AGE = 10`\n> Lines: 368-368\n```\npublic const int MIN_AGE = 10;\n```\n\n### CONSTANT: `RETRY_LIMIT`\n> Signature: `public const int RETRY_LIMIT = 3`\n> Lines: 369-369\n```\npublic const int RETRY_LIMIT = 3;\n```\n\n### CONSTANT: `CACHE_SIZE`\n> Signature: `public const int CACHE_SIZE = 128`\n> Lines: 370-370\n```\npublic const int CACHE_SIZE = 128;\n```\n\n### CONSTANT: `DEFAULT_PAGE`\n> Signature: `public const int DEFAULT_PAGE = 1`\n> Lines: 371-371\n```\npublic const int DEFAULT_PAGE = 1;\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_elixir.ex.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_elixir.ex | elixir\n\n### MODULE: `MyApp.Server`\n> Signature: `defmodule MyApp.Server do`\n> Lines: 10-183\n```\ndefmodule MyApp.Server do\n  @moduledoc \"\"\"\n  GenServer implementation for managing application state.\n  Handles synchronous calls, asynchronous casts, and info messages.\n  Supports state initialization with validated options.\n  \"\"\"\n  use GenServer\n  import Enum\n  alias MyApp.Config\n  alias MyApp.Server.State\n  require Logger\n  @behaviour GenServer\n  @default_timeout 5_000\n  @max_items 1_000\n  @doc \"\"\"\n  Internal state struct for the server.\n  @field name Server instance name.\n  @field port Listening port number.\n  @field items List of stored items.\n  @field started_at Timestamp of server start.\n  \"\"\"\n  defstruct [:name, :port, items: [], started_at: nil]\n  @type t :: %__MODULE__{\n    name: String.t(),\n    port: non_neg_integer(),\n    items: list(any()),\n    started_at: DateTime.t() | nil\n  }\n  @type option :: {:name, String.t()} | {:port, non_neg_integer()}\n  @doc \"\"\"\n  Start a new server process linked to the caller.\n  @param opts Keyword list of options (:name, :port).\n  @return {:ok, pid} on success or {:error, reason} on failure.\n  \"\"\"\n  @spec start_link(keyword()) :: GenServer.on_start()\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  @doc \"\"\"\n  Add an item to the server's collection.\n  @param server The server PID or registered name.\n  @param item The item to store.\n  @return :ok\n  \"\"\"\n  @spec add_item(GenServer.server(), any()) :: :ok\n  def add_item(server, item) do\n    GenServer.call(server, {:add_item, item})\n  end\n  @doc \"\"\"\n  Retrieve all stored items.\n  @param server The server PID or registered name.\n  @return List of stored items.\n  \"\"\"\n  @spec get_items(GenServer.server()) :: list(any())\n  def get_items(server) do\n    GenServer.call(server, :get_items)\n  end\n  @doc \"\"\"\n  Asynchronously notify the server of an event.\n  @param server The server PID.\n  @param event The event data to process.\n  @return :ok\n  \"\"\"\n  @spec notify(GenServer.server(), any()) :: :ok\n  def notify(server, event) do\n    GenServer.cast(server, {:notify, event})\n  end\n  defp via_tuple(name) do\n    {:via, Registry, {MyApp.Registry, name}}\n  end\n  @impl true\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  @impl true\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  @impl true\n  def handle_call(:get_items, _from, state) do\n    {:reply, Enum.reverse(state.items), state}\n  end\n  @impl true\n  def handle_cast({:notify, event}, state) do\n    Logger.debug(\"Received event: #{inspect(event)}\")\n    {:noreply, state}\n  end\n  @impl true\n  def handle_info(:timeout, state) do\n    Logger.warn(\"Server #{state.name} timed out\")\n    {:noreply, state}\n  end\n  defp handle_internal(state) do\n    pruned = Enum.take(state.items, @max_items)\n    %{state | items: pruned}\n  end\n  @doc \"\"\"\n  Define a macro for compile-time code generation.\n  @param expr The expression to wrap.\n  @return Quoted AST wrapping the expression.\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\nend\n```\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### STRUCT: `[:name, :port, items: [], started_at: nil]`\n> Signature: `defstruct [:name, :port, items: [], started_at: nil]`\n> Lines: 44-69\n- @brief Maximum items stored in server state.\n```\n  defstruct [:name, :port, items: [], started_at: nil]\n  @type t :: %__MODULE__{\n    name: String.t(),\n    port: non_neg_integer(),\n    items: list(any()),\n    started_at: DateTime.t() | nil\n  }\n  @type option :: {:name, String.t()} | {:port, non_neg_integer()}\n  @doc \"\"\"\n  Start a new server process linked to the caller.\n  @param opts Keyword list of options (:name, :port).\n  @return {:ok, pid} on success or {:error, reason} on failure.\n  \"\"\"\n  @spec start_link(keyword()) :: GenServer.on_start()\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: `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### PROTOCOL: `Printable`\n> Signature: `defprotocol Printable do`\n> Lines: 187-200\n```\ndefprotocol Printable do\n  @moduledoc \"\"\"\n  Protocol for types that can be printed as formatted strings.\n  \"\"\"\n  @doc \"\"\"\n  Convert a value to its formatted string representation.\n  @param data The value to format.\n  @return Formatted string.\n  \"\"\"\n  @spec print(t) :: String.t()\n  def print(data)\nend\n```\n\n### FUNCTION: `print`\n> Signature: `def print(data)`\n> Lines: 199-200\n```\n  def print(data)\nend\n```\n\n### IMPL: `Printable`\n> Signature: `defimpl Printable, for: MyApp.Server do`\n> Lines: 204-214\n```\ndefimpl Printable, for: MyApp.Server do\n  @doc \"\"\"\n  Format a server struct for display.\n  @param server The server struct to format.\n  @return String in format \"Server(name:port)\".\n  \"\"\"\n  def print(server) do\n    \"Server(#{server.name}:#{server.port})\"\n  end\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### IMPL: `Printable`\n> Signature: `defimpl Printable, for: BitString do`\n> Lines: 216-220\n```\ndefimpl Printable, for: BitString do\n  def print(str) do\n    \"String(#{str})\"\n  end\nend\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### MODULE: `MyApp.Utils`\n> Signature: `defmodule MyApp.Utils do`\n> Lines: 224-296\n```\ndefmodule MyApp.Utils do\n  @moduledoc \"\"\"\n  Utility functions demonstrating pattern matching, guards,\n  pipe operators, and comprehensions.\n  \"\"\"\n  @doc \"\"\"\n  Classify a value using guard clauses and pattern matching.\n  @param value The value to classify.\n  @return Atom describing the value's category.\n  \"\"\"\n  @spec classify(any()) :: atom()\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  @doc \"\"\"\n  Demonstrate for-comprehension with multiple generators and filters.\n  @param range Upper bound for the search space.\n  @return List of Pythagorean triples.\n  \"\"\"\n  @spec pythagorean_triples(pos_integer()) :: list(tuple())\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  @doc \"\"\"\n  Safe division returning :error tuple on zero divisor.\n  @param a Dividend.\n  @param b Divisor.\n  @return {:ok, result} or {:error, :division_by_zero}.\n  \"\"\"\n  @spec safe_divide(number(), number()) :: {:ok, float()} | {:error, atom()}\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: `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### MODULE: `MyApp.Plugin`\n> Signature: `defmodule MyApp.Plugin do`\n> Lines: 300-315\n```\ndefmodule MyApp.Plugin do\n  @moduledoc \"\"\"\n  Behaviour defining the plugin interface.\n  \"\"\"\n  @doc \"Initialize the plugin with configuration options.\"\n  @callback init(opts :: keyword()) :: {:ok, any()} | {:error, String.t()}\n  @doc \"Execute the plugin's main logic.\"\n  @callback execute(state :: any()) :: :ok | {:error, String.t()}\n  @doc \"Clean up plugin resources.\"\n  @callback cleanup(state :: any()) :: :ok\n  @optional_callbacks [cleanup: 1]\nend\n```\n\n### MODULE: `MyApp.Extra`\n> Signature: `defmodule MyApp.Extra do`\n> Lines: 318-321\n```\ndefmodule MyApp.Extra do\n  defstruct [:name]\nend\n```\n\n### STRUCT: `[:name]`\n> Signature: `defstruct [:name]`\n> Lines: 320-321\n```\n  defstruct [:name]\nend\n```\n\n### MODULE: `MyApp.Audit`\n> Signature: `defmodule MyApp.Audit do`\n> Lines: 323-325\n```\ndefmodule MyApp.Audit do\n  defstruct [:id]\nend\n```\n\n### STRUCT: `[:id]`\n> Signature: `defstruct [:id]`\n> Lines: 324-325\n```\n  defstruct [:id]\nend\n```\n\n### MODULE: `MyApp.State`\n> Signature: `defmodule MyApp.State do`\n> Lines: 327-329\n```\ndefmodule MyApp.State do\n  defstruct [:status]\nend\n```\n\n### STRUCT: `[:status]`\n> Signature: `defstruct [:status]`\n> Lines: 328-329\n```\n  defstruct [:status]\nend\n```\n\n### MODULE: `MyApp.Payload`\n> Signature: `defmodule MyApp.Payload do`\n> Lines: 331-333\n```\ndefmodule MyApp.Payload do\n  defstruct [:value]\nend\n```\n\n### STRUCT: `[:value]`\n> Signature: `defstruct [:value]`\n> Lines: 332-333\n```\n  defstruct [:value]\nend\n```\n\n### MODULE: `MyApp.Context`\n> Signature: `defmodule MyApp.Context do`\n> Lines: 335-337\n```\ndefmodule MyApp.Context do\n  defstruct [:meta]\nend\n```\n\n### STRUCT: `[:meta]`\n> Signature: `defstruct [:meta]`\n> Lines: 336-337\n```\n  defstruct [:meta]\nend\n```\n\n### PROTOCOL: `Auditable`\n> Signature: `defprotocol Auditable do`\n> Lines: 339-341\n```\ndefprotocol Auditable do\n  def audit(data)\nend\n```\n\n### FUNCTION: `audit`\n> Signature: `def audit(data)`\n> Lines: 340-341\n```\n  def audit(data)\nend\n```\n\n### PROTOCOL: `Renderable`\n> Signature: `defprotocol Renderable do`\n> Lines: 343-345\n```\ndefprotocol Renderable do\n  def render(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### PROTOCOL: `Parsable`\n> Signature: `defprotocol Parsable do`\n> Lines: 347-349\n```\ndefprotocol Parsable do\n  def parse(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### PROTOCOL: `Validatable`\n> Signature: `defprotocol Validatable do`\n> Lines: 351-353\n```\ndefprotocol Validatable do\n  def validate(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### IMPL: `Auditable`\n> Signature: `defimpl Auditable, for: Any do`\n> Lines: 355-357\n```\ndefimpl Auditable, for: Any do\n  def audit(data), do: 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### IMPL: `Renderable`\n> Signature: `defimpl Renderable, for: Any do`\n> Lines: 359-361\n```\ndefimpl Renderable, for: Any do\n  def render(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### IMPL: `Parsable`\n> Signature: `defimpl Parsable, for: Any do`\n> Lines: 363-365\n```\ndefimpl Parsable, for: Any do\n  def parse(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### IMPL: `Validatable`\n> Signature: `defimpl Validatable, for: Any do`\n> Lines: 367-369\n```\ndefimpl Validatable, for: Any do\n  def validate(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### MODULE: `ReqCoverElixir`\n> Signature: `defmodule ReqCoverElixir do`\n> Lines: 372-408\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n```\ndefmodule ReqCoverElixir do\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_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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_go.go.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_go.go | go\n\n### MODULE: `main`\n> Signature: `package main`\n> Lines: 12-48\n```\npackage main\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"io\"\n\t\"sync\"\n)\nconst MaxSize = 100\nvar globalVar = 0\nconst (\n\tLogDebug = iota\n\tLogInfo\n\tLogError\n)\ntype Server struct {\n\tPort int\n\tHost string\n\tsync.Mutex\n\thandlers map[string]HandlerFunc\n}\n```\n\n### IMPORT: `(`\n> Lines: 14-14\n```\nimport (\n```\n\n### CONSTANT: `MaxSize`\n> Signature: `const MaxSize = 100`\n> Lines: 24-24\n```\nconst MaxSize = 100\n```\n\n### CONSTANT: `globalVar`\n> Signature: `var globalVar = 0`\n> Lines: 27-27\n```\nvar globalVar = 0\n```\n\n### STRUCT: `Server`\n> Signature: `type Server struct`\n> Lines: 43-48\n```\ntype Server struct {\n\tPort int\n\tHost string\n\tsync.Mutex\n\thandlers map[string]HandlerFunc\n}\n```\n\n### TYPE_ALIAS: `HandlerFunc`\n> Signature: `type HandlerFunc func(ctx context.Context, req []byte) ([]byte, error)`\n> Lines: 51-51\n```\ntype HandlerFunc func(ctx context.Context, req []byte) ([]byte, error)\n```\n\n### STRUCT: `Address`\n> Signature: `type Address struct`\n> Lines: 54-58\n```\ntype Address struct {\n\tStreet string\n\tCity   string\n\tZip    string\n}\n```\n\n### STRUCT: `Employee`\n> Signature: `type Employee struct`\n> Lines: 61-66\n```\ntype Employee struct {\n\tName    string\n\tAge     int\n\tAddress\n\tManager *Employee\n}\n```\n\n### INTERFACE: `Handler`\n> Signature: `type Handler interface`\n> Lines: 71-74\n```\ntype Handler interface {\n\tHandle(ctx context.Context, data []byte) error\n}\n```\n\n### INTERFACE: `ReadWriteCloser`\n> Signature: `type ReadWriteCloser interface`\n> Lines: 77-81\n```\ntype ReadWriteCloser interface {\n\tio.Reader\n\tio.Writer\n\tio.Closer\n}\n```\n\n### TYPE_ALIAS: `MyInt`\n> Signature: `type MyInt int`\n> Lines: 86-86\n```\ntype MyInt int\n```\n\n### METHOD: `String`\n> Signature: `func (m MyInt) String() string`\n> Lines: 89-91\n```\nfunc (m MyInt) String() string {\n\treturn fmt.Sprintf(\"MyInt(%d)\", int(m))\n}\n```\n\n### INTERFACE: `Ordered`\n> Signature: `type Ordered interface`\n> Lines: 104-106\n```\ntype Ordered interface {\n\t~int | ~float64 | ~string\n}\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### METHOD: `Start`\n> Signature: `func (s *Server) Start() error`\n> Lines: 123-132\n```\nfunc (s *Server) Start() error {\n\ts.Lock()\n\tdefer s.Unlock()\n\tif s.Port <= 0 {\n\t\treturn fmt.Errorf(\"invalid port: %d\", s.Port)\n\t}\n\tfmt.Printf(\"Starting on %s:%d\\n\", s.Host, s.Port)\n\treturn nil\n}\n```\n\n### METHOD: `Register`\n> Signature: `func (s *Server) Register(path string, handler HandlerFunc)`\n> Lines: 138-143\n- @param path The URL path to register.\n- @param handler The function to invoke for this path.\n```\nfunc (s *Server) Register(path string, handler HandlerFunc) {\n\tif s.handlers == nil {\n\t\ts.handlers = make(map[string]HandlerFunc)\n\t}\n\ts.handlers[path] = handler\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### CONSTANT: `wg`\n> Signature: `\tvar wg sync.WaitGroup`\n> Lines: 223-223\n```\n\tvar wg sync.WaitGroup\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### MODULE: `utilx`\n> Signature: `package utilx`\n> Lines: 285-293\n```\npackage utilx\npackage configx\npackage jobsx\npackage metricx\nimport \"os\"\nimport \"time\"\nimport \"strings\"\nimport \"bytes\"\nfunc (s *Server) Stop() {}\n```\n\n### MODULE: `configx`\n> Signature: `package configx`\n> Lines: 286-293\n```\npackage configx\npackage jobsx\npackage metricx\nimport \"os\"\nimport \"time\"\nimport \"strings\"\nimport \"bytes\"\nfunc (s *Server) Stop() {}\n```\n\n### MODULE: `jobsx`\n> Signature: `package jobsx`\n> Lines: 287-293\n```\npackage jobsx\npackage metricx\nimport \"os\"\nimport \"time\"\nimport \"strings\"\nimport \"bytes\"\nfunc (s *Server) Stop() {}\n```\n\n### MODULE: `metricx`\n> Signature: `package metricx`\n> Lines: 288-293\n```\npackage metricx\nimport \"os\"\nimport \"time\"\nimport \"strings\"\nimport \"bytes\"\nfunc (s *Server) Stop() {}\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### METHOD: `Stop`\n> Signature: `func (s *Server) Stop() {}`\n> Lines: 293-293\n```\nfunc (s *Server) Stop() {}\n```\n\n### METHOD: `Reset`\n> Signature: `func (s *Server) Reset() {}`\n> Lines: 294-294\n```\nfunc (s *Server) Reset() {}\n```\n\n### STRUCT: `Session`\n> Signature: `type Session struct { Id string }`\n> Lines: 295-295\n```\ntype Session struct { Id string }\n```\n\n### STRUCT: `Bucket`\n> Signature: `type Bucket struct { Name string }`\n> Lines: 296-296\n```\ntype Bucket struct { Name string }\n```\n\n### INTERFACE: `Closer`\n> Signature: `type Closer interface { Close() error }`\n> Lines: 297-297\n```\ntype Closer interface { Close() error }\n```\n\n### INTERFACE: `Starter`\n> Signature: `type Starter interface { Start() error }`\n> Lines: 298-298\n```\ntype Starter interface { Start() error }\n```\n\n### TYPE_ALIAS: `UserAlias`\n> Signature: `type UserAlias string`\n> Lines: 299-299\n```\ntype UserAlias string\n```\n\n### TYPE_ALIAS: `Amount`\n> Signature: `type Amount int`\n> Lines: 300-300\n```\ntype Amount int\n```\n\n### TYPE_ALIAS: `Resolver`\n> Signature: `type Resolver func(string) error`\n> Lines: 301-301\n```\ntype Resolver func(string) error\n```\n\n### CONSTANT: `RetryCount`\n> Signature: `const RetryCount = 3`\n> Lines: 302-302\n```\nconst RetryCount = 3\n```\n\n### CONSTANT: `LastError`\n> Signature: `var LastError error`\n> Lines: 303-303\n```\nvar LastError error\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_haskell.hs.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_haskell.hs | haskell\n\n### MODULE: `MyModule`\n> Signature: `module MyModule`\n> Lines: 11-21\n```\nmodule MyModule\n  ( Name\n  , Person(..)\n  , Printable(..)\n  , Expr(..)\n  , greet\n  , safeDiv\n  , processList\n  , fibonacci\n  ) where\n```\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### TYPE_ALIAS: `Name`\n> Signature: `type Name = String`\n> Lines: 30-30\n```\ntype Name = String\n```\n\n### TYPE_ALIAS: `Config`\n> Signature: `type Config = Map.Map String Int`\n> Lines: 33-33\n```\ntype Config = Map.Map String Int\n```\n\n### TYPE_ALIAS: `Transform`\n> Signature: `type Transform a = a -> a`\n> Lines: 36-36\n```\ntype Transform a = a -> a\n```\n\n### STRUCT: `Person`\n> Signature: `data Person = Person`\n> Lines: 42-46\n```\ndata Person = Person\n  { personName :: String\n  , personAge  :: Int\n  } deriving (Show, Eq, Ord)\n```\n\n### STRUCT: `Tree`\n> Signature: `data Tree a`\n> Lines: 49-53\n```\ndata Tree a\n  = Leaf\n  | Node a (Tree a) (Tree a)\n  deriving (Show, Eq)\n```\n\n### STRUCT: `Expr`\n> Signature: `data Expr`\n> Lines: 56-62\n```\ndata Expr\n  = Lit Double\n  | Add Expr Expr\n  | Mul Expr Expr\n  | Neg Expr\n  deriving (Show)\n```\n\n### STRUCT: `Result`\n> Signature: `data Result a`\n> Lines: 64-68\n```\ndata Result a\n  = Ok a\n  | Err String\n  deriving (Show)\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### MODULE: `Extra.One`\n> Signature: `module Extra.One where`\n> Lines: 197-197\n```\nmodule Extra.One where\n```\n\n### MODULE: `Extra.Two`\n> Signature: `module Extra.Two where`\n> Lines: 198-198\n```\nmodule Extra.Two where\n```\n\n### MODULE: `Extra.Three`\n> Signature: `module Extra.Three where`\n> Lines: 199-199\n```\nmodule Extra.Three where\n```\n\n### MODULE: `Extra.Four`\n> Signature: `module Extra.Four where`\n> Lines: 200-200\n```\nmodule Extra.Four where\n```\n\n### IMPORT: `Data.Set as Set`\n> Lines: 201-201\n```\nimport qualified Data.Set as Set\n```\n\n### TYPE_ALIAS: `RequestId`\n> Signature: `type RequestId = Int`\n> Lines: 202-202\n```\ntype RequestId = Int\n```\n\n### TYPE_ALIAS: `ResponseId`\n> Signature: `type ResponseId = Int`\n> Lines: 203-203\n```\ntype ResponseId = Int\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### STRUCT: `Envelope`\n> Signature: `data Envelope = Envelope String`\n> Lines: 207-208\n```\ndata Envelope = Envelope String\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_java.java.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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### MODULE: `com.example.app`\n> Signature: `package com.example.app`\n> Lines: 11-29\n```\npackage com.example.app;\nimport java.util.List;\nimport java.util.Map;\nimport java.util.Optional;\nimport java.util.function.Function;\nimport java.util.function.Predicate;\nimport java.util.stream.Collectors;\nimport static java.lang.Math.PI;\n@interface RequiresAuth {\nString role() default \"user\";\n}\n```\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### CONSTANT: `MAX_SIZE`\n> Signature: `public static final int MAX_SIZE = 100`\n> Lines: 42-42\n- @brief Maximum buffer size constant. */\n```\npublic static final int MAX_SIZE = 100;\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### INTERFACE: `Greeter`\n> Signature: `public interface Greeter`\n> Lines: 173-196\n- @brief Functional interface for greeting operations.\n- @brief Perform a greeting to the named person.\n- @param name Recipient of the greeting.\n```\npublic interface Greeter {\nvoid sayHello(String name);\ndefault void sayGoodbye(String name) {\nSystem.out.println(\"Goodbye, \" + name);\n}\nstatic Greeter simple() {\nreturn name -> System.out.println(\"Hi, \" + name);\n}\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### ENUM: `Color`\n> Signature: `public enum Color`\n> Lines: 204-230\n- @brief Color enum with associated hex values and behavior.\n- @brief Red color with hex #FF0000.\n- @brief Green color with hex #00FF00.\n```\npublic enum Color {\nRED(\"#FF0000\"),\nGREEN(\"#00FF00\"),\nBLUE(\"#0000FF\");\nprivate final String hex;\nColor(String hex) {\nthis.hex = hex;\n}\npublic String getHex() {\nreturn hex;\n}\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### MODULE: `com.example.extra.one`\n> Signature: `package com.example.extra.one`\n> Lines: 364-368\n```\npackage com.example.extra.one;\npackage com.example.extra.two;\npackage com.example.extra.three;\npackage com.example.extra.four;\ninterface Runner {}\n```\n\n### MODULE: `com.example.extra.two`\n> Signature: `package com.example.extra.two`\n> Lines: 365-368\n```\npackage com.example.extra.two;\npackage com.example.extra.three;\npackage com.example.extra.four;\ninterface Runner {}\n```\n\n### MODULE: `com.example.extra.three`\n> Signature: `package com.example.extra.three`\n> Lines: 366-368\n```\npackage com.example.extra.three;\npackage com.example.extra.four;\ninterface Runner {}\n```\n\n### MODULE: `com.example.extra.four`\n> Signature: `package com.example.extra.four`\n> Lines: 367-368\n```\npackage com.example.extra.four;\ninterface Runner {}\n```\n\n### INTERFACE: `Runner`\n> Signature: `interface Runner {}`\n> Lines: 368-368\n```\ninterface Runner {}\n```\n\n### INTERFACE: `Mapper`\n> Signature: `public interface Mapper {}`\n> Lines: 369-369\n```\npublic interface Mapper {}\n```\n\n### INTERFACE: `Handler`\n> Signature: `public interface Handler {}`\n> Lines: 370-370\n```\npublic interface Handler {}\n```\n\n### INTERFACE: `Auditor`\n> Signature: `public interface Auditor {}`\n> Lines: 371-371\n```\npublic interface Auditor {}\n```\n\n### ENUM: `ModeJava`\n> Signature: `enum ModeJava { FAST, SAFE }`\n> Lines: 372-372\n```\nenum ModeJava { FAST, SAFE }\n```\n\n### ENUM: `PhaseJava`\n> Signature: `enum PhaseJava { INIT, RUN }`\n> Lines: 373-373\n```\nenum PhaseJava { INIT, RUN }\n```\n\n### ENUM: `StatusJava`\n> Signature: `enum StatusJava { OPEN, CLOSED }`\n> Lines: 374-374\n```\nenum StatusJava { OPEN, CLOSED }\n```\n\n### ENUM: `KindJava`\n> Signature: `enum KindJava { A, B }`\n> Lines: 375-375\n```\nenum KindJava { A, B }\n```\n\n### CONSTANT: `DEFAULT_LIMIT`\n> Signature: `public static final int DEFAULT_LIMIT = 10`\n> Lines: 376-376\n```\npublic static final int DEFAULT_LIMIT = 10;\n```\n\n### CONSTANT: `RETRY_LIMIT`\n> Signature: `public static final int RETRY_LIMIT = 3`\n> Lines: 377-377\n```\npublic static final int RETRY_LIMIT = 3;\n```\n\n### CONSTANT: `BUFFER_SIZE`\n> Signature: `public static final int BUFFER_SIZE = 512`\n> Lines: 378-378\n```\npublic static final int BUFFER_SIZE = 512;\n```\n\n### CONSTANT: `MAX_USERS`\n> Signature: `public static final int MAX_USERS = 99`\n> Lines: 379-379\n```\npublic static final int MAX_USERS = 99;\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_javascript.js.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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### CONSTANT: `MAX_SIZE`\n> Signature: `const MAX_SIZE = 100`\n> Lines: 141-141\n```\nconst MAX_SIZE = 100;\n```\n\n### CONSTANT: `PLUGIN_KEY`\n> Signature: `const PLUGIN_KEY = Symbol('plugin')`\n> Lines: 144-144\n```\nconst PLUGIN_KEY = Symbol('plugin');\n```\n\n### COMPONENT: `MyWrapped`\n> Signature: `const MyWrapped = React.memo(() =>`\n> Lines: 153-155\n- @brief Memoized functional component demonstrating React.memo usage.\n- @return {null} Renders nothing; serves as a parser test case.\n```\nconst MyWrapped = React.memo(() => {\nreturn null;\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### MODULE: `fs`\n> Signature: `const fs = require('fs')`\n> Lines: 297-307\n- @brief Load the Node.js filesystem module via CommonJS. */\n```\nconst fs = require('fs');\nconst _privateState = new WeakMap();\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### COMPONENT: `BoundComponent`\n> Signature: `const BoundComponent = React.memo(() => null)`\n> Lines: 335-336\n```\nconst BoundComponent = React.memo(() => null);\nconst ForwardedWidget = React.forwardRef((_, ref) => ({ ref }));\n```\n\n### COMPONENT: `ForwardedWidget`\n> Signature: `const ForwardedWidget = React.forwardRef((_, ref) => ({ ref }))`\n> Lines: 336-336\n```\nconst ForwardedWidget = React.forwardRef((_, ref) => ({ ref }));\n```\n\n### COMPONENT: `LazyWidget`\n> Signature: `const LazyWidget = React.lazy(() => import('./Widget'))`\n> Lines: 337-353\n```\nconst LazyWidget = React.lazy(() => import('./Widget'));\nconst MemoPanel = memo(() => null);\nconst API_TOKEN = 'tok';\nconst CACHE_SIZE = 128;\nconst RETRY_LIMIT = 5;\nconst pathMod = require('path');\nconst cryptoMod = require('crypto');\nconst utilMod = require('util');\nconst osMod = require('os');\nfunction reqCoverJs1(value) { return value + 1; }\n```\n\n### COMPONENT: `MemoPanel`\n> Signature: `const MemoPanel = memo(() => null)`\n> Lines: 338-353\n```\nconst MemoPanel = memo(() => null);\nconst API_TOKEN = 'tok';\nconst CACHE_SIZE = 128;\nconst RETRY_LIMIT = 5;\nconst pathMod = require('path');\nconst cryptoMod = require('crypto');\nconst utilMod = require('util');\nconst osMod = require('os');\nfunction reqCoverJs1(value) { return value + 1; }\n```\n\n### CONSTANT: `API_TOKEN`\n> Signature: `const API_TOKEN = 'tok'`\n> Lines: 339-339\n```\nconst API_TOKEN = 'tok';\n```\n\n### CONSTANT: `CACHE_SIZE`\n> Signature: `const CACHE_SIZE = 128`\n> Lines: 340-340\n```\nconst CACHE_SIZE = 128;\n```\n\n### CONSTANT: `RETRY_LIMIT`\n> Signature: `const RETRY_LIMIT = 5`\n> Lines: 341-341\n```\nconst RETRY_LIMIT = 5;\n```\n\n### MODULE: `pathMod`\n> Signature: `const pathMod = require('path')`\n> Lines: 342-353\n```\nconst pathMod = require('path');\nconst cryptoMod = require('crypto');\nconst utilMod = require('util');\nconst osMod = require('os');\nfunction reqCoverJs1(value) { return value + 1; }\n```\n\n### MODULE: `cryptoMod`\n> Signature: `const cryptoMod = require('crypto')`\n> Lines: 343-353\n```\nconst cryptoMod = require('crypto');\nconst utilMod = require('util');\nconst osMod = require('os');\nfunction reqCoverJs1(value) { return value + 1; }\n```\n\n### MODULE: `utilMod`\n> Signature: `const utilMod = require('util')`\n> Lines: 344-353\n```\nconst utilMod = require('util');\nconst osMod = require('os');\nfunction reqCoverJs1(value) { return value + 1; }\n```\n\n### MODULE: `osMod`\n> Signature: `const osMod = require('os')`\n> Lines: 345-353\n```\nconst osMod = require('os');\nfunction reqCoverJs1(value) { return value + 1; }\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_kotlin.kt.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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### MODULE: `Loading`\n> Signature: `object Loading : Result<Nothing>()`\n> Lines: 48-60\n- @brief Singleton state representing an in-progress operation.\n- @brief Map the success value using a transform function. @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```\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### INTERFACE: `Repository`\n> Signature: `interface Repository<T>`\n> Lines: 70-90\n- @brief Generic CRUD repository interface.\n@tparam T Entity type managed by this repository.\n- @brief Find an entity by its unique identifier.\n- @param id Entity ID.\n- @return The entity or null if not found.\n```\ninterface Repository<T> {\nfun findById(id: Int): T?\nfun save(entity: T): Boolean\nfun findAll(): Flow<T>\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### CONSTANT: `id`\n> Signature: `val id: Int`\n> Lines: 98-98\n- @brief Unique entity identifier. */\n```\nval id: Int\n```\n\n### ENUM: `Color`\n> Signature: `enum class Color(val hex: String)`\n> Lines: 107-123\n- @brief Color enum with hex value property and companion factory.\n- @brief Red color channel.\n- @brief Green color channel.\n```\nenum class Color(val hex: String) {\nRED(\"#FF0000\"),\nGREEN(\"#00FF00\"),\nBLUE(\"#0000FF\");\ncompanion object {\nfun fromHex(hex: String): Color? = values().find { it.hex == hex }\n}\n}\n```\n\n### MODULE: `companion object`\n> Signature: `companion object`\n> Lines: 115-122\n- @brief Blue color channel. */\n- @brief Parse a color from its hex string.\n- @param hex Hex color code including '#' prefix.\n- @return Matching Color or null.\n```\ncompanion object {\nfun fromHex(hex: String): Color? = values().find { it.hex == hex }\n}\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### CONSTANT: `name`\n> Signature: `val name: String,`\n> Lines: 136-136\n```\nval name: String,\n```\n\n### CONSTANT: `status`\n> Signature: `val status: String = \"active\",`\n> Lines: 137-137\n```\nval status: String = \"active\",\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### CONSTANT: `domain`\n> Signature: `val domain: String get() = value.substringAfter('@')`\n> Lines: 154-154\n- @brief Extract the domain part of the email. */\n```\nval domain: String get() = value.substringAfter('@')\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### CONSTANT: `String`\n> Signature: `val String.lastChar: Char?`\n> Lines: 205-205\n- @brief Extension property returning the last character or null.\n@receiver String The string to inspect.\n```\nval String.lastChar: Char?\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### CONSTANT: `PI`\n> Signature: `val PI = 3.14159265`\n> Lines: 254-254\n- @brief Mathematical constant Pi. */\n```\nval PI = 3.14159265\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### MODULE: `Singleton`\n> Signature: `object Singleton`\n> Lines: 265-286\n- @brief Application-wide singleton for configuration management.\n- @brief Mutable configuration map.\n```\nobject Singleton {\nprivate val config = mutableMapOf<String, Any>()\nfun set(key: String, value: Any) {\nconfig[key] = value\n}\n@Suppress(\"UNCHECKED_CAST\")\nfun <T> get(key: String): T? = config[key] as? T\n}\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### MODULE: `Factory`\n> Signature: `companion object Factory`\n> Lines: 292-293\n- @brief Companion object pattern for factory construction.\n```\ncompanion object Factory {\n}\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### CONSTANT: `resource`\n> Signature: `val resource: String by lazy`\n> Lines: 329-329\n- @brief Lazily computed expensive resource. */\n```\nval resource: String by lazy {\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### CONSTANT: `inner`\n> Signature: `val inner = HtmlBuilder()`\n> Lines: 355-355\n```\nval inner = HtmlBuilder()\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### CONSTANT: `builder`\n> Signature: `val builder = HtmlBuilder()`\n> Lines: 382-382\n```\nval builder = HtmlBuilder()\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### INTERFACE: `Logger`\n> Signature: `interface Logger`\n> Lines: 390-394\n```\ninterface Logger\ninterface Parser\ninterface Emitter\ninterface Formatter\nenum class ModeKt { FAST, SAFE }\n```\n\n### INTERFACE: `Parser`\n> Signature: `interface Parser`\n> Lines: 391-394\n```\ninterface Parser\ninterface Emitter\ninterface Formatter\nenum class ModeKt { FAST, SAFE }\n```\n\n### INTERFACE: `Emitter`\n> Signature: `interface Emitter`\n> Lines: 392-394\n```\ninterface Emitter\ninterface Formatter\nenum class ModeKt { FAST, SAFE }\n```\n\n### INTERFACE: `Formatter`\n> Signature: `interface Formatter`\n> Lines: 393-394\n```\ninterface Formatter\nenum class ModeKt { FAST, SAFE }\n```\n\n### ENUM: `ModeKt`\n> Signature: `enum class ModeKt { FAST, SAFE }`\n> Lines: 394-394\n```\nenum class ModeKt { FAST, SAFE }\n```\n\n### ENUM: `PhaseKt`\n> Signature: `enum class PhaseKt { INIT, RUN }`\n> Lines: 395-395\n```\nenum class PhaseKt { INIT, RUN }\n```\n\n### ENUM: `StatusKt`\n> Signature: `enum class StatusKt { READY, WAITING }`\n> Lines: 396-396\n```\nenum class StatusKt { READY, WAITING }\n```\n\n### ENUM: `SignalKt`\n> Signature: `enum class SignalKt { ON, OFF }`\n> Lines: 397-397\n```\nenum class SignalKt { ON, OFF }\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### MODULE: `CacheStore`\n> Signature: `object CacheStore`\n> Lines: 400-400\n```\nobject CacheStore\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_lua.lua.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_perl.pl.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_perl.pl | perl\n\n### MODULE: `MyPackage`\n> Signature: `package MyPackage`\n> Lines: 16-16\n- @brief Comprehensive Perl test fixture for parser validation.\n- @brief Documentation block for the fixture module.\n- @details Covers OOP with bless, Moose-like attributes, closures,\nhere-docs, wantarray, dispatch tables, prototypes, AUTOLOAD,\nand regular expressions.\nSingle line comment\n=pod\n- @details This module demonstrates advanced Perl constructs including\nobject-oriented patterns, closures, and metaprogramming.\n=cut\n```\npackage MyPackage;\n```\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### CONSTANT: `MAX_SIZE`\n> Signature: `use constant MAX_SIZE => 100`\n> Lines: 22-22\n```\nuse constant MAX_SIZE => 100;\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### MODULE: `Extra::One`\n> Signature: `package Extra::One`\n> Lines: 248-248\n```\npackage Extra::One;\n```\n\n### MODULE: `Extra::Two`\n> Signature: `package Extra::Two`\n> Lines: 249-249\n```\npackage Extra::Two;\n```\n\n### MODULE: `Extra::Three`\n> Signature: `package Extra::Three`\n> Lines: 250-250\n```\npackage Extra::Three;\n```\n\n### MODULE: `Extra::Four`\n> Signature: `package Extra::Four`\n> Lines: 251-251\n```\npackage Extra::Four;\n```\n\n### CONSTANT: `RETRY_LIMIT`\n> Signature: `use constant RETRY_LIMIT => 5`\n> Lines: 252-252\n```\nuse constant RETRY_LIMIT => 5;\n```\n\n### CONSTANT: `API_HOST`\n> Signature: `use constant API_HOST => 'localhost'`\n> Lines: 253-253\n```\nuse constant API_HOST => 'localhost';\n```\n\n### CONSTANT: `FEATURE_FLAG`\n> Signature: `use constant FEATURE_FLAG => 1`\n> Lines: 254-254\n```\nuse constant FEATURE_FLAG => 1;\n```\n\n### CONSTANT: `CACHE_SIZE`\n> Signature: `use constant CACHE_SIZE => 256`\n> Lines: 255-255\n```\nuse constant CACHE_SIZE => 256;\n```\n\n### CONSTANT: `DEFAULT_USER`\n> Signature: `use constant DEFAULT_USER => 'guest'`\n> Lines: 256-256\n```\nuse constant DEFAULT_USER => 'guest';\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_php.php.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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### NAMESPACE: `App\\Models`\n> Signature: `namespace App\\Models`\n> Lines: 12-15\n```\nnamespace App\\Models;\nuse App\\Contracts\\Repository;\nuse App\\Events\\{ModelCreated, ModelDeleted};\n```\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### CONSTANT: `VERSION`\n> Signature: `const VERSION = \"1.0\"`\n> Lines: 22-22\n- @brief Application version string. */\n```\nconst VERSION = \"1.0\";\n```\n\n### CONSTANT: `MAX_PER_PAGE`\n> Signature: `const MAX_PER_PAGE = 50`\n> Lines: 25-25\n- @brief Maximum number of query results per page. */\n```\nconst MAX_PER_PAGE = 50;\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### INTERFACE: `Repo`\n> Signature: `interface Repo`\n> Lines: 187-207\n- @brief Generic repository interface for data access patterns.\n- @brief Retrieve all entities.\n- @return iterable<BaseModel> Collection of models.\n```\ninterface Repo {\npublic function findAll(): iterable;\npublic function findById(int $id): ?BaseModel;\npublic function count(array $criteria = []): int;\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### TRAIT: `Cacheable`\n> Signature: `trait Cacheable`\n> Lines: 215-241\n- @brief Provides caching capabilities for models.\n- @brief Cache TTL in seconds.\n```\ntrait Cacheable {\nprotected int $cacheTtl = 3600;\npublic function cache(): bool {\nreturn true;\n}\npublic function invalidateCache(): void {\n}\nabstract public function cacheKey(): string;\n}\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### TRAIT: `SoftDeletable`\n> Signature: `trait SoftDeletable`\n> Lines: 247-266\n- @brief Adds soft delete functionality to models.\n- @brief Timestamp of soft deletion or null if active.\n```\ntrait SoftDeletable {\nprotected ?\\DateTimeImmutable $deletedAt = null;\npublic function softDelete(): void {\n$this->deletedAt = new \\DateTimeImmutable();\n}\npublic function isDeleted(): bool {\nreturn $this->deletedAt !== null;\n}\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### NAMESPACE: `App\\Services`\n> Signature: `namespace App\\Services`\n> Lines: 371-375\n```\nnamespace App\\Services;\nnamespace App\\Http;\nnamespace App\\Domain;\nnamespace App\\Support;\ninterface ServiceContract {}\n```\n\n### NAMESPACE: `App\\Http`\n> Signature: `namespace App\\Http`\n> Lines: 372-375\n```\nnamespace App\\Http;\nnamespace App\\Domain;\nnamespace App\\Support;\ninterface ServiceContract {}\n```\n\n### NAMESPACE: `App\\Domain`\n> Signature: `namespace App\\Domain`\n> Lines: 373-375\n```\nnamespace App\\Domain;\nnamespace App\\Support;\ninterface ServiceContract {}\n```\n\n### NAMESPACE: `App\\Support`\n> Signature: `namespace App\\Support`\n> Lines: 374-375\n```\nnamespace App\\Support;\ninterface ServiceContract {}\n```\n\n### INTERFACE: `ServiceContract`\n> Signature: `interface ServiceContract {}`\n> Lines: 375-375\n```\ninterface ServiceContract {}\n```\n\n### INTERFACE: `CacheContract`\n> Signature: `interface CacheContract {}`\n> Lines: 376-376\n```\ninterface CacheContract {}\n```\n\n### INTERFACE: `LoggerContract`\n> Signature: `interface LoggerContract {}`\n> Lines: 377-377\n```\ninterface LoggerContract {}\n```\n\n### INTERFACE: `EventContract`\n> Signature: `interface EventContract {}`\n> Lines: 378-378\n```\ninterface EventContract {}\n```\n\n### TRAIT: `HandlesEvents`\n> Signature: `trait HandlesEvents {}`\n> Lines: 379-379\n```\ntrait HandlesEvents {}\n```\n\n### TRAIT: `TracksChanges`\n> Signature: `trait TracksChanges {}`\n> Lines: 380-380\n```\ntrait TracksChanges {}\n```\n\n### TRAIT: `AuthorizesRequests`\n> Signature: `trait AuthorizesRequests {}`\n> Lines: 381-381\n```\ntrait AuthorizesRequests {}\n```\n\n### CONSTANT: `API_LIMIT`\n> Signature: `const API_LIMIT = 50`\n> Lines: 382-382\n```\nconst API_LIMIT = 50;\n```\n\n### CONSTANT: `DEFAULT_PAGE`\n> Signature: `const DEFAULT_PAGE = 1`\n> Lines: 383-383\n```\nconst DEFAULT_PAGE = 1;\n```\n\n### CONSTANT: `TIMEOUT`\n> Signature: `const TIMEOUT = 30`\n> Lines: 384-384\n```\nconst TIMEOUT = 30;\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",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_python.py.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/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",
-  "stderr": ""
-}