pi-usereq 0.49.0 → 0.50.0

package/tests/fixtures_attended_results/standalone/files-find/fixture_ruby.rb.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_ruby.rb | ruby\n\n### IMPORT: `'json'`\n> Lines: 10-10\n```\nrequire 'json'\n```\n\n### IMPORT: `'set'`\n> Lines: 11-11\n```\nrequire 'set'\n```\n\n### IMPORT: `'helper'`\n> Lines: 12-12\n```\nrequire_relative 'helper'\n```\n\n### CONSTANT: `MAX_RETRIES`\n> Signature: `MAX_RETRIES = 42`\n> Lines: 15-15\n- @brief Maximum retry attempts for transient failures.\n```\nMAX_RETRIES = 42\n```\n\n### CONSTANT: `DEFAULT_ENCODING`\n> Signature: `DEFAULT_ENCODING = 'utf-8'.freeze`\n> Lines: 18-18\n- @brief Frozen string constant for default encoding.\n```\nDEFAULT_ENCODING = 'utf-8'.freeze\n```\n\n### DECORATOR: `:name, :age`\n> Lines: 20-20\n```\nattr_accessor :name, :age\n```\n\n### MODULE: `Loggable`\n> Signature: `module Loggable`\n> Lines: 26-39\n- @brief Mixin providing logging capabilities to including classes.\n- @brief Log a message to stdout with the class name prefix.\n- @param message [String] The message to log.\n```\nmodule Loggable\ndef log(message)\nputs \"[#{self.class.name}] #{message}\"\nend\ndef log_error(error)\nputs \"[ERROR] #{error.message}\"\nputs error.backtrace.first(5).join(\"\\n\") if error.backtrace\nend\nend\n```\n\n### FUNCTION: `log`\n> Signature: `def log(message)`\n> Lines: 29-31\n- @brief Log a message to stdout with the class name prefix.\n- @param message [String] The message to log.\n```\ndef log(message)\nputs \"[#{self.class.name}] #{message}\"\nend\n```\n\n### FUNCTION: `log_error`\n> Signature: `def log_error(error)`\n> Lines: 35-38\n- @brief Log an error with backtrace information.\n- @param error [Exception] The exception to log.\n```\ndef log_error(error)\nputs \"[ERROR] #{error.message}\"\nputs error.backtrace.first(5).join(\"\\n\") if error.backtrace\nend\n```\n\n### CLASS: `MyClass`\n> Signature: `class MyClass`\n> Lines: 47-153\n```\nclass MyClass\ninclude Loggable\ninclude Comparable\nattr_accessor :name\nattr_reader :created_at\ndef initialize(name, **options)\n@name = name\n@options = options\n@created_at = Time.now\n@options[:retries] ||= MAX_RETRIES\nend\ndef self.create(attrs)\nnew(attrs[:name], **attrs.except(:name))\nend\ndef self.bulk_create(names)\nnames.map { |n| new(n) }\nend\ndef valid?\n!@name.nil? && !@name.empty?\nend\ndef matches?(pattern)\nreturn false if @name.nil?\npattern.match?(@name)\nend\ndef <=>(other)\n@name <=> other.name\nend\ndef +(other)\nself.class.new(\"#{@name}+#{other.name}\")\nend\ndef to_s\n\"MyClass(#{@name})\"\nend\ndef method_missing(method, *args, &block)\nif method.to_s.start_with?('find_by_')\nfield = method.to_s.sub('find_by_', '')\n\"Finding by #{field}: #{args.first}\"\nelse\nsuper\nend\nend\ndef respond_to_missing?(method, include_private = false)\nmethod.to_s.start_with?('find_by_') || super\nend\nprotected\ndef internal_config\n@options.dup\nend\nprivate\ndef validate!\nraise \"Invalid name\" unless valid?\nend\nend\n```\n\n### DECORATOR: `:name`\n> Lines: 52-52\n- @brief Read/write accessor for the instance name.\n```\nattr_accessor :name\n```\n\n### DECORATOR: `:created_at`\n> Lines: 55-55\n- @brief Read-only accessor for the creation timestamp.\n```\nattr_reader :created_at\n```\n\n### FUNCTION: `initialize`\n> Signature: `def initialize(name, **options)`\n> Lines: 60-66\n- @brief Initialize a new MyClass instance.\n- @param name [String] The instance identifier.\n- @param options [Hash] Optional configuration hash.\n```\ndef initialize(name, **options)\n@name = name\n@options = options\n@created_at = Time.now\n@options[:retries] ||= MAX_RETRIES\nend\n```\n\n### FUNCTION: `create`\n> Signature: `def self.create(attrs)`\n> Lines: 71-73\n- @brief Factory method creating an instance from a hash.\n- @param attrs [Hash] Attribute hash with :name key required.\n- @return [MyClass] A new instance populated from attrs.\n```\ndef self.create(attrs)\nnew(attrs[:name], **attrs.except(:name))\nend\n```\n\n### FUNCTION: `bulk_create`\n> Signature: `def self.bulk_create(names)`\n> Lines: 78-80\n- @brief Build multiple instances from an array of names.\n- @param names [Array<String>] Names to create instances for.\n- @return [Array<MyClass>] Array of new instances.\n```\ndef self.bulk_create(names)\nnames.map { |n| new(n) }\nend\n```\n\n### FUNCTION: `valid?`\n> Signature: `def valid?`\n> Lines: 84-86\n- @brief Predicate checking if the instance is valid.\n- @return [Boolean] True if name is non-empty.\n```\ndef valid?\n!@name.nil? && !@name.empty?\nend\n```\n\n### FUNCTION: `matches?`\n> Signature: `def matches?(pattern)`\n> Lines: 91-94\n- @brief Check if name matches a pattern.\n- @param pattern [Regexp] Regular expression to test against.\n- @return [Boolean] True if name matches the pattern.\n```\ndef matches?(pattern)\nreturn false if @name.nil?\npattern.match?(@name)\nend\n```\n\n### FUNCTION: `to_s`\n> Signature: `def to_s`\n> Lines: 112-114\n- @brief Convert to string representation.\n- @return [String] Human-readable description.\n```\ndef to_s\n\"MyClass(#{@name})\"\nend\n```\n\n### FUNCTION: `method_missing`\n> Signature: `def method_missing(method, *args, &block)`\n> Lines: 121-128\n```\ndef method_missing(method, *args, &block)\nif method.to_s.start_with?('find_by_')\nfield = method.to_s.sub('find_by_', '')\n\"Finding by #{field}: #{args.first}\"\nelse\nsuper\nend\nend\n```\n\n### FUNCTION: `respond_to_missing?`\n> Signature: `def respond_to_missing?(method, include_private = false)`\n> Lines: 134-136\n- @brief Declare which dynamic methods respond_to? should recognize.\n- @param method [Symbol] The method name to check.\n- @param include_private [Boolean] Whether to include private methods.\n- @return [Boolean] True if the method is handled dynamically.\n```\ndef respond_to_missing?(method, include_private = false)\nmethod.to_s.start_with?('find_by_') || super\nend\n```\n\n### FUNCTION: `internal_config`\n> Signature: `def internal_config`\n> Lines: 142-144\n- @brief Protected helper for internal computations.\n- @return [Hash] Current options hash.\n```\ndef internal_config\n@options.dup\nend\n```\n\n### FUNCTION: `validate!`\n> Signature: `def validate!`\n> Lines: 150-152\n```\ndef validate!\nraise \"Invalid name\" unless valid?\nend\n```\n\n### CLASS: `SpecialClass`\n> Signature: `class SpecialClass < MyClass`\n> Lines: 160-174\n- @brief Specialized subclass with additional behavior.\n- @brief Initialize with a priority level.\n- @param name [String] Instance name.\n- @param priority [Integer] Processing priority (lower = first).\n```\nclass SpecialClass < MyClass\ndef initialize(name, priority: 0, **options)\nsuper(name, **options)\n@priority = priority\nend\ndef to_s\n\"SpecialClass(#{@name}, pri=#{@priority})\"\nend\nend\n```\n\n### FUNCTION: `initialize`\n> Signature: `def initialize(name, priority: 0, **options)`\n> Lines: 164-167\n- @brief Initialize with a priority level.\n- @param name [String] Instance name.\n- @param priority [Integer] Processing priority (lower = first).\n```\ndef initialize(name, priority: 0, **options)\nsuper(name, **options)\n@priority = priority\nend\n```\n\n### FUNCTION: `to_s`\n> Signature: `def to_s`\n> Lines: 171-173\n- @brief Override to_s with priority information.\n- @return [String] Description including priority.\n```\ndef to_s\n\"SpecialClass(#{@name}, pri=#{@priority})\"\nend\n```\n\n### MODULE: `MyModule`\n> Signature: `module MyModule`\n> Lines: 180-207\n- @brief Utility module providing helper methods.\n- @brief Module-level helper returning a boolean.\n- @return [Boolean] Always returns true.\n```\nmodule MyModule\ndef helper\ntrue\nend\ndef process_with_block(data)\nif block_given?\nyield(data)\nelse\ndata\nend\nend\ndef self.format_list(items)\nitems.map(&:to_s).join(', ')\nend\nend\n```\n\n### FUNCTION: `helper`\n> Signature: `def helper`\n> Lines: 183-185\n- @brief Module-level helper returning a boolean.\n- @return [Boolean] Always returns true.\n```\ndef helper\ntrue\nend\n```\n\n### FUNCTION: `process_with_block`\n> Signature: `def process_with_block(data)`\n> Lines: 191-197\n- @brief Process data with block yield pattern.\n- @param data [Object] Data to process.\n@yield [Object] Yields data for caller-defined processing.\n- @return [Object] The block's return value or data itself.\n```\ndef process_with_block(data)\nif block_given?\nyield(data)\nelse\ndata\nend\nend\n```\n\n### FUNCTION: `format_list`\n> Signature: `def self.format_list(items)`\n> Lines: 204-206\n- @brief Utility function accessible without mixing in.\n- @param items [Array] Items to format.\n- @return [String] Comma-separated formatted string.\n```\ndef self.format_list(items)\nitems.map(&:to_s).join(', ')\nend\n```\n\n### FUNCTION: `distance_from_origin`\n> Signature: `def distance_from_origin`\n> Lines: 216-218\n- @brief Compute the Euclidean distance from origin.\n- @return [Float] Distance from (0, 0).\n```\ndef distance_from_origin\nMath.sqrt(x**2 + y**2)\nend\n```\n\n### CLASS: `DynamicModel`\n> Signature: `class DynamicModel`\n> Lines: 225-238\n- @brief Demonstrates metaprogramming with define_method.\n- @brief Dynamically defined getter for #{field}.\n```\nclass DynamicModel\n%w[title body author].each do |field|\ndefine_method(field) do\ninstance_variable_get(\"@#{field}\")\nend\ndefine_method(\"#{field}=\") do |value|\ninstance_variable_set(\"@#{field}\", value)\nend\nend\nend\n```\n\n### FUNCTION: `with_retry`\n> Signature: `def with_retry(attempts: MAX_RETRIES)`\n> Lines: 255-268\n```\ndef with_retry(attempts: MAX_RETRIES)\ntries = 0\nbegin\ntries += 1\nyield\nrescue StandardError => e\nretry if tries < attempts\nraise \"Failed after #{attempts} attempts: #{e.message}\"\nensure\nputs \"Completed after #{tries} attempt(s)\"\nend\nend\n```\n\n### MODULE: `StringExtensions`\n> Signature: `module StringExtensions`\n> Lines: 274-282\n- @brief Refinement adding utility methods to String.\n- @brief Check if the string is a valid email address.\n- @return [Boolean] True if string matches email pattern.\n```\nmodule StringExtensions\nrefine String do\ndef email?\nmatch?(/\\A[\\w+\\-.]+@[a-z\\d\\-]+(\\.[a-z\\d\\-]+)*\\.[a-z]+\\z/i)\nend\nend\nend\n```\n\n### FUNCTION: `email?`\n> Signature: `def email?`\n> Lines: 278-280\n- @brief Check if the string is a valid email address.\n- @return [Boolean] True if string matches email pattern.\n```\ndef email?\nmatch?(/\\A[\\w+\\-.]+@[a-z\\d\\-]+(\\.[a-z\\d\\-]+)*\\.[a-z]+\\z/i)\nend\n```\n\n### CLASS: `ServiceObject`\n> Signature: `class ServiceObject; end # inline class comment`\n> Lines: 287-307\n```\nclass ServiceObject; end\nclass ReportBuilder; end\nmodule Metrics; end\nmodule Extras; end\nMAX_LIMIT = 100\nAPI_VERSION = \"v2\"\nCACHE_SIZE = 1024\nattr_writer :token\nattr_reader :state\nrequire 'yaml'\nrequire 'logger'\ndef req_cover_ruby_1(value)\nvalue + 1\nend\n```\n\n### CLASS: `ReportBuilder`\n> Signature: `class ReportBuilder; end`\n> Lines: 288-307\n```\nclass ReportBuilder; end\nmodule Metrics; end\nmodule Extras; end\nMAX_LIMIT = 100\nAPI_VERSION = \"v2\"\nCACHE_SIZE = 1024\nattr_writer :token\nattr_reader :state\nrequire 'yaml'\nrequire 'logger'\ndef req_cover_ruby_1(value)\nvalue + 1\nend\n```\n\n### MODULE: `Metrics`\n> Signature: `module Metrics; end`\n> Lines: 289-307\n```\nmodule Metrics; end\nmodule Extras; end\nMAX_LIMIT = 100\nAPI_VERSION = \"v2\"\nCACHE_SIZE = 1024\nattr_writer :token\nattr_reader :state\nrequire 'yaml'\nrequire 'logger'\ndef req_cover_ruby_1(value)\nvalue + 1\nend\n```\n\n### MODULE: `Extras`\n> Signature: `module Extras; end`\n> Lines: 290-307\n```\nmodule Extras; end\nMAX_LIMIT = 100\nAPI_VERSION = \"v2\"\nCACHE_SIZE = 1024\nattr_writer :token\nattr_reader :state\nrequire 'yaml'\nrequire 'logger'\ndef req_cover_ruby_1(value)\nvalue + 1\nend\n```\n\n### CONSTANT: `MAX_LIMIT`\n> Signature: `MAX_LIMIT = 100`\n> Lines: 291-291\n```\nMAX_LIMIT = 100\n```\n\n### CONSTANT: `API_VERSION`\n> Signature: `API_VERSION = \"v2\"`\n> Lines: 292-292\n```\nAPI_VERSION = \"v2\"\n```\n\n### CONSTANT: `CACHE_SIZE`\n> Signature: `CACHE_SIZE = 1024`\n> Lines: 293-293\n```\nCACHE_SIZE = 1024\n```\n\n### DECORATOR: `:token`\n> Lines: 294-294\n```\nattr_writer :token\n```\n\n### DECORATOR: `:state`\n> Lines: 295-295\n```\nattr_reader :state\n```\n\n### IMPORT: `'yaml'`\n> Lines: 296-296\n```\nrequire 'yaml'\n```\n\n### IMPORT: `'logger'`\n> Lines: 297-297\n```\nrequire 'logger'\n```\n\n### FUNCTION: `req_cover_ruby_1`\n> Signature: `def req_cover_ruby_1(value)`\n> Lines: 305-307\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\ndef req_cover_ruby_1(value)\nvalue + 1\nend\n```\n\n### FUNCTION: `req_cover_ruby_2`\n> Signature: `def req_cover_ruby_2(value)`\n> Lines: 314-316\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\ndef req_cover_ruby_2(value)\nvalue + 2\nend\n```\n\n### FUNCTION: `req_cover_ruby_3`\n> Signature: `def req_cover_ruby_3(value)`\n> Lines: 323-325\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\ndef req_cover_ruby_3(value)\nvalue + 3\nend\n```\n\n### FUNCTION: `req_cover_ruby_4`\n> Signature: `def req_cover_ruby_4(value)`\n> Lines: 332-334\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\ndef req_cover_ruby_4(value)\nvalue + 4\nend\n```\n\n### FUNCTION: `req_cover_ruby_5`\n> Signature: `def req_cover_ruby_5(value)`\n> Lines: 341-343\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\ndef req_cover_ruby_5(value)\nvalue + 5\nend\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_rust.rs.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_rust.rs | rust\n\n### IMPORT: `std::io`\n> Lines: 9-9\n```\nuse std::io;\n```\n\n### IMPORT: `std::collections::HashMap`\n> Lines: 10-10\n```\nuse std::collections::HashMap;\n```\n\n### IMPORT: `std::fmt::{self, Display, Formatter}`\n> Lines: 11-11\n```\nuse std::fmt::{self, Display, Formatter};\n```\n\n### IMPORT: `std::sync::{Arc, Mutex}`\n> Lines: 12-12\n```\nuse std::sync::{Arc, Mutex};\n```\n\n### DECORATOR: `derive(Debug, Clone, PartialEq)`\n> Lines: 19-19\n- @brief Holds a single i32 field with Debug/Clone derives.\n```\n#[derive(Debug, Clone, PartialEq)]\n```\n\n### STRUCT: `MyStruct`\n> Signature: `pub struct MyStruct`\n> Lines: 20-23\n- @brief Primary integer field.\n```\npub struct MyStruct {\nfield: i32,\n}\n```\n\n### DECORATOR: `derive(Debug)`\n> Lines: 29-29\n```\n#[derive(Debug)]\n```\n\n### STRUCT: `BorrowedData`\n> Signature: `pub struct BorrowedData<'a>`\n> Lines: 30-35\n- @brief Reference to externally-owned string data.\n- @brief Numeric tag for identification.\n```\npub struct BorrowedData<'a> {\ncontent: &'a str,\ntag: u64,\n}\n```\n\n### STRUCT: `TypedMap`\n> Signature: `pub struct TypedMap<K: std::hash::Hash + Eq, V: Clone>`\n> Lines: 41-44\n- @brief Internal hash map storage.\n```\npub struct TypedMap<K: std::hash::Hash + Eq, V: Clone> {\ninner: HashMap<K, V>,\n}\n```\n\n### ENUM: `MyEnum`\n> Signature: `pub enum MyEnum`\n> Lines: 51-58\n- @brief Represents either structured data, a simple flag, or a pair.\n- @brief Unit variant carrying no data.\n- @brief Tuple variant holding a string payload.\n```\npub enum MyEnum {\nA,\nB(String),\nC { x: i32, y: i32 },\n}\n```\n\n### TRAIT: `MyTrait`\n> Signature: `pub trait MyTrait`\n> Lines: 65-79\n- @brief Implementors must provide both sync and optional async execution.\n```\npub trait MyTrait {\nfn do_work(&self);\nfn do_work_with_ctx(&self, ctx: &str) -> bool {\nprintln!(\"ctx: {}\", ctx);\nself.do_work();\ntrue\n}\n}\n```\n\n### FUNCTION: `do_work`\n> Signature: `fn do_work(&self)`\n> Lines: 67-78\n```\nfn do_work(&self);\nfn do_work_with_ctx(&self, ctx: &str) -> bool {\nprintln!(\"ctx: {}\", ctx);\nself.do_work();\ntrue\n}\n```\n\n### FUNCTION: `do_work_with_ctx`\n> Signature: `fn do_work_with_ctx(&self, ctx: &str) -> bool`\n> Lines: 73-78\n- @param ctx Contextual string passed to the implementation.\n- @return True if work completed successfully.\n```\nfn do_work_with_ctx(&self, ctx: &str) -> bool {\nprintln!(\"ctx: {}\", ctx);\nself.do_work();\ntrue\n}\n```\n\n### TRAIT: `Parser`\n> Signature: `pub trait Parser<'a>`\n> Lines: 85-94\n- @brief The output type produced by parsing.\n```\npub trait Parser<'a> {\ntype Output;\nfn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>;\n}\n```\n\n### TYPE_ALIAS: `Output`\n> Signature: `type Output`\n> Lines: 87-87\n- @brief The output type produced by parsing.\n```\ntype Output;\n```\n\n### FUNCTION: `parse`\n> Signature: `fn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>`\n> Lines: 93-96\n- @param input Byte slice to parse.\n- @return Parsed output or an IO error.\n```\nfn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>;\n}\nimpl MyStruct {\n```\n\n### IMPL: `MyStruct`\n> Signature: `impl MyStruct`\n> Lines: 96-132\n- @return A MyStruct with field initialized to 0.\n```\nimpl MyStruct {\nfn new() -> Self {\nSelf { field: 0 }\n}\npub fn with_value(val: i32) -> Self {\nSelf { field: val }\n}\npub fn value(&self) -> i32 {\nself.field\n}\npub fn try_update(&mut self, new_val: i32) -> Option<i32> {\nif new_val == self.field {\nreturn None;\n}\nlet old = self.field;\nself.field = new_val;\nSome(old)\n}\n}\n```\n\n### FUNCTION: `new`\n> Signature: `fn new() -> Self`\n> Lines: 100-102\n- @return A MyStruct with field initialized to 0.\n```\nfn new() -> Self {\nSelf { field: 0 }\n}\n```\n\n### FUNCTION: `with_value`\n> Signature: `pub fn with_value(val: i32) -> Self`\n> Lines: 108-110\n- @param val The initial field value.\n- @return A new MyStruct.\n```\npub fn with_value(val: i32) -> Self {\nSelf { field: val }\n}\n```\n\n### FUNCTION: `value`\n> Signature: `pub fn value(&self) -> i32`\n> Lines: 115-117\n- @return The stored integer.\n```\npub fn value(&self) -> i32 {\nself.field\n}\n```\n\n### FUNCTION: `try_update`\n> Signature: `pub fn try_update(&mut self, new_val: i32) -> Option<i32>`\n> Lines: 123-131\n- @param new_val New value to set.\n- @return Old value if updated, None if new_val equals current.\n```\npub fn try_update(&mut self, new_val: i32) -> Option<i32> {\nif new_val == self.field {\nreturn None;\n}\nlet old = self.field;\nself.field = new_val;\nSome(old)\n}\n```\n\n### IMPL: `MyStruct`\n> Signature: `impl MyTrait for MyStruct`\n> Lines: 134-139\n```\nimpl MyTrait for MyStruct {\nfn do_work(&self) {\nprintln!(\"{:?}\", self);\n}\n}\n```\n\n### FUNCTION: `do_work`\n> Signature: `fn do_work(&self)`\n> Lines: 136-138\n```\nfn do_work(&self) {\nprintln!(\"{:?}\", self);\n}\n```\n\n### IMPL: `MyStruct`\n> Signature: `impl Display for MyStruct`\n> Lines: 141-149\n- @param f Formatter to write into.\n```\nimpl Display for MyStruct {\nfn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\nwrite!(f, \"MyStruct({})\", self.field)\n}\n}\n```\n\n### FUNCTION: `fmt`\n> Signature: `fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result`\n> Lines: 146-148\n- @param f Formatter to write into.\n- @return fmt::Result indicating success or failure.\n```\nfn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\nwrite!(f, \"MyStruct({})\", self.field)\n}\n```\n\n### IMPL: `TypedMap`\n> Signature: `impl<K, V> TypedMap<K, V>`\n> Lines: 153-177\n```\nimpl<K, V> TypedMap<K, V>\nwhere\nK: std::hash::Hash + Eq + Display,\nV: Clone + Default,\n{\npub fn insert(&mut self, key: K, value: V) -> Option<V> {\nself.inner.insert(key, value)\n}\npub fn get_or_default(&self, key: &K) -> V {\nmatch self.inner.get(key) {\nSome(v) => v.clone(),\nNone => V::default(),\n}\n}\n}\n```\n\n### FUNCTION: `insert`\n> Signature: `pub fn insert(&mut self, key: K, value: V) -> Option<V>`\n> Lines: 163-165\n- @param key The lookup key.\n- @param value The value to associate with the key.\n- @return Previous value for this key, or None.\n```\npub fn insert(&mut self, key: K, value: V) -> Option<V> {\nself.inner.insert(key, value)\n}\n```\n\n### FUNCTION: `get_or_default`\n> Signature: `pub fn get_or_default(&self, key: &K) -> V`\n> Lines: 171-176\n- @param key The key to look up.\n- @return Cloned value if found, or the default for V.\n```\npub fn get_or_default(&self, key: &K) -> V {\nmatch self.inner.get(key) {\nSome(v) => v.clone(),\nNone => V::default(),\n}\n}\n```\n\n### MODULE: `my_module`\n> Signature: `pub mod my_module`\n> Lines: 182-189\n- @brief Sub-module containing utility helpers.\n- @brief Inline module with pub(crate) scoped items.\n```\npub mod my_module;\npub(crate) mod internal {\npub(crate) static COUNTER: std::sync::atomic::AtomicUsize =\nstd::sync::atomic::AtomicUsize::new(0);\n}\n```\n\n### MODULE: `internal`\n> Signature: `pub(crate) mod internal`\n> Lines: 185-189\n- @brief Inline module with pub(crate) scoped items.\n```\npub(crate) mod internal {\npub(crate) static COUNTER: std::sync::atomic::AtomicUsize =\nstd::sync::atomic::AtomicUsize::new(0);\n}\n```\n\n### CONSTANT: `COUNTER`\n> Signature: `pub(crate) static COUNTER: std::sync::atomic::AtomicUsize =`\n> Lines: 187-187\n```\npub(crate) static COUNTER: std::sync::atomic::AtomicUsize =\n```\n\n### MACRO: `hashmap`\n> Signature: `macro_rules! hashmap`\n> Lines: 196-196\n- @brief Usage: `hashmap!{ \"a\" => 1, \"b\" => 2 }`.\n```\nmacro_rules! hashmap {\n```\n\n### MACRO: `my_macro`\n> Signature: `macro_rules! my_macro`\n> Lines: 205-205\n```\nmacro_rules! my_macro {\n```\n\n### CONSTANT: `MY_CONST`\n> Signature: `const MY_CONST: i32 = 42`\n> Lines: 217-217\n- @brief Compile-time constant for maximum retry attempts.\n```\nconst MY_CONST: i32 = 42;\n```\n\n### CONSTANT: `MY_STATIC`\n> Signature: `static MY_STATIC: i32 = 0`\n> Lines: 220-220\n- @brief Mutable static requiring unsafe access.\n```\nstatic MY_STATIC: i32 = 0;\n```\n\n### CONSTANT: `CONFIG`\n> Signature: `static CONFIG: std::sync::LazyLock<HashMap<String, String>> =`\n> Lines: 223-223\n- @brief Thread-safe lazy-initialized global configuration.\n```\nstatic CONFIG: std::sync::LazyLock<HashMap<String, String>> =\n```\n\n### TYPE_ALIAS: `IoResult`\n> Signature: `pub type IoResult<T> = Result<T, io::Error>`\n> Lines: 229-229\n- @brief Alias for a common Result type with IO errors.\n```\npub type IoResult<T> = Result<T, io::Error>;\n```\n\n### TYPE_ALIAS: `MyAlias`\n> Signature: `pub type MyAlias = i32`\n> Lines: 232-232\n- @brief Simple integer alias.\n```\npub type MyAlias = i32;\n```\n\n### FUNCTION: `my_function`\n> Signature: `pub fn my_function(input: Option<&str>) -> String`\n> Lines: 240-249\n- @param input Optional string to evaluate.\n- @return Processed string or a fallback default.\n```\npub fn my_function(input: Option<&str>) -> String {\nlet text = match input {\nSome(s) if !s.is_empty() => s,\nSome(_) => return String::from(\"empty\"),\nNone => return String::from(\"none\"),\n};\ntext.to_uppercase()\n}\n```\n\n### FUNCTION: `async_function`\n> Signature: `pub async fn async_function() -> String`\n> Lines: 254-257\n- @return A greeting string after async computation.\n```\npub async fn async_function() -> String {\nString::from(\"hello async\")\n}\n```\n\n### FUNCTION: `filter_with`\n> Signature: `pub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>`\n> Lines: 264-269\n- @param items Slice of integers to filter.\n- @param predicate Closure returning true for items to keep.\n- @return Vector of items passing the predicate.\n```\npub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>\nwhere\nF: Fn(&i32) -> bool,\n{\nitems.iter().copied().filter(|x| predicate(x)).collect()\n}\n```\n\n### FUNCTION: `create_worker`\n> Signature: `pub fn create_worker(use_struct: bool) -> Box<dyn MyTrait>`\n> Lines: 275-281\n- @param use_struct If true, returns MyStruct; otherwise panics.\n- @return A heap-allocated trait object implementing MyTrait.\n```\npub fn create_worker(use_struct: bool) -> Box<dyn MyTrait> {\nif use_struct {\nBox::new(MyStruct::new())\n} else {\npanic!(\"No alternative implementation available\");\n}\n}\n```\n\n### FUNCTION: `read_raw`\n> Signature: `pub unsafe fn read_raw(ptr: *const i32) -> i32`\n> Lines: 288-291\n- @param ptr Raw pointer to an i32 value.\n- @return The value pointed to by ptr.\n- @sa fety Caller must ensure ptr is valid and aligned.\n```\npub unsafe fn read_raw(ptr: *const i32) -> i32 {\n*ptr\n}\n```\n\n### FUNCTION: `ffi_double`\n> Signature: `pub extern \"C\" fn ffi_double(x: i32) -> i32`\n> Lines: 297-299\n- @param x Integer to double.\n- @return The input multiplied by 2.\n```\npub extern \"C\" fn ffi_double(x: i32) -> i32 {\nx * 2\n}\n```\n\n### FUNCTION: `describe_enum`\n> Signature: `pub fn describe_enum(val: &MyEnum) -> String`\n> Lines: 305-315\n- @param val An enum variant to match against.\n- @return A description string for the matched variant.\n```\npub fn describe_enum(val: &MyEnum) -> String {\nmatch val {\nMyEnum::A => String::from(\"unit\"),\nMyEnum::B(s) => format!(\"string: {}\", s),\nMyEnum::C { x, y } => {\nlet mag = ((x * x + y * y) as f64).sqrt();\nformat!(\"point({}, {}) mag={:.2}\", x, y, mag)\n}\n}\n}\n```\n\n### IMPORT: `std::time::Duration`\n> Lines: 318-318\n```\nuse std::time::Duration;\n```\n\n### MODULE: `ext_tools`\n> Signature: `pub mod ext_tools { pub fn id() -> i32 { 1 } }`\n> Lines: 319-319\n```\npub mod ext_tools { pub fn id() -> i32 { 1 } }\n```\n\n### MODULE: `ext_local`\n> Signature: `mod ext_local { pub fn ping() -> i32 { 2 } }`\n> Lines: 320-320\n```\nmod ext_local { pub fn ping() -> i32 { 2 } }\n```\n\n### MODULE: `ext_api`\n> Signature: `pub mod ext_api { pub fn pong() -> i32 { 3 } }`\n> Lines: 321-321\n```\npub mod ext_api { pub fn pong() -> i32 { 3 } }\n```\n\n### DECORATOR: `inline`\n> Lines: 322-322\n```\n#[inline]\n```\n\n### DECORATOR: `allow(dead_code)`\n> Lines: 323-323\n```\n#[allow(dead_code)]\n```\n\n### DECORATOR: `cfg(test)`\n> Lines: 324-324\n```\n#[cfg(test)]\n```\n\n### ENUM: `Status`\n> Signature: `pub enum Status { Ready, Busy }`\n> Lines: 325-325\n```\npub enum Status { Ready, Busy }\n```\n\n### ENUM: `Mode`\n> Signature: `pub enum Mode { Alpha, Beta }`\n> Lines: 326-326\n```\npub enum Mode { Alpha, Beta }\n```\n\n### ENUM: `Signal`\n> Signature: `pub enum Signal { On, Off }`\n> Lines: 327-327\n```\npub enum Signal { On, Off }\n```\n\n### ENUM: `ErrorKind`\n> Signature: `pub enum ErrorKind { Io, Parse }`\n> Lines: 328-328\n```\npub enum ErrorKind { Io, Parse }\n```\n\n### STRUCT: `ExtraNode`\n> Signature: `pub struct ExtraNode { pub id: i32 }`\n> Lines: 329-329\n```\npub struct ExtraNode { pub id: i32 }\n```\n\n### STRUCT: `InnerNode`\n> Signature: `struct InnerNode { id: i32 }`\n> Lines: 330-330\n```\nstruct InnerNode { id: i32 }\n```\n\n### TRAIT: `Inspectable`\n> Signature: `pub trait Inspectable { fn inspect(&self) -> i32; }`\n> Lines: 331-331\n```\npub trait Inspectable { fn inspect(&self) -> i32; }\n```\n\n### TRAIT: `Named`\n> Signature: `trait Named { fn name(&self) -> &'static str; }`\n> Lines: 332-332\n```\ntrait Named { fn name(&self) -> &'static str; }\n```\n\n### TRAIT: `Executable`\n> Signature: `pub trait Executable { fn exec(&self) -> i32; }`\n> Lines: 333-333\n```\npub trait Executable { fn exec(&self) -> i32; }\n```\n\n### IMPL: `ExtraNode`\n> Signature: `impl Inspectable for ExtraNode { fn inspect(&self) -> i32 { self.id } }`\n> Lines: 334-334\n```\nimpl Inspectable for ExtraNode { fn inspect(&self) -> i32 { self.id } }\n```\n\n### IMPL: `InnerNode`\n> Signature: `impl Named for InnerNode { fn name(&self) -> &'static str { \"inner\" } }`\n> Lines: 335-335\n```\nimpl Named for InnerNode { fn name(&self) -> &'static str { \"inner\" } }\n```\n\n### IMPL: `MyEnum`\n> Signature: `impl Executable for MyEnum { fn exec(&self) -> i32 { 1 } }`\n> Lines: 336-336\n```\nimpl Executable for MyEnum { fn exec(&self) -> i32 { 1 } }\n```\n\n### MACRO: `ext_macro`\n> Signature: `macro_rules! ext_macro { () => { 42 } }`\n> Lines: 337-337\n```\nmacro_rules! ext_macro { () => { 42 } }\n```\n\n### MACRO: `trace_macro`\n> Signature: `macro_rules! trace_macro { ($v:expr) => { $v }; }`\n> Lines: 338-338\n```\nmacro_rules! trace_macro { ($v:expr) => { $v }; }\n```\n\n### MACRO: `build_pair`\n> Signature: `macro_rules! build_pair { ($a:expr,$b:expr) => { ($a,$b) }; }`\n> Lines: 339-339\n```\nmacro_rules! build_pair { ($a:expr,$b:expr) => { ($a,$b) }; }\n```\n\n### CONSTANT: `LIMIT`\n> Signature: `pub const LIMIT: usize = 8`\n> Lines: 340-340\n```\npub const LIMIT: usize = 8;\n```\n\n### TYPE_ALIAS: `ItemId`\n> Signature: `pub type ItemId = u64`\n> Lines: 341-341\n```\npub type ItemId = u64;\n```\n\n### TYPE_ALIAS: `AliasValue`\n> Signature: `type AliasValue = i32`\n> Lines: 342-342\n```\ntype AliasValue = i32;\n```\n\n### FUNCTION: `req_cover_rust_1`\n> Signature: `fn req_cover_rust_1(value: i32) -> i32 { value + 1 }`\n> Lines: 350-350\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfn req_cover_rust_1(value: i32) -> i32 { value + 1 }\n```\n\n### FUNCTION: `req_cover_rust_2`\n> Signature: `fn req_cover_rust_2(value: i32) -> i32 { value + 2 }`\n> Lines: 357-357\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfn req_cover_rust_2(value: i32) -> i32 { value + 2 }\n```\n\n### FUNCTION: `req_cover_rust_3`\n> Signature: `fn req_cover_rust_3(value: i32) -> i32 { value + 3 }`\n> Lines: 364-364\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfn req_cover_rust_3(value: i32) -> i32 { value + 3 }\n```\n\n### FUNCTION: `req_cover_rust_4`\n> Signature: `fn req_cover_rust_4(value: i32) -> i32 { value + 4 }`\n> Lines: 371-371\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfn req_cover_rust_4(value: i32) -> i32 { value + 4 }\n```\n\n### FUNCTION: `req_cover_rust_5`\n> Signature: `fn req_cover_rust_5(value: i32) -> i32 { value + 5 }`\n> Lines: 378-378\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfn req_cover_rust_5(value: i32) -> i32 { value + 5 }\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_scala.scala.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_scala.scala | scala\n- @brief Comprehensive Scala test fixture for parser validation.\n- @details Covers implicits/givens, pattern matching, higher-kinded types,\nself-types, variance, opaque types, extension methods, enums,\nfor comprehensions, and cake pattern.\n\n### IMPORT: `scala.collection.mutable`\n> Lines: 11-11\n```\nimport scala.collection.mutable\n```\n\n### IMPORT: `scala.concurrent.{Future, ExecutionContext}`\n> Lines: 12-12\n```\nimport scala.concurrent.{Future, ExecutionContext}\n```\n\n### IMPORT: `scala.util.{Try, Success, Failure}`\n> Lines: 13-13\n```\nimport scala.util.{Try, Success, Failure}\n```\n\n### CLASS: `Person`\n> Signature: `case class Person(name: String, age: Int)`\n> Lines: 23-35\n- @brief Immutable data class for person entities.\n- @brief Check if the person is an adult.\n- @param name Display name.\n- @param age Age in years; must be non-negative.\n- @return True if age >= 18.\n```\ncase class Person(name: String, age: Int) {\ndef isAdult: Boolean = age >= 18\ndef greet: String = s\"Hi, I'm $name, age $age\"\n}\n```\n\n### FUNCTION: `isAdult`\n> Signature: `def isAdult: Boolean = age >= 18`\n> Lines: 28-43\n- @brief Check if the person is an adult.\n- @brief Create a greeting string.\n- @return True if age >= 18.\n- @return Formatted greeting including name and age.\n```\ndef isAdult: Boolean = age >= 18\ndef greet: String = s\"Hi, I'm $name, age $age\"\n}\nsealed trait Shape {\n```\n\n### FUNCTION: `greet`\n> Signature: `def greet: String = s\"Hi, I'm $name, age $age\"`\n> Lines: 34-43\n- @brief Create a greeting string.\n- @return Formatted greeting including name and age.\n```\ndef greet: String = s\"Hi, I'm $name, age $age\"\n}\nsealed trait Shape {\n```\n\n### FUNCTION: `area`\n> Signature: `def area: Double`\n> Lines: 48-56\n- @brief Compute the area of this shape.\n- @brief Circle shape with radius.\n- @param radius The circle's radius.\n- @return Area as a Double.\n```\ndef area: Double\n}\ncase class Circle(radius: Double) extends Shape {\n```\n\n### CLASS: `Circle`\n> Signature: `case class Circle(radius: Double) extends Shape`\n> Lines: 56-58\n- @brief Circle shape with radius.\n- @param radius The circle's radius.\n```\ncase class Circle(radius: Double) extends Shape {\noverride def area: Double = math.Pi * radius * radius\n}\n```\n\n### FUNCTION: `area`\n> Signature: `override def area: Double = math.Pi * radius * radius`\n> Lines: 57-66\n- @brief Rectangle shape with width and height.\n- @param width The rectangle's width.\n- @param height The rectangle's height.\n```\noverride def area: Double = math.Pi * radius * radius\n}\ncase class Rectangle(width: Double, height: Double) extends Shape {\n```\n\n### CLASS: `Rectangle`\n> Signature: `case class Rectangle(width: Double, height: Double) extends Shape`\n> Lines: 66-68\n- @brief Rectangle shape with width and height.\n- @param width The rectangle's width.\n- @param height The rectangle's height.\n```\ncase class Rectangle(width: Double, height: Double) extends Shape {\noverride def area: Double = width * height\n}\n```\n\n### FUNCTION: `area`\n> Signature: `override def area: Double = width * height`\n> Lines: 67-76\n```\noverride def area: Double = width * height\n}\nabstract class Animal {\n```\n\n### CLASS: `Animal`\n> Signature: `abstract class Animal`\n> Lines: 76-88\n- @brief Abstract base class for animals with sound production.\n- @brief The sound this animal makes.\n- @return Sound description string.\n```\nabstract class Animal {\ndef sound: String\ndef describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n}\n```\n\n### FUNCTION: `sound`\n> Signature: `def sound: String`\n> Lines: 81-87\n- @brief The sound this animal makes.\n- @brief Describe the animal including its sound.\n- @return Sound description string.\n- @return Formatted description string.\n```\ndef sound: String\ndef describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n```\n\n### FUNCTION: `describe`\n> Signature: `def describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"`\n> Lines: 87-87\n- @brief Describe the animal including its sound.\n- @return Formatted description string.\n```\ndef describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n```\n\n### TRAIT: `Drawable`\n> Signature: `trait Drawable`\n> Lines: 96-102\n- @brief Trait for rendering objects to string representation.\n- @brief Draw the object as a string.\n- @return Rendered string representation.\n```\ntrait Drawable {\ndef draw(): Unit\n}\n```\n\n### FUNCTION: `draw`\n> Signature: `def draw(): Unit`\n> Lines: 101-109\n- @brief Draw the object as a string.\n- @brief Self-type trait requiring Drawable to be mixed in.\n- @details Demonstrates the cake pattern for dependency injection.\n- @return Rendered string representation.\n```\ndef draw(): Unit\n}\ntrait Logging { self: Drawable =>\n```\n\n### TRAIT: `Logging`\n> Signature: `trait Logging { self: Drawable =>`\n> Lines: 109-117\n- @brief Self-type trait requiring Drawable to be mixed in.\n- @brief Log the drawing operation and then draw.\n- @details Demonstrates the cake pattern for dependency injection.\n```\ntrait Logging { self: Drawable =>\ndef logAndDraw(): Unit = {\nprintln(\"About to draw\")\ndraw()\n}\n}\n```\n\n### FUNCTION: `logAndDraw`\n> Signature: `def logAndDraw(): Unit =`\n> Lines: 113-116\n- @brief Log the drawing operation and then draw.\n```\ndef logAndDraw(): Unit = {\nprintln(\"About to draw\")\ndraw()\n}\n```\n\n### TRAIT: `Serializable`\n> Signature: `trait Serializable`\n> Lines: 123-129\n- @brief Trait for objects convertible to byte arrays.\n- @brief Serialize this object to bytes.\n- @return Byte array representation.\n```\ntrait Serializable {\ndef serialize: Array[Byte]\n}\n```\n\n### FUNCTION: `serialize`\n> Signature: `def serialize: Array[Byte]`\n> Lines: 128-137\n- @brief Serialize this object to bytes.\n- @return Byte array representation.\n```\ndef serialize: Array[Byte]\n}\nobject Main {\n```\n\n### MODULE: `Main`\n> Signature: `object Main`\n> Lines: 137-192\n- @brief Application entry point and utility function container.\n- @brief Application entry point.\n- @param args Command-line arguments.\n```\nobject Main {\ndef main(args: Array[String]): Unit = {\nval people = List(Person(\"Alice\", 30), Person(\"Bob\", 17))\nval adults = people.filter(_.isAdult)\nadults.foreach(p => println(p.greet))\n}\noverride def toString: String = \"Main\"\nval pi = 3.14159265\nvar counter = 0\ntype StringList = List[String]\ntype Transformer[A] = A => A\ndef describeShape(shape: Shape): String = shape match {\ncase Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\ncase Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n}\ndef classify(x: Int): String = x match {\ncase 0 => \"zero\"\ncase n if n < 0 => \"negative\"\ncase n if n > 100 => \"large\"\ncase _ => \"positive\"\n}\n}\n```\n\n### FUNCTION: `main`\n> Signature: `def main(args: Array[String]): Unit =`\n> Lines: 142-147\n- @brief Application entry point.\n- @param args Command-line arguments.\n```\ndef main(args: Array[String]): Unit = {\nval people = List(Person(\"Alice\", 30), Person(\"Bob\", 17))\nval adults = people.filter(_.isAdult)\nadults.foreach(p => println(p.greet))\n}\n```\n\n### CONSTANT: `people`\n> Signature: `val people = List(Person(\"Alice\", 30), Person(\"Bob\", 17))`\n> Lines: 143-143\n```\nval people = List(Person(\"Alice\", 30), Person(\"Bob\", 17))\n```\n\n### CONSTANT: `adults`\n> Signature: `val adults = people.filter(_.isAdult)`\n> Lines: 145-145\n```\nval adults = people.filter(_.isAdult)\n```\n\n### FUNCTION: `toString`\n> Signature: `override def toString: String = \"Main\"`\n> Lines: 153-179\n- @brief Override toString for Main object display.\n- @brief Mathematical constant pi.\n- @return String representation.\n```\noverride def toString: String = \"Main\"\nval pi = 3.14159265\nvar counter = 0\ntype StringList = List[String]\ntype Transformer[A] = A => A\ndef describeShape(shape: Shape): String = shape match {\ncase Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\ncase Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n}\n```\n\n### CONSTANT: `pi`\n> Signature: `val pi = 3.14159265`\n> Lines: 156-156\n- @brief Mathematical constant pi. */\n```\nval pi = 3.14159265\n```\n\n### VARIABLE: `counter`\n> Signature: `var counter = 0`\n> Lines: 159-159\n- @brief Mutable counter for tracking operations. */\n```\nvar counter = 0\n```\n\n### TYPE_ALIAS: `StringList`\n> Signature: `type StringList = List[String]`\n> Lines: 164-164\n- @brief Type alias for lists of strings.\n```\ntype StringList = List[String]\n```\n\n### TYPE_ALIAS: `Transformer`\n> Signature: `type Transformer[A] = A => A`\n> Lines: 169-169\n- @brief Type alias for function transformers.\n```\ntype Transformer[A] = A => A\n```\n\n### FUNCTION: `describeShape`\n> Signature: `def describeShape(shape: Shape): String = shape match`\n> Lines: 176-179\n- @brief Describe a shape using exhaustive pattern matching.\n- @param shape The shape to describe.\n- @return Human-readable description with area.\n```\ndef describeShape(shape: Shape): String = shape match {\ncase Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\ncase Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n}\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(x: Int): String = x match`\n> Lines: 186-191\n- @brief Process a value with multiple match guards.\n- @param x Integer input to classify.\n- @return Classification string.\n```\ndef classify(x: Int): String = x match {\ncase 0 => \"zero\"\ncase n if n < 0 => \"negative\"\ncase n if n > 100 => \"large\"\ncase _ => \"positive\"\n}\n```\n\n### CLASS: `Config`\n> Signature: `class Config private (val entries: Map[String, String])`\n> Lines: 201-208\n- @brief Configuration holder with companion factory.\n- @brief Retrieve a value by key.\n- @param entries Key-value pairs.\n- @param key The configuration key.\n- @return Optional value.\n```\nclass Config private (val entries: Map[String, String]) {\ndef get(key: String): Option[String] = entries.get(key)\n}\n```\n\n### FUNCTION: `get`\n> Signature: `def get(key: String): Option[String] = entries.get(key)`\n> Lines: 207-214\n- @brief Retrieve a value by key.\n- @brief Companion object with factory methods for Config.\n- @param key The configuration key.\n- @return Optional value.\n```\ndef get(key: String): Option[String] = entries.get(key)\n}\nobject Config {\n```\n\n### MODULE: `Config`\n> Signature: `object Config`\n> Lines: 214-227\n- @brief Companion object with factory methods for Config.\n- @brief Create a Config from key-value pairs.\n- @param entries Variable number of key-value tuples.\n- @return A new Config instance.\n```\nobject Config {\ndef apply(entries: (String, String)*): Config = new Config(entries.toMap)\ndef empty: Config = new Config(Map.empty)\n}\n```\n\n### FUNCTION: `apply`\n> Signature: `def apply(entries: (String, String)*): Config = new Config(entries.toMap)`\n> Lines: 220-236\n- @brief Create a Config from key-value pairs.\n- @brief Create an empty Config.\n- @param entries Variable number of key-value tuples.\n- @return A new Config instance.\n- @return Config with no entries.\n```\ndef apply(entries: (String, String)*): Config = new Config(entries.toMap)\ndef empty: Config = new Config(Map.empty)\n}\nclass Container[+A](val value: A) {\n```\n\n### FUNCTION: `empty`\n> Signature: `def empty: Config = new Config(Map.empty)`\n> Lines: 226-236\n- @brief Create an empty Config.\n- @return Config with no entries.\n```\ndef empty: Config = new Config(Map.empty)\n}\nclass Container[+A](val value: A) {\n```\n\n### CLASS: `Container`\n> Signature: `class Container[+A](val value: A)`\n> Lines: 236-252\n- @brief Covariant generic container.\n@tparam +A Element type (covariant).\n- @brief Map the contained value. @tparam B Target type.\n- @param f Transform function.\n- @return New Container with transformed value.\n```\nclass Container[+A](val value: A) {\ndef map[B](f: A => B): Container[B] = new Container(f(value))\ndef flatMap[B](f: A => Container[B]): Container[B] = f(value)\n}\n```\n\n### FUNCTION: `map`\n> Signature: `def map[B](f: A => B): Container[B] = new Container(f(value))`\n> Lines: 243-261\n- @brief Map the contained value.\n@tparam B Target type.\n- @brief Flat-map the contained value. @tparam B Target type.\n- @param f Transform function.\n- @param f Transform function returning a Container.\n- @return New Container with transformed value.\n- @return Flattened Container.\n```\ndef map[B](f: A => B): Container[B] = new Container(f(value))\ndef flatMap[B](f: A => Container[B]): Container[B] = f(value)\n}\nimplicit class RichInt(val n: Int) extends AnyVal {\n```\n\n### FUNCTION: `flatMap`\n> Signature: `def flatMap[B](f: A => Container[B]): Container[B] = f(value)`\n> Lines: 251-261\n- @brief Flat-map the contained value.\n@tparam B Target type.\n- @param f Transform function returning a Container.\n- @return Flattened Container.\n```\ndef flatMap[B](f: A => Container[B]): Container[B] = f(value)\n}\nimplicit class RichInt(val n: Int) extends AnyVal {\n```\n\n### FUNCTION: `isEven`\n> Signature: `def isEven: Boolean = n % 2 == 0`\n> Lines: 266-282\n- @brief Check if the number is even.\n- @brief Repeat a string n times.\n- @param s The string to repeat.\n- @return True if n is divisible by 2.\n- @return Concatenated result.\n```\ndef isEven: Boolean = n % 2 == 0\ndef times(s: String): String = s * n\n}\nobject ForCompExample {\n```\n\n### FUNCTION: `times`\n> Signature: `def times(s: String): String = s * n`\n> Lines: 273-282\n- @brief Repeat a string n times.\n- @param s The string to repeat.\n- @return Concatenated result.\n```\ndef times(s: String): String = s * n\n}\nobject ForCompExample {\n```\n\n### MODULE: `ForCompExample`\n> Signature: `object ForCompExample`\n> Lines: 282-296\n- @brief Demonstrates for-comprehension with multiple generators.\n- @brief Compute all pairs of integers whose sum equals target.\n- @param range Upper bound of the search space.\n- @param target Desired sum.\n- @return List of pairs summing to target.\n```\nobject ForCompExample {\ndef findPairs(range: Int, target: Int): List[(Int, Int)] = {\nfor {\nx <- (1 to range).toList\ny <- (x to range).toList\nif x + y == target\n} yield (x, y)\n}\n}\n```\n\n### FUNCTION: `findPairs`\n> Signature: `def findPairs(range: Int, target: Int): List[(Int, Int)] =`\n> Lines: 289-295\n- @brief Compute all pairs of integers whose sum equals target.\n- @param range Upper bound of the search space.\n- @param target Desired sum.\n- @return List of pairs summing to target.\n```\ndef findPairs(range: Int, target: Int): List[(Int, Int)] = {\nfor {\nx <- (1 to range).toList\ny <- (x to range).toList\nif x + y == target\n} yield (x, y)\n}\n```\n\n### MODULE: `FuncUtils`\n> Signature: `object FuncUtils`\n> Lines: 304-332\n- @brief Utility functions demonstrating functional patterns.\n- @brief Curried addition function.\n- @param a First operand.\n- @param b Second operand.\n- @return Sum of a and b.\n```\nobject FuncUtils {\ndef add(a: Int)(b: Int): Int = a + b\ndef twice[A](f: A => A)(x: A): A = f(f(x))\ndef compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n}\n```\n\n### FUNCTION: `add`\n> Signature: `def add(a: Int)(b: Int): Int = a + b`\n> Lines: 311-351\n- @brief Curried addition function.\n- @brief Apply a function twice to an initial value. @tparam A Value type.\n- @param a First operand.\n- @param b Second operand.\n- @param f Function to apply.\n- @param x Initial value.\n- @return Sum of a and b.\n- @return Result of f(f(x)).\n```\ndef add(a: Int)(b: Int): Int = a + b\ndef twice[A](f: A => A)(x: A): A = f(f(x))\ndef compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n}\nimport scala.util.Random\nimport scala.concurrent.duration._\ntrait Runner\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\n```\n\n### FUNCTION: `twice`\n> Signature: `def twice[A](f: A => A)(x: A): A = f(f(x))`\n> Lines: 320-351\n- @brief Apply a function twice to an initial value.\n@tparam A Value type.\n- @brief Compose two functions left to right. @tparam A Input type. @tparam B Intermediate type. @tparam C Output type.\n- @param f Function to apply.\n- @param x Initial value.\n- @param f First function.\n- @param g Second function.\n- @return Result of f(f(x)).\n- @return Composed function.\n```\ndef twice[A](f: A => A)(x: A): A = f(f(x))\ndef compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n}\nimport scala.util.Random\nimport scala.concurrent.duration._\ntrait Runner\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\n```\n\n### FUNCTION: `compose`\n> Signature: `def compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))`\n> Lines: 331-351\n- @brief Compose two functions left to right.\n@tparam A Input type.\n@tparam B Intermediate type.\n@tparam C Output type.\n- @param f First function.\n- @param g Second function.\n- @return Composed function.\n```\ndef compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n}\nimport scala.util.Random\nimport scala.concurrent.duration._\ntrait Runner\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\n```\n\n### IMPORT: `scala.util.Random`\n> Lines: 335-335\n```\nimport scala.util.Random\n```\n\n### IMPORT: `scala.concurrent.duration._`\n> Lines: 336-336\n```\nimport scala.concurrent.duration._\n```\n\n### TRAIT: `Runner`\n> Signature: `trait Runner`\n> Lines: 337-397\n```\ntrait Runner\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\ndef reqCoverScala1(value: Int): Int = value + 1\ndef reqCoverScala2(value: Int): Int = value + 2\ndef reqCoverScala3(value: Int): Int = value + 3\ndef reqCoverScala4(value: Int): Int = value + 4\ndef reqCoverScala5(value: Int): Int = value + 5\n}\n```\n\n### TRAIT: `Parser`\n> Signature: `trait Parser`\n> Lines: 338-397\n```\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\ndef reqCoverScala1(value: Int): Int = value + 1\ndef reqCoverScala2(value: Int): Int = value + 2\ndef reqCoverScala3(value: Int): Int = value + 3\ndef reqCoverScala4(value: Int): Int = value + 4\ndef reqCoverScala5(value: Int): Int = value + 5\n}\n```\n\n### MODULE: `Metrics`\n> Signature: `object Metrics`\n> Lines: 339-397\n```\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\ndef reqCoverScala1(value: Int): Int = value + 1\ndef reqCoverScala2(value: Int): Int = value + 2\ndef reqCoverScala3(value: Int): Int = value + 3\ndef reqCoverScala4(value: Int): Int = value + 4\ndef reqCoverScala5(value: Int): Int = value + 5\n}\n```\n\n### CONSTANT: `MaxUsers`\n> Signature: `val MaxUsers = 100`\n> Lines: 340-340\n```\nval MaxUsers = 100\n```\n\n### CONSTANT: `RetryLimit`\n> Signature: `val RetryLimit = 3`\n> Lines: 341-341\n```\nval RetryLimit = 3\n```\n\n### TYPE_ALIAS: `UserKey`\n> Signature: `type UserKey = String`\n> Lines: 342-342\n```\ntype UserKey = String\n```\n\n### TYPE_ALIAS: `ErrorCode`\n> Signature: `type ErrorCode = Int`\n> Lines: 343-343\n```\ntype ErrorCode = Int\n```\n\n### TYPE_ALIAS: `Mapper`\n> Signature: `type Mapper = String => String`\n> Lines: 344-344\n```\ntype Mapper = String => String\n```\n\n### VARIABLE: `attempts`\n> Signature: `var attempts = 0`\n> Lines: 345-345\n```\nvar attempts = 0\n```\n\n### VARIABLE: `cursor`\n> Signature: `var cursor = 1`\n> Lines: 346-346\n```\nvar cursor = 1\n```\n\n### VARIABLE: `stage`\n> Signature: `var stage = \"init\"`\n> Lines: 347-347\n```\nvar stage = \"init\"\n```\n\n### VARIABLE: `status`\n> Signature: `var status = \"ready\"`\n> Lines: 348-348\n```\nvar status = \"ready\"\n```\n\n### MODULE: `ReqCoverScala`\n> Signature: `object ReqCoverScala`\n> Lines: 351-397\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```\nobject ReqCoverScala {\ndef reqCoverScala1(value: Int): Int = value + 1\ndef reqCoverScala2(value: Int): Int = value + 2\ndef reqCoverScala3(value: Int): Int = value + 3\ndef reqCoverScala4(value: Int): Int = value + 4\ndef reqCoverScala5(value: Int): Int = value + 5\n}\n```\n\n### FUNCTION: `reqCoverScala1`\n> Signature: `def reqCoverScala1(value: Int): Int = value + 1`\n> Lines: 359-359\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\ndef reqCoverScala1(value: Int): Int = value + 1\n```\n\n### FUNCTION: `reqCoverScala2`\n> Signature: `def reqCoverScala2(value: Int): Int = value + 2`\n> Lines: 368-368\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\ndef reqCoverScala2(value: Int): Int = value + 2\n```\n\n### FUNCTION: `reqCoverScala3`\n> Signature: `def reqCoverScala3(value: Int): Int = value + 3`\n> Lines: 377-377\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\ndef reqCoverScala3(value: Int): Int = value + 3\n```\n\n### FUNCTION: `reqCoverScala4`\n> Signature: `def reqCoverScala4(value: Int): Int = value + 4`\n> Lines: 386-386\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\ndef reqCoverScala4(value: Int): Int = value + 4\n```\n\n### FUNCTION: `reqCoverScala5`\n> Signature: `def reqCoverScala5(value: Int): Int = value + 5`\n> Lines: 395-395\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\ndef reqCoverScala5(value: Int): Int = value + 5\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_shell.sh.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_shell.sh | shell\n\n### VARIABLE: `MY_VAR`\n> Signature: `MY_VAR=\"hello\"`\n> Lines: 12-12\n- @brief Greeting message template.\n```\nMY_VAR=\"hello\"\n```\n\n### VARIABLE: `PATH_EXT`\n> Signature: `export PATH_EXT=\"/usr/local/bin\"`\n> Lines: 15-15\n- @brief Extended PATH including local binary directory.\n```\nexport PATH_EXT=\"/usr/local/bin\"\n```\n\n### VARIABLE: `MAX_COUNT`\n> Signature: `readonly MAX_COUNT=10`\n> Lines: 18-18\n- @brief Immutable maximum iteration counter.\n```\nreadonly MAX_COUNT=10\n```\n\n### VARIABLE: `BUILD_VERSION`\n> Signature: `declare -r BUILD_VERSION=\"1.0.0\"`\n> Lines: 21-21\n- @brief Build version set via declare.\n```\ndeclare -r BUILD_VERSION=\"1.0.0\"\n```\n\n### VARIABLE: `DEBUG_MODE`\n> Signature: `DEBUG_MODE=0`\n> Lines: 24-24\n- @brief Debug mode flag (0=off, 1=on).\n```\nDEBUG_MODE=0\n```\n\n### VARIABLE: `LANGUAGES`\n> Signature: `declare -a LANGUAGES=(\"python\" \"rust\" \"go\" \"java\" \"typescript\")`\n> Lines: 29-29\n- @brief Indexed array of supported languages.\n```\ndeclare -a LANGUAGES=(\"python\" \"rust\" \"go\" \"java\" \"typescript\")\n```\n\n### VARIABLE: `EXT_MAP`\n> Signature: `declare -A EXT_MAP=(`\n> Lines: 32-32\n- @brief Associative array mapping extensions to languages.\n```\ndeclare -A EXT_MAP=(\n```\n\n### FUNCTION: `greet`\n> Signature: `function greet()`\n> Lines: 44-44\n- @brief Greet a user by name on stdout.\n- @param $1 The user's name.\n```\nfunction greet() {\n```\n\n### FUNCTION: `cleanup`\n> Signature: `cleanup()`\n> Lines: 56-56\n- @brief Remove temporary files and directories.\n- @details Called by trap on EXIT for cleanup.\n```\ncleanup() {\n```\n\n### FUNCTION: `parse_args`\n> Signature: `parse_args()`\n> Lines: 68-68\n- @brief Parse command-line options using getopts.\n- @param $@ Command-line arguments.\n- @return Sets global variables based on parsed options.\n```\nparse_args() {\n```\n\n### VARIABLE: `VERBOSE`\n> Signature: `VERBOSE=1`\n> Lines: 74-74\n```\nVERBOSE=1\n```\n\n### VARIABLE: `DEBUG_MODE`\n> Signature: `DEBUG_MODE=1`\n> Lines: 78-78\n```\nDEBUG_MODE=1\n```\n\n### VARIABLE: `INPUT_FILE`\n> Signature: `INPUT_FILE=\"$OPTARG\"`\n> Lines: 82-82\n```\nINPUT_FILE=\"$OPTARG\"\n```\n\n### VARIABLE: `OUTPUT_FILE`\n> Signature: `OUTPUT_FILE=\"$OPTARG\"`\n> Lines: 86-86\n```\nOUTPUT_FILE=\"$OPTARG\"\n```\n\n### FUNCTION: `process_file`\n> Signature: `process_file()`\n> Lines: 105-105\n- @brief Process a file with error handling and logging.\n- @param $1 Path to the input file.\n- @param $2 Optional output path (defaults to stdout).\n- @return 0 on success, 1 on failure.\n```\nprocess_file() {\n```\n\n### FUNCTION: `retry_command`\n> Signature: `retry_command()`\n> Lines: 139-139\n- @brief Execute a command with retry logic.\n- @param $1 Maximum number of retry attempts.\n- @param $@ The command and arguments to execute.\n- @return Exit code of the final attempt.\n```\nretry_command() {\n```\n\n### FUNCTION: `log_message`\n> Signature: `log_message()`\n> Lines: 162-162\n- @brief Log a message with timestamp prefix.\n- @param $1 Log level (INFO, WARN, ERROR).\n- @param $@ Message text.\n```\nlog_message() {\n```\n\n### FUNCTION: `make_temp`\n> Signature: `make_temp()`\n> Lines: 172-172\n- @brief Generate a temporary file and return its path.\n- @return Path to the created temporary file.\n```\nmake_temp() {\n```\n\n### FUNCTION: `generate_config`\n> Signature: `generate_config()`\n> Lines: 189-189\n- @brief Generate a configuration file using heredoc.\n```\ngenerate_config() {\n```\n\n### FUNCTION: `factorial`\n> Signature: `factorial()`\n> Lines: 203-203\n- @brief Compute factorial iteratively.\n- @param $1 Non-negative integer.\n- @return Factorial result.\n```\nfactorial() {\n```\n\n### IMPORT: `./config.sh`\n> Lines: 218-218\n- @brief Load external configuration script if present.\n```\nsource ./config.sh\n```\n\n### IMPORT: `./env.sh`\n> Lines: 222-222\n```\nsource ./env.sh\n```\n\n### IMPORT: `./shared.sh`\n> Lines: 224-224\n```\nsource ./shared.sh\n```\n\n### IMPORT: `./runtime.sh`\n> Lines: 226-226\n```\nsource ./runtime.sh\n```\n\n### IMPORT: `./network.sh`\n> Lines: 228-228\n```\nsource ./network.sh\n```\n\n### FUNCTION: `req_cover_shell_1`\n> Signature: `req_cover_shell_1()`\n> Lines: 236-236\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nreq_cover_shell_1() {\n```\n\n### FUNCTION: `req_cover_shell_2`\n> Signature: `req_cover_shell_2()`\n> Lines: 245-245\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nreq_cover_shell_2() {\n```\n\n### FUNCTION: `req_cover_shell_3`\n> Signature: `req_cover_shell_3()`\n> Lines: 254-254\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nreq_cover_shell_3() {\n```\n\n### FUNCTION: `req_cover_shell_4`\n> Signature: `req_cover_shell_4()`\n> Lines: 263-263\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nreq_cover_shell_4() {\n```\n\n### FUNCTION: `req_cover_shell_5`\n> Signature: `req_cover_shell_5()`\n> Lines: 272-272\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nreq_cover_shell_5() {\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_swift.swift.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_swift.swift | swift\n\n### IMPORT: `Foundation`\n> Lines: 8-8\n```\nimport Foundation\n```\n\n### IMPORT: `Combine`\n> Lines: 9-9\n```\nimport Combine\n```\n\n### CLASS: `Animal`\n> Signature: `class Animal`\n> Lines: 16-58\n- @brief Base class with stored, computed, and observed properties.\n- @brief Species name identifier.\n```\nclass Animal {\nvar species: String\nvar legs: Int = 4 {\nwillSet {\nprint(\"Legs changing from \\(legs) to \\(newValue)\")\n}\ndidSet {\nif legs < 0 { legs = 0 }\n}\n}\nvar description: String {\nreturn \"\\(species) with \\(legs) legs\"\n}\ninit(species: String) {\nself.species = species\n}\nfunc speak() {\nprint(\"...\")\n}\nclass func createDefault() -> Animal {\nreturn Animal(species: \"Unknown\")\n}\ndeinit {\nprint(\"\\(species) deallocated\")\n}\n}\n```\n\n### VARIABLE: `species`\n> Signature: `var species: String`\n> Lines: 18-18\n- @brief Species name identifier.\n```\nvar species: String\n```\n\n### VARIABLE: `legs`\n> Signature: `var legs: Int = 4`\n> Lines: 21-21\n- @brief Number of legs; triggers a didSet observer on change.\n```\nvar legs: Int = 4 {\n```\n\n### VARIABLE: `description`\n> Signature: `var description: String`\n> Lines: 33-33\n- @brief Computed property returning a descriptive string.\n```\nvar description: String {\n```\n\n### FUNCTION: `speak`\n> Signature: `func speak()`\n> Lines: 44-46\n- @brief Produce a sound; subclasses should override.\n```\nfunc speak() {\nprint(\"...\")\n}\n```\n\n### CLASS: `func`\n> Signature: `class func createDefault() -> Animal`\n> Lines: 50-52\n- @brief Class method creating a generic instance.\n- @return An Animal with species \"Unknown\".\n```\nclass func createDefault() -> Animal {\nreturn Animal(species: \"Unknown\")\n}\n```\n\n### CLASS: `Dog`\n> Signature: `class Dog: Animal`\n> Lines: 63-78\n- @brief Concrete animal with dog-specific behavior.\n- @brief Dog's name.\n```\nclass Dog: Animal {\nlet name: String\ninit(name: String) {\nself.name = name\nsuper.init(species: \"Dog\")\n}\noverride func speak() {\nprint(\"\\(name) says: Woof!\")\n}\n}\n```\n\n### CONSTANT: `name`\n> Signature: `let name: String`\n> Lines: 65-65\n- @brief Dog's name.\n```\nlet name: String\n```\n\n### FUNCTION: `speak`\n> Signature: `override func speak()`\n> Lines: 75-77\n- @brief Override speak to produce dog-specific sound.\n```\noverride func speak() {\nprint(\"\\(name) says: Woof!\")\n}\n```\n\n### STRUCT: `Point`\n> Signature: `struct Point: Equatable`\n> Lines: 85-102\n- @brief Value type representing a coordinate pair.\n```\nstruct Point: Equatable {\nvar x: Double = 0.0\nvar y: Double = 0.0\nstatic func + (lhs: Point, rhs: Point) -> Point {\nreturn Point(x: lhs.x + rhs.x, y: lhs.y + rhs.y)\n}\nvar magnitude: Double {\nreturn (x * x + y * y).squareRoot()\n}\n}\n```\n\n### VARIABLE: `x`\n> Signature: `var x: Double = 0.0`\n> Lines: 86-86\n```\nvar x: Double = 0.0\n```\n\n### VARIABLE: `y`\n> Signature: `var y: Double = 0.0`\n> Lines: 87-87\n```\nvar y: Double = 0.0\n```\n\n### VARIABLE: `magnitude`\n> Signature: `var magnitude: Double`\n> Lines: 99-99\n- @brief Compute Euclidean distance from origin.\n- @return Distance as a Double.\n```\nvar magnitude: Double {\n```\n\n### STRUCT: `Matrix`\n> Signature: `struct Matrix`\n> Lines: 107-133\n- @brief 2D matrix supporting element access via subscript.\n- @brief Flat storage for matrix values.\n```\nstruct Matrix {\nprivate var data: [[Double]]\nlet rows: Int\nlet cols: Int\ninit(rows: Int, cols: Int) {\nself.rows = rows\nself.cols = cols\ndata = Array(repeating: Array(repeating: 0.0, count: cols), count: rows)\n}\nsubscript(row: Int, col: Int) -> Double {\nget { return data[row][col] }\nset { data[row][col] = newValue }\n}\n}\n```\n\n### VARIABLE: `data`\n> Signature: `private var data: [[Double]]`\n> Lines: 109-109\n- @brief Flat storage for matrix values.\n```\nprivate var data: [[Double]]\n```\n\n### CONSTANT: `rows`\n> Signature: `let rows: Int`\n> Lines: 112-112\n- @brief Number of rows.\n```\nlet rows: Int\n```\n\n### CONSTANT: `cols`\n> Signature: `let cols: Int`\n> Lines: 114-114\n- @brief Number of columns.\n```\nlet cols: Int\n```\n\n### ENUM: `Direction`\n> Signature: `enum Direction: String, CaseIterable`\n> Lines: 140-156\n- @brief Cardinal directions supporting CaseIterable iteration.\n```\nenum Direction: String, CaseIterable {\ncase up = \"UP\"\ncase down = \"DOWN\"\ncase left = \"LEFT\"\ncase right = \"RIGHT\"\nvar opposite: Direction {\nswitch self {\ncase .up: return .down\ncase .down: return .up\ncase .left: return .right\ncase .right: return .left\n}\n}\n}\n```\n\n### VARIABLE: `opposite`\n> Signature: `var opposite: Direction`\n> Lines: 148-148\n- @brief Compute the opposite direction.\n- @return The direction 180 degrees from self.\n```\nvar opposite: Direction {\n```\n\n### ENUM: `AppResult`\n> Signature: `enum AppResult<T>`\n> Lines: 162-179\n- @brief Successful result carrying a value.\n- @brief Failure carrying an error description.\n```\nenum AppResult<T> {\ncase success(T)\ncase failure(Error)\nfunc map<U>(_ transform: (T) -> U) -> AppResult<U> {\nswitch self {\ncase .success(let value):\nreturn .success(transform(value))\ncase .failure(let error):\nreturn .failure(error)\n}\n}\n}\n```\n\n### FUNCTION: `map`\n> Signature: `func map<U>(_ transform: (T) -> U) -> AppResult<U>`\n> Lines: 171-178\n- @brief Map the success value using a transform closure.\n- @param transform Closure converting T to U.\n- @return A new AppResult with the transformed value.\n```\nfunc map<U>(_ transform: (T) -> U) -> AppResult<U> {\nswitch self {\ncase .success(let value):\nreturn .success(transform(value))\ncase .failure(let error):\nreturn .failure(error)\n}\n}\n```\n\n### PROTOCOL: `Drawable`\n> Signature: `protocol Drawable`\n> Lines: 186-193\n- @brief Defines the render contract with a default extension implementation.\n- @brief Render the object to a string representation.\n- @return Rendered string output.\n```\nprotocol Drawable {\nfunc draw() -> String\nvar renderPriority: Int { get }\n}\n```\n\n### FUNCTION: `draw`\n> Signature: `func draw() -> String`\n> Lines: 189-192\n- @brief Render the object to a string representation.\n- @brief Optional priority for render ordering.\n- @return Rendered string output.\n```\nfunc draw() -> String\nvar renderPriority: Int { get }\n```\n\n### VARIABLE: `renderPriority`\n> Signature: `var renderPriority: Int { get }`\n> Lines: 192-192\n- @brief Optional priority for render ordering.\n```\nvar renderPriority: Int { get }\n```\n\n### PROTOCOL: `Container`\n> Signature: `protocol Container`\n> Lines: 198-208\n- @brief Defines a type-erased container interface.\n- @brief The type of element stored in the container.\n```\nprotocol Container {\nassociatedtype Item\nmutating func add(_ item: Item)\nvar count: Int { get }\n}\n```\n\n### VARIABLE: `count`\n> Signature: `var count: Int { get }`\n> Lines: 207-207\n- @brief Number of elements in the container.\n```\nvar count: Int { get }\n```\n\n### EXTENSION: `Drawable`\n> Signature: `extension Drawable`\n> Lines: 212-221\n- @brief Default render priority for all Drawable conformants.\n```\nextension Drawable {\nvar renderPriority: Int { return 0 }\nfunc debugDraw() -> String {\nreturn \"[\\(renderPriority)] \\(draw())\"\n}\n}\n```\n\n### VARIABLE: `renderPriority`\n> Signature: `var renderPriority: Int { return 0 }`\n> Lines: 214-214\n- @brief Default render priority for all Drawable conformants.\n```\nvar renderPriority: Int { return 0 }\n```\n\n### FUNCTION: `debugDraw`\n> Signature: `func debugDraw() -> String`\n> Lines: 218-220\n- @brief Debug draw with priority prefix.\n- @return String with priority and rendered content.\n```\nfunc debugDraw() -> String {\nreturn \"[\\(renderPriority)] \\(draw())\"\n}\n```\n\n### EXTENSION: `Animal`\n> Signature: `extension Animal: Drawable`\n> Lines: 226-238\n- @brief Render animal as a descriptive string.\n- @return Description of the animal.\n```\nextension Animal: Drawable {\nfunc draw() -> String {\nreturn description\n}\nfunc describe() -> String {\nreturn \"Animal: \\(species)\"\n}\n}\n```\n\n### FUNCTION: `draw`\n> Signature: `func draw() -> String`\n> Lines: 229-231\n- @brief Render animal as a descriptive string.\n- @return Description of the animal.\n```\nfunc draw() -> String {\nreturn description\n}\n```\n\n### FUNCTION: `describe`\n> Signature: `func describe() -> String`\n> Lines: 235-237\n- @brief Describe the animal for UI display.\n- @return A formatted string suitable for labels.\n```\nfunc describe() -> String {\nreturn \"Animal: \\(species)\"\n}\n```\n\n### STRUCT: `Clamped`\n> Signature: `struct Clamped<Value: Comparable>`\n> Lines: 247-268\n- @brief Minimum allowed value.\n- @brief Maximum allowed value.\n```\nstruct Clamped<Value: Comparable> {\nlet min: Value\nlet max: Value\nprivate var value: Value\nvar wrappedValue: Value {\nget { return value }\nset { value = Swift.min(Swift.max(newValue, min), max) }\n}\ninit(wrappedValue: Value, min: Value, max: Value) {\nself.min = min\nself.max = max\nself.value = Swift.min(Swift.max(wrappedValue, min), max)\n}\n}\n```\n\n### CONSTANT: `min`\n> Signature: `let min: Value`\n> Lines: 249-249\n- @brief Minimum allowed value.\n```\nlet min: Value\n```\n\n### CONSTANT: `max`\n> Signature: `let max: Value`\n> Lines: 251-251\n- @brief Maximum allowed value.\n```\nlet max: Value\n```\n\n### VARIABLE: `value`\n> Signature: `private var value: Value`\n> Lines: 253-253\n- @brief Current stored value.\n```\nprivate var value: Value\n```\n\n### VARIABLE: `wrappedValue`\n> Signature: `var wrappedValue: Value`\n> Lines: 256-256\n- @brief The wrapped value, clamped on set.\n```\nvar wrappedValue: Value {\n```\n\n### VARIABLE: `value`\n> Signature: `private var value: Int = 0`\n> Lines: 277-277\n- @brief Current count value.\n```\nprivate var value: Int = 0\n```\n\n### FUNCTION: `increment`\n> Signature: `func increment() -> Int`\n> Lines: 281-284\n- @brief Increment the counter and return the new value.\n- @return The incremented count.\n```\nfunc increment() -> Int {\nvalue += 1\nreturn value\n}\n```\n\n### FUNCTION: `reset`\n> Signature: `func reset()`\n> Lines: 287-289\n- @brief Reset the counter to zero.\n```\nfunc reset() {\nvalue = 0\n}\n```\n\n### FUNCTION: `greet`\n> Signature: `public func greet(name: String)`\n> Lines: 296-298\n- @brief Greet a person by name.\n- @param name The person's name.\n```\npublic func greet(name: String) {\nprint(\"Hello \\(name)\")\n}\n```\n\n### FUNCTION: `makeDrawable`\n> Signature: `func makeDrawable() -> some Drawable`\n> Lines: 302-304\n- @brief Build an opaque some-typed Drawable.\n- @return An opaque Drawable hiding the concrete type.\n```\nfunc makeDrawable() -> some Drawable {\nreturn Animal(species: \"Cat\")\n}\n```\n\n### FUNCTION: `contains`\n> Signature: `func contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable`\n> Lines: 311-313\n- @brief Generic function with where clause constraint.\n@tparam T Must be Equatable.\n- @param items Collection of items to search.\n- @param target The item to find.\n- @return True if target exists in items.\n```\nfunc contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable {\nreturn items.contains(target)\n}\n```\n\n### FUNCTION: `deferred`\n> Signature: `func deferred(_ action: @escaping () -> Void) -> () -> Void`\n> Lines: 318-323\n- @brief Higher-order function accepting an escaping closure.\n- @param action The closure to store for later execution.\n- @return A wrapper closure that invokes action.\n```\nfunc deferred(_ action: @escaping () -> Void) -> () -> Void {\nreturn {\naction()\n}\n}\n```\n\n### CONSTANT: `MAX_SIZE`\n> Signature: `let MAX_SIZE = 1024`\n> Lines: 328-328\n- @brief Application-wide maximum buffer size constant.\n```\nlet MAX_SIZE = 1024\n```\n\n### VARIABLE: `counter`\n> Signature: `private var counter = 0`\n> Lines: 331-331\n- @brief Module-scoped mutable counter with restricted access.\n```\nprivate var counter = 0\n```\n\n### CONSTANT: `defaultConfig`\n> Signature: `let defaultConfig: [String: Any] =`\n> Lines: 334-334\n- @brief Lazy computed constant using a closure.\n```\nlet defaultConfig: [String: Any] = {\n```\n\n### VARIABLE: `config`\n> Signature: `var config: [String: Any] = [:]`\n> Lines: 335-335\n```\nvar config: [String: Any] = [:]\n```\n\n### IMPORT: `SwiftUI`\n> Lines: 342-342\n```\nimport SwiftUI\n```\n\n### IMPORT: `Combine`\n> Lines: 343-343\n```\nimport Combine\n```\n\n### IMPORT: `Foundation`\n> Lines: 344-344\n```\nimport Foundation\n```\n\n### IMPORT: `Dispatch`\n> Lines: 345-345\n```\nimport Dispatch\n```\n\n### IMPORT: `UIKit`\n> Lines: 346-346\n```\nimport UIKit\n```\n\n### CLASS: `ServiceController`\n> Signature: `class ServiceController {}`\n> Lines: 347-347\n```\nclass ServiceController {}\n```\n\n### CLASS: `CacheStore`\n> Signature: `final class CacheStore {}`\n> Lines: 348-348\n```\nfinal class CacheStore {}\n```\n\n### STRUCT: `Vector2`\n> Signature: `struct Vector2 { let x: Int; let y: Int }`\n> Lines: 349-349\n```\nstruct Vector2 { let x: Int; let y: Int }\n```\n\n### STRUCT: `Limits`\n> Signature: `struct Limits { let max: Int }`\n> Lines: 350-350\n```\nstruct Limits { let max: Int }\n```\n\n### ENUM: `ModeSwift`\n> Signature: `enum ModeSwift { case fast, safe }`\n> Lines: 351-351\n```\nenum ModeSwift { case fast, safe }\n```\n\n### ENUM: `PhaseSwift`\n> Signature: `enum PhaseSwift { case initState, done }`\n> Lines: 352-352\n```\nenum PhaseSwift { case initState, done }\n```\n\n### ENUM: `SignalSwift`\n> Signature: `enum SignalSwift { case on, off }`\n> Lines: 353-353\n```\nenum SignalSwift { case on, off }\n```\n\n### PROTOCOL: `RunnerSwift`\n> Signature: `protocol RunnerSwift { func run() }`\n> Lines: 354-354\n```\nprotocol RunnerSwift { func run() }\n```\n\n### PROTOCOL: `LoggerSwift`\n> Signature: `protocol LoggerSwift { func log(_ msg: String) }`\n> Lines: 355-355\n```\nprotocol LoggerSwift { func log(_ msg: String) }\n```\n\n### PROTOCOL: `ParserSwift`\n> Signature: `protocol ParserSwift { func parse(_ input: String) -> String }`\n> Lines: 356-356\n```\nprotocol ParserSwift { func parse(_ input: String) -> String }\n```\n\n### EXTENSION: `String`\n> Signature: `extension String { func trimmed2() -> String { self.trimmingCharacters(in: .whitespaces) } }`\n> Lines: 357-357\n```\nextension String { func trimmed2() -> String { self.trimmingCharacters(in: .whitespaces) } }\n```\n\n### EXTENSION: `Int`\n> Signature: `extension Int { func doubled2() -> Int { self * 2 } }`\n> Lines: 358-358\n```\nextension Int { func doubled2() -> Int { self * 2 } }\n```\n\n### EXTENSION: `Array`\n> Signature: `extension Array { var isNotEmpty: Bool { !self.isEmpty } }`\n> Lines: 359-359\n```\nextension Array { var isNotEmpty: Bool { !self.isEmpty } }\n```\n\n### FUNCTION: `reqCoverSwift1`\n> Signature: `func reqCoverSwift1(_ value: Int) -> Int { value + 1 }`\n> Lines: 367-367\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfunc reqCoverSwift1(_ value: Int) -> Int { value + 1 }\n```\n\n### FUNCTION: `reqCoverSwift2`\n> Signature: `func reqCoverSwift2(_ value: Int) -> Int { value + 2 }`\n> Lines: 374-374\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfunc reqCoverSwift2(_ value: Int) -> Int { value + 2 }\n```\n\n### FUNCTION: `reqCoverSwift3`\n> Signature: `func reqCoverSwift3(_ value: Int) -> Int { value + 3 }`\n> Lines: 381-381\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfunc reqCoverSwift3(_ value: Int) -> Int { value + 3 }\n```\n\n### FUNCTION: `reqCoverSwift4`\n> Signature: `func reqCoverSwift4(_ value: Int) -> Int { value + 4 }`\n> Lines: 388-388\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfunc reqCoverSwift4(_ value: Int) -> Int { value + 4 }\n```\n\n### FUNCTION: `reqCoverSwift5`\n> Signature: `func reqCoverSwift5(_ value: Int) -> Int { value + 5 }`\n> Lines: 395-395\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfunc reqCoverSwift5(_ value: Int) -> Int { value + 5 }\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_typescript.ts.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_typescript.ts | typescript\n- @brief Comprehensive TypeScript test fixture for parser validation.\n- @details Covers conditional types, mapped types, template literal types,\nsatisfies operator, overload signatures, discriminated unions,\nmodule augmentation, decorators, generic constraints, and utility types.\n\n### IMPORT: `{ Component } from 'react';`\n> Lines: 10-10\n```\nimport { Component } from 'react';\n```\n\n### IMPORT: `type { ReactNode } from 'react';`\n> Lines: 11-11\n```\nimport type { ReactNode } from 'react';\n```\n\n### INTERFACE: `User`\n> Signature: `interface User`\n> Lines: 19-28\n- @brief Core user entity with identity fields.\n- @brief Display name of the user.\n- @brief Age in years; must be non-negative.\n```\ninterface User {\nname: string;\nage: number;\nemail?: string;\nreadonly id: string;\n}\n```\n\n### INTERFACE: `Repository`\n> Signature: `interface Repository<T>`\n> Lines: 35-42\n- @brief Generic CRUD repository with type parameter.\n@tparam T Entity type managed by this repository.\n- @brief Find an entity by its ID.\n- @brief Persist an entity, returning the saved version.\n```\ninterface Repository<T> {\nfindById(id: string): Promise<T | null>;\nsave(entity: T): Promise<T>;\ndelete(id: string): Promise<boolean>;\n}\n```\n\n### INTERFACE: `Serializable`\n> Signature: `interface Serializable`\n> Lines: 48-51\n- @brief Marks objects that can be serialized to JSON.\n- @brief Convert to a JSON-compatible string.\n```\ninterface Serializable {\ntoJSON(): string;\n}\n```\n\n### TYPE_ALIAS: `StringOrNumber`\n> Signature: `type StringOrNumber = string | number`\n> Lines: 56-56\n- @brief Union type for values that can be string or number. */\n```\ntype StringOrNumber = string | number;\n```\n\n### TYPE_ALIAS: `DeepReadonly`\n> Signature: `type DeepReadonly<T> =`\n> Lines: 59-59\n- @brief Mapped type making all properties of T optional and readonly. */\n```\ntype DeepReadonly<T> = {\n```\n\n### TYPE_ALIAS: `Unwrap`\n> Signature: `type Unwrap<T> = T extends Array<infer U> ? U : T`\n> Lines: 64-64\n- @brief Conditional type extracting array element type. */\n```\ntype Unwrap<T> = T extends Array<infer U> ? U : T;\n```\n\n### TYPE_ALIAS: `PixelValue`\n> Signature: `type PixelValue = `${number}px``\n> Lines: 67-67\n- @brief Template literal type for CSS pixel values. */\n```\ntype PixelValue = `${number}px`;\n```\n\n### TYPE_ALIAS: `ApiResponse`\n> Signature: `type ApiResponse<T> =`\n> Lines: 70-70\n- @brief Discriminated union tag for API responses. */\n```\ntype ApiResponse<T> =\n```\n\n### TYPE_ALIAS: `KeysOfType`\n> Signature: `type KeysOfType<T, V> =`\n> Lines: 76-76\n- @brief Extract keys of T whose values extend a given type. */\n```\ntype KeysOfType<T, V> = {\n```\n\n### ENUM: `Direction`\n> Signature: `const enum Direction`\n> Lines: 86-91\n- @brief Const enum for cardinal directions (inlined at compile time).\n```\nconst enum Direction {\nUp = 'UP',\nDown = 'DOWN',\nLeft = 'LEFT',\nRight = 'RIGHT',\n}\n```\n\n### ENUM: `Color`\n> Signature: `enum Color`\n> Lines: 97-104\n- @brief Regular enum with numeric values for color channels.\n- @brief Red channel identifier.\n- @brief Blue channel identifier.\n```\nenum Color {\nRed,\nBlue,\nGreen = 10,\n}\n```\n\n### ENUM: `HttpStatus`\n> Signature: `enum HttpStatus`\n> Lines: 110-114\n- @brief String enum mapping HTTP status codes.\n```\nenum HttpStatus {\nOK = '200',\nNotFound = '404',\nServerError = '500',\n}\n```\n\n### CLASS: `Base`\n> Signature: `export abstract class Base`\n> Lines: 122-139\n- @brief Abstract base class with template method pattern.\n- @brief Abstract render method to be implemented by subclasses.\n- @return void\n```\nexport abstract class Base {\nabstract render(): void;\nexecute(): void {\nconsole.log('before render');\nthis.render();\nconsole.log('after render');\n}\n}\n```\n\n### CLASS: `Derived`\n> Signature: `class Derived extends Base`\n> Lines: 148-161\n- @brief Concrete implementation with typed value storage.\n- @brief Stored numeric value.\n```\nclass Derived extends Base {\nvalue: number = 0;\nlabel?: string;\nrender(): void {\nconsole.log(this.value);\n}\n}\n```\n\n### CLASS: `TypedContainer`\n> Signature: `class TypedContainer<T extends Serializable>`\n> Lines: 168-201\n- @brief Generic container with constraint on Serializable.\n@tparam T Must implement Serializable interface.\n- @brief Internal array storage for items.\n```\nclass TypedContainer<T extends Serializable> {\nprivate items: T[] = [];\nadd(item: T): void {\nthis.items.push(item);\n}\ntoJSON(): string {\nreturn `[${this.items.map(i => i.toJSON()).join(',')}]`;\n}\nfind(predicate: (item: T) => boolean): T | undefined {\nfor (const item of this.items) {\nif (predicate(item)) {\nreturn item;\n}\n}\nreturn undefined;\n}\n}\n```\n\n### CLASS: `UserEntity`\n> Signature: `class UserEntity implements User, Serializable`\n> Lines: 210-228\n- @brief Full user entity implementing both User and Serializable.\n```\nclass UserEntity implements User, Serializable {\nreadonly id: string;\nname: string;\nage: number;\nconstructor(id: string, name: string, age: number) {\nthis.id = id;\nthis.name = name;\nthis.age = age;\n}\ntoJSON(): string {\nreturn JSON.stringify({ id: this.id, name: this.name, age: this.age });\n}\n}\n```\n\n### FUNCTION: `greet`\n> Signature: `export function greet(name: string): void`\n> Lines: 237-239\n- @brief Greet a person by name with type-safe parameter.\n- @param name The person's name to display.\n```\nexport function greet(name: string): void {\nconsole.log(`Hello, ${name}`);\n}\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: string): number`\n> Lines: 249-256\n- @brief Parse input with overloaded signatures for type safety.\n@overload Parse a string input into a number.\n@overload Parse a number input into a string.\n```\nfunction parse(input: string): number;\nfunction parse(input: number): string;\nfunction parse(input: string | number): string | number {\nif (typeof input === 'string') {\nreturn parseInt(input, 10);\n}\nreturn input.toString();\n}\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: number): string`\n> Lines: 250-256\n```\nfunction parse(input: number): string;\nfunction parse(input: string | number): string | number {\nif (typeof input === 'string') {\nreturn parseInt(input, 10);\n}\nreturn input.toString();\n}\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: string | number): string | number`\n> Lines: 251-256\n```\nfunction parse(input: string | number): string | number {\nif (typeof input === 'string') {\nreturn parseInt(input, 10);\n}\nreturn input.toString();\n}\n```\n\n### FUNCTION: `add`\n> Signature: `const add = (a: number): number => a + 1`\n> Lines: 266-277\n- @brief Add one to a number (arrow function syntax).\n- @brief Generic transform function with constraint. @tparam T Must have a toString method.\n- @param a The input number.\n- @param value Input value to transform.\n- @return The incremented value.\n- @return String representation of the value.\n```\nconst add = (a: number): number => a + 1;\nconst transform = <T extends { toString(): string }>(value: T): string => {\nreturn value.toString();\n};\n```\n\n### FUNCTION: `fetchEntity`\n> Signature: `async function fetchEntity<T>(url: string): Promise<T>`\n> Lines: 288-292\n- @brief Fetch and deserialize a typed entity from an API.\n@tparam T The expected response entity type.\n- @param url Endpoint URL.\n- @return Promise resolving to the typed entity.\n```\nasync function fetchEntity<T>(url: string): Promise<T> {\nconst response = await fetch(url);\nreturn response.json() as Promise<T>;\n}\n```\n\n### NAMESPACE: `MyNS`\n> Signature: `export namespace MyNS`\n> Lines: 300-312\n- @brief Namespace grouping related constants and helpers.\n- @brief Exported constant within namespace.\n```\nexport namespace MyNS {\nexport const x = 1;\nexport function double(val: number): number {\nreturn val * 2;\n}\n}\n```\n\n### FUNCTION: `double`\n> Signature: `export function double(val: number): number`\n> Lines: 309-311\n- @brief Helper function scoped to namespace.\n- @param val Numeric input to double.\n- @return The doubled value.\n```\nexport function double(val: number): number {\nreturn val * 2;\n}\n```\n\n### MODULE: `MyMod`\n> Signature: `declare module MyMod`\n> Lines: 320-323\n- @brief Ambient module declaration for external library typings.\n- @brief Version string exposed by the external module.\n```\ndeclare module MyMod {\nexport const version: string;\n}\n```\n\n### DECORATOR: `Component`\n> Lines: 331-331\n- @brief Class using a decorator annotation.\n```\n@Component\n```\n\n### CLASS: `Decorated`\n> Signature: `class Decorated`\n> Lines: 332-335\n- @brief Template string for rendering.\n```\nclass Decorated {\ntemplate: string = '<div></div>';\n}\n```\n\n### FUNCTION: `isUser`\n> Signature: `function isUser(value: unknown): value is User`\n> Lines: 345-351\n- @brief Type guard narrowing unknown to User interface.\n- @param value Unknown input to validate.\n- @return True if value conforms to User shape.\n```\nfunction isUser(value: unknown): value is User {\nif (typeof value !== 'object' || value === null) {\nreturn false;\n}\nconst obj = value as Record<string, unknown>;\nreturn typeof obj.name === 'string' && typeof obj.age === 'number';\n}\n```\n\n### FUNCTION: `makeOptional`\n> Signature: `function makeOptional<T extends object>(obj: T): Partial<T>`\n> Lines: 373-375\n- @brief Convert all properties of an object to optional at runtime.\n@tparam T Source object type.\n- @param obj The source object.\n- @return A partial copy of the object.\n```\nfunction makeOptional<T extends object>(obj: T): Partial<T> {\nreturn { ...obj };\n}\n```\n\n### IMPORT: `{ Injectable } from 'inversify';`\n> Lines: 378-378\n```\nimport { Injectable } from 'inversify';\n```\n\n### IMPORT: `{ Observable } from 'rxjs';`\n> Lines: 379-379\n```\nimport { Observable } from 'rxjs';\n```\n\n### IMPORT: `{ FC } from 'react';`\n> Lines: 380-380\n```\nimport { FC } from 'react';\n```\n\n### DECORATOR: `injectable`\n> Lines: 381-381\n```\n@injectable\n```\n\n### DECORATOR: `sealed`\n> Lines: 382-382\n```\n@sealed\n```\n\n### DECORATOR: `track`\n> Lines: 383-383\n```\n@track\n```\n\n### DECORATOR: `memoized`\n> Lines: 384-384\n```\n@memoized\n```\n\n### INTERFACE: `CacheEntry`\n> Signature: `interface CacheEntry { key: string; value: string }`\n> Lines: 385-385\n```\ninterface CacheEntry { key: string; value: string }\n```\n\n### INTERFACE: `Runner`\n> Signature: `export interface Runner { run(): Promise<void> }`\n> Lines: 386-386\n```\nexport interface Runner { run(): Promise<void> }\n```\n\n### ENUM: `ModeTs`\n> Signature: `enum ModeTs { Fast, Safe }`\n> Lines: 387-387\n```\nenum ModeTs { Fast, Safe }\n```\n\n### ENUM: `StatusTs`\n> Signature: `enum StatusTs { Ready, Busy }`\n> Lines: 388-388\n```\nenum StatusTs { Ready, Busy }\n```\n\n### NAMESPACE: `ExtNSOne`\n> Signature: `namespace ExtNSOne { export const v = 1; }`\n> Lines: 389-389\n```\nnamespace ExtNSOne { export const v = 1; }\n```\n\n### NAMESPACE: `ExtNSTwo`\n> Signature: `namespace ExtNSTwo { export const v = 2; }`\n> Lines: 390-390\n```\nnamespace ExtNSTwo { export const v = 2; }\n```\n\n### NAMESPACE: `ExtNSThree`\n> Signature: `namespace ExtNSThree { export const v = 3; }`\n> Lines: 391-391\n```\nnamespace ExtNSThree { export const v = 3; }\n```\n\n### NAMESPACE: `ExtNSFour`\n> Signature: `namespace ExtNSFour { export const v = 4; }`\n> Lines: 392-392\n```\nnamespace ExtNSFour { export const v = 4; }\n```\n\n### MODULE: `ExtOne`\n> Signature: `declare module ExtOne { export const one: number; }`\n> Lines: 393-393\n```\ndeclare module ExtOne { export const one: number; }\n```\n\n### MODULE: `ExtTwo`\n> Signature: `module ExtTwo { export const two = 2; }`\n> Lines: 394-394\n```\nmodule ExtTwo { export const two = 2; }\n```\n\n### MODULE: `ExtThree`\n> Signature: `module ExtThree { export const three = 3; }`\n> Lines: 395-395\n```\nmodule ExtThree { export const three = 3; }\n```\n\n### MODULE: `ExtFour`\n> Signature: `module ExtFour { export const four = 4; }`\n> Lines: 396-396\n```\nmodule ExtFour { export const four = 4; }\n```\n\n### FUNCTION: `reqCoverTs1`\n> Signature: `function reqCoverTs1(value: number): number { return value + 1; }`\n> Lines: 404-404\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfunction reqCoverTs1(value: number): number { return value + 1; }\n```\n\n### FUNCTION: `reqCoverTs2`\n> Signature: `function reqCoverTs2(value: number): number { return value + 2; }`\n> Lines: 411-411\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfunction reqCoverTs2(value: number): number { return value + 2; }\n```\n\n### FUNCTION: `reqCoverTs3`\n> Signature: `function reqCoverTs3(value: number): number { return value + 3; }`\n> Lines: 418-418\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfunction reqCoverTs3(value: number): number { return value + 3; }\n```\n\n### FUNCTION: `reqCoverTs4`\n> Signature: `function reqCoverTs4(value: number): number { return value + 4; }`\n> Lines: 425-425\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfunction reqCoverTs4(value: number): number { return value + 4; }\n```\n\n### FUNCTION: `reqCoverTs5`\n> Signature: `function reqCoverTs5(value: number): number { return value + 5; }`\n> Lines: 432-432\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfunction reqCoverTs5(value: number): number { return value + 5; }\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find/fixture_zig.zig.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_zig.zig | zig\n\n### IMPORT: `std`\n> Lines: 7-7\n```\nconst std = @import(\"std\");\n```\n\n### IMPORT: `mem`\n> Lines: 8-8\n```\nconst mem = @import(\"std\").mem;\n```\n\n### CONSTANT: `Allocator`\n> Signature: `const Allocator = std.mem.Allocator`\n> Lines: 9-9\n```\nconst Allocator = std.mem.Allocator;\n```\n\n### FUNCTION: `main`\n> Signature: `pub fn main() void`\n> Lines: 14-16\n```\npub fn main() void {\nstd.debug.print(\"Hello\\n\", .{});\n}\n```\n\n### FUNCTION: `add`\n> Signature: `pub fn add(a: i32, b: i32) i32`\n> Lines: 22-24\n- @param a First operand.\n- @param b Second operand.\n- @return Sum of a and b.\n```\npub fn add(a: i32, b: i32) i32 {\nreturn a + b;\n}\n```\n\n### FUNCTION: `safeDivide`\n> Signature: `pub fn safeDivide(numerator: i32, denominator: i32) !i32`\n> Lines: 30-35\n- @param numerator The dividend.\n- @param denominator The divisor; must not be zero.\n- @return Quotient or error.DivisionByZero.\n```\npub fn safeDivide(numerator: i32, denominator: i32) !i32 {\nif (denominator == 0) {\nreturn error.DivisionByZero;\n}\nreturn @divTrunc(numerator, denominator);\n}\n```\n\n### FUNCTION: `max`\n> Signature: `pub fn max(comptime T: type, a: T, b: T) T`\n> Lines: 42-44\n- @param T The element type (comptime resolved).\n- @param a First value.\n- @param b Second value.\n- @return The larger of a and b.\n```\npub fn max(comptime T: type, a: T, b: T) T {\nreturn if (a > b) a else b;\n}\n```\n\n### FUNCTION: `indexOf`\n> Signature: `pub fn indexOf(comptime T: type, haystack: []const T, needle: T) ?usize`\n> Lines: 51-59\n- @param T Element type.\n- @param haystack Slice to search.\n- @param needle Value to find.\n- @return Index of needle or null if not found.\n```\npub fn indexOf(comptime T: type, haystack: []const T, needle: T) ?usize {\nfor (haystack, 0..) |item, i| {\nif (item == needle) {\nreturn i;\n}\n}\nreturn null;\n}\n```\n\n### FUNCTION: `comptimeConcat`\n> Signature: `pub fn comptimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8`\n> Lines: 65-67\n- @param a First string literal.\n- @param b Second string literal.\n- @return Concatenated string at compile time.\n```\npub fn comptimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8 {\nreturn a ++ b;\n}\n```\n\n### FUNCTION: `createBuffer`\n> Signature: `pub fn createBuffer(allocator: Allocator) ![]u8`\n> Lines: 72-78\n- @param allocator Memory allocator for buffer creation.\n- @return Allocated buffer or error.\n```\npub fn createBuffer(allocator: Allocator) ![]u8 {\nconst buf = try allocator.alloc(u8, 1024);\nerrdefer allocator.free(buf);\n@memset(buf, 0);\nreturn buf;\n}\n```\n\n### CONSTANT: `buf`\n> Signature: `const buf = try allocator.alloc(u8, 1024)`\n> Lines: 73-73\n```\nconst buf = try allocator.alloc(u8, 1024);\n```\n\n### VARIABLE: `total`\n> Signature: `var total: f32 = 0.0`\n> Lines: 84-84\n- @param values Slice of floats to sum.\n- @return Sum of all elements.\n```\nvar total: f32 = 0.0;\n```\n\n### FUNCTION: `doubleValue`\n> Signature: `export fn doubleValue(x: i32) i32`\n> Lines: 94-96\n- @param x Value to double.\n- @return Input multiplied by two.\n```\nexport fn doubleValue(x: i32) i32 {\nreturn x * 2;\n}\n```\n\n### STRUCT: `Point`\n> Signature: `const Point = struct`\n> Lines: 102-121\n- @brief Basic coordinate pair for geometric computations.\n```\nconst Point = struct {\nx: f64,\ny: f64,\npub fn distSquared(self: Point, other: Point) f64 {\nconst dx = self.x - other.x;\nconst dy = self.y - other.y;\nreturn dx * dx + dy * dy;\n}\npub fn origin() Point {\nreturn .{ .x = 0.0, .y = 0.0 };\n}\n};\n```\n\n### FUNCTION: `distSquared`\n> Signature: `pub fn distSquared(self: Point, other: Point) f64`\n> Lines: 110-114\n- @param self This point.\n- @param other Target point.\n- @return Distance squared (avoids sqrt).\n```\npub fn distSquared(self: Point, other: Point) f64 {\nconst dx = self.x - other.x;\nconst dy = self.y - other.y;\nreturn dx * dx + dy * dy;\n}\n```\n\n### CONSTANT: `dx`\n> Signature: `const dx = self.x - other.x`\n> Lines: 111-111\n```\nconst dx = self.x - other.x;\n```\n\n### CONSTANT: `dy`\n> Signature: `const dy = self.y - other.y`\n> Lines: 112-112\n```\nconst dy = self.y - other.y;\n```\n\n### FUNCTION: `origin`\n> Signature: `pub fn origin() Point`\n> Lines: 118-120\n- @return A zero-initialized Point.\n```\npub fn origin() Point {\nreturn .{ .x = 0.0, .y = 0.0 };\n}\n```\n\n### STRUCT: `PackedFlags`\n> Signature: `const PackedFlags = packed struct`\n> Lines: 125-130\n- @brief Tests parser handling of packed layout specifier.\n```\nconst PackedFlags = packed struct {\nreadable: bool,\nwritable: bool,\nexecutable: bool,\nreserved: u5,\n};\n```\n\n### STRUCT: `Config`\n> Signature: `const Config = struct`\n> Lines: 133-144\n```\nconst Config = struct {\nname: []const u8 = \"default\",\nmax_retries: u32 = 3,\ntimeout_ms: u64 = 5000,\ndebug: bool = false,\npub fn testing() Config {\nreturn .{ .debug = true, .name = \"test\" };\n}\n};\n```\n\n### FUNCTION: `testing`\n> Signature: `pub fn testing() Config`\n> Lines: 141-143\n- @return Config with debug=true.\n```\npub fn testing() Config {\nreturn .{ .debug = true, .name = \"test\" };\n}\n```\n\n### ENUM: `Color`\n> Signature: `const Color = enum`\n> Lines: 149-164\n```\nconst Color = enum {\nred,\ngreen,\nblue,\npub fn toRgb(self: Color) u32 {\nreturn switch (self) {\n.red => 0xFF0000,\n.green => 0x00FF00,\n.blue => 0x0000FF,\n};\n}\n};\n```\n\n### FUNCTION: `toRgb`\n> Signature: `pub fn toRgb(self: Color) u32`\n> Lines: 157-163\n- @param self The color variant.\n- @return 24-bit RGB integer.\n```\npub fn toRgb(self: Color) u32 {\nreturn switch (self) {\n.red => 0xFF0000,\n.green => 0x00FF00,\n.blue => 0x0000FF,\n};\n}\n```\n\n### ENUM: `Status`\n> Signature: `const Status = enum(u8)`\n> Lines: 167-172\n```\nconst Status = enum(u8) {\nidle = 0,\nrunning = 1,\nerror = 2,\ndone = 3,\n};\n```\n\n### UNION: `Result`\n> Signature: `const Result = union(enum)`\n> Lines: 177-187\n```\nconst Result = union(enum) {\nok: i32,\nerr: []const u8,\npub fn isOk(self: Result) bool {\nreturn self == .ok;\n}\n};\n```\n\n### FUNCTION: `isOk`\n> Signature: `pub fn isOk(self: Result) bool`\n> Lines: 184-186\n- @param self The result to inspect.\n- @return True if variant is ok.\n```\npub fn isOk(self: Result) bool {\nreturn self == .ok;\n}\n```\n\n### UNION: `ExternData`\n> Signature: `const ExternData = extern union`\n> Lines: 190-194\n```\nconst ExternData = extern union {\nint_val: i32,\nfloat_val: f32,\nbytes: [4]u8,\n};\n```\n\n### CONSTANT: `MAX_SIZE`\n> Signature: `const MAX_SIZE: usize = 1024`\n> Lines: 199-199\n- @brief Maximum allocation size in bytes.\n```\nconst MAX_SIZE: usize = 1024;\n```\n\n### VARIABLE: `global_state`\n> Signature: `pub var global_state: i32 = 0`\n> Lines: 202-202\n- @brief Global mutable state counter.\n```\npub var global_state: i32 = 0;\n```\n\n### CONSTANT: `MAGIC_NUMBER`\n> Signature: `const MAGIC_NUMBER: u32 = comptime blk:`\n> Lines: 205-205\n- @brief Compile-time computed constant.\n```\nconst MAGIC_NUMBER: u32 = comptime blk: {\n```\n\n### VARIABLE: `x`\n> Signature: `var x: u32 = 1`\n> Lines: 206-206\n```\nvar x: u32 = 1;\n```\n\n### CONSTANT: `ParseError`\n> Signature: `const ParseError = error`\n> Lines: 214-214\n```\nconst ParseError = error{\n```\n\n### CONSTANT: `result`\n> Signature: `const result = add(2, 3)`\n> Lines: 225-225\n```\nconst result = add(2, 3);\n```\n\n### CONSTANT: `result`\n> Signature: `const result = safeDivide(10, 0)`\n> Lines: 231-231\n```\nconst result = safeDivide(10, 0);\n```\n\n### CONSTANT: `items`\n> Signature: `const items = [_]i32{ 1, 2, 3, 4, 5 }`\n> Lines: 237-237\n```\nconst items = [_]i32{ 1, 2, 3, 4, 5 };\n```\n\n### CONSTANT: `idx`\n> Signature: `const idx = indexOf(i32, &items, 3)`\n> Lines: 238-238\n```\nconst idx = indexOf(i32, &items, 3);\n```\n\n### IMPORT: `io`\n> Lines: 243-243\n```\nconst io = @import(\"std\");\n```\n\n### IMPORT: `fs`\n> Lines: 244-244\n```\nconst fs = @import(\"std\");\n```\n\n### IMPORT: `mem`\n> Lines: 245-245\n```\nconst mem = @import(\"std\");\n```\n\n### IMPORT: `math`\n> Lines: 246-246\n```\nconst math = @import(\"std\");\n```\n\n### IMPORT: `json`\n> Lines: 247-247\n```\nconst json = @import(\"std\");\n```\n\n### ENUM: `Mode`\n> Signature: `const Mode = enum { fast, safe }`\n> Lines: 248-248\n```\nconst Mode = enum { fast, safe };\n```\n\n### ENUM: `Phase`\n> Signature: `const Phase = enum { init, done }`\n> Lines: 249-249\n```\nconst Phase = enum { init, done };\n```\n\n### ENUM: `Signal`\n> Signature: `const Signal = enum { on, off }`\n> Lines: 250-250\n```\nconst Signal = enum { on, off };\n```\n\n### STRUCT: `Packet`\n> Signature: `const Packet = struct { id: i32 }`\n> Lines: 251-251\n```\nconst Packet = struct { id: i32 };\n```\n\n### STRUCT: `Limits`\n> Signature: `const Limits = struct { max: i32 }`\n> Lines: 252-252\n```\nconst Limits = struct { max: i32 };\n```\n\n### UNION: `Variant`\n> Signature: `const Variant = union { i: i32, f: f32 }`\n> Lines: 253-253\n```\nconst Variant = union { i: i32, f: f32 };\n```\n\n### UNION: `Payload`\n> Signature: `const Payload = extern union { a: i32, b: i32 }`\n> Lines: 254-254\n```\nconst Payload = extern union { a: i32, b: i32 };\n```\n\n### UNION: `Message`\n> Signature: `const Message = union { txt: [4]u8, len: u32 }`\n> Lines: 255-255\n```\nconst Message = union { txt: [4]u8, len: u32 };\n```\n\n### VARIABLE: `retries`\n> Signature: `var retries: i32 = 0`\n> Lines: 256-256\n```\nvar retries: i32 = 0;\n```\n\n### VARIABLE: `pointer`\n> Signature: `var pointer: usize = 0`\n> Lines: 257-257\n```\nvar pointer: usize = 0;\n```\n\n### FUNCTION: `reqCoverZig1`\n> Signature: `fn reqCoverZig1(value: i32) i32 { return value + 1; }`\n> Lines: 265-265\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\nfn reqCoverZig1(value: i32) i32 { return value + 1; }\n```\n\n### FUNCTION: `reqCoverZig2`\n> Signature: `fn reqCoverZig2(value: i32) i32 { return value + 2; }`\n> Lines: 272-272\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\nfn reqCoverZig2(value: i32) i32 { return value + 2; }\n```\n\n### FUNCTION: `reqCoverZig3`\n> Signature: `fn reqCoverZig3(value: i32) i32 { return value + 3; }`\n> Lines: 279-279\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\nfn reqCoverZig3(value: i32) i32 { return value + 3; }\n```\n\n### FUNCTION: `reqCoverZig4`\n> Signature: `fn reqCoverZig4(value: i32) i32 { return value + 4; }`\n> Lines: 286-286\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\nfn reqCoverZig4(value: i32) i32 { return value + 4; }\n```\n\n### FUNCTION: `reqCoverZig5`\n> Signature: `fn reqCoverZig5(value: i32) i32 { return value + 5; }`\n> Lines: 293-293\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\nfn reqCoverZig5(value: i32) i32 { return value + 5; }\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_c.c | c\n- @brief Comprehensive C language test fixture for parser validation.\n- @details Covers structs, unions, enums, function pointers, inline functions,\npreprocessor directives, bitfields, variadic functions, and complex\ntypedef chains that stress-test regex-based parsing.\n\n### IMPORT: `\"myheader.h\"`\n> Lines: 14-14\n```\n14: #include \"myheader.h\"\n```\n\n### IMPORT: `<stdarg.h>`\n> Lines: 15-15\n```\n15: #include <stdarg.h>\n```\n\n### IMPORT: `<stdio.h>`\n> Lines: 16-16\n```\n16: #include <stdio.h>\n```\n\n### IMPORT: `<stdlib.h>`\n> Lines: 17-17\n```\n17: #include <stdlib.h>\n```\n\n### IMPORT: `<string.h>`\n> Lines: 18-18\n```\n18: #include <string.h>\n```\n\n### MACRO: `MAX_SIZE`\n> Signature: `#define MAX_SIZE 100`\n> Lines: 22-22\n```\n22: #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```\n31: #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```\n34: #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```\n40: #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```\n43: #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```\n45: #define LOG(fmt, ...) ((void)0)\n```\n\n### TYPEDEF: `my_int`\n> Signature: `typedef int my_int`\n> Lines: 51-51\n```\n51: typedef int my_int;\n```\n\n### TYPEDEF: `byte_t`\n> Signature: `typedef unsigned char byte_t`\n> Lines: 54-54\n```\n54: typedef 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```\n62: struct Point {\n63: int x;\n64: int y;\n65: };\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```\n71: struct PackedFlags {\n72: unsigned int readable : 1;\n73: unsigned int writable : 1;\n74: unsigned int executable : 1;\n75: unsigned int reserved : 5;\n76: };\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```\n82: struct Node {\n84: union {\n85: int i_val;\n86: float f_val;\n87: } payload;\n88: struct Node *next;\n89: };\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```\n85: int i_val;\n```\n\n### VARIABLE: `f_val`\n> Signature: `float f_val`\n> Lines: 86-86\n```\n86: float 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```\n97: union Data {\n98: int i;\n99: float f;\n100: char s[16];\n101: };\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```\n109: enum Color {\n110: RED,\n111: GREEN,\n112: BLUE\n113: };\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```\n124: typedef int (*comparator_fn)(const void *a, const void *b);\n130: typedef int (*transform_fn)(int value);\n138: typedef struct {\n139: const char *name;\n140: comparator_fn handler;\n141: int priority;\n142: } 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```\n130: typedef int (*transform_fn)(int value);\n138: typedef struct {\n139: const char *name;\n140: comparator_fn handler;\n141: int priority;\n142: } 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```\n147: static 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```\n150: static 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```\n160: static 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```\n168: void greet(const char *name) {\n170: if (name == NULL) {\n171: return;\n172: }\n173: printf(\"Hello %s\\n\", name);\n174: }\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```\n182: int main(int argc, char **argv) {\n183: if (argc < 2) {\n185: fprintf(stderr, \"Usage: %s <name>\\n\", argv[0]);\n186: return 1;\n187: }\n188: greet(argv[1]);\n189: return 0;\n190: }\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```\n200: int sum_ints(int count, ...) {\n201: va_list ap;\n202: va_start(ap, count);\n203: int total = 0;\n205: for (int i = 0; i < count; i++) {\n206: total += va_arg(ap, int);\n207: }\n208: va_end(ap);\n209: return total;\n210: }\n```\n\n### VARIABLE: `total`\n> Signature: `int total = 0`\n> Lines: 203-203\n```\n203: int 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```\n220: void apply_transform(int *arr, size_t len, transform_fn fn) {\n221: for (size_t i = 0; i < len; i++) {\n223: arr[i] = fn(arr[i]);\n224: }\n225: }\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```\n234: unsigned long factorial(unsigned int n) {\n236: if (n <= 1) {\n237: return 1;\n238: }\n240: return n * factorial(n - 1);\n241: }\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```\n251: static void fast_copy(void *restrict dest, const void *restrict src, size_t n) {\n252: memcpy(dest, src, n);\n253: }\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```\n260: static 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```\n269: int sum_fixed(int arr[static 10]) {\n270: int s = 0;\n271: for (int i = 0; i < 10; i++) {\n272: s += arr[i];\n273: }\n274: return s;\n275: }\n```\n\n### VARIABLE: `s`\n> Signature: `int s = 0`\n> Lines: 270-270\n```\n270: int s = 0;\n```\n\n### STRUCT: `Vector2`\n> Signature: `struct Vector2`\n> Lines: 278-281\n```\n278: struct Vector2 {\n279: int x;\n280: int y;\n281: };\n```\n\n### VARIABLE: `x`\n> Signature: `int x`\n> Lines: 279-279\n```\n279: int x;\n```\n\n### VARIABLE: `y`\n> Signature: `int y`\n> Lines: 280-280\n```\n280: int y;\n```\n\n### STRUCT: `Matrix2`\n> Signature: `struct Matrix2`\n> Lines: 282-285\n```\n282: struct Matrix2 {\n283: int a11;\n284: int a22;\n285: };\n```\n\n### VARIABLE: `a11`\n> Signature: `int a11`\n> Lines: 283-283\n```\n283: int a11;\n```\n\n### VARIABLE: `a22`\n> Signature: `int a22`\n> Lines: 284-284\n```\n284: int a22;\n```\n\n### ENUM: `StatusCode`\n> Signature: `enum StatusCode { STATUS_OK, STATUS_ERR, STATUS_UNKNOWN }`\n> Lines: 286-286\n```\n286: enum 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```\n287: enum 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```\n288: enum ModeCode { MODE_A, MODE_B };\n```\n\n### ENUM: `FlagCode`\n> Signature: `enum FlagCode { FLAG_ON, FLAG_OFF }`\n> Lines: 289-289\n```\n289: enum FlagCode { FLAG_ON, FLAG_OFF };\n```\n\n### UNION: `NumberValue`\n> Signature: `union NumberValue`\n> Lines: 290-293\n```\n290: union NumberValue {\n291: int i;\n292: float f;\n293: };\n```\n\n### VARIABLE: `i`\n> Signature: `int i`\n> Lines: 291-291\n```\n291: int i;\n```\n\n### VARIABLE: `f`\n> Signature: `float f`\n> Lines: 292-292\n```\n292: float f;\n```\n\n### UNION: `PtrValue`\n> Signature: `union PtrValue`\n> Lines: 294-297\n```\n294: union PtrValue {\n295: void *p;\n296: long l;\n297: };\n```\n\n### VARIABLE: `l`\n> Signature: `long l`\n> Lines: 296-296\n```\n296: long l;\n```\n\n### UNION: `StateValue`\n> Signature: `union StateValue`\n> Lines: 298-301\n```\n298: union StateValue {\n299: int s;\n300: char c;\n301: };\n```\n\n### VARIABLE: `s`\n> Signature: `int s`\n> Lines: 299-299\n```\n299: int s;\n```\n\n### VARIABLE: `c`\n> Signature: `char c`\n> Lines: 300-300\n```\n300: char c;\n```\n\n### UNION: `PairValue`\n> Signature: `union PairValue`\n> Lines: 302-305\n```\n302: union PairValue {\n303: int x;\n304: int y;\n305: };\n```\n\n### VARIABLE: `x`\n> Signature: `int x`\n> Lines: 303-303\n```\n303: int x;\n```\n\n### VARIABLE: `y`\n> Signature: `int y`\n> Lines: 304-304\n```\n304: int y;\n```\n\n### TYPEDEF: `index_t`\n> Signature: `typedef long index_t`\n> Lines: 306-306\n```\n306: typedef long index_t;\n```\n\n### TYPEDEF: `ratio_t`\n> Signature: `typedef float ratio_t`\n> Lines: 307-307\n```\n307: typedef float ratio_t;\n```\n\n### STRUCT: `Point`\n> Signature: `typedef struct Point point_t`\n> Lines: 308-319\n```\n308: typedef struct Point point_t;\n309: typedef double score_t;\n319: int 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```\n309: typedef 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```\n319: int 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```\n328: int 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```\n337: int 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```\n346: int 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```\n355: int req_cover_c_5(int value) { return value + 5; }\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_cpp.cpp | cpp\n- @brief Comprehensive C++ test fixture for parser stress-testing.\n- @details Covers templates, SFINAE, constexpr, lambdas, concepts, CRTP,\noperator overloading, move semantics, nested namespaces, and\nmodern C++20/23 constructs.\n\n### IMPORT: `<concepts>`\n> Lines: 13-13\n```\n13: #include <concepts>\n```\n\n### IMPORT: `<functional>`\n> Lines: 14-14\n```\n14: #include <functional>\n```\n\n### IMPORT: `<iostream>`\n> Lines: 15-15\n```\n15: #include <iostream>\n```\n\n### IMPORT: `<memory>`\n> Lines: 16-16\n```\n16: #include <memory>\n```\n\n### IMPORT: `<optional>`\n> Lines: 17-17\n```\n17: #include <optional>\n```\n\n### IMPORT: `<string>`\n> Lines: 18-18\n```\n18: #include <string>\n```\n\n### IMPORT: `<vector>`\n> Lines: 19-19\n```\n19: #include <vector>\n```\n\n### MACRO: `VERSION`\n> Signature: `#define VERSION 2`\n> Lines: 21-21\n```\n21: #define VERSION 2\n```\n\n### MACRO: `LIKELY`\n> Signature: `#define LIKELY(x) __builtin_expect(!!(x), 1)`\n> Lines: 24-24\n```\n24: #define LIKELY(x) __builtin_expect(!!(x), 1)\n```\n\n### NAMESPACE: `MyNS`\n> Signature: `namespace MyNS`\n> Lines: 28-299\n```\n28: namespace MyNS {\n36: template <typename T>\n37: concept Printable = requires(std::ostream &os, T val) {\n38: { os << val } -> std::same_as<std::ostream &>;\n39: };\n45: template <typename T>\n46: concept Numeric = std::integral<T> || std::floating_point<T>;\n55: template <Printable T> class Container {\n56: public:\n57: T value;\n63: explicit Container(T v) : value(std::move(v)) {}\n69: Container(const Container &other) = default;\n75: Container(Container &&other) noexcept = default;\n82: Container &operator=(const Container &other) = default;\n89: Container &operator=(Container &&other) noexcept = default;\n92: ~Container() = default;\n100: friend std::ostream &operator<<(std::ostream &os, const Container &c) {\n101: return os << c.value;\n102: }\n109: bool operator==(const Container &other) const { return value == other.value; }\n110: };\n118: struct Point {\n119: double x;\n120: double y;\n127: constexpr double dist_sq(const Point &other) const {\n129: double dx = x - other.x;\n130: double dy = y - other.y;\n131: return dx * dx + dy * dy;\n132: }\n139: constexpr Point operator+(const Point &rhs) const {\n140: return {x + rhs.x, y + rhs.y};\n141: }\n142: };\n150: enum class Direction {\n151: Up,\n152: Down,\n153: Left,\n154: Right\n155: };\n160: using StringVec = std::vector<std::string>;\n163: typedef int my_int_t;\n166: using Callback = std::function<void(int)>;\n175: template <typename Derived> class Cloneable {\n176: public:\n181: std::unique_ptr<Derived> clone() const {\n183: return std::make_unique<Derived>(static_cast<const Derived &>(*this));\n184: }\n185: };\n193: class Base {\n194: public:\n199: virtual const char *type_name() const = 0;\n200: virtual ~Base() = default;\n201: };\n207: class DerivedA : public virtual Base {\n208: public:\n209: const char *type_name() const override { return \"DerivedA\"; }\n210: };\n216: class DerivedB : public virtual Base {\n217: public:\n218: const char *type_name() const override { return \"DerivedB\"; }\n219: };\n225: class Diamond : public DerivedA, public DerivedB {\n226: public:\n227: const char *type_name() const override { return \"Diamond\"; }\n228: };\n237: constexpr unsigned long long constexpr_factorial(unsigned int n) {\n239: return n <= 1 ? 1ULL : n * constexpr_factorial(n - 1);\n240: }\n249: std::pair<std::string, std::string> parse_kv(const std::string &input) {\n250: auto pos = input.find('=');\n251: if (pos == std::string::npos) {\n253: return {\"\", \"\"};\n254: }\n255: return {input.substr(0, pos), input.substr(pos + 1)};\n256: }\n264: void greet(std::string name) { std::cout << \"Hello, \" << name << \"\\n\"; }\n270: int main() {\n272: auto [key, val] = parse_kv(\"lang=cpp\");\n273: greet(key);\n274: return 0;\n275: }\n284: constexpr auto square = [](auto x) { return x * x; };\n288: namespace Inner::Detail {\n295: inline std::string format_int(int v) { return std::to_string(v); }\n297: }\n299: }\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```\n55: template <Printable T> class Container {\n56: public:\n57: T value;\n63: explicit Container(T v) : value(std::move(v)) {}\n69: Container(const Container &other) = default;\n75: Container(Container &&other) noexcept = default;\n82: Container &operator=(const Container &other) = default;\n89: Container &operator=(Container &&other) noexcept = default;\n92: ~Container() = default;\n100: friend std::ostream &operator<<(std::ostream &os, const Container &c) {\n101: return os << c.value;\n102: }\n109: bool operator==(const Container &other) const { return value == other.value; }\n110: };\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```\n63: explicit 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```\n69: Container(const Container &other) = default;\n75: Container(Container &&other) noexcept = default;\n82: Container &operator=(const Container &other) = default;\n89: Container &operator=(Container &&other) noexcept = default;\n92: ~Container() = default;\n100: friend std::ostream &operator<<(std::ostream &os, const Container &c) {\n101: return os << c.value;\n102: }\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```\n75: Container(Container &&other) noexcept = default;\n82: Container &operator=(const Container &other) = default;\n89: Container &operator=(Container &&other) noexcept = default;\n92: ~Container() = default;\n100: friend std::ostream &operator<<(std::ostream &os, const Container &c) {\n101: return os << c.value;\n102: }\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```\n118: struct Point {\n119: double x;\n120: double y;\n127: constexpr double dist_sq(const Point &other) const {\n129: double dx = x - other.x;\n130: double dy = y - other.y;\n131: return dx * dx + dy * dy;\n132: }\n139: constexpr Point operator+(const Point &rhs) const {\n140: return {x + rhs.x, y + rhs.y};\n141: }\n142: };\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```\n127: constexpr double dist_sq(const Point &other) const {\n129: double dx = x - other.x;\n130: double dy = y - other.y;\n131: return dx * dx + dy * dy;\n132: }\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```\n150: enum class Direction {\n151: Up,\n152: Down,\n153: Left,\n154: Right\n155: };\n```\n\n### TYPE_ALIAS: `StringVec`\n> Signature: `using StringVec = std::vector<std::string>`\n> Lines: 160-160\n```\n160: using StringVec = std::vector<std::string>;\n```\n\n### TYPE_ALIAS: `int`\n> Signature: `typedef int my_int_t`\n> Lines: 163-163\n```\n163: typedef int my_int_t;\n```\n\n### TYPE_ALIAS: `Callback`\n> Signature: `using Callback = std::function<void(int)>`\n> Lines: 166-166\n```\n166: using 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```\n175: template <typename Derived> class Cloneable {\n176: public:\n181: std::unique_ptr<Derived> clone() const {\n183: return std::make_unique<Derived>(static_cast<const Derived &>(*this));\n184: }\n185: };\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```\n193: class Base {\n194: public:\n199: virtual const char *type_name() const = 0;\n200: virtual ~Base() = default;\n201: };\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```\n199: virtual const char *type_name() const = 0;\n200: virtual ~Base() = default;\n201: };\n207: class 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```\n207: class DerivedA : public virtual Base {\n208: public:\n209: const char *type_name() const override { return \"DerivedA\"; }\n210: };\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"DerivedA\"; }`\n> Lines: 209-209\n```\n209: const 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```\n216: class DerivedB : public virtual Base {\n217: public:\n218: const char *type_name() const override { return \"DerivedB\"; }\n219: };\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"DerivedB\"; }`\n> Lines: 218-218\n```\n218: const 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```\n225: class Diamond : public DerivedA, public DerivedB {\n226: public:\n227: const char *type_name() const override { return \"Diamond\"; }\n228: };\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"Diamond\"; }`\n> Lines: 227-227\n```\n227: const 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```\n251: if (pos == std::string::npos) {\n253: return {\"\", \"\"};\n254: }\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```\n264: void 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```\n270: int main() {\n272: auto [key, val] = parse_kv(\"lang=cpp\");\n273: greet(key);\n274: return 0;\n275: }\n```\n\n### FUNCTION: `t`\n> Signature: `greet(key)`\n> Lines: 273-284\n```\n273: greet(key);\n274: return 0;\n275: }\n284: constexpr 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```\n288: namespace Inner::Detail {\n295: inline std::string format_int(int v) { return std::to_string(v); }\n297: }\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```\n295: inline 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```\n310: return std::to_string(value);\n311: }\n318: inline 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```\n318: inline std::string serialize(const std::string &value) { return value; }\n```\n\n### STRUCT: `Pixel`\n> Signature: `struct Pixel`\n> Lines: 321-325\n```\n321: struct Pixel {\n322: int r;\n323: int g;\n324: int b;\n325: };\n```\n\n### STRUCT: `Size`\n> Signature: `struct Size`\n> Lines: 326-329\n```\n326: struct Size {\n327: int w;\n328: int h;\n329: };\n```\n\n### STRUCT: `Bounds`\n> Signature: `struct Bounds`\n> Lines: 330-335\n```\n330: struct Bounds {\n331: int x;\n332: int y;\n333: int w;\n334: int h;\n335: };\n```\n\n### STRUCT: `Marker`\n> Signature: `struct Marker`\n> Lines: 336-338\n```\n336: struct Marker {\n337: int id;\n338: };\n```\n\n### ENUM: `Mode`\n> Signature: `enum Mode { ModeA, ModeB }`\n> Lines: 339-339\n```\n339: enum Mode { ModeA, ModeB };\n```\n\n### ENUM: `State`\n> Signature: `enum State { StateIdle, StateBusy }`\n> Lines: 340-340\n```\n340: enum State { StateIdle, StateBusy };\n```\n\n### ENUM: `Grade`\n> Signature: `enum Grade { GradeA, GradeB }`\n> Lines: 341-341\n```\n341: enum Grade { GradeA, GradeB };\n```\n\n### ENUM: `Severity`\n> Signature: `enum Severity { SevLow, SevHigh }`\n> Lines: 342-342\n```\n342: enum Severity { SevLow, SevHigh };\n```\n\n### NAMESPACE: `extns`\n> Signature: `namespace extns`\n> Lines: 343-345\n```\n343: namespace extns {\n344: inline int add_one(int v) { return v + 1; }\n345: }\n```\n\n### FUNCTION: `add_one`\n> Signature: `inline int add_one(int v) { return v + 1; }`\n> Lines: 344-344\n```\n344: inline int add_one(int v) { return v + 1; }\n```\n\n### NAMESPACE: `ext_alpha`\n> Signature: `namespace ext_alpha`\n> Lines: 346-348\n```\n346: namespace ext_alpha {\n347: inline int ping() { return 1; }\n348: }\n```\n\n### FUNCTION: `ping`\n> Signature: `inline int ping() { return 1; }`\n> Lines: 347-347\n```\n347: inline int ping() { return 1; }\n```\n\n### NAMESPACE: `ext_beta`\n> Signature: `namespace ext_beta`\n> Lines: 349-351\n```\n349: namespace ext_beta {\n350: inline int pong() { return 2; }\n351: }\n```\n\n### FUNCTION: `pong`\n> Signature: `inline int pong() { return 2; }`\n> Lines: 350-350\n```\n350: inline int pong() { return 2; }\n```\n\n### MACRO: `FEATURE_ALPHA`\n> Signature: `#define FEATURE_ALPHA 1`\n> Lines: 352-352\n```\n352: #define FEATURE_ALPHA 1\n```\n\n### MACRO: `FEATURE_BETA`\n> Signature: `#define FEATURE_BETA 2`\n> Lines: 353-353\n```\n353: #define FEATURE_BETA 2\n```\n\n### MACRO: `FEATURE_GAMMA`\n> Signature: `#define FEATURE_GAMMA 3`\n> Lines: 354-354\n```\n354: #define FEATURE_GAMMA 3\n```\n\n### TYPE_ALIAS: `NumberVec`\n> Signature: `using NumberVec = std::vector<int>`\n> Lines: 355-355\n```\n355: using NumberVec = std::vector<int>;\n```\n\n### TYPE_ALIAS: `long`\n> Signature: `typedef long LongId`\n> Lines: 356-356\n```\n356: typedef 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```\n366: int 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```\n375: int 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```\n384: int 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```\n393: int 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```\n402: int req_cover_cpp_5(int value) { return value + 5; }\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_csharp.cs | csharp\n\n### IMPORT: `System`\n> Lines: 9-9\n```\n9: using System;\n```\n\n### IMPORT: `System.Collections.Generic`\n> Lines: 10-10\n```\n10: using System.Collections.Generic;\n```\n\n### IMPORT: `System.Linq`\n> Lines: 11-11\n```\n11: using System.Linq;\n```\n\n### IMPORT: `System.Threading.Tasks`\n> Lines: 12-12\n```\n12: using System.Threading.Tasks;\n```\n\n### IMPORT: `System.Threading`\n> Lines: 13-13\n```\n13: using System.Threading;\n```\n\n### NAMESPACE: `MyApp`\n> Signature: `namespace MyApp`\n> Lines: 15-314\n```\n15: namespace MyApp {\n24: public delegate void DataChangedHandler(object sender, string data);\n32: public delegate T Transform<T>(T value);\n39: [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]\n40: public class AuditableAttribute : Attribute {\n42: public int Level { get; set; } = 1;\n43: }\n51: [Serializable]\n52: [Auditable(Level = 2)]\n53: public class Person : IComparable<Person>, IDisposable {\n55: public const int MAX_AGE = 150;\n58: private static int _instanceCount = 0;\n61: private string _name;\n68: public string Name {\n69: get => _name;\n70: set {\n72: if (string.IsNullOrWhiteSpace(value))\n73: throw new ArgumentException(\"Name cannot be empty\");\n74: _name = value;\n75: }\n76: }\n79: public int Age { get; init; }\n82: public string? Email { get; set; }\n85: public Guid Id { get; } = Guid.NewGuid();\n90: public event DataChangedHandler? OnDataChanged;\n97: public Person(string name, int age) {\n98: _name = name;\n99: Age = age;\n100: Interlocked.Increment(ref _instanceCount);\n101: }\n106: public void Greet() {\n108: OnDataChanged?.Invoke(this, $\"Greeted {Name}\");\n109: Console.WriteLine($\"Hello, {Name}!\");\n110: }\n117: public static async Task<string> FetchAsync(CancellationToken token = default) {\n118: await Task.Delay(100, token);\n119: return \"data\";\n120: }\n127: public int CompareTo(Person? other) {\n128: if (other is null) return 1;\n129: return Age.CompareTo(other.Age);\n130: }\n135: public void Dispose() {\n137: Interlocked.Decrement(ref _instanceCount);\n138: GC.SuppressFinalize(this);\n139: }\n146: public object? this[string propertyName] {\n147: get {\n148: return propertyName switch {\n149: \"Name\" => Name,\n150: \"Age\" => Age,\n151: \"Email\" => Email,\n152: _ => null,\n153: };\n154: }\n155: }\n162: public void Deconstruct(out string name, out int age) {\n163: name = Name;\n164: age = Age;\n165: }\n171: public static int GetInstanceCount() => _instanceCount;\n172: }\n179: public interface IGreeter {\n184: void SayHello(string name);\n190: void SayGoodbye(string name) {\n191: Console.WriteLine($\"Goodbye, {name}\");\n192: }\n193: }\n199: public interface IRepository<T> where T : class, new() {\n201: Task<T?> FindByIdAsync(int id);\n204: IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\n207: Task<bool> SaveAsync(T entity);\n208: }\n215: public readonly struct Point {\n217: public double X { get; init; }\n219: public double Y { get; init; }\n224: public static Point operator +(Point a, Point b) => new() { X = a.X + b.X, Y = a.Y + b.Y };\n229: public double Magnitude => Math.Sqrt(X * X + Y * Y);\n230: }\n237: [Flags]\n238: public enum Color {\n240: None = 0,\n242: Red = 1,\n244: Green = 2,\n246: Blue = 4,\n248: All = Red | Green | Blue,\n249: }\n258: public record ConfigEntry(string Key, string Value);\n265: public record struct Vector2(double X, double Y);\n272: public static class StringExtensions {\n279: public static string Truncate(this string str, int maxLength) {\n280: if (str.Length <= maxLength) return str;\n281: return str[..maxLength] + \"...\";\n282: }\n289: public static bool IsAscii(this string str) {\n290: return str.All(c => c < 128);\n291: }\n292: }\n300: public class SortedCollection<T> where T : IComparable<T> {\n301: private readonly List<T> _items = new();\n307: public void Add(T item) {\n309: var index = _items.BinarySearch(item);\n310: if (index < 0) index = ~index;\n311: _items.Insert(index, item);\n312: }\n```\n\n### DECORATOR: `AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)`\n> Lines: 39-39\n```\n39: [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]\n```\n\n### CLASS: `AuditableAttribute`\n> Signature: `public class AuditableAttribute : Attribute`\n> Lines: 40-43\n```\n40: public class AuditableAttribute : Attribute {\n42: public int Level { get; set; } = 1;\n43: }\n```\n\n### PROPERTY: `Level`\n> Signature: `public int Level { get; set; } = 1`\n> Lines: 42-42\n```\n42: public int Level { get; set; } = 1;\n```\n\n### DECORATOR: `Serializable`\n> Lines: 51-51\n```\n51: [Serializable]\n```\n\n### DECORATOR: `Auditable(Level = 2)`\n> Lines: 52-52\n```\n52: [Auditable(Level = 2)]\n```\n\n### CLASS: `Person`\n> Signature: `public class Person : IComparable<Person>, IDisposable`\n> Lines: 53-172\n```\n53: public class Person : IComparable<Person>, IDisposable {\n55: public const int MAX_AGE = 150;\n58: private static int _instanceCount = 0;\n61: private string _name;\n68: public string Name {\n69: get => _name;\n70: set {\n72: if (string.IsNullOrWhiteSpace(value))\n73: throw new ArgumentException(\"Name cannot be empty\");\n74: _name = value;\n75: }\n76: }\n79: public int Age { get; init; }\n82: public string? Email { get; set; }\n85: public Guid Id { get; } = Guid.NewGuid();\n90: public event DataChangedHandler? OnDataChanged;\n97: public Person(string name, int age) {\n98: _name = name;\n99: Age = age;\n100: Interlocked.Increment(ref _instanceCount);\n101: }\n106: public void Greet() {\n108: OnDataChanged?.Invoke(this, $\"Greeted {Name}\");\n109: Console.WriteLine($\"Hello, {Name}!\");\n110: }\n117: public static async Task<string> FetchAsync(CancellationToken token = default) {\n118: await Task.Delay(100, token);\n119: return \"data\";\n120: }\n127: public int CompareTo(Person? other) {\n128: if (other is null) return 1;\n129: return Age.CompareTo(other.Age);\n130: }\n135: public void Dispose() {\n137: Interlocked.Decrement(ref _instanceCount);\n138: GC.SuppressFinalize(this);\n139: }\n146: public object? this[string propertyName] {\n147: get {\n148: return propertyName switch {\n149: \"Name\" => Name,\n150: \"Age\" => Age,\n151: \"Email\" => Email,\n152: _ => null,\n153: };\n154: }\n155: }\n162: public void Deconstruct(out string name, out int age) {\n163: name = Name;\n164: age = Age;\n165: }\n171: public static int GetInstanceCount() => _instanceCount;\n172: }\n```\n\n### CONSTANT: `MAX_AGE`\n> Signature: `public const int MAX_AGE = 150`\n> Lines: 55-55\n```\n55: public const int MAX_AGE = 150;\n```\n\n### PROPERTY: `Name`\n> Signature: `public string Name`\n> Lines: 68-68\n```\n68: public string Name {\n```\n\n### PROPERTY: `Age`\n> Signature: `public int Age { get; init; }`\n> Lines: 79-79\n```\n79: public int Age { get; init; }\n```\n\n### PROPERTY: `Id`\n> Signature: `public Guid Id { get; } = Guid.NewGuid()`\n> Lines: 85-85\n```\n85: public 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```\n97: public Person(string name, int age) {\n98: _name = name;\n99: Age = age;\n100: Interlocked.Increment(ref _instanceCount);\n101: }\n```\n\n### FUNCTION: `Greet`\n> Signature: `public void Greet()`\n> Lines: 106-110\n```\n106: public void Greet() {\n108: OnDataChanged?.Invoke(this, $\"Greeted {Name}\");\n109: Console.WriteLine($\"Hello, {Name}!\");\n110: }\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```\n117: public static async Task<string> FetchAsync(CancellationToken token = default) {\n118: await Task.Delay(100, token);\n119: return \"data\";\n120: }\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```\n127: public int CompareTo(Person? other) {\n128: if (other is null) return 1;\n129: return Age.CompareTo(other.Age);\n130: }\n```\n\n### FUNCTION: `Dispose`\n> Signature: `public void Dispose()`\n> Lines: 135-139\n```\n135: public void Dispose() {\n137: Interlocked.Decrement(ref _instanceCount);\n138: GC.SuppressFinalize(this);\n139: }\n```\n\n### FUNCTION: `Deconstruct`\n> Signature: `public void Deconstruct(out string name, out int age)`\n> Lines: 162-165\n```\n162: public void Deconstruct(out string name, out int age) {\n163: name = Name;\n164: age = Age;\n165: }\n```\n\n### FUNCTION: `GetInstanceCount`\n> Signature: `public static int GetInstanceCount() => _instanceCount`\n> Lines: 171-179\n```\n171: public static int GetInstanceCount() => _instanceCount;\n172: }\n179: public interface IGreeter {\n```\n\n### INTERFACE: `IGreeter`\n> Signature: `public interface IGreeter`\n> Lines: 179-193\n```\n179: public interface IGreeter {\n184: void SayHello(string name);\n190: void SayGoodbye(string name) {\n191: Console.WriteLine($\"Goodbye, {name}\");\n192: }\n193: }\n```\n\n### FUNCTION: `SayHello`\n> Signature: `void SayHello(string name)`\n> Lines: 184-192\n```\n184: void SayHello(string name);\n190: void SayGoodbye(string name) {\n191: Console.WriteLine($\"Goodbye, {name}\");\n192: }\n```\n\n### FUNCTION: `SayGoodbye`\n> Signature: `void SayGoodbye(string name)`\n> Lines: 190-192\n```\n190: void SayGoodbye(string name) {\n191: Console.WriteLine($\"Goodbye, {name}\");\n192: }\n```\n\n### INTERFACE: `IRepository`\n> Signature: `public interface IRepository<T> where T : class, new()`\n> Lines: 199-208\n```\n199: public interface IRepository<T> where T : class, new() {\n201: Task<T?> FindByIdAsync(int id);\n204: IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\n207: Task<bool> SaveAsync(T entity);\n208: }\n```\n\n### FUNCTION: `FindByIdAsync`\n> Signature: `Task<T?> FindByIdAsync(int id)`\n> Lines: 201-215\n```\n201: Task<T?> FindByIdAsync(int id);\n204: IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\n207: Task<bool> SaveAsync(T entity);\n208: }\n215: public readonly struct Point {\n```\n\n### FUNCTION: `GetAllAsync`\n> Signature: `IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default)`\n> Lines: 204-215\n```\n204: IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\n207: Task<bool> SaveAsync(T entity);\n208: }\n215: public readonly struct Point {\n```\n\n### FUNCTION: `SaveAsync`\n> Signature: `Task<bool> SaveAsync(T entity)`\n> Lines: 207-215\n```\n207: Task<bool> SaveAsync(T entity);\n208: }\n215: public readonly struct Point {\n```\n\n### STRUCT: `Point`\n> Signature: `public readonly struct Point`\n> Lines: 215-230\n```\n215: public readonly struct Point {\n217: public double X { get; init; }\n219: public double Y { get; init; }\n224: public static Point operator +(Point a, Point b) => new() { X = a.X + b.X, Y = a.Y + b.Y };\n229: public double Magnitude => Math.Sqrt(X * X + Y * Y);\n230: }\n```\n\n### PROPERTY: `X`\n> Signature: `public double X { get; init; }`\n> Lines: 217-217\n```\n217: public double X { get; init; }\n```\n\n### PROPERTY: `Y`\n> Signature: `public double Y { get; init; }`\n> Lines: 219-219\n```\n219: public double Y { get; init; }\n```\n\n### DECORATOR: `Flags`\n> Lines: 237-237\n```\n237: [Flags]\n```\n\n### ENUM: `Color`\n> Signature: `public enum Color`\n> Lines: 238-249\n```\n238: public enum Color {\n240: None = 0,\n242: Red = 1,\n244: Green = 2,\n246: Blue = 4,\n248: All = Red | Green | Blue,\n249: }\n```\n\n### FUNCTION: `ConfigEntry`\n> Signature: `public record ConfigEntry(string Key, string Value)`\n> Lines: 258-292\n```\n258: public record ConfigEntry(string Key, string Value);\n265: public record struct Vector2(double X, double Y);\n272: public static class StringExtensions {\n279: public static string Truncate(this string str, int maxLength) {\n280: if (str.Length <= maxLength) return str;\n281: return str[..maxLength] + \"...\";\n282: }\n289: public static bool IsAscii(this string str) {\n290: return str.All(c => c < 128);\n291: }\n292: }\n```\n\n### CLASS: `StringExtensions`\n> Signature: `public static class StringExtensions`\n> Lines: 272-292\n```\n272: public static class StringExtensions {\n279: public static string Truncate(this string str, int maxLength) {\n280: if (str.Length <= maxLength) return str;\n281: return str[..maxLength] + \"...\";\n282: }\n289: public static bool IsAscii(this string str) {\n290: return str.All(c => c < 128);\n291: }\n292: }\n```\n\n### FUNCTION: `Truncate`\n> Signature: `public static string Truncate(this string str, int maxLength)`\n> Lines: 279-282\n```\n279: public static string Truncate(this string str, int maxLength) {\n280: if (str.Length <= maxLength) return str;\n281: return str[..maxLength] + \"...\";\n282: }\n```\n\n### FUNCTION: `IsAscii`\n> Signature: `public static bool IsAscii(this string str)`\n> Lines: 289-291\n```\n289: public static bool IsAscii(this string str) {\n290: return str.All(c => c < 128);\n291: }\n```\n\n### CLASS: `SortedCollection`\n> Signature: `public class SortedCollection<T> where T : IComparable<T>`\n> Lines: 300-322\n```\n300: public class SortedCollection<T> where T : IComparable<T> {\n301: private readonly List<T> _items = new();\n307: public void Add(T item) {\n309: var index = _items.BinarySearch(item);\n310: if (index < 0) index = ~index;\n311: _items.Insert(index, item);\n312: }\n319: public IEnumerable<T> Where(Func<T, bool> predicate) {\n320: return _items.Where(predicate);\n321: }\n322: }\n```\n\n### FUNCTION: `Add`\n> Signature: `public void Add(T item)`\n> Lines: 307-312\n```\n307: public void Add(T item) {\n309: var index = _items.BinarySearch(item);\n310: if (index < 0) index = ~index;\n311: _items.Insert(index, item);\n312: }\n```\n\n### FUNCTION: `Where`\n> Signature: `public IEnumerable<T> Where(Func<T, bool> predicate)`\n> Lines: 319-321\n```\n319: public IEnumerable<T> Where(Func<T, bool> predicate) {\n320: return _items.Where(predicate);\n321: }\n```\n\n### CLASS: `PatternMatcher`\n> Signature: `public static class PatternMatcher`\n> Lines: 329-347\n```\n329: public static class PatternMatcher {\n335: public static string Describe(object? obj) {\n336: return obj switch {\n337: null => \"null\",\n338: int i when i > 0 => $\"positive int: {i}\",\n339: int i => $\"non-positive int: {i}\",\n340: string { Length: 0 } => \"empty string\",\n341: string s => $\"string({s.Length}): {s}\",\n342: Person { Age: >= 18 } p => $\"adult: {p.Name}\",\n343: Person p => $\"minor: {p.Name}\",\n344: _ => $\"unknown: {obj.GetType().Name}\",\n345: };\n346: }\n347: }\n```\n\n### FUNCTION: `Describe`\n> Signature: `public static string Describe(object? obj)`\n> Lines: 335-346\n```\n335: public static string Describe(object? obj) {\n336: return obj switch {\n337: null => \"null\",\n338: int i when i > 0 => $\"positive int: {i}\",\n339: int i => $\"non-positive int: {i}\",\n340: string { Length: 0 } => \"empty string\",\n341: string s => $\"string({s.Length}): {s}\",\n342: Person { Age: >= 18 } p => $\"adult: {p.Name}\",\n343: Person p => $\"minor: {p.Name}\",\n344: _ => $\"unknown: {obj.GetType().Name}\",\n345: };\n346: }\n```\n\n### NAMESPACE: `MyApp.Services`\n> Signature: `namespace MyApp.Services {}`\n> Lines: 352-352\n```\n352: namespace MyApp.Services {}\n```\n\n### NAMESPACE: `MyApp.Core`\n> Signature: `namespace MyApp.Core {}`\n> Lines: 353-353\n```\n353: namespace MyApp.Core {}\n```\n\n### NAMESPACE: `MyApp.Data`\n> Signature: `namespace MyApp.Data {}`\n> Lines: 354-354\n```\n354: namespace MyApp.Data {}\n```\n\n### NAMESPACE: `MyApp.Api`\n> Signature: `namespace MyApp.Api {}`\n> Lines: 355-355\n```\n355: namespace MyApp.Api {}\n```\n\n### INTERFACE: `ILogger`\n> Signature: `public interface ILogger {}`\n> Lines: 356-356\n```\n356: public interface ILogger {}\n```\n\n### INTERFACE: `IParser`\n> Signature: `public interface IParser {}`\n> Lines: 357-357\n```\n357: public interface IParser {}\n```\n\n### INTERFACE: `IRunner`\n> Signature: `public interface IRunner {}`\n> Lines: 358-358\n```\n358: public interface IRunner {}\n```\n\n### ENUM: `ModeCs`\n> Signature: `public enum ModeCs { Fast, Safe }`\n> Lines: 359-359\n```\n359: public enum ModeCs { Fast, Safe }\n```\n\n### ENUM: `PhaseCs`\n> Signature: `public enum PhaseCs { Init, Done }`\n> Lines: 360-360\n```\n360: public enum PhaseCs { Init, Done }\n```\n\n### ENUM: `StateCs`\n> Signature: `public enum StateCs { Open, Closed }`\n> Lines: 361-361\n```\n361: public enum StateCs { Open, Closed }\n```\n\n### ENUM: `SignalCs`\n> Signature: `public enum SignalCs { On, Off }`\n> Lines: 362-362\n```\n362: public 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```\n363: public 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```\n364: public 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```\n365: public struct Limits { public int Max; }\n```\n\n### STRUCT: `Cursor`\n> Signature: `public struct Cursor { public int Index; }`\n> Lines: 366-366\n```\n366: public struct Cursor { public int Index; }\n```\n\n### DECORATOR: `DebuggerDisplay(\"{Value}\")`\n> Lines: 367-367\n```\n367: [DebuggerDisplay(\"{Value}\")]\n```\n\n### CONSTANT: `MIN_AGE`\n> Signature: `public const int MIN_AGE = 10`\n> Lines: 368-368\n```\n368: public const int MIN_AGE = 10;\n```\n\n### CONSTANT: `RETRY_LIMIT`\n> Signature: `public const int RETRY_LIMIT = 3`\n> Lines: 369-369\n```\n369: public const int RETRY_LIMIT = 3;\n```\n\n### CONSTANT: `CACHE_SIZE`\n> Signature: `public const int CACHE_SIZE = 128`\n> Lines: 370-370\n```\n370: public const int CACHE_SIZE = 128;\n```\n\n### CONSTANT: `DEFAULT_PAGE`\n> Signature: `public const int DEFAULT_PAGE = 1`\n> Lines: 371-371\n```\n371: public 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```\n374: public static class ReqCoverCsharp {\n380: public static int ReqCoverCsharp1(int value) { return value + 1; }\n387: public static int ReqCoverCsharp2(int value) { return value + 2; }\n394: public static int ReqCoverCsharp3(int value) { return value + 3; }\n401: public static int ReqCoverCsharp4(int value) { return value + 4; }\n408: public static int ReqCoverCsharp5(int value) { return value + 5; }\n410: }\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```\n380: public 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```\n387: public 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```\n394: public 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```\n401: public 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```\n408: public static int ReqCoverCsharp5(int value) { return value + 5; }\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_elixir.ex | elixir\n\n### MODULE: `MyApp.Server`\n> Signature: `defmodule MyApp.Server do`\n> Lines: 10-183\n```\n10: defmodule MyApp.Server do\n11:   @moduledoc \"\"\"\n12:   GenServer implementation for managing application state.\n14:   Handles synchronous calls, asynchronous casts, and info messages.\n15:   Supports state initialization with validated options.\n16:   \"\"\"\n18:   use GenServer\n19:   import Enum\n20:   alias MyApp.Config\n21:   alias MyApp.Server.State\n22:   require Logger\n24:   @behaviour GenServer\n29:   @default_timeout 5_000\n32:   @max_items 1_000\n36:   @doc \"\"\"\n37:   Internal state struct for the server.\n39:   @field name Server instance name.\n40:   @field port Listening port number.\n41:   @field items List of stored items.\n42:   @field started_at Timestamp of server start.\n43:   \"\"\"\n44:   defstruct [:name, :port, items: [], started_at: nil]\n48:   @type t :: %__MODULE__{\n49:     name: String.t(),\n50:     port: non_neg_integer(),\n51:     items: list(any()),\n52:     started_at: DateTime.t() | nil\n53:   }\n55:   @type option :: {:name, String.t()} | {:port, non_neg_integer()}\n59:   @doc \"\"\"\n60:   Start a new server process linked to the caller.\n62:   @param opts Keyword list of options (:name, :port).\n63:   @return {:ok, pid} on success or {:error, reason} on failure.\n64:   \"\"\"\n65:   @spec start_link(keyword()) :: GenServer.on_start()\n66:   def start_link(opts) do\n67:     name = Keyword.get(opts, :name, \"default\")\n68:     GenServer.start_link(__MODULE__, opts, name: via_tuple(name))\n69:   end\n71:   @doc \"\"\"\n72:   Add an item to the server's collection.\n74:   @param server The server PID or registered name.\n75:   @param item The item to store.\n76:   @return :ok\n77:   \"\"\"\n78:   @spec add_item(GenServer.server(), any()) :: :ok\n79:   def add_item(server, item) do\n80:     GenServer.call(server, {:add_item, item})\n81:   end\n83:   @doc \"\"\"\n84:   Retrieve all stored items.\n86:   @param server The server PID or registered name.\n87:   @return List of stored items.\n88:   \"\"\"\n89:   @spec get_items(GenServer.server()) :: list(any())\n90:   def get_items(server) do\n91:     GenServer.call(server, :get_items)\n92:   end\n94:   @doc \"\"\"\n95:   Asynchronously notify the server of an event.\n97:   @param server The server PID.\n98:   @param event The event data to process.\n99:   @return :ok\n100:   \"\"\"\n101:   @spec notify(GenServer.server(), any()) :: :ok\n102:   def notify(server, event) do\n103:     GenServer.cast(server, {:notify, event})\n104:   end\n111:   defp via_tuple(name) do\n112:     {:via, Registry, {MyApp.Registry, name}}\n113:   end\n117:   @impl true\n118:   def init(opts) do\n120:     name = Keyword.fetch!(opts, :name)\n121:     port = Keyword.get(opts, :port, 4000)\n123:     state = %__MODULE__{\n124:       name: name,\n125:       port: port,\n126:       started_at: DateTime.utc_now()\n127:     }\n129:     Logger.info(\"Server #{name} started on port #{port}\")\n130:     {:ok, state}\n131:   end\n133:   @impl true\n134:   def handle_call({:add_item, item}, _from, state) do\n136:     if length(state.items) >= @max_items do\n137:       {:reply, {:error, :capacity_exceeded}, state}\n138:     else\n139:       new_state = %{state | items: [item | state.items]}\n140:       {:reply, :ok, new_state}\n141:     end\n142:   end\n144:   @impl true\n145:   def handle_call(:get_items, _from, state) do\n146:     {:reply, Enum.reverse(state.items), state}\n147:   end\n149:   @impl true\n150:   def handle_cast({:notify, event}, state) do\n151:     Logger.debug(\"Received event: #{inspect(event)}\")\n152:     {:noreply, state}\n153:   end\n155:   @impl true\n156:   def handle_info(:timeout, state) do\n157:     Logger.warn(\"Server #{state.name} timed out\")\n158:     {:noreply, state}\n159:   end\n164:   defp handle_internal(state) do\n166:     pruned = Enum.take(state.items, @max_items)\n167:     %{state | items: pruned}\n168:   end\n170:   @doc \"\"\"\n171:   Define a macro for compile-time code generation.\n173:   @param expr The expression to wrap.\n174:   @return Quoted AST wrapping the expression.\n175:   \"\"\"\n176:   defmacro my_macro(expr) do\n177:     quote do\n178:       result = unquote(expr)\n179:       Logger.debug(\"Macro result: #{inspect(result)}\")\n180:       result\n181:     end\n182:   end\n183: end\n```\n\n### IMPORT: `GenServer`\n> Lines: 18-18\n```\n18:   use GenServer\n```\n\n### IMPORT: `Enum`\n> Lines: 19-19\n```\n19:   import Enum\n```\n\n### IMPORT: `MyApp.Config`\n> Lines: 20-20\n```\n20:   alias MyApp.Config\n```\n\n### IMPORT: `MyApp.Server.State`\n> Lines: 21-21\n```\n21:   alias MyApp.Server.State\n```\n\n### IMPORT: `Logger`\n> Lines: 22-22\n```\n22:   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```\n44:   defstruct [:name, :port, items: [], started_at: nil]\n48:   @type t :: %__MODULE__{\n49:     name: String.t(),\n50:     port: non_neg_integer(),\n51:     items: list(any()),\n52:     started_at: DateTime.t() | nil\n53:   }\n55:   @type option :: {:name, String.t()} | {:port, non_neg_integer()}\n59:   @doc \"\"\"\n60:   Start a new server process linked to the caller.\n62:   @param opts Keyword list of options (:name, :port).\n63:   @return {:ok, pid} on success or {:error, reason} on failure.\n64:   \"\"\"\n65:   @spec start_link(keyword()) :: GenServer.on_start()\n66:   def start_link(opts) do\n67:     name = Keyword.get(opts, :name, \"default\")\n68:     GenServer.start_link(__MODULE__, opts, name: via_tuple(name))\n69:   end\n```\n\n### FUNCTION: `start_link`\n> Signature: `def start_link(opts) do`\n> Lines: 66-69\n```\n66:   def start_link(opts) do\n67:     name = Keyword.get(opts, :name, \"default\")\n68:     GenServer.start_link(__MODULE__, opts, name: via_tuple(name))\n69:   end\n```\n\n### FUNCTION: `add_item`\n> Signature: `def add_item(server, item) do`\n> Lines: 79-81\n```\n79:   def add_item(server, item) do\n80:     GenServer.call(server, {:add_item, item})\n81:   end\n```\n\n### FUNCTION: `get_items`\n> Signature: `def get_items(server) do`\n> Lines: 90-92\n```\n90:   def get_items(server) do\n91:     GenServer.call(server, :get_items)\n92:   end\n```\n\n### FUNCTION: `notify`\n> Signature: `def notify(server, event) do`\n> Lines: 102-104\n```\n102:   def notify(server, event) do\n103:     GenServer.cast(server, {:notify, event})\n104:   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```\n111:   defp via_tuple(name) do\n112:     {:via, Registry, {MyApp.Registry, name}}\n113:   end\n```\n\n### FUNCTION: `init`\n> Signature: `def init(opts) do`\n> Lines: 118-131\n```\n118:   def init(opts) do\n120:     name = Keyword.fetch!(opts, :name)\n121:     port = Keyword.get(opts, :port, 4000)\n123:     state = %__MODULE__{\n124:       name: name,\n125:       port: port,\n126:       started_at: DateTime.utc_now()\n127:     }\n129:     Logger.info(\"Server #{name} started on port #{port}\")\n130:     {:ok, state}\n131:   end\n```\n\n### FUNCTION: `handle_call`\n> Signature: `def handle_call({:add_item, item}, _from, state) do`\n> Lines: 134-142\n```\n134:   def handle_call({:add_item, item}, _from, state) do\n136:     if length(state.items) >= @max_items do\n137:       {:reply, {:error, :capacity_exceeded}, state}\n138:     else\n139:       new_state = %{state | items: [item | state.items]}\n140:       {:reply, :ok, new_state}\n141:     end\n142:   end\n```\n\n### FUNCTION: `handle_call`\n> Signature: `def handle_call(:get_items, _from, state) do`\n> Lines: 145-147\n```\n145:   def handle_call(:get_items, _from, state) do\n146:     {:reply, Enum.reverse(state.items), state}\n147:   end\n```\n\n### FUNCTION: `handle_cast`\n> Signature: `def handle_cast({:notify, event}, state) do`\n> Lines: 150-153\n```\n150:   def handle_cast({:notify, event}, state) do\n151:     Logger.debug(\"Received event: #{inspect(event)}\")\n152:     {:noreply, state}\n153:   end\n```\n\n### FUNCTION: `handle_info`\n> Signature: `def handle_info(:timeout, state) do`\n> Lines: 156-159\n```\n156:   def handle_info(:timeout, state) do\n157:     Logger.warn(\"Server #{state.name} timed out\")\n158:     {:noreply, state}\n159:   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```\n164:   defp handle_internal(state) do\n166:     pruned = Enum.take(state.items, @max_items)\n167:     %{state | items: pruned}\n168:   end\n```\n\n### FUNCTION: `my_macro`\n> Signature: `defmacro my_macro(expr) do`\n> Lines: 176-182\n```\n176:   defmacro my_macro(expr) do\n177:     quote do\n178:       result = unquote(expr)\n179:       Logger.debug(\"Macro result: #{inspect(result)}\")\n180:       result\n181:     end\n182:   end\n```\n\n### PROTOCOL: `Printable`\n> Signature: `defprotocol Printable do`\n> Lines: 187-200\n```\n187: defprotocol Printable do\n188:   @moduledoc \"\"\"\n189:   Protocol for types that can be printed as formatted strings.\n190:   \"\"\"\n192:   @doc \"\"\"\n193:   Convert a value to its formatted string representation.\n195:   @param data The value to format.\n196:   @return Formatted string.\n197:   \"\"\"\n198:   @spec print(t) :: String.t()\n199:   def print(data)\n200: end\n```\n\n### FUNCTION: `print`\n> Signature: `def print(data)`\n> Lines: 199-200\n```\n199:   def print(data)\n200: end\n```\n\n### IMPL: `Printable`\n> Signature: `defimpl Printable, for: MyApp.Server do`\n> Lines: 204-214\n```\n204: defimpl Printable, for: MyApp.Server do\n205:   @doc \"\"\"\n206:   Format a server struct for display.\n208:   @param server The server struct to format.\n209:   @return String in format \"Server(name:port)\".\n210:   \"\"\"\n211:   def print(server) do\n212:     \"Server(#{server.name}:#{server.port})\"\n213:   end\n214: end\n```\n\n### FUNCTION: `print`\n> Signature: `def print(server) do`\n> Lines: 211-213\n```\n211:   def print(server) do\n212:     \"Server(#{server.name}:#{server.port})\"\n213:   end\n```\n\n### IMPL: `Printable`\n> Signature: `defimpl Printable, for: BitString do`\n> Lines: 216-220\n```\n216: defimpl Printable, for: BitString do\n217:   def print(str) do\n218:     \"String(#{str})\"\n219:   end\n220: end\n```\n\n### FUNCTION: `print`\n> Signature: `def print(str) do`\n> Lines: 217-219\n```\n217:   def print(str) do\n218:     \"String(#{str})\"\n219:   end\n```\n\n### MODULE: `MyApp.Utils`\n> Signature: `defmodule MyApp.Utils do`\n> Lines: 224-296\n```\n224: defmodule MyApp.Utils do\n225:   @moduledoc \"\"\"\n226:   Utility functions demonstrating pattern matching, guards,\n227:   pipe operators, and comprehensions.\n228:   \"\"\"\n230:   @doc \"\"\"\n231:   Classify a value using guard clauses and pattern matching.\n233:   @param value The value to classify.\n234:   @return Atom describing the value's category.\n235:   \"\"\"\n236:   @spec classify(any()) :: atom()\n237:   def classify(value) when is_integer(value) and value > 0, do: :positive\n238:   def classify(value) when is_integer(value) and value < 0, do: :negative\n239:   def classify(0), do: :zero\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n260:   @doc \"\"\"\n261:   Demonstrate for-comprehension with multiple generators and filters.\n263:   @param range Upper bound for the search space.\n264:   @return List of Pythagorean triples.\n265:   \"\"\"\n266:   @spec pythagorean_triples(pos_integer()) :: list(tuple())\n267:   def pythagorean_triples(range) do\n268:     for a <- 1..range,\n269:         b <- a..range,\n270:         c <- b..range,\n271:         a * a + b * b == c * c do\n272:       {a, b, c}\n273:     end\n274:   end\n276:   @doc \"\"\"\n277:   Safe division returning :error tuple on zero divisor.\n279:   @param a Dividend.\n280:   @param b Divisor.\n281:   @return {:ok, result} or {:error, :division_by_zero}.\n282:   \"\"\"\n283:   @spec safe_divide(number(), number()) :: {:ok, float()} | {:error, atom()}\n284:   def safe_divide(_, 0), do: {:error, :division_by_zero}\n285:   def safe_divide(a, b), do: {:ok, a / b}\n287:   @doc \"\"\"\n288:   Recursively compute factorial with guard clause.\n290:   @param n Non-negative integer.\n291:   @return Factorial of n.\n292:   \"\"\"\n293:   @spec factorial(non_neg_integer()) :: pos_integer()\n294:   def factorial(0), do: 1\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_integer(value) and value > 0, do: :positive`\n> Lines: 237-258\n```\n237:   def classify(value) when is_integer(value) and value > 0, do: :positive\n238:   def classify(value) when is_integer(value) and value < 0, do: :negative\n239:   def classify(0), do: :zero\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   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```\n238:   def classify(value) when is_integer(value) and value < 0, do: :negative\n239:   def classify(0), do: :zero\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(0), do: :zero`\n> Lines: 239-258\n```\n239:   def classify(0), do: :zero\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_binary(value), do: :string`\n> Lines: 240-258\n```\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_list(value), do: :list`\n> Lines: 241-258\n```\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(_), do: :unknown`\n> Lines: 242-258\n```\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `process_list`\n> Signature: `def process_list(items) do`\n> Lines: 251-258\n```\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `pythagorean_triples`\n> Signature: `def pythagorean_triples(range) do`\n> Lines: 267-274\n```\n267:   def pythagorean_triples(range) do\n268:     for a <- 1..range,\n269:         b <- a..range,\n270:         c <- b..range,\n271:         a * a + b * b == c * c do\n272:       {a, b, c}\n273:     end\n274:   end\n```\n\n### FUNCTION: `safe_divide`\n> Signature: `def safe_divide(_, 0), do: {:error, :division_by_zero}`\n> Lines: 284-296\n```\n284:   def safe_divide(_, 0), do: {:error, :division_by_zero}\n285:   def safe_divide(a, b), do: {:ok, a / b}\n287:   @doc \"\"\"\n288:   Recursively compute factorial with guard clause.\n290:   @param n Non-negative integer.\n291:   @return Factorial of n.\n292:   \"\"\"\n293:   @spec factorial(non_neg_integer()) :: pos_integer()\n294:   def factorial(0), do: 1\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### FUNCTION: `safe_divide`\n> Signature: `def safe_divide(a, b), do: {:ok, a / b}`\n> Lines: 285-296\n```\n285:   def safe_divide(a, b), do: {:ok, a / b}\n287:   @doc \"\"\"\n288:   Recursively compute factorial with guard clause.\n290:   @param n Non-negative integer.\n291:   @return Factorial of n.\n292:   \"\"\"\n293:   @spec factorial(non_neg_integer()) :: pos_integer()\n294:   def factorial(0), do: 1\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### FUNCTION: `factorial`\n> Signature: `def factorial(0), do: 1`\n> Lines: 294-296\n```\n294:   def factorial(0), do: 1\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### FUNCTION: `factorial`\n> Signature: `def factorial(n) when n > 0, do: n * factorial(n - 1)`\n> Lines: 295-296\n```\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### MODULE: `MyApp.Plugin`\n> Signature: `defmodule MyApp.Plugin do`\n> Lines: 300-315\n```\n300: defmodule MyApp.Plugin do\n301:   @moduledoc \"\"\"\n302:   Behaviour defining the plugin interface.\n303:   \"\"\"\n305:   @doc \"Initialize the plugin with configuration options.\"\n306:   @callback init(opts :: keyword()) :: {:ok, any()} | {:error, String.t()}\n308:   @doc \"Execute the plugin's main logic.\"\n309:   @callback execute(state :: any()) :: :ok | {:error, String.t()}\n311:   @doc \"Clean up plugin resources.\"\n312:   @callback cleanup(state :: any()) :: :ok\n314:   @optional_callbacks [cleanup: 1]\n315: end\n```\n\n### MODULE: `MyApp.Extra`\n> Signature: `defmodule MyApp.Extra do`\n> Lines: 318-321\n```\n318: defmodule MyApp.Extra do\n320:   defstruct [:name]\n321: end\n```\n\n### STRUCT: `[:name]`\n> Signature: `defstruct [:name]`\n> Lines: 320-321\n```\n320:   defstruct [:name]\n321: end\n```\n\n### MODULE: `MyApp.Audit`\n> Signature: `defmodule MyApp.Audit do`\n> Lines: 323-325\n```\n323: defmodule MyApp.Audit do\n324:   defstruct [:id]\n325: end\n```\n\n### STRUCT: `[:id]`\n> Signature: `defstruct [:id]`\n> Lines: 324-325\n```\n324:   defstruct [:id]\n325: end\n```\n\n### MODULE: `MyApp.State`\n> Signature: `defmodule MyApp.State do`\n> Lines: 327-329\n```\n327: defmodule MyApp.State do\n328:   defstruct [:status]\n329: end\n```\n\n### STRUCT: `[:status]`\n> Signature: `defstruct [:status]`\n> Lines: 328-329\n```\n328:   defstruct [:status]\n329: end\n```\n\n### MODULE: `MyApp.Payload`\n> Signature: `defmodule MyApp.Payload do`\n> Lines: 331-333\n```\n331: defmodule MyApp.Payload do\n332:   defstruct [:value]\n333: end\n```\n\n### STRUCT: `[:value]`\n> Signature: `defstruct [:value]`\n> Lines: 332-333\n```\n332:   defstruct [:value]\n333: end\n```\n\n### MODULE: `MyApp.Context`\n> Signature: `defmodule MyApp.Context do`\n> Lines: 335-337\n```\n335: defmodule MyApp.Context do\n336:   defstruct [:meta]\n337: end\n```\n\n### STRUCT: `[:meta]`\n> Signature: `defstruct [:meta]`\n> Lines: 336-337\n```\n336:   defstruct [:meta]\n337: end\n```\n\n### PROTOCOL: `Auditable`\n> Signature: `defprotocol Auditable do`\n> Lines: 339-341\n```\n339: defprotocol Auditable do\n340:   def audit(data)\n341: end\n```\n\n### FUNCTION: `audit`\n> Signature: `def audit(data)`\n> Lines: 340-341\n```\n340:   def audit(data)\n341: end\n```\n\n### PROTOCOL: `Renderable`\n> Signature: `defprotocol Renderable do`\n> Lines: 343-345\n```\n343: defprotocol Renderable do\n344:   def render(data)\n345: end\n```\n\n### FUNCTION: `render`\n> Signature: `def render(data)`\n> Lines: 344-345\n```\n344:   def render(data)\n345: end\n```\n\n### PROTOCOL: `Parsable`\n> Signature: `defprotocol Parsable do`\n> Lines: 347-349\n```\n347: defprotocol Parsable do\n348:   def parse(data)\n349: end\n```\n\n### FUNCTION: `parse`\n> Signature: `def parse(data)`\n> Lines: 348-349\n```\n348:   def parse(data)\n349: end\n```\n\n### PROTOCOL: `Validatable`\n> Signature: `defprotocol Validatable do`\n> Lines: 351-353\n```\n351: defprotocol Validatable do\n352:   def validate(data)\n353: end\n```\n\n### FUNCTION: `validate`\n> Signature: `def validate(data)`\n> Lines: 352-353\n```\n352:   def validate(data)\n353: end\n```\n\n### IMPL: `Auditable`\n> Signature: `defimpl Auditable, for: Any do`\n> Lines: 355-357\n```\n355: defimpl Auditable, for: Any do\n356:   def audit(data), do: data\n357: end\n```\n\n### FUNCTION: `audit`\n> Signature: `def audit(data), do: data`\n> Lines: 356-357\n```\n356:   def audit(data), do: data\n357: end\n```\n\n### IMPL: `Renderable`\n> Signature: `defimpl Renderable, for: Any do`\n> Lines: 359-361\n```\n359: defimpl Renderable, for: Any do\n360:   def render(data), do: data\n361: end\n```\n\n### FUNCTION: `render`\n> Signature: `def render(data), do: data`\n> Lines: 360-361\n```\n360:   def render(data), do: data\n361: end\n```\n\n### IMPL: `Parsable`\n> Signature: `defimpl Parsable, for: Any do`\n> Lines: 363-365\n```\n363: defimpl Parsable, for: Any do\n364:   def parse(data), do: data\n365: end\n```\n\n### FUNCTION: `parse`\n> Signature: `def parse(data), do: data`\n> Lines: 364-365\n```\n364:   def parse(data), do: data\n365: end\n```\n\n### IMPL: `Validatable`\n> Signature: `defimpl Validatable, for: Any do`\n> Lines: 367-369\n```\n367: defimpl Validatable, for: Any do\n368:   def validate(data), do: data\n369: end\n```\n\n### FUNCTION: `validate`\n> Signature: `def validate(data), do: data`\n> Lines: 368-369\n```\n368:   def validate(data), do: data\n369: end\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```\n372: defmodule ReqCoverElixir do\n378:   def req_cover_elixir_1(value), do: value + 1\n385:   def req_cover_elixir_2(value), do: value + 2\n392:   def req_cover_elixir_3(value), do: value + 3\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\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```\n378:   def req_cover_elixir_1(value), do: value + 1\n385:   def req_cover_elixir_2(value), do: value + 2\n392:   def req_cover_elixir_3(value), do: value + 3\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\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```\n385:   def req_cover_elixir_2(value), do: value + 2\n392:   def req_cover_elixir_3(value), do: value + 3\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\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```\n392:   def req_cover_elixir_3(value), do: value + 3\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\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```\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\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```\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_go.go | go\n\n### MODULE: `main`\n> Signature: `package main`\n> Lines: 12-48\n```\n12: package main\n14: import (\n15: \t\"context\"\n16: \t\"fmt\"\n17: \t\"io\"\n18: \t\"sync\"\n19: )\n24: const MaxSize = 100\n27: var globalVar = 0\n30: const (\n32: \tLogDebug = iota\n34: \tLogInfo\n36: \tLogError\n37: )\n43: type Server struct {\n44: \tPort int\n45: \tHost string\n46: \tsync.Mutex\n47: \thandlers map[string]HandlerFunc\n48: }\n```\n\n### IMPORT: `(`\n> Lines: 14-14\n```\n14: import (\n```\n\n### CONSTANT: `MaxSize`\n> Signature: `const MaxSize = 100`\n> Lines: 24-24\n```\n24: const MaxSize = 100\n```\n\n### CONSTANT: `globalVar`\n> Signature: `var globalVar = 0`\n> Lines: 27-27\n```\n27: var globalVar = 0\n```\n\n### STRUCT: `Server`\n> Signature: `type Server struct`\n> Lines: 43-48\n```\n43: type Server struct {\n44: \tPort int\n45: \tHost string\n46: \tsync.Mutex\n47: \thandlers map[string]HandlerFunc\n48: }\n```\n\n### TYPE_ALIAS: `HandlerFunc`\n> Signature: `type HandlerFunc func(ctx context.Context, req []byte) ([]byte, error)`\n> Lines: 51-51\n```\n51: type HandlerFunc func(ctx context.Context, req []byte) ([]byte, error)\n```\n\n### STRUCT: `Address`\n> Signature: `type Address struct`\n> Lines: 54-58\n```\n54: type Address struct {\n55: \tStreet string\n56: \tCity   string\n57: \tZip    string\n58: }\n```\n\n### STRUCT: `Employee`\n> Signature: `type Employee struct`\n> Lines: 61-66\n```\n61: type Employee struct {\n62: \tName    string\n63: \tAge     int\n64: \tAddress\n65: \tManager *Employee\n66: }\n```\n\n### INTERFACE: `Handler`\n> Signature: `type Handler interface`\n> Lines: 71-74\n```\n71: type Handler interface {\n73: \tHandle(ctx context.Context, data []byte) error\n74: }\n```\n\n### INTERFACE: `ReadWriteCloser`\n> Signature: `type ReadWriteCloser interface`\n> Lines: 77-81\n```\n77: type ReadWriteCloser interface {\n78: \tio.Reader\n79: \tio.Writer\n80: \tio.Closer\n81: }\n```\n\n### TYPE_ALIAS: `MyInt`\n> Signature: `type MyInt int`\n> Lines: 86-86\n```\n86: type MyInt int\n```\n\n### METHOD: `String`\n> Signature: `func (m MyInt) String() string`\n> Lines: 89-91\n```\n89: func (m MyInt) String() string {\n90: \treturn fmt.Sprintf(\"MyInt(%d)\", int(m))\n91: }\n```\n\n### INTERFACE: `Ordered`\n> Signature: `type Ordered interface`\n> Lines: 104-106\n```\n104: type Ordered interface {\n105: \t~int | ~float64 | ~string\n106: }\n```\n\n### FUNCTION: `main`\n> Signature: `func main()`\n> Lines: 111-113\n```\n111: func main() {\n112: \tfmt.Println(\"hello\")\n113: }\n```\n\n### FUNCTION: `init`\n> Signature: `func init()`\n> Lines: 116-119\n```\n116: func init() {\n118: \tglobalVar = 1\n119: }\n```\n\n### METHOD: `Start`\n> Signature: `func (s *Server) Start() error`\n> Lines: 123-132\n```\n123: func (s *Server) Start() error {\n124: \ts.Lock()\n125: \tdefer s.Unlock()\n127: \tif s.Port <= 0 {\n128: \t\treturn fmt.Errorf(\"invalid port: %d\", s.Port)\n129: \t}\n130: \tfmt.Printf(\"Starting on %s:%d\\n\", s.Host, s.Port)\n131: \treturn nil\n132: }\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```\n138: func (s *Server) Register(path string, handler HandlerFunc) {\n139: \tif s.handlers == nil {\n140: \t\ts.handlers = make(map[string]HandlerFunc)\n141: \t}\n142: \ts.handlers[path] = handler\n143: }\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```\n180: func Divide(a, b int) (int, int, error) {\n181: \tif b == 0 {\n182: \t\treturn 0, 0, fmt.Errorf(\"division by zero\")\n183: \t}\n184: \treturn a / b, a % b, nil\n185: }\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```\n192: func ParseConfig(input string) (host string, port int, err error) {\n194: \t_, scanErr := fmt.Sscanf(input, \"%s:%d\", &host, &port)\n195: \tif scanErr != nil {\n196: \t\terr = scanErr\n197: \t\treturn\n198: \t}\n199: \treturn\n200: }\n```\n\n### FUNCTION: `Counter`\n> Signature: `func Counter() func() int`\n> Lines: 206-213\n- @return Closure yielding successive integer counts.\n```\n206: func Counter() func() int {\n207: \tcount := 0\n208: \treturn func() int {\n210: \t\tcount++\n211: \t\treturn count\n212: \t}\n213: }\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```\n221: func FanOut(items []string, workers int) <-chan string {\n222: \tresults := make(chan string, len(items))\n223: \tvar wg sync.WaitGroup\n225: \tfor i := 0; i < workers; i++ {\n226: \t\twg.Add(1)\n227: \t\tgo func(id int) {\n228: \t\t\tdefer wg.Done()\n230: \t\t\tfor _, item := range items {\n231: \t\t\t\tresults <- fmt.Sprintf(\"[%d] %s\", id, item)\n232: \t\t\t}\n233: \t\t}(i)\n234: \t}\n237: \tgo func() {\n238: \t\twg.Wait()\n239: \t\tclose(results)\n240: \t}()\n242: \treturn results\n243: }\n```\n\n### CONSTANT: `wg`\n> Signature: `\tvar wg sync.WaitGroup`\n> Lines: 223-223\n```\n223: \tvar wg sync.WaitGroup\n```\n\n### FUNCTION: `Describe`\n> Signature: `func Describe(v interface{}) string`\n> Lines: 250-266\n- @param v Any value to describe.\n- @return Human-readable type description.\n```\n250: func Describe(v interface{}) string {\n251: \tswitch val := v.(type) {\n252: \tcase int:\n253: \t\treturn fmt.Sprintf(\"int: %d\", val)\n254: \tcase string:\n255: \t\treturn fmt.Sprintf(\"string: %q\", val)\n256: \tcase bool:\n257: \t\tif val {\n258: \t\t\treturn \"bool: true\"\n259: \t\t}\n260: \t\treturn \"bool: false\"\n261: \tcase nil:\n262: \t\treturn \"nil\"\n263: \tdefault:\n264: \t\treturn fmt.Sprintf(\"unknown: %T\", val)\n265: \t}\n266: }\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```\n273: func SafeExecute(fn func()) (err error) {\n274: \tdefer func() {\n275: \t\tif r := recover(); r != nil {\n277: \t\t\terr = fmt.Errorf(\"panic: %v\", r)\n278: \t\t}\n279: \t}()\n280: \tfn()\n281: \treturn nil\n282: }\n```\n\n### MODULE: `utilx`\n> Signature: `package utilx`\n> Lines: 285-293\n```\n285: package utilx\n286: package configx\n287: package jobsx\n288: package metricx\n289: import \"os\"\n290: import \"time\"\n291: import \"strings\"\n292: import \"bytes\"\n293: func (s *Server) Stop() {}\n```\n\n### MODULE: `configx`\n> Signature: `package configx`\n> Lines: 286-293\n```\n286: package configx\n287: package jobsx\n288: package metricx\n289: import \"os\"\n290: import \"time\"\n291: import \"strings\"\n292: import \"bytes\"\n293: func (s *Server) Stop() {}\n```\n\n### MODULE: `jobsx`\n> Signature: `package jobsx`\n> Lines: 287-293\n```\n287: package jobsx\n288: package metricx\n289: import \"os\"\n290: import \"time\"\n291: import \"strings\"\n292: import \"bytes\"\n293: func (s *Server) Stop() {}\n```\n\n### MODULE: `metricx`\n> Signature: `package metricx`\n> Lines: 288-293\n```\n288: package metricx\n289: import \"os\"\n290: import \"time\"\n291: import \"strings\"\n292: import \"bytes\"\n293: func (s *Server) Stop() {}\n```\n\n### IMPORT: `\"os\"`\n> Lines: 289-289\n```\n289: import \"os\"\n```\n\n### IMPORT: `\"time\"`\n> Lines: 290-290\n```\n290: import \"time\"\n```\n\n### IMPORT: `\"strings\"`\n> Lines: 291-291\n```\n291: import \"strings\"\n```\n\n### IMPORT: `\"bytes\"`\n> Lines: 292-292\n```\n292: import \"bytes\"\n```\n\n### METHOD: `Stop`\n> Signature: `func (s *Server) Stop() {}`\n> Lines: 293-293\n```\n293: func (s *Server) Stop() {}\n```\n\n### METHOD: `Reset`\n> Signature: `func (s *Server) Reset() {}`\n> Lines: 294-294\n```\n294: func (s *Server) Reset() {}\n```\n\n### STRUCT: `Session`\n> Signature: `type Session struct { Id string }`\n> Lines: 295-295\n```\n295: type Session struct { Id string }\n```\n\n### STRUCT: `Bucket`\n> Signature: `type Bucket struct { Name string }`\n> Lines: 296-296\n```\n296: type Bucket struct { Name string }\n```\n\n### INTERFACE: `Closer`\n> Signature: `type Closer interface { Close() error }`\n> Lines: 297-297\n```\n297: type Closer interface { Close() error }\n```\n\n### INTERFACE: `Starter`\n> Signature: `type Starter interface { Start() error }`\n> Lines: 298-298\n```\n298: type Starter interface { Start() error }\n```\n\n### TYPE_ALIAS: `UserAlias`\n> Signature: `type UserAlias string`\n> Lines: 299-299\n```\n299: type UserAlias string\n```\n\n### TYPE_ALIAS: `Amount`\n> Signature: `type Amount int`\n> Lines: 300-300\n```\n300: type Amount int\n```\n\n### TYPE_ALIAS: `Resolver`\n> Signature: `type Resolver func(string) error`\n> Lines: 301-301\n```\n301: type Resolver func(string) error\n```\n\n### CONSTANT: `RetryCount`\n> Signature: `const RetryCount = 3`\n> Lines: 302-302\n```\n302: const RetryCount = 3\n```\n\n### CONSTANT: `LastError`\n> Signature: `var LastError error`\n> Lines: 303-303\n```\n303: var 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```\n311: func 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```\n318: func 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```\n325: func 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```\n332: func 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```\n339: func reqCoverGo5(value int) int { return value + 5 }\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_haskell.hs | haskell\n\n### MODULE: `MyModule`\n> Signature: `module MyModule`\n> Lines: 11-21\n```\n11: module MyModule\n12:   ( Name\n13:   , Person(..)\n14:   , Printable(..)\n15:   , Expr(..)\n16:   , greet\n17:   , safeDiv\n18:   , processList\n19:   , fibonacci\n20:   ) where\n```\n\n### IMPORT: `Data.List (sort, nub, intercalate)`\n> Lines: 22-22\n```\n22: import Data.List (sort, nub, intercalate)\n```\n\n### IMPORT: `Data.Maybe (fromMaybe, isJust)`\n> Lines: 23-23\n```\n23: import Data.Maybe (fromMaybe, isJust)\n```\n\n### IMPORT: `Data.Map as Map`\n> Lines: 24-24\n```\n24: import qualified Data.Map as Map\n```\n\n### IMPORT: `Control.Monad (when, unless, forM_)`\n> Lines: 25-25\n```\n25: import Control.Monad (when, unless, forM_)\n```\n\n### TYPE_ALIAS: `Name`\n> Signature: `type Name = String`\n> Lines: 30-30\n```\n30: type Name = String\n```\n\n### TYPE_ALIAS: `Config`\n> Signature: `type Config = Map.Map String Int`\n> Lines: 33-33\n```\n33: type Config = Map.Map String Int\n```\n\n### TYPE_ALIAS: `Transform`\n> Signature: `type Transform a = a -> a`\n> Lines: 36-36\n```\n36: type Transform a = a -> a\n```\n\n### STRUCT: `Person`\n> Signature: `data Person = Person`\n> Lines: 42-46\n```\n42: data Person = Person\n43:   { personName :: String\n44:   , personAge  :: Int\n45:   } deriving (Show, Eq, Ord)\n```\n\n### STRUCT: `Tree`\n> Signature: `data Tree a`\n> Lines: 49-53\n```\n49: data Tree a\n50:   = Leaf\n51:   | Node a (Tree a) (Tree a)\n52:   deriving (Show, Eq)\n```\n\n### STRUCT: `Expr`\n> Signature: `data Expr`\n> Lines: 56-62\n```\n56: data Expr\n57:   = Lit Double\n58:   | Add Expr Expr\n59:   | Mul Expr Expr\n60:   | Neg Expr\n61:   deriving (Show)\n```\n\n### STRUCT: `Result`\n> Signature: `data Result a`\n> Lines: 64-68\n```\n64: data Result a\n65:   = Ok a\n66:   | Err String\n67:   deriving (Show)\n```\n\n### CLASS: `Printable`\n> Signature: `class Printable a where`\n> Lines: 72-79\n```\n72: class Printable a where\n74:   printIt :: a -> String\n77:   debugPrint :: a -> String\n78:   debugPrint x = \"Debug: \" ++ printIt x\n```\n\n### CLASS: `Serializable`\n> Signature: `class Serializable a where`\n> Lines: 81-84\n```\n81: class Serializable a where\n83:   serialize :: a -> [(String, String)]\n```\n\n### FUNCTION: `greet`\n> Signature: `greet :: String -> String`\n> Lines: 112-112\n```\n112: greet :: String -> String\n```\n\n### FUNCTION: `safeDiv`\n> Signature: `safeDiv :: Double -> Double -> Maybe Double`\n> Lines: 117-117\n```\n117: safeDiv :: Double -> Double -> Maybe Double\n```\n\n### FUNCTION: `eval`\n> Signature: `eval :: Expr -> Double`\n> Lines: 123-123\n```\n123: eval :: Expr -> Double\n```\n\n### FUNCTION: `processList`\n> Signature: `processList :: [Int] -> [Int]`\n> Lines: 131-131\n```\n131: processList :: [Int] -> [Int]\n```\n\n### FUNCTION: `fibonacci`\n> Signature: `fibonacci :: Int -> Integer`\n> Lines: 143-143\n```\n143: fibonacci :: Int -> Integer\n```\n\n### FUNCTION: `insertTree`\n> Signature: `insertTree :: (Ord a) => a -> Tree a -> Tree a`\n> Lines: 155-155\n```\n155: insertTree :: (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```\n164: foldTree :: (b -> a -> b) -> b -> Tree a -> b\n```\n\n### FUNCTION: `lookupConfig`\n> Signature: `lookupConfig :: Config -> String -> Int -> Int`\n> Lines: 173-173\n```\n173: lookupConfig :: Config -> String -> Int -> Int\n```\n\n### FUNCTION: `applyN`\n> Signature: `applyN :: Int -> Transform a -> a -> a`\n> Lines: 178-178\n```\n178: applyN :: Int -> Transform a -> a -> a\n```\n\n### FUNCTION: `formatPersons`\n> Signature: `formatPersons :: (Printable a) => [a] -> String`\n> Lines: 184-184\n```\n184: formatPersons :: (Printable a) => [a] -> String\n```\n\n### FUNCTION: `safeCompute`\n> Signature: `safeCompute :: Double -> Double -> Double -> Maybe Double`\n> Lines: 189-189\n```\n189: safeCompute :: Double -> Double -> Double -> Maybe Double\n```\n\n### MODULE: `Extra.One`\n> Signature: `module Extra.One where`\n> Lines: 197-197\n```\n197: module Extra.One where\n```\n\n### MODULE: `Extra.Two`\n> Signature: `module Extra.Two where`\n> Lines: 198-198\n```\n198: module Extra.Two where\n```\n\n### MODULE: `Extra.Three`\n> Signature: `module Extra.Three where`\n> Lines: 199-199\n```\n199: module Extra.Three where\n```\n\n### MODULE: `Extra.Four`\n> Signature: `module Extra.Four where`\n> Lines: 200-200\n```\n200: module Extra.Four where\n```\n\n### IMPORT: `Data.Set as Set`\n> Lines: 201-201\n```\n201: import qualified Data.Set as Set\n```\n\n### TYPE_ALIAS: `RequestId`\n> Signature: `type RequestId = Int`\n> Lines: 202-202\n```\n202: type RequestId = Int\n```\n\n### TYPE_ALIAS: `ResponseId`\n> Signature: `type ResponseId = Int`\n> Lines: 203-203\n```\n203: type ResponseId = Int\n```\n\n### CLASS: `Renderable`\n> Signature: `class Renderable a where`\n> Lines: 204-204\n```\n204: class Renderable a where\n```\n\n### CLASS: `Parsable`\n> Signature: `class Parsable a where`\n> Lines: 205-205\n```\n205: class Parsable a where\n```\n\n### CLASS: `Executable`\n> Signature: `class Executable a where`\n> Lines: 206-206\n```\n206: class Executable a where\n```\n\n### STRUCT: `Envelope`\n> Signature: `data Envelope = Envelope String`\n> Lines: 207-208\n```\n207: data 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```\n215: reqCoverHaskell1 :: 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```\n223: reqCoverHaskell2 :: 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```\n231: reqCoverHaskell3 :: 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```\n239: reqCoverHaskell4 :: 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```\n247: reqCoverHaskell5 :: Int -> Int\n```\n",
-  "stderr": ""
-}