pi-usereq 0.4.0

package/tests/fixtures_attended_results/standalone/files-compress-line-numbers/fixture_ruby.rb.json

@@ -0,0 +1,5 @@
+{
+  "code": 0,
+  "stdout": "@@@ tests/fixtures/fixture_ruby.rb | ruby\n> Lines: 10-343\n```\n10: require 'json'\n11: require 'set'\n12: require_relative 'helper'\n15: MAX_RETRIES = 42\n18: DEFAULT_ENCODING = 'utf-8'.freeze\n20: attr_accessor :name, :age\n26: module Loggable\n29: def log(message)\n30: puts \"[#{self.class.name}] #{message}\"\n31: end\n35: def log_error(error)\n36: puts \"[ERROR] #{error.message}\"\n37: puts error.backtrace.first(5).join(\"\\n\") if error.backtrace\n38: end\n39: end\n47: class MyClass\n48: include Loggable\n49: include Comparable\n52: attr_accessor :name\n55: attr_reader :created_at\n60: def initialize(name, **options)\n61: @name = name\n62: @options = options\n63: @created_at = Time.now\n65: @options[:retries] ||= MAX_RETRIES\n66: end\n71: def self.create(attrs)\n72: new(attrs[:name], **attrs.except(:name))\n73: end\n78: def self.bulk_create(names)\n79: names.map { |n| new(n) }\n80: end\n84: def valid?\n85: !@name.nil? && !@name.empty?\n86: end\n91: def matches?(pattern)\n92: return false if @name.nil?\n93: pattern.match?(@name)\n94: end\n99: def <=>(other)\n100: @name <=> other.name\n101: end\n106: def +(other)\n107: self.class.new(\"#{@name}+#{other.name}\")\n108: end\n112: def to_s\n113: \"MyClass(#{@name})\"\n114: end\n121: def method_missing(method, *args, &block)\n122: if method.to_s.start_with?('find_by_')\n123: field = method.to_s.sub('find_by_', '')\n124: \"Finding by #{field}: #{args.first}\"\n125: else\n126: super\n127: end\n128: end\n134: def respond_to_missing?(method, include_private = false)\n135: method.to_s.start_with?('find_by_') || super\n136: end\n138: protected\n142: def internal_config\n143: @options.dup\n144: end\n146: private\n150: def validate!\n151: raise \"Invalid name\" unless valid?\n152: end\n153: end\n160: class SpecialClass < MyClass\n164: def initialize(name, priority: 0, **options)\n165: super(name, **options)\n166: @priority = priority\n167: end\n171: def to_s\n172: \"SpecialClass(#{@name}, pri=#{@priority})\"\n173: end\n174: end\n180: module MyModule\n183: def helper\n184: true\n185: end\n191: def process_with_block(data)\n192: if block_given?\n193: yield(data)\n194: else\n195: data\n196: end\n197: end\n204: def self.format_list(items)\n205: items.map(&:to_s).join(', ')\n206: end\n207: end\n213: Coordinate = Struct.new(:x, :y) do\n216: def distance_from_origin\n217: Math.sqrt(x**2 + y**2)\n218: end\n219: end\n225: class DynamicModel\n227: %w[title body author].each do |field|\n229: define_method(field) do\n230: instance_variable_get(\"@#{field}\")\n231: end\n234: define_method(\"#{field}=\") do |value|\n235: instance_variable_set(\"@#{field}\", value)\n236: end\n237: end\n238: end\n243: doubler = ->(x) { x * 2 }\n246: greeting_proc = Proc.new { |name| \"Hello, #{name}!\" }\n255: def with_retry(attempts: MAX_RETRIES)\n256: tries = 0\n257: begin\n258: tries += 1\n259: yield\n260: rescue StandardError => e\n262: retry if tries < attempts\n263: raise \"Failed after #{attempts} attempts: #{e.message}\"\n264: ensure\n266: puts \"Completed after #{tries} attempt(s)\"\n267: end\n268: end\n274: module StringExtensions\n275: refine String do\n278: def email?\n279: match?(/\\A[\\w+\\-.]+@[a-z\\d\\-]+(\\.[a-z\\d\\-]+)*\\.[a-z]+\\z/i)\n280: end\n281: end\n282: end\n287: class ServiceObject; end\n288: class ReportBuilder; end\n289: module Metrics; end\n290: module Extras; end\n291: MAX_LIMIT = 100\n292: API_VERSION = \"v2\"\n293: CACHE_SIZE = 1024\n294: attr_writer :token\n295: attr_reader :state\n296: require 'yaml'\n297: require 'logger'\n305: def req_cover_ruby_1(value)\n306: value + 1\n307: end\n314: def req_cover_ruby_2(value)\n315: value + 2\n316: end\n323: def req_cover_ruby_3(value)\n324: value + 3\n325: end\n332: def req_cover_ruby_4(value)\n333: value + 4\n334: end\n341: def req_cover_ruby_5(value)\n342: value + 5\n343: end\n```\n",
+  "stderr": ""
+}

package/tests/fixtures_attended_results/standalone/files-compress-line-numbers/fixture_rust.rs.json

@@ -0,0 +1,5 @@
+{
+  "code": 0,
+  "stdout": "@@@ tests/fixtures/fixture_rust.rs | rust\n> Lines: 9-378\n```\n9: use std::io;\n10: use std::collections::HashMap;\n11: use std::fmt::{self, Display, Formatter};\n12: use std::sync::{Arc, Mutex};\n19: #[derive(Debug, Clone, PartialEq)]\n20: pub struct MyStruct {\n22: field: i32,\n23: }\n29: #[derive(Debug)]\n30: pub struct BorrowedData<'a> {\n32: content: &'a str,\n34: tag: u64,\n35: }\n41: pub struct TypedMap<K: std::hash::Hash + Eq, V: Clone> {\n43: inner: HashMap<K, V>,\n44: }\n51: pub enum MyEnum {\n53: A,\n55: B(String),\n57: C { x: i32, y: i32 },\n58: }\n65: pub trait MyTrait {\n67: fn do_work(&self);\n73: fn do_work_with_ctx(&self, ctx: &str) -> bool {\n75: println!(\"ctx: {}\", ctx);\n76: self.do_work();\n77: true\n78: }\n79: }\n85: pub trait Parser<'a> {\n87: type Output;\n93: fn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>;\n94: }\n96: impl MyStruct {\n100: fn new() -> Self {\n101: Self { field: 0 }\n102: }\n108: pub fn with_value(val: i32) -> Self {\n109: Self { field: val }\n110: }\n115: pub fn value(&self) -> i32 {\n116: self.field\n117: }\n123: pub fn try_update(&mut self, new_val: i32) -> Option<i32> {\n124: if new_val == self.field {\n125: return None;\n126: }\n127: let old = self.field;\n128: self.field = new_val;\n130: Some(old)\n131: }\n132: }\n134: impl MyTrait for MyStruct {\n136: fn do_work(&self) {\n137: println!(\"{:?}\", self);\n138: }\n139: }\n141: impl Display for MyStruct {\n146: fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\n147: write!(f, \"MyStruct({})\", self.field)\n148: }\n149: }\n153: impl<K, V> TypedMap<K, V>\n154: where\n155: K: std::hash::Hash + Eq + Display,\n156: V: Clone + Default,\n157: {\n163: pub fn insert(&mut self, key: K, value: V) -> Option<V> {\n164: self.inner.insert(key, value)\n165: }\n171: pub fn get_or_default(&self, key: &K) -> V {\n172: match self.inner.get(key) {\n173: Some(v) => v.clone(),\n174: None => V::default(),\n175: }\n176: }\n177: }\n182: pub mod my_module;\n185: pub(crate) mod internal {\n187: pub(crate) static COUNTER: std::sync::atomic::AtomicUsize =\n188: std::sync::atomic::AtomicUsize::new(0);\n189: }\n196: macro_rules! hashmap {\n197: ($($key:expr => $val:expr),* $(,)?) => {{\n198: let mut map = HashMap::new();\n199: $(map.insert($key, $val);)*\n200: map\n201: }};\n202: }\n205: macro_rules! my_macro {\n206: () => {};\n207: ($x:expr) => { println!(\"{}\", $x) };\n208: ($x:expr, $($rest:expr),+) => {\n209: print!(\"{}, \", $x);\n210: my_macro!($($rest),+);\n211: };\n212: }\n217: const MY_CONST: i32 = 42;\n220: static MY_STATIC: i32 = 0;\n223: static CONFIG: std::sync::LazyLock<HashMap<String, String>> =\n224: std::sync::LazyLock::new(|| HashMap::new());\n229: pub type IoResult<T> = Result<T, io::Error>;\n232: pub type MyAlias = i32;\n240: pub fn my_function(input: Option<&str>) -> String {\n242: let text = match input {\n243: Some(s) if !s.is_empty() => s,\n244: Some(_) => return String::from(\"empty\"),\n245: None => return String::from(\"none\"),\n246: };\n248: text.to_uppercase()\n249: }\n254: pub async fn async_function() -> String {\n256: String::from(\"hello async\")\n257: }\n264: pub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>\n265: where\n266: F: Fn(&i32) -> bool,\n267: {\n268: items.iter().copied().filter(|x| predicate(x)).collect()\n269: }\n275: pub fn create_worker(use_struct: bool) -> Box<dyn MyTrait> {\n276: if use_struct {\n277: Box::new(MyStruct::new())\n278: } else {\n279: panic!(\"No alternative implementation available\");\n280: }\n281: }\n288: pub unsafe fn read_raw(ptr: *const i32) -> i32 {\n290: *ptr\n291: }\n297: pub extern \"C\" fn ffi_double(x: i32) -> i32 {\n298: x * 2\n299: }\n305: pub fn describe_enum(val: &MyEnum) -> String {\n306: match val {\n307: MyEnum::A => String::from(\"unit\"),\n308: MyEnum::B(s) => format!(\"string: {}\", s),\n309: MyEnum::C { x, y } => {\n311: let mag = ((x * x + y * y) as f64).sqrt();\n312: format!(\"point({}, {}) mag={:.2}\", x, y, mag)\n313: }\n314: }\n315: }\n318: use std::time::Duration;\n319: pub mod ext_tools { pub fn id() -> i32 { 1 } }\n320: mod ext_local { pub fn ping() -> i32 { 2 } }\n321: pub mod ext_api { pub fn pong() -> i32 { 3 } }\n322: #[inline]\n323: #[allow(dead_code)]\n324: #[cfg(test)]\n325: pub enum Status { Ready, Busy }\n326: pub enum Mode { Alpha, Beta }\n327: pub enum Signal { On, Off }\n328: pub enum ErrorKind { Io, Parse }\n329: pub struct ExtraNode { pub id: i32 }\n330: struct InnerNode { id: i32 }\n331: pub trait Inspectable { fn inspect(&self) -> i32; }\n332: trait Named { fn name(&self) -> &'static str; }\n333: pub trait Executable { fn exec(&self) -> i32; }\n334: impl Inspectable for ExtraNode { fn inspect(&self) -> i32 { self.id } }\n335: impl Named for InnerNode { fn name(&self) -> &'static str { \"inner\" } }\n336: impl Executable for MyEnum { fn exec(&self) -> i32 { 1 } }\n337: macro_rules! ext_macro { () => { 42 } }\n338: macro_rules! trace_macro { ($v:expr) => { $v }; }\n339: macro_rules! build_pair { ($a:expr,$b:expr) => { ($a,$b) }; }\n340: pub const LIMIT: usize = 8;\n341: pub type ItemId = u64;\n342: type AliasValue = i32;\n350: fn req_cover_rust_1(value: i32) -> i32 { value + 1 }\n357: fn req_cover_rust_2(value: i32) -> i32 { value + 2 }\n364: fn req_cover_rust_3(value: i32) -> i32 { value + 3 }\n371: fn req_cover_rust_4(value: i32) -> i32 { value + 4 }\n378: fn req_cover_rust_5(value: i32) -> i32 { value + 5 }\n```\n",
+  "stderr": ""
+}

package/tests/fixtures_attended_results/standalone/files-compress-line-numbers/fixture_scala.scala.json

@@ -0,0 +1,5 @@
+{
+  "code": 0,
+  "stdout": "@@@ tests/fixtures/fixture_scala.scala | scala\n> Lines: 11-397\n```\n11: import scala.collection.mutable\n12: import scala.concurrent.{Future, ExecutionContext}\n13: import scala.util.{Try, Success, Failure}\n23: case class Person(name: String, age: Int) {\n28: def isAdult: Boolean = age >= 18\n34: def greet: String = s\"Hi, I'm $name, age $age\"\n35: }\n43: sealed trait Shape {\n48: def area: Double\n49: }\n56: case class Circle(radius: Double) extends Shape {\n57: override def area: Double = math.Pi * radius * radius\n58: }\n66: case class Rectangle(width: Double, height: Double) extends Shape {\n67: override def area: Double = width * height\n68: }\n76: abstract class Animal {\n81: def sound: String\n87: def describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n88: }\n96: trait Drawable {\n101: def draw(): Unit\n102: }\n109: trait Logging { self: Drawable =>\n113: def logAndDraw(): Unit = {\n114: println(\"About to draw\")\n115: draw()\n116: }\n117: }\n123: trait Serializable {\n128: def serialize: Array[Byte]\n129: }\n137: object Main {\n142: def main(args: Array[String]): Unit = {\n143: val people = List(Person(\"Alice\", 30), Person(\"Bob\", 17))\n145: val adults = people.filter(_.isAdult)\n146: adults.foreach(p => println(p.greet))\n147: }\n153: override def toString: String = \"Main\"\n156: val pi = 3.14159265\n159: var counter = 0\n164: type StringList = List[String]\n169: type Transformer[A] = A => A\n176: def describeShape(shape: Shape): String = shape match {\n177: case Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\n178: case Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n179: }\n186: def classify(x: Int): String = x match {\n187: case 0 => \"zero\"\n188: case n if n < 0 => \"negative\"\n189: case n if n > 100 => \"large\"\n190: case _ => \"positive\"\n191: }\n192: }\n201: class Config private (val entries: Map[String, String]) {\n207: def get(key: String): Option[String] = entries.get(key)\n208: }\n214: object Config {\n220: def apply(entries: (String, String)*): Config = new Config(entries.toMap)\n226: def empty: Config = new Config(Map.empty)\n227: }\n236: class Container[+A](val value: A) {\n243: def map[B](f: A => B): Container[B] = new Container(f(value))\n251: def flatMap[B](f: A => Container[B]): Container[B] = f(value)\n252: }\n261: implicit class RichInt(val n: Int) extends AnyVal {\n266: def isEven: Boolean = n % 2 == 0\n273: def times(s: String): String = s * n\n274: }\n282: object ForCompExample {\n289: def findPairs(range: Int, target: Int): List[(Int, Int)] = {\n290: for {\n291: x <- (1 to range).toList\n292: y <- (x to range).toList\n293: if x + y == target\n294: } yield (x, y)\n295: }\n296: }\n304: object FuncUtils {\n311: def add(a: Int)(b: Int): Int = a + b\n320: def twice[A](f: A => A)(x: A): A = f(f(x))\n331: def compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n332: }\n335: import scala.util.Random\n336: import scala.concurrent.duration._\n337: trait Runner\n338: trait Parser\n339: object Metrics\n340: val MaxUsers = 100\n341: val RetryLimit = 3\n342: type UserKey = String\n343: type ErrorCode = Int\n344: type Mapper = String => String\n345: var attempts = 0\n346: var cursor = 1\n347: var stage = \"init\"\n348: var status = \"ready\"\n351: object ReqCoverScala {\n359: def reqCoverScala1(value: Int): Int = value + 1\n368: def reqCoverScala2(value: Int): Int = value + 2\n377: def reqCoverScala3(value: Int): Int = value + 3\n386: def reqCoverScala4(value: Int): Int = value + 4\n395: def reqCoverScala5(value: Int): Int = value + 5\n397: }\n```\n",
+  "stderr": ""
+}

package/tests/fixtures_attended_results/standalone/files-compress-line-numbers/fixture_shell.sh.json

@@ -0,0 +1,5 @@
+{
+  "code": 0,
+  "stdout": "@@@ tests/fixtures/fixture_shell.sh | shell\n> Lines: 1-274\n```\n1: #!/bin/bash\n12: MY_VAR=\"hello\"\n15: export PATH_EXT=\"/usr/local/bin\"\n18: readonly MAX_COUNT=10\n21: declare -r BUILD_VERSION=\"1.0.0\"\n24: DEBUG_MODE=0\n29: declare -a LANGUAGES=(\"python\" \"rust\" \"go\" \"java\" \"typescript\")\n32: declare -A EXT_MAP=(\n33: [py]=\"python\"\n34: [rs]=\"rust\"\n35: [go]=\"go\"\n36: [java]=\"java\"\n37: [ts]=\"typescript\"\n38: )\n44: function greet() {\n45: local name=\"${1:?Name required}\"\n47: if [[ -z \"$name\" ]]; then\n48: echo \"Error: empty name\" >&2\n49: return 1\n50: fi\n51: echo \"Hello ${name}!\"\n52: }\n56: cleanup() {\n57: local tmp_dir=\"${TMPDIR:-/tmp}/myapp_$$\"\n58: if [[ -d \"$tmp_dir\" ]]; then\n60: rm -rf \"$tmp_dir\"\n61: fi\n62: echo \"Cleanup complete\"\n63: }\n68: parse_args() {\n69: local opt\n70: while getopts \"vdhf:o:\" opt; do\n71: case \"$opt\" in\n72: v)\n74: VERBOSE=1\n75: ;;\n76: d)\n78: DEBUG_MODE=1\n79: ;;\n80: f)\n82: INPUT_FILE=\"$OPTARG\"\n83: ;;\n84: o)\n86: OUTPUT_FILE=\"$OPTARG\"\n87: ;;\n88: h)\n89: echo \"Usage: $0 [-v] [-d] [-f file] [-o output] [-h]\"\n90: return 0\n91: ;;\n92: *)\n93: echo \"Unknown option: $opt\" >&2\n94: return 1\n95: ;;\n96: esac\n97: done\n98: shift $((OPTIND - 1))\n99: }\n105: process_file() {\n106: local input=\"$1\"\n107: local output=\"${2:-/dev/stdout}\"\n110: if [[ ! -f \"$input\" ]]; then\n111: echo \"Error: file not found: $input\" >&2\n112: return 1\n113: fi\n115: if [[ ! -r \"$input\" ]]; then\n116: echo \"Error: file not readable: $input\" >&2\n117: return 1\n118: fi\n121: local line_count\n122: line_count=$(wc -l < \"$input\")\n123: echo \"Processing $input ($line_count lines)\" >&2\n126: while IFS= read -r line; do\n128: [[ -z \"$line\" || \"$line\" =~ ^[[:space:]]*\n129: echo \"$line\"\n130: done < \"$input\" > \"$output\"\n132: return 0\n133: }\n139: retry_command() {\n140: local max_attempts=\"$1\"\n141: shift\n142: local attempt=1\n144: while (( attempt <= max_attempts )); do\n146: if \"$@\"; then\n147: return 0\n148: fi\n149: echo \"Attempt $attempt/$max_attempts failed\" >&2\n150: (( attempt++ ))\n152: sleep $(( 2 ** (attempt - 1) ))\n153: done\n155: echo \"All $max_attempts attempts failed\" >&2\n156: return 1\n157: }\n162: log_message() {\n163: local level=\"$1\"\n164: shift\n165: local timestamp\n166: timestamp=$(date '+%Y-%m-%d %H:%M:%S')\n167: echo \"[$timestamp] [$level] $*\" >&2\n168: }\n172: make_temp() {\n173: local tmpfile\n174: tmpfile=$(mktemp \"${TMPDIR:-/tmp}/myapp_XXXXXX\")\n175: echo \"$tmpfile\"\n176: }\n181: trap cleanup EXIT\n184: trap 'echo \"Interrupted\"; exit 130' INT TERM\n189: generate_config() {\n190: cat <<EOF\n192: version=${BUILD_VERSION}\n193: debug=${DEBUG_MODE}\n194: max_count=${MAX_COUNT}\n195: EOF\n196: }\n203: factorial() {\n204: local n=\"${1:-1}\"\n205: local result=1\n206: local i\n207: for (( i = 2; i <= n; i++ )); do\n209: (( result *= i ))\n210: done\n211: echo \"$result\"\n212: }\n217: if [[ -f ./config.sh ]]; then\n218: source ./config.sh\n219: fi\n222: source ./env.sh\n223: . ./helpers.sh\n224: source ./shared.sh\n225: . ./paths.sh\n226: source ./runtime.sh\n227: . ./exports.sh\n228: source ./network.sh\n236: req_cover_shell_1() {\n237: echo \"$(( $1 + 1 ))\"\n238: }\n245: req_cover_shell_2() {\n246: echo \"$(( $1 + 2 ))\"\n247: }\n254: req_cover_shell_3() {\n255: echo \"$(( $1 + 3 ))\"\n256: }\n263: req_cover_shell_4() {\n264: echo \"$(( $1 + 4 ))\"\n265: }\n272: req_cover_shell_5() {\n273: echo \"$(( $1 + 5 ))\"\n274: }\n```\n",
+  "stderr": ""
+}

package/tests/fixtures_attended_results/standalone/files-compress-line-numbers/fixture_swift.swift.json

@@ -0,0 +1,5 @@
+{
+  "code": 0,
+  "stdout": "@@@ tests/fixtures/fixture_swift.swift | swift\n> Lines: 8-395\n```\n8: import Foundation\n9: import Combine\n16: class Animal {\n18: var species: String\n21: var legs: Int = 4 {\n22: willSet {\n24: print(\"Legs changing from \\(legs) to \\(newValue)\")\n25: }\n26: didSet {\n28: if legs < 0 { legs = 0 }\n29: }\n30: }\n33: var description: String {\n34: return \"\\(species) with \\(legs) legs\"\n35: }\n39: init(species: String) {\n40: self.species = species\n41: }\n44: func speak() {\n45: print(\"...\")\n46: }\n50: class func createDefault() -> Animal {\n51: return Animal(species: \"Unknown\")\n52: }\n55: deinit {\n56: print(\"\\(species) deallocated\")\n57: }\n58: }\n63: class Dog: Animal {\n65: let name: String\n69: init(name: String) {\n70: self.name = name\n71: super.init(species: \"Dog\")\n72: }\n75: override func speak() {\n76: print(\"\\(name) says: Woof!\")\n77: }\n78: }\n85: struct Point: Equatable {\n86: var x: Double = 0.0\n87: var y: Double = 0.0\n93: static func + (lhs: Point, rhs: Point) -> Point {\n94: return Point(x: lhs.x + rhs.x, y: lhs.y + rhs.y)\n95: }\n99: var magnitude: Double {\n100: return (x * x + y * y).squareRoot()\n101: }\n102: }\n107: struct Matrix {\n109: private var data: [[Double]]\n112: let rows: Int\n114: let cols: Int\n119: init(rows: Int, cols: Int) {\n120: self.rows = rows\n121: self.cols = cols\n122: data = Array(repeating: Array(repeating: 0.0, count: cols), count: rows)\n123: }\n129: subscript(row: Int, col: Int) -> Double {\n130: get { return data[row][col] }\n131: set { data[row][col] = newValue }\n132: }\n133: }\n140: enum Direction: String, CaseIterable {\n141: case up = \"UP\"\n142: case down = \"DOWN\"\n143: case left = \"LEFT\"\n144: case right = \"RIGHT\"\n148: var opposite: Direction {\n149: switch self {\n150: case .up: return .down\n151: case .down: return .up\n152: case .left: return .right\n153: case .right: return .left\n154: }\n155: }\n156: }\n162: enum AppResult<T> {\n164: case success(T)\n166: case failure(Error)\n171: func map<U>(_ transform: (T) -> U) -> AppResult<U> {\n172: switch self {\n173: case .success(let value):\n174: return .success(transform(value))\n175: case .failure(let error):\n176: return .failure(error)\n177: }\n178: }\n179: }\n186: protocol Drawable {\n189: func draw() -> String\n192: var renderPriority: Int { get }\n193: }\n198: protocol Container {\n200: associatedtype Item\n204: mutating func add(_ item: Item)\n207: var count: Int { get }\n208: }\n212: extension Drawable {\n214: var renderPriority: Int { return 0 }\n218: func debugDraw() -> String {\n219: return \"[\\(renderPriority)] \\(draw())\"\n220: }\n221: }\n226: extension Animal: Drawable {\n229: func draw() -> String {\n230: return description\n231: }\n235: func describe() -> String {\n236: return \"Animal: \\(species)\"\n237: }\n238: }\n246: @propertyWrapper\n247: struct Clamped<Value: Comparable> {\n249: let min: Value\n251: let max: Value\n253: private var value: Value\n256: var wrappedValue: Value {\n257: get { return value }\n258: set { value = Swift.min(Swift.max(newValue, min), max) }\n259: }\n262: init(wrappedValue: Value, min: Value, max: Value) {\n263: self.min = min\n264: self.max = max\n266: self.value = Swift.min(Swift.max(wrappedValue, min), max)\n267: }\n268: }\n275: actor Counter {\n277: private var value: Int = 0\n281: func increment() -> Int {\n282: value += 1\n283: return value\n284: }\n287: func reset() {\n288: value = 0\n289: }\n290: }\n296: public func greet(name: String) {\n297: print(\"Hello \\(name)\")\n298: }\n302: func makeDrawable() -> some Drawable {\n303: return Animal(species: \"Cat\")\n304: }\n311: func contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable {\n312: return items.contains(target)\n313: }\n318: func deferred(_ action: @escaping () -> Void) -> () -> Void {\n319: return {\n321: action()\n322: }\n323: }\n328: let MAX_SIZE = 1024\n331: private var counter = 0\n334: let defaultConfig: [String: Any] = {\n335: var config: [String: Any] = [:]\n336: config[\"debug\"] = false\n337: config[\"version\"] = \"1.0\"\n338: return config\n339: }()\n342: import SwiftUI\n343: import Combine\n344: import Foundation\n345: import Dispatch\n346: import UIKit\n347: class ServiceController {}\n348: final class CacheStore {}\n349: struct Vector2 { let x: Int; let y: Int }\n350: struct Limits { let max: Int }\n351: enum ModeSwift { case fast, safe }\n352: enum PhaseSwift { case initState, done }\n353: enum SignalSwift { case on, off }\n354: protocol RunnerSwift { func run() }\n355: protocol LoggerSwift { func log(_ msg: String) }\n356: protocol ParserSwift { func parse(_ input: String) -> String }\n357: extension String { func trimmed2() -> String { self.trimmingCharacters(in: .whitespaces) } }\n358: extension Int { func doubled2() -> Int { self * 2 } }\n359: extension Array { var isNotEmpty: Bool { !self.isEmpty } }\n367: func reqCoverSwift1(_ value: Int) -> Int { value + 1 }\n374: func reqCoverSwift2(_ value: Int) -> Int { value + 2 }\n381: func reqCoverSwift3(_ value: Int) -> Int { value + 3 }\n388: func reqCoverSwift4(_ value: Int) -> Int { value + 4 }\n395: func reqCoverSwift5(_ value: Int) -> Int { value + 5 }\n```\n",
+  "stderr": ""
+}

package/tests/fixtures_attended_results/standalone/files-compress-line-numbers/fixture_typescript.ts.json

@@ -0,0 +1,5 @@
+{
+  "code": 0,
+  "stdout": "@@@ tests/fixtures/fixture_typescript.ts | typescript\n> Lines: 10-432\n```\n10: import { Component } from 'react';\n11: import type { ReactNode } from 'react';\n19: interface User {\n21: name: string;\n23: age: number;\n25: email?: string;\n27: readonly id: string;\n28: }\n35: interface Repository<T> {\n37: findById(id: string): Promise<T | null>;\n39: save(entity: T): Promise<T>;\n41: delete(id: string): Promise<boolean>;\n42: }\n48: interface Serializable {\n50: toJSON(): string;\n51: }\n56: type StringOrNumber = string | number;\n59: type DeepReadonly<T> = {\n60: readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];\n61: };\n64: type Unwrap<T> = T extends Array<infer U> ? U : T;\n67: type PixelValue = `${number}px`;\n70: type ApiResponse<T> =\n71: | { status: 'success'; data: T }\n72: | { status: 'error'; message: string }\n73: | { status: 'loading' };\n76: type KeysOfType<T, V> = {\n77: [K in keyof T]: T[K] extends V ? K : never;\n78: }[keyof T];\n86: const enum Direction {\n87: Up = 'UP',\n88: Down = 'DOWN',\n89: Left = 'LEFT',\n90: Right = 'RIGHT',\n91: }\n97: enum Color {\n99: Red,\n101: Blue,\n103: Green = 10,\n104: }\n110: enum HttpStatus {\n111: OK = '200',\n112: NotFound = '404',\n113: ServerError = '500',\n114: }\n122: export abstract class Base {\n127: abstract render(): void;\n132: execute(): void {\n134: console.log('before render');\n135: this.render();\n137: console.log('after render');\n138: }\n139: }\n148: class Derived extends Base {\n150: value: number = 0;\n153: label?: string;\n158: render(): void {\n159: console.log(this.value);\n160: }\n161: }\n168: class TypedContainer<T extends Serializable> {\n170: private items: T[] = [];\n176: add(item: T): void {\n177: this.items.push(item);\n178: }\n184: toJSON(): string {\n185: return `[${this.items.map(i => i.toJSON()).join(',')}]`;\n186: }\n193: find(predicate: (item: T) => boolean): T | undefined {\n194: for (const item of this.items) {\n195: if (predicate(item)) {\n196: return item;\n197: }\n198: }\n199: return undefined;\n200: }\n201: }\n210: class UserEntity implements User, Serializable {\n211: readonly id: string;\n212: name: string;\n213: age: number;\n215: constructor(id: string, name: string, age: number) {\n216: this.id = id;\n217: this.name = name;\n218: this.age = age;\n219: }\n225: toJSON(): string {\n226: return JSON.stringify({ id: this.id, name: this.name, age: this.age });\n227: }\n228: }\n237: export function greet(name: string): void {\n238: console.log(`Hello, ${name}`);\n239: }\n249: function parse(input: string): number;\n250: function parse(input: number): string;\n251: function parse(input: string | number): string | number {\n252: if (typeof input === 'string') {\n253: return parseInt(input, 10);\n254: }\n255: return input.toString();\n256: }\n266: const add = (a: number): number => a + 1;\n275: const transform = <T extends { toString(): string }>(value: T): string => {\n276: return value.toString();\n277: };\n288: async function fetchEntity<T>(url: string): Promise<T> {\n289: const response = await fetch(url);\n291: return response.json() as Promise<T>;\n292: }\n300: export namespace MyNS {\n302: export const x = 1;\n309: export function double(val: number): number {\n310: return val * 2;\n311: }\n312: }\n320: declare module MyMod {\n322: export const version: string;\n323: }\n331: @Component\n332: class Decorated {\n334: template: string = '<div></div>';\n335: }\n345: function isUser(value: unknown): value is User {\n346: if (typeof value !== 'object' || value === null) {\n347: return false;\n348: }\n349: const obj = value as Record<string, unknown>;\n350: return typeof obj.name === 'string' && typeof obj.age === 'number';\n351: }\n359: const config = {\n360: width: '100px' as PixelValue,\n361: height: '200px' as PixelValue,\n362: } satisfies Record<string, PixelValue>;\n373: function makeOptional<T extends object>(obj: T): Partial<T> {\n374: return { ...obj };\n375: }\n378: import { Injectable } from 'inversify';\n379: import { Observable } from 'rxjs';\n380: import { FC } from 'react';\n381: @injectable\n382: @sealed\n383: @track\n384: @memoized\n385: interface CacheEntry { key: string; value: string }\n386: export interface Runner { run(): Promise<void> }\n387: enum ModeTs { Fast, Safe }\n388: enum StatusTs { Ready, Busy }\n389: namespace ExtNSOne { export const v = 1; }\n390: namespace ExtNSTwo { export const v = 2; }\n391: namespace ExtNSThree { export const v = 3; }\n392: namespace ExtNSFour { export const v = 4; }\n393: declare module ExtOne { export const one: number; }\n394: module ExtTwo { export const two = 2; }\n395: module ExtThree { export const three = 3; }\n396: module ExtFour { export const four = 4; }\n404: function reqCoverTs1(value: number): number { return value + 1; }\n411: function reqCoverTs2(value: number): number { return value + 2; }\n418: function reqCoverTs3(value: number): number { return value + 3; }\n425: function reqCoverTs4(value: number): number { return value + 4; }\n432: function reqCoverTs5(value: number): number { return value + 5; }\n```\n",
+  "stderr": ""
+}

package/tests/fixtures_attended_results/standalone/files-compress-line-numbers/fixture_zig.zig.json

@@ -0,0 +1,5 @@
+{
+  "code": 0,
+  "stdout": "@@@ tests/fixtures/fixture_zig.zig | zig\n> Lines: 7-293\n```\n7: const std = @import(\"std\");\n8: const mem = @import(\"std\").mem;\n9: const Allocator = std.mem.Allocator;\n14: pub fn main() void {\n15: std.debug.print(\"Hello\\n\", .{});\n16: }\n22: pub fn add(a: i32, b: i32) i32 {\n23: return a + b;\n24: }\n30: pub fn safeDivide(numerator: i32, denominator: i32) !i32 {\n31: if (denominator == 0) {\n32: return error.DivisionByZero;\n33: }\n34: return @divTrunc(numerator, denominator);\n35: }\n42: pub fn max(comptime T: type, a: T, b: T) T {\n43: return if (a > b) a else b;\n44: }\n51: pub fn indexOf(comptime T: type, haystack: []const T, needle: T) ?usize {\n52: for (haystack, 0..) |item, i| {\n53: if (item == needle) {\n54: return i;\n55: }\n56: }\n58: return null;\n59: }\n65: pub fn comptimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8 {\n66: return a ++ b;\n67: }\n72: pub fn createBuffer(allocator: Allocator) ![]u8 {\n73: const buf = try allocator.alloc(u8, 1024);\n74: errdefer allocator.free(buf);\n76: @memset(buf, 0);\n77: return buf;\n78: }\n83: inline fn fastSum(values: []const f32) f32 {\n84: var total: f32 = 0.0;\n85: for (values) |v| {\n86: total += v;\n87: }\n88: return total;\n89: }\n94: export fn doubleValue(x: i32) i32 {\n95: return x * 2;\n96: }\n102: const Point = struct {\n103: x: f64,\n104: y: f64,\n110: pub fn distSquared(self: Point, other: Point) f64 {\n111: const dx = self.x - other.x;\n112: const dy = self.y - other.y;\n113: return dx * dx + dy * dy;\n114: }\n118: pub fn origin() Point {\n119: return .{ .x = 0.0, .y = 0.0 };\n120: }\n121: };\n125: const PackedFlags = packed struct {\n126: readable: bool,\n127: writable: bool,\n128: executable: bool,\n129: reserved: u5,\n130: };\n133: const Config = struct {\n134: name: []const u8 = \"default\",\n135: max_retries: u32 = 3,\n136: timeout_ms: u64 = 5000,\n137: debug: bool = false,\n141: pub fn testing() Config {\n142: return .{ .debug = true, .name = \"test\" };\n143: }\n144: };\n149: const Color = enum {\n150: red,\n151: green,\n152: blue,\n157: pub fn toRgb(self: Color) u32 {\n158: return switch (self) {\n159: .red => 0xFF0000,\n160: .green => 0x00FF00,\n161: .blue => 0x0000FF,\n162: };\n163: }\n164: };\n167: const Status = enum(u8) {\n168: idle = 0,\n169: running = 1,\n170: error = 2,\n171: done = 3,\n172: };\n177: const Result = union(enum) {\n178: ok: i32,\n179: err: []const u8,\n184: pub fn isOk(self: Result) bool {\n185: return self == .ok;\n186: }\n187: };\n190: const ExternData = extern union {\n191: int_val: i32,\n192: float_val: f32,\n193: bytes: [4]u8,\n194: };\n199: const MAX_SIZE: usize = 1024;\n202: pub var global_state: i32 = 0;\n205: const MAGIC_NUMBER: u32 = comptime blk: {\n206: var x: u32 = 1;\n207: x *= 42;\n208: break :blk x;\n209: };\n214: const ParseError = error{\n215: InvalidInput,\n216: UnexpectedToken,\n217: EndOfStream,\n218: BufferOverflow,\n219: };\n224: test \"add returns correct sum\" {\n225: const result = add(2, 3);\n226: try std.testing.expectEqual(@as(i32, 5), result);\n227: }\n230: test \"safeDivide handles zero\" {\n231: const result = safeDivide(10, 0);\n232: try std.testing.expectError(error.DivisionByZero, result);\n233: }\n236: test \"indexOf finds element\" {\n237: const items = [_]i32{ 1, 2, 3, 4, 5 };\n238: const idx = indexOf(i32, &items, 3);\n239: try std.testing.expectEqual(@as(?usize, 2), idx);\n240: }\n243: const io = @import(\"std\");\n244: const fs = @import(\"std\");\n245: const mem = @import(\"std\");\n246: const math = @import(\"std\");\n247: const json = @import(\"std\");\n248: const Mode = enum { fast, safe };\n249: const Phase = enum { init, done };\n250: const Signal = enum { on, off };\n251: const Packet = struct { id: i32 };\n252: const Limits = struct { max: i32 };\n253: const Variant = union { i: i32, f: f32 };\n254: const Payload = extern union { a: i32, b: i32 };\n255: const Message = union { txt: [4]u8, len: u32 };\n256: var retries: i32 = 0;\n257: var pointer: usize = 0;\n265: fn reqCoverZig1(value: i32) i32 { return value + 1; }\n272: fn reqCoverZig2(value: i32) i32 { return value + 2; }\n279: fn reqCoverZig3(value: i32) i32 { return value + 3; }\n286: fn reqCoverZig4(value: i32) i32 { return value + 4; }\n293: fn reqCoverZig5(value: i32) i32 { return value + 5; }\n```\n",
+  "stderr": ""
+}

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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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\"context\"\n\"fmt\"\n\"io\"\n\"sync\"\n)\nconst MaxSize = 100\nvar globalVar = 0\nconst (\nLogDebug = iota\nLogInfo\nLogError\n)\ntype Server struct {\nPort int\nHost string\nsync.Mutex\nhandlers 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 {\nPort int\nHost string\nsync.Mutex\nhandlers 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 {\nStreet string\nCity   string\nZip    string\n}\n```\n\n### STRUCT: `Employee`\n> Signature: `type Employee struct`\n> Lines: 61-66\n```\ntype Employee struct {\nName    string\nAge     int\nAddress\nManager *Employee\n}\n```\n\n### INTERFACE: `Handler`\n> Signature: `type Handler interface`\n> Lines: 71-74\n```\ntype Handler interface {\nHandle(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 {\nio.Reader\nio.Writer\nio.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 {\nreturn 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~int | ~float64 | ~string\n}\n```\n\n### FUNCTION: `main`\n> Signature: `func main()`\n> Lines: 111-113\n```\nfunc main() {\nfmt.Println(\"hello\")\n}\n```\n\n### FUNCTION: `init`\n> Signature: `func init()`\n> Lines: 116-119\n```\nfunc init() {\nglobalVar = 1\n}\n```\n\n### METHOD: `Start`\n> Signature: `func (s *Server) Start() error`\n> Lines: 123-132\n```\nfunc (s *Server) Start() error {\ns.Lock()\ndefer s.Unlock()\nif s.Port <= 0 {\nreturn fmt.Errorf(\"invalid port: %d\", s.Port)\n}\nfmt.Printf(\"Starting on %s:%d\\n\", s.Host, s.Port)\nreturn 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) {\nif s.handlers == nil {\ns.handlers = make(map[string]HandlerFunc)\n}\ns.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) {\nif b == 0 {\nreturn 0, 0, fmt.Errorf(\"division by zero\")\n}\nreturn 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_, scanErr := fmt.Sscanf(input, \"%s:%d\", &host, &port)\nif scanErr != nil {\nerr = scanErr\nreturn\n}\nreturn\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 {\ncount := 0\nreturn func() int {\ncount++\nreturn count\n}\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 {\nresults := make(chan string, len(items))\nvar wg sync.WaitGroup\nfor i := 0; i < workers; i++ {\nwg.Add(1)\ngo func(id int) {\ndefer wg.Done()\nfor _, item := range items {\nresults <- fmt.Sprintf(\"[%d] %s\", id, item)\n}\n}(i)\n}\ngo func() {\nwg.Wait()\nclose(results)\n}()\nreturn results\n}\n```\n\n### CONSTANT: `wg`\n> Signature: `var wg sync.WaitGroup`\n> Lines: 223-223\n```\nvar 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 {\nswitch val := v.(type) {\ncase int:\nreturn fmt.Sprintf(\"int: %d\", val)\ncase string:\nreturn fmt.Sprintf(\"string: %q\", val)\ncase bool:\nif val {\nreturn \"bool: true\"\n}\nreturn \"bool: false\"\ncase nil:\nreturn \"nil\"\ndefault:\nreturn fmt.Sprintf(\"unknown: %T\", val)\n}\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) {\ndefer func() {\nif r := recover(); r != nil {\nerr = fmt.Errorf(\"panic: %v\", r)\n}\n}()\nfn()\nreturn 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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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

@@ -0,0 +1,5 @@
+{
+  "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": ""
+}