pi-usereq 0.49.0 → 0.51.0

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_java.java | java\n- @brief Comprehensive Java test fixture for parser validation.\n- @details Covers generics with wildcards, sealed classes, records, inner classes,\nanonymous classes, lambdas, method references, switch expressions,\ntry-with-resources, annotations, and default interface methods.\n\n### MODULE: `com.example.app`\n> Signature: `package com.example.app`\n> Lines: 11-29\n```\n11: package com.example.app;\n13: import java.util.List;\n14: import java.util.Map;\n15: import java.util.Optional;\n16: import java.util.function.Function;\n17: import java.util.function.Predicate;\n18: import java.util.stream.Collectors;\n19: import static java.lang.Math.PI;\n27: @interface RequiresAuth {\n28: String role() default \"user\";\n29: }\n```\n\n### IMPORT: `java.util.List`\n> Lines: 13-13\n```\n13: import java.util.List;\n```\n\n### IMPORT: `java.util.Map`\n> Lines: 14-14\n```\n14: import java.util.Map;\n```\n\n### IMPORT: `java.util.Optional`\n> Lines: 15-15\n```\n15: import java.util.Optional;\n```\n\n### IMPORT: `java.util.function.Function`\n> Lines: 16-16\n```\n16: import java.util.function.Function;\n```\n\n### IMPORT: `java.util.function.Predicate`\n> Lines: 17-17\n```\n17: import java.util.function.Predicate;\n```\n\n### IMPORT: `java.util.stream.Collectors`\n> Lines: 18-18\n```\n18: import java.util.stream.Collectors;\n```\n\n### IMPORT: `java.lang.Math.PI`\n> Lines: 19-19\n```\n19: import static java.lang.Math.PI;\n```\n\n### DECORATOR: `interface`\n> Lines: 27-27\n- @brief Marks a method as requiring authentication before invocation.\n- @param role The minimum role level required for access.\n```\n27: @interface RequiresAuth {\n```\n\n### FUNCTION: `role`\n> Signature: `String role() default \"user\"`\n> Lines: 28-39\n```\n28: String role() default \"user\";\n29: }\n38: @SuppressWarnings(\"unchecked\")\n39: public class MyClass<T extends Comparable<T>> {\n```\n\n### DECORATOR: `SuppressWarnings(\"unchecked\")`\n> Lines: 38-38\n- @brief Primary class demonstrating various Java constructs.\n- @param <T> Generic type parameter for flexible data handling.\n```\n38: @SuppressWarnings(\"unchecked\")\n```\n\n### CLASS: `MyClass`\n> Signature: `public class MyClass<T extends Comparable<T>>`\n> Lines: 39-165\n- @brief Maximum buffer size constant.\n```\n39: public class MyClass<T extends Comparable<T>> {\n42: public static final int MAX_SIZE = 100;\n45: private List<T> items;\n51: public MyClass(List<T> items) {\n52: this.items = items;\n53: }\n59: public void greet(String name) {\n61: if (name == null) {\n62: return;\n63: }\n64: System.out.println(\"Hello, \" + name);\n65: }\n71: private static String helper() {\n72: return \"ok\";\n73: }\n80: public Optional<T> findFirst(Predicate<T> predicate) {\n81: for (T item : items) {\n83: if (predicate.test(item)) {\n84: return Optional.of(item);\n85: }\n86: }\n87: return Optional.empty();\n88: }\n96: public <R> List<R> map(Function<T, R> mapper) {\n97: return items.stream()\n98: .map(mapper)\n99: .collect(Collectors.toList());\n100: }\n107: public double sumWildcard(List<? extends Number> source) {\n108: double total = 0.0;\n109: for (Number n : source) {\n110: total += n.doubleValue();\n111: }\n112: return total;\n113: }\n121: public class Builder {\n122: private List<T> pending;\n129: public Builder add(T item) {\n130: pending.add(item);\n131: return this;\n132: }\n138: public MyClass<T> build() {\n139: return new MyClass<>(pending);\n140: }\n141: }\n149: public static class Config {\n151: public final String key;\n153: public final Object value;\n160: public Config(String key, Object value) {\n161: this.key = key;\n162: this.value = value;\n163: }\n164: }\n165: }\n```\n\n### CONSTANT: `MAX_SIZE`\n> Signature: `public static final int MAX_SIZE = 100`\n> Lines: 42-42\n- @brief Maximum buffer size constant. */\n```\n42: public static final int MAX_SIZE = 100;\n```\n\n### FUNCTION: `MyClass`\n> Signature: `public MyClass(List<T> items)`\n> Lines: 51-53\n- @brief Construct MyClass with an initial item list.\n- @param items The starting collection of items.\n```\n51: public MyClass(List<T> items) {\n52: this.items = items;\n53: }\n```\n\n### FUNCTION: `greet`\n> Signature: `public void greet(String name)`\n> Lines: 59-65\n- @brief Greet a person by name on standard output.\n- @param name The person's name; must not be null.\n```\n59: public void greet(String name) {\n61: if (name == null) {\n62: return;\n63: }\n64: System.out.println(\"Hello, \" + name);\n65: }\n```\n\n### FUNCTION: `helper`\n> Signature: `private static String helper()`\n> Lines: 71-73\n- @brief Helper method returning a status string.\n- @return Always returns \"ok\".\n```\n71: private static String helper() {\n72: return \"ok\";\n73: }\n```\n\n### FUNCTION: `findFirst`\n> Signature: `public Optional<T> findFirst(Predicate<T> predicate)`\n> Lines: 80-88\n- @brief Find the first item matching a predicate.\n- @param predicate Filter condition for items.\n- @return Optional containing the first match, or empty.\n```\n80: public Optional<T> findFirst(Predicate<T> predicate) {\n81: for (T item : items) {\n83: if (predicate.test(item)) {\n84: return Optional.of(item);\n85: }\n86: }\n87: return Optional.empty();\n88: }\n```\n\n### FUNCTION: `map`\n> Signature: `public <R> List<R> map(Function<T, R> mapper)`\n> Lines: 96-100\n- @brief Transform all items using a mapping function.\n- @param <R> The result type after transformation.\n- @param mapper Function to apply to each item.\n- @return List of transformed results.\n```\n96: public <R> List<R> map(Function<T, R> mapper) {\n97: return items.stream()\n98: .map(mapper)\n99: .collect(Collectors.toList());\n100: }\n```\n\n### FUNCTION: `sumWildcard`\n> Signature: `public double sumWildcard(List<? extends Number> source)`\n> Lines: 107-113\n- @brief Process items with a wildcard-bounded list.\n- @param source List of items extending Number.\n- @return Sum of all numeric values as double.\n```\n107: public double sumWildcard(List<? extends Number> source) {\n108: double total = 0.0;\n109: for (Number n : source) {\n110: total += n.doubleValue();\n111: }\n112: return total;\n113: }\n```\n\n### CLASS: `Builder`\n> Signature: `public class Builder`\n> Lines: 121-141\n- @brief Inner builder class for constructing MyClass instances.\n- @brief Add an item to the builder.\n- @param item Item to include in the built instance.\n- @return This builder for chaining.\n```\n121: public class Builder {\n122: private List<T> pending;\n129: public Builder add(T item) {\n130: pending.add(item);\n131: return this;\n132: }\n138: public MyClass<T> build() {\n139: return new MyClass<>(pending);\n140: }\n141: }\n```\n\n### FUNCTION: `add`\n> Signature: `public Builder add(T item)`\n> Lines: 129-132\n- @brief Add an item to the builder.\n- @param item Item to include in the built instance.\n- @return This builder for chaining.\n```\n129: public Builder add(T item) {\n130: pending.add(item);\n131: return this;\n132: }\n```\n\n### FUNCTION: `build`\n> Signature: `public MyClass<T> build()`\n> Lines: 138-140\n- @brief Finalize and create the MyClass instance.\n- @return A new MyClass populated with accumulated items.\n```\n138: public MyClass<T> build() {\n139: return new MyClass<>(pending);\n140: }\n```\n\n### CLASS: `Config`\n> Signature: `public static class Config`\n> Lines: 149-164\n- @brief Static configuration holder with validation.\n- @brief Configuration key string.\n- @brief Configuration value.\n```\n149: public static class Config {\n151: public final String key;\n153: public final Object value;\n160: public Config(String key, Object value) {\n161: this.key = key;\n162: this.value = value;\n163: }\n164: }\n```\n\n### FUNCTION: `Config`\n> Signature: `public Config(String key, Object value)`\n> Lines: 160-163\n- @brief Construct a Config entry.\n- @param key The configuration key.\n- @param value The associated value.\n```\n160: public Config(String key, Object value) {\n161: this.key = key;\n162: this.value = value;\n163: }\n```\n\n### INTERFACE: `Greeter`\n> Signature: `public interface Greeter`\n> Lines: 173-196\n- @brief Functional interface for greeting operations.\n- @brief Perform a greeting to the named person.\n- @param name Recipient of the greeting.\n```\n173: public interface Greeter {\n178: void sayHello(String name);\n184: default void sayGoodbye(String name) {\n185: System.out.println(\"Goodbye, \" + name);\n186: }\n192: static Greeter simple() {\n194: return name -> System.out.println(\"Hi, \" + name);\n195: }\n196: }\n```\n\n### FUNCTION: `sayHello`\n> Signature: `void sayHello(String name)`\n> Lines: 178-186\n- @brief Perform a greeting to the named person.\n- @brief Default farewell method with implementation.\n- @param name Recipient of the greeting.\n- @param name Person to bid farewell.\n```\n178: void sayHello(String name);\n184: default void sayGoodbye(String name) {\n185: System.out.println(\"Goodbye, \" + name);\n186: }\n```\n\n### FUNCTION: `simple`\n> Signature: `static Greeter simple()`\n> Lines: 192-195\n- @brief Static factory creating a simple Greeter.\n- @return A Greeter that prints to stdout.\n```\n192: static Greeter simple() {\n194: return name -> System.out.println(\"Hi, \" + name);\n195: }\n```\n\n### ENUM: `Color`\n> Signature: `public enum Color`\n> Lines: 204-230\n- @brief Color enum with associated hex values and behavior.\n- @brief Red color with hex #FF0000.\n- @brief Green color with hex #00FF00.\n```\n204: public enum Color {\n206: RED(\"#FF0000\"),\n208: GREEN(\"#00FF00\"),\n210: BLUE(\"#0000FF\");\n213: private final String hex;\n219: Color(String hex) {\n220: this.hex = hex;\n221: }\n227: public String getHex() {\n228: return hex;\n229: }\n230: }\n```\n\n### FUNCTION: `getHex`\n> Signature: `public String getHex()`\n> Lines: 227-229\n- @brief Get the hex code of this color.\n- @return Hex string including '#' prefix.\n```\n227: public String getHex() {\n228: return hex;\n229: }\n```\n\n### FUNCTION: `Point`\n> Signature: `public record Point(double x, double y)`\n> Lines: 240-261\n- @brief Immutable 2D coordinate record.\n- @brief Compact constructor validating coordinates.\n- @param x Horizontal coordinate.\n- @param y Vertical coordinate.\n- @throws IllegalArgumentException If either coordinate is NaN.\n```\n240: public record Point(double x, double y) {\n245: public Point {\n246: if (Double.isNaN(x) || Double.isNaN(y)) {\n247: throw new IllegalArgumentException(\"NaN coordinates\");\n248: }\n249: }\n256: public double distanceTo(Point other) {\n257: double dx = this.x - other.x;\n258: double dy = this.y - other.y;\n259: return Math.sqrt(dx * dx + dy * dy);\n260: }\n261: }\n```\n\n### FUNCTION: `distanceTo`\n> Signature: `public double distanceTo(Point other)`\n> Lines: 256-260\n- @brief Compute distance to another point.\n- @param other Target point.\n- @return Euclidean distance.\n```\n256: public double distanceTo(Point other) {\n257: double dx = this.x - other.x;\n258: double dy = this.y - other.y;\n259: return Math.sqrt(dx * dx + dy * dy);\n260: }\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 274-276\n- @brief Compute the area of this shape.\n- @return Area as a double; subclasses provide implementation.\n```\n274: public double area() {\n275: return 0.0;\n276: }\n```\n\n### CLASS: `Circle`\n> Signature: `public final class Circle extends Shape`\n> Lines: 284-304\n- @brief Circle shape with radius-based area computation.\n- @brief Radius of the circle.\n```\n284: public final class Circle extends Shape {\n286: private final double radius;\n292: public Circle(double radius) {\n293: this.radius = radius;\n294: }\n300: @Override\n301: public double area() {\n302: return PI * radius * radius;\n303: }\n304: }\n```\n\n### FUNCTION: `Circle`\n> Signature: `public Circle(double radius)`\n> Lines: 292-294\n- @brief Construct a circle with a given radius.\n- @param radius Non-negative radius value.\n```\n292: public Circle(double radius) {\n293: this.radius = radius;\n294: }\n```\n\n### DECORATOR: `Override`\n> Lines: 300-300\n- @brief Compute circle area using π×r².\n- @return The area of the circle.\n```\n300: @Override\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 301-303\n```\n301: public double area() {\n302: return PI * radius * radius;\n303: }\n```\n\n### CLASS: `Rectangle`\n> Signature: `public final class Rectangle extends Shape`\n> Lines: 311-324\n- @brief Rectangle shape with width and height.\n```\n311: public final class Rectangle extends Shape {\n312: private final double width;\n313: private final double height;\n315: public Rectangle(double width, double height) {\n316: this.width = width;\n317: this.height = height;\n318: }\n320: @Override\n321: public double area() {\n322: return width * height;\n323: }\n324: }\n```\n\n### FUNCTION: `Rectangle`\n> Signature: `public Rectangle(double width, double height)`\n> Lines: 315-318\n```\n315: public Rectangle(double width, double height) {\n316: this.width = width;\n317: this.height = height;\n318: }\n```\n\n### DECORATOR: `Override`\n> Lines: 320-320\n```\n320: @Override\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 321-323\n```\n321: public double area() {\n322: return width * height;\n323: }\n```\n\n### CLASS: `Evaluator`\n> Signature: `public class Evaluator`\n> Lines: 332-361\n- @brief Demonstrates switch expressions and try-with-resources.\n- @brief Describe a shape using pattern matching switch expression.\n- @param shape The shape to describe.\n- @return Human-readable description string.\n```\n332: public class Evaluator {\n339: public static String describe(Shape shape) {\n341: return switch (shape) {\n342: case Circle c -> \"Circle with radius \" + c.area();\n343: case Rectangle r -> \"Rectangle with area \" + r.area();\n344: default -> \"Unknown shape\";\n345: };\n346: }\n354: @RequiresAuth(role = \"admin\")\n355: public static String readFile(String path) throws java.io.IOException {\n357: try (var reader = new java.io.BufferedReader(new java.io.FileReader(path))) {\n358: return reader.lines().collect(Collectors.joining(\"\\n\"));\n359: }\n360: }\n361: }\n```\n\n### FUNCTION: `describe`\n> Signature: `public static String describe(Shape shape)`\n> Lines: 339-346\n- @brief Describe a shape using pattern matching switch expression.\n- @param shape The shape to describe.\n- @return Human-readable description string.\n```\n339: public static String describe(Shape shape) {\n341: return switch (shape) {\n342: case Circle c -> \"Circle with radius \" + c.area();\n343: case Rectangle r -> \"Rectangle with area \" + r.area();\n344: default -> \"Unknown shape\";\n345: };\n346: }\n```\n\n### FUNCTION: `switch`\n> Signature: `return switch (shape)`\n> Lines: 341-345\n```\n341: return switch (shape) {\n342: case Circle c -> \"Circle with radius \" + c.area();\n343: case Rectangle r -> \"Rectangle with area \" + r.area();\n344: default -> \"Unknown shape\";\n345: };\n```\n\n### DECORATOR: `RequiresAuth(role = \"admin\")`\n> Lines: 354-354\n- @brief Read a file safely with try-with-resources.\n- @param path File system path to read.\n- @return File contents as a string.\n- @throws java.io.IOException If the file cannot be read.\n```\n354: @RequiresAuth(role = \"admin\")\n```\n\n### FUNCTION: `readFile`\n> Signature: `public static String readFile(String path) throws java.io.IOException`\n> Lines: 355-360\n```\n355: public static String readFile(String path) throws java.io.IOException {\n357: try (var reader = new java.io.BufferedReader(new java.io.FileReader(path))) {\n358: return reader.lines().collect(Collectors.joining(\"\\n\"));\n359: }\n360: }\n```\n\n### MODULE: `com.example.extra.one`\n> Signature: `package com.example.extra.one`\n> Lines: 364-368\n```\n364: package com.example.extra.one;\n365: package com.example.extra.two;\n366: package com.example.extra.three;\n367: package com.example.extra.four;\n368: interface Runner {}\n```\n\n### MODULE: `com.example.extra.two`\n> Signature: `package com.example.extra.two`\n> Lines: 365-368\n```\n365: package com.example.extra.two;\n366: package com.example.extra.three;\n367: package com.example.extra.four;\n368: interface Runner {}\n```\n\n### MODULE: `com.example.extra.three`\n> Signature: `package com.example.extra.three`\n> Lines: 366-368\n```\n366: package com.example.extra.three;\n367: package com.example.extra.four;\n368: interface Runner {}\n```\n\n### MODULE: `com.example.extra.four`\n> Signature: `package com.example.extra.four`\n> Lines: 367-368\n```\n367: package com.example.extra.four;\n368: interface Runner {}\n```\n\n### INTERFACE: `Runner`\n> Signature: `interface Runner {}`\n> Lines: 368-368\n```\n368: interface Runner {}\n```\n\n### INTERFACE: `Mapper`\n> Signature: `public interface Mapper {}`\n> Lines: 369-369\n```\n369: public interface Mapper {}\n```\n\n### INTERFACE: `Handler`\n> Signature: `public interface Handler {}`\n> Lines: 370-370\n```\n370: public interface Handler {}\n```\n\n### INTERFACE: `Auditor`\n> Signature: `public interface Auditor {}`\n> Lines: 371-371\n```\n371: public interface Auditor {}\n```\n\n### ENUM: `ModeJava`\n> Signature: `enum ModeJava { FAST, SAFE }`\n> Lines: 372-372\n```\n372: enum ModeJava { FAST, SAFE }\n```\n\n### ENUM: `PhaseJava`\n> Signature: `enum PhaseJava { INIT, RUN }`\n> Lines: 373-373\n```\n373: enum PhaseJava { INIT, RUN }\n```\n\n### ENUM: `StatusJava`\n> Signature: `enum StatusJava { OPEN, CLOSED }`\n> Lines: 374-374\n```\n374: enum StatusJava { OPEN, CLOSED }\n```\n\n### ENUM: `KindJava`\n> Signature: `enum KindJava { A, B }`\n> Lines: 375-375\n```\n375: enum KindJava { A, B }\n```\n\n### CONSTANT: `DEFAULT_LIMIT`\n> Signature: `public static final int DEFAULT_LIMIT = 10`\n> Lines: 376-376\n```\n376: public static final int DEFAULT_LIMIT = 10;\n```\n\n### CONSTANT: `RETRY_LIMIT`\n> Signature: `public static final int RETRY_LIMIT = 3`\n> Lines: 377-377\n```\n377: public static final int RETRY_LIMIT = 3;\n```\n\n### CONSTANT: `BUFFER_SIZE`\n> Signature: `public static final int BUFFER_SIZE = 512`\n> Lines: 378-378\n```\n378: public static final int BUFFER_SIZE = 512;\n```\n\n### CONSTANT: `MAX_USERS`\n> Signature: `public static final int MAX_USERS = 99`\n> Lines: 379-379\n```\n379: public static final int MAX_USERS = 99;\n```\n\n### DECORATOR: `Trace`\n> Lines: 380-380\n```\n380: @Trace\n```\n\n### CLASS: `ReqCoverJava`\n> Signature: `class ReqCoverJava`\n> Lines: 383-429\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n383: class ReqCoverJava {\n391: static int reqCoverJava1(int value) { return value + 1; }\n400: static int reqCoverJava2(int value) { return value + 2; }\n409: static int reqCoverJava3(int value) { return value + 3; }\n418: static int reqCoverJava4(int value) { return value + 4; }\n427: static int reqCoverJava5(int value) { return value + 5; }\n429: }\n```\n\n### FUNCTION: `reqCoverJava1`\n> Signature: `static int reqCoverJava1(int value) { return value + 1; }`\n> Lines: 391-391\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n391: static int reqCoverJava1(int value) { return value + 1; }\n```\n\n### FUNCTION: `reqCoverJava2`\n> Signature: `static int reqCoverJava2(int value) { return value + 2; }`\n> Lines: 400-400\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n400: static int reqCoverJava2(int value) { return value + 2; }\n```\n\n### FUNCTION: `reqCoverJava3`\n> Signature: `static int reqCoverJava3(int value) { return value + 3; }`\n> Lines: 409-409\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n409: static int reqCoverJava3(int value) { return value + 3; }\n```\n\n### FUNCTION: `reqCoverJava4`\n> Signature: `static int reqCoverJava4(int value) { return value + 4; }`\n> Lines: 418-418\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n418: static int reqCoverJava4(int value) { return value + 4; }\n```\n\n### FUNCTION: `reqCoverJava5`\n> Signature: `static int reqCoverJava5(int value) { return value + 5; }`\n> Lines: 427-427\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n427: static int reqCoverJava5(int value) { return value + 5; }\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_javascript.js | javascript\n- @brief Comprehensive JavaScript test fixture for parser validation.\n- @details Covers classes with private fields, generators, async generators,\nproxies, symbols, IIFE, dynamic imports, destructuring, computed\nproperties, and chained promise patterns.\n\n### IMPORT: `React from 'react';`\n> Lines: 11-11\n```\n11: import React from 'react';\n```\n\n### IMPORT: `{ useState, useEffect } from 'react';`\n> Lines: 12-12\n```\n12: import { useState, useEffect } from 'react';\n```\n\n### CLASS: `MyComponent`\n> Signature: `class MyComponent`\n> Lines: 20-66\n- @brief React-like component with private fields and static initialization.\n- @brief Private instance counter, not accessible outside the class.\n```\n20: class MyComponent {\n22: #instanceId;\n25: static #registry = new Map();\n28: static {\n29: console.log('MyComponent class loaded');\n30: }\n36: constructor(id = 0) {\n37: this.#instanceId = id;\n38: MyComponent.#registry.set(id, this);\n39: }\n45: render() {\n47: return null;\n48: }\n54: getId() {\n55: return this.#instanceId;\n56: }\n63: static has(id) {\n64: return MyComponent.#registry.has(id);\n65: }\n66: }\n```\n\n### CLASS: `EnhancedComponent`\n> Signature: `class EnhancedComponent extends MyComponent`\n> Lines: 75-93\n- @brief Extended component with lifecycle hooks.\n- @brief Override render to return a div element.\n- @return {Object} A simple virtual DOM node.\n```\n75: class EnhancedComponent extends MyComponent {\n80: render() {\n82: super.render();\n83: return { type: 'div', children: [] };\n84: }\n90: componentDidMount() {\n91: console.log('mounted');\n92: }\n93: }\n```\n\n### FUNCTION: `greet`\n> Signature: `function greet(name)`\n> Lines: 103-105\n- @brief Greet a person by name.\n- @param {string} name The person's name.\n- @return {string} Greeting message.\n```\n103: function greet(name) {\n104: return \"Hello \" + name;\n105: }\n```\n\n### FUNCTION: `fetchData`\n> Signature: `async function fetchData()`\n> Lines: 112-115\n- @brief Fetch data from the API endpoint asynchronously.\n- @return {Promise<Response>} The fetch response promise.\n```\n112: async function fetchData() {\n114: return await fetch('/api');\n115: }\n```\n\n### FUNCTION: `handler`\n> Signature: `const handler = (event) =>`\n> Lines: 122-126\n- @brief Event handler arrow function for UI events.\n- @param {Event} event The DOM event object.\n```\n122: const handler = (event) => {\n124: event.preventDefault();\n125: console.log(event.type);\n126: };\n```\n\n### FUNCTION: `processItems`\n> Signature: `const processItems = ({ items, count }) =>`\n> Lines: 134-136\n- @brief Arrow function with destructuring parameter.\n- @param {{ items: Array, count: number }} param0 Destructured config.\n- @return {Array} Processed item list.\n```\n134: const processItems = ({ items, count }) => {\n135: return items.slice(0, count).map(i => i.toUpperCase());\n136: };\n```\n\n### CONSTANT: `MAX_SIZE`\n> Signature: `const MAX_SIZE = 100`\n> Lines: 141-141\n```\n141: const MAX_SIZE = 100;\n```\n\n### CONSTANT: `PLUGIN_KEY`\n> Signature: `const PLUGIN_KEY = Symbol('plugin')`\n> Lines: 144-144\n```\n144: const PLUGIN_KEY = Symbol('plugin');\n```\n\n### COMPONENT: `MyWrapped`\n> Signature: `const MyWrapped = React.memo(() =>`\n> Lines: 153-155\n- @brief Memoized functional component demonstrating React.memo usage.\n- @return {null} Renders nothing; serves as a parser test case.\n```\n153: const MyWrapped = React.memo(() => {\n154: return null;\n155: });\n```\n\n### FUNCTION: `idGenerator`\n> Signature: `function* idGenerator()`\n> Lines: 164-170\n- @brief Infinite generator producing sequential integer IDs.\n@yields {number} The next unique ID.\n```\n164: function* idGenerator() {\n165: let id = 0;\n166: while (true) {\n168: yield id++;\n169: }\n170: }\n```\n\n### FUNCTION: `rangeGenerator`\n> Signature: `function* rangeGenerator(start, end)`\n> Lines: 179-183\n- @brief Generator yielding integers in a bounded range.\n- @param {number} start Inclusive lower bound.\n- @param {number} end Exclusive upper bound.\n@yields {number} Each integer from start to end-1.\n```\n179: function* rangeGenerator(start, end) {\n180: for (let i = start; i < end; i++) {\n181: yield i;\n182: }\n183: }\n```\n\n### FUNCTION: `asyncDataStream`\n> Signature: `async function* asyncDataStream(url)`\n> Lines: 194-206\n- @brief Asynchronously yield paginated API results.\n- @param {string} url Base URL for pagination.\n@yields {Object} Each page's parsed JSON data.\n```\n194: async function* asyncDataStream(url) {\n195: let page = 0;\n196: while (true) {\n197: const response = await fetch(`${url}?page=${page}`);\n198: const data = await response.json();\n199: if (data.length === 0) {\n201: return;\n202: }\n203: yield data;\n204: page++;\n205: }\n206: }\n```\n\n### FUNCTION: `initResult`\n> Signature: `const initResult = (() =>`\n> Lines: 213-217\n- @brief Immediately invoked function expression for module initialization.\n```\n213: const initResult = (() => {\n215: const config = { debug: false };\n216: return Object.freeze(config);\n217: })();\n```\n\n### FUNCTION: `createProxy`\n> Signature: `function createProxy(target)`\n> Lines: 227-240\n- @brief Create a logging proxy around any target object.\n- @param {Object} target The object to wrap with proxy traps.\n- @return {Proxy} Proxied object that logs property access.\n```\n227: function createProxy(target) {\n228: return new Proxy(target, {\n229: get(obj, prop) {\n231: console.log(`Access: ${String(prop)}`);\n232: return Reflect.get(obj, prop);\n233: },\n234: set(obj, prop, value) {\n236: console.log(`Set: ${String(prop)} = ${value}`);\n237: return Reflect.set(obj, prop, value);\n238: },\n239: });\n240: }\n```\n\n### FUNCTION: `buildDynamic`\n> Signature: `function buildDynamic(prefix)`\n> Lines: 250-258\n- @brief Build an object with computed property keys.\n- @param {string} prefix Key prefix for dynamic properties.\n- @return {Object} Object with dynamically named properties.\n```\n250: function buildDynamic(prefix) {\n251: return {\n252: [`${prefix}_name`]: 'value',\n253: [`${prefix}_id`]: 42,\n254: [Symbol.toPrimitive](hint) {\n255: return hint === 'string' ? prefix : 0;\n256: },\n257: };\n258: }\n```\n\n### FUNCTION: `fetchAndProcess`\n> Signature: `function fetchAndProcess(url)`\n> Lines: 268-280\n- @brief Demonstrate chained promise pattern with error recovery.\n- @param {string} url The resource URL to fetch.\n- @return {Promise<Object>} Processed data or fallback on error.\n```\n268: function fetchAndProcess(url) {\n269: return fetch(url)\n270: .then(res => res.json())\n271: .then(data => {\n273: return { ...data, processed: true };\n274: })\n275: .catch(err => {\n277: console.error(err);\n278: return { error: true, processed: false };\n279: });\n280: }\n```\n\n### FUNCTION: `configureApp`\n> Signature: `function configureApp({ host = 'localhost', port = 3000, db: { url: dbUrl = 'sqlite://' } = {} } = {})`\n> Lines: 290-292\n- @brief Configure application with deep destructuring defaults.\n- @param {Object} options Configuration object with nested defaults.\n- @return {Object} Resolved configuration.\n```\n290: function configureApp({ host = 'localhost', port = 3000, db: { url: dbUrl = 'sqlite://' } = {} } = {}) {\n291: return { host, port, dbUrl };\n292: }\n```\n\n### MODULE: `fs`\n> Signature: `const fs = require('fs')`\n> Lines: 297-307\n- @brief Load the Node.js filesystem module via CommonJS. */\n```\n297: const fs = require('fs');\n302: const _privateState = new WeakMap();\n```\n\n### FUNCTION: `setPrivate`\n> Signature: `function setPrivate(obj, data)`\n> Lines: 310-312\n- @brief Store private data associated with an object.\n- @param {Object} obj The key object.\n- @param {*} data The private data to associate.\n```\n310: function setPrivate(obj, data) {\n311: _privateState.set(obj, data);\n312: }\n```\n\n### FUNCTION: `loadPlugin`\n> Signature: `async function loadPlugin(name)`\n> Lines: 322-326\n- @brief Dynamically import a module at runtime.\n- @param {string} name Module specifier to import.\n- @return {Promise<Module>} The loaded module namespace.\n```\n322: async function loadPlugin(name) {\n324: const mod = await import(`./${name}.js`);\n325: return mod;\n326: }\n```\n\n### IMPORT: `fs from 'fs';`\n> Lines: 329-329\n```\n329: import fs from 'fs';\n```\n\n### IMPORT: `path from 'path';`\n> Lines: 330-330\n```\n330: import path from 'path';\n```\n\n### IMPORT: `url from 'url';`\n> Lines: 331-331\n```\n331: import url from 'url';\n```\n\n### CLASS: `ExtraService`\n> Signature: `export class ExtraService { constructor() { this.ready = true; } }`\n> Lines: 332-332\n```\n332: export class ExtraService { constructor() { this.ready = true; } }\n```\n\n### CLASS: `HelperComponent`\n> Signature: `class HelperComponent { render() { return null; } }`\n> Lines: 333-333\n```\n333: class HelperComponent { render() { return null; } }\n```\n\n### CLASS: `WidgetFactory`\n> Signature: `export default class WidgetFactory { create() { return {}; } }`\n> Lines: 334-334\n```\n334: export default class WidgetFactory { create() { return {}; } }\n```\n\n### COMPONENT: `BoundComponent`\n> Signature: `const BoundComponent = React.memo(() => null)`\n> Lines: 335-336\n```\n335: const BoundComponent = React.memo(() => null);\n336: const ForwardedWidget = React.forwardRef((_, ref) => ({ ref }));\n```\n\n### COMPONENT: `ForwardedWidget`\n> Signature: `const ForwardedWidget = React.forwardRef((_, ref) => ({ ref }))`\n> Lines: 336-336\n```\n336: const ForwardedWidget = React.forwardRef((_, ref) => ({ ref }));\n```\n\n### COMPONENT: `LazyWidget`\n> Signature: `const LazyWidget = React.lazy(() => import('./Widget'))`\n> Lines: 337-353\n```\n337: const LazyWidget = React.lazy(() => import('./Widget'));\n338: const MemoPanel = memo(() => null);\n339: const API_TOKEN = 'tok';\n340: const CACHE_SIZE = 128;\n341: const RETRY_LIMIT = 5;\n342: const pathMod = require('path');\n343: const cryptoMod = require('crypto');\n344: const utilMod = require('util');\n345: const osMod = require('os');\n353: function reqCoverJs1(value) { return value + 1; }\n```\n\n### COMPONENT: `MemoPanel`\n> Signature: `const MemoPanel = memo(() => null)`\n> Lines: 338-353\n```\n338: const MemoPanel = memo(() => null);\n339: const API_TOKEN = 'tok';\n340: const CACHE_SIZE = 128;\n341: const RETRY_LIMIT = 5;\n342: const pathMod = require('path');\n343: const cryptoMod = require('crypto');\n344: const utilMod = require('util');\n345: const osMod = require('os');\n353: function reqCoverJs1(value) { return value + 1; }\n```\n\n### CONSTANT: `API_TOKEN`\n> Signature: `const API_TOKEN = 'tok'`\n> Lines: 339-339\n```\n339: const API_TOKEN = 'tok';\n```\n\n### CONSTANT: `CACHE_SIZE`\n> Signature: `const CACHE_SIZE = 128`\n> Lines: 340-340\n```\n340: const CACHE_SIZE = 128;\n```\n\n### CONSTANT: `RETRY_LIMIT`\n> Signature: `const RETRY_LIMIT = 5`\n> Lines: 341-341\n```\n341: const RETRY_LIMIT = 5;\n```\n\n### MODULE: `pathMod`\n> Signature: `const pathMod = require('path')`\n> Lines: 342-353\n```\n342: const pathMod = require('path');\n343: const cryptoMod = require('crypto');\n344: const utilMod = require('util');\n345: const osMod = require('os');\n353: function reqCoverJs1(value) { return value + 1; }\n```\n\n### MODULE: `cryptoMod`\n> Signature: `const cryptoMod = require('crypto')`\n> Lines: 343-353\n```\n343: const cryptoMod = require('crypto');\n344: const utilMod = require('util');\n345: const osMod = require('os');\n353: function reqCoverJs1(value) { return value + 1; }\n```\n\n### MODULE: `utilMod`\n> Signature: `const utilMod = require('util')`\n> Lines: 344-353\n```\n344: const utilMod = require('util');\n345: const osMod = require('os');\n353: function reqCoverJs1(value) { return value + 1; }\n```\n\n### MODULE: `osMod`\n> Signature: `const osMod = require('os')`\n> Lines: 345-353\n```\n345: const osMod = require('os');\n353: function reqCoverJs1(value) { return value + 1; }\n```\n\n### FUNCTION: `reqCoverJs1`\n> Signature: `function reqCoverJs1(value) { return value + 1; }`\n> Lines: 353-353\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n353: function reqCoverJs1(value) { return value + 1; }\n```\n\n### FUNCTION: `reqCoverJs2`\n> Signature: `function reqCoverJs2(value) { return value + 2; }`\n> Lines: 360-360\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n360: function reqCoverJs2(value) { return value + 2; }\n```\n\n### FUNCTION: `reqCoverJs3`\n> Signature: `function reqCoverJs3(value) { return value + 3; }`\n> Lines: 367-367\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n367: function reqCoverJs3(value) { return value + 3; }\n```\n\n### FUNCTION: `reqCoverJs4`\n> Signature: `function reqCoverJs4(value) { return value + 4; }`\n> Lines: 374-374\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n374: function reqCoverJs4(value) { return value + 4; }\n```\n\n### FUNCTION: `reqCoverJs5`\n> Signature: `function reqCoverJs5(value) { return value + 5; }`\n> Lines: 381-381\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n381: function reqCoverJs5(value) { return value + 5; }\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_kotlin.kt | kotlin\n- @brief Comprehensive Kotlin test fixture for parser validation.\n- @details Covers extension functions, inline/reified generics, DSL builders,\ndelegation, coroutine scope, destructuring, sealed interfaces,\nvalue classes, operator overloading, and lateinit.\n\n### IMPORT: `kotlin.collections.List`\n> Lines: 11-11\n```\n11: import kotlin.collections.List\n```\n\n### IMPORT: `kotlinx.coroutines.flow.Flow`\n> Lines: 12-12\n```\n12: import kotlinx.coroutines.flow.Flow\n```\n\n### IMPORT: `kotlinx.coroutines.flow.flow`\n> Lines: 13-13\n```\n13: import kotlinx.coroutines.flow.flow\n```\n\n### DECORATOR: `Deprecated`\n> Lines: 18-18\n- @brief Marks a class or function as deprecated with migration path. */\n```\n18: @Deprecated(\"Use UserV2 instead\", replaceWith = ReplaceWith(\"UserV2\"))\n```\n\n### CLASS: `User`\n> Signature: `data class User(val name: String, val age: Int = 0)`\n> Lines: 19-61\n```\n19: data class User(val name: String, val age: Int = 0)\n28: sealed class Result<out T> {\n34: data class Success<T>(val value: T) : Result<T>()\n42: data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n61: }\n```\n\n### CLASS: `Result`\n> Signature: `sealed class Result<out T>`\n> Lines: 28-61\n- @brief Sealed class representing success/failure outcomes.\n@tparam T The success value type.\n- @brief Successful outcome holding a value.\n- @param value The result data.\n```\n28: sealed class Result<out T> {\n34: data class Success<T>(val value: T) : Result<T>()\n42: data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n61: }\n```\n\n### CLASS: `Success`\n> Signature: `data class Success<T>(val value: T) : Result<T>()`\n> Lines: 34-60\n- @brief Successful outcome holding a value.\n- @brief Failed outcome holding an error message.\n- @param value The result data.\n- @param message Description of the failure.\n- @param cause Optional underlying exception.\n```\n34: data class Success<T>(val value: T) : Result<T>()\n42: data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n```\n\n### CLASS: `Error`\n> Signature: `data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()`\n> Lines: 42-60\n- @brief Failed outcome holding an error message.\n- @brief Singleton state representing an in-progress operation.\n- @param message Description of the failure.\n- @param cause Optional underlying exception.\n```\n42: data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n```\n\n### MODULE: `Loading`\n> Signature: `object Loading : Result<Nothing>()`\n> Lines: 48-60\n- @brief Singleton state representing an in-progress operation.\n- @brief Map the success value using a transform function. @tparam R The target type after transformation.\n- @param transform Function converting T to R.\n- @return Transformed Result or original error/loading state.\n```\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n```\n\n### FUNCTION: `map`\n> Signature: `fun <R> map(transform: (T) -> R): Result<R> = when (this)`\n> Lines: 56-60\n- @brief Map the success value using a transform function.\n@tparam R The target type after transformation.\n- @param transform Function converting T to R.\n- @return Transformed Result or original error/loading state.\n```\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n```\n\n### INTERFACE: `Repository`\n> Signature: `interface Repository<T>`\n> Lines: 70-90\n- @brief Generic CRUD repository interface.\n@tparam T Entity type managed by this repository.\n- @brief Find an entity by its unique identifier.\n- @param id Entity ID.\n- @return The entity or null if not found.\n```\n70: interface Repository<T> {\n76: fun findById(id: Int): T?\n83: fun save(entity: T): Boolean\n89: fun findAll(): Flow<T>\n90: }\n```\n\n### FUNCTION: `findById`\n> Signature: `fun findById(id: Int): T?`\n> Lines: 76-96\n- @brief Find an entity by its unique identifier.\n- @brief Persist an entity.\n- @param id Entity ID.\n- @param entity The entity to save.\n- @return The entity or null if not found.\n- @return True if save succeeded.\n```\n76: fun findById(id: Int): T?\n83: fun save(entity: T): Boolean\n89: fun findAll(): Flow<T>\n90: }\n96: sealed interface Identifiable {\n```\n\n### FUNCTION: `save`\n> Signature: `fun save(entity: T): Boolean`\n> Lines: 83-96\n- @brief Persist an entity.\n- @brief Retrieve all entities as a Flow stream.\n- @param entity The entity to save.\n- @return True if save succeeded.\n- @return Flow emitting all stored entities.\n```\n83: fun save(entity: T): Boolean\n89: fun findAll(): Flow<T>\n90: }\n96: sealed interface Identifiable {\n```\n\n### FUNCTION: `findAll`\n> Signature: `fun findAll(): Flow<T>`\n> Lines: 89-96\n- @brief Retrieve all entities as a Flow stream.\n- @brief Sealed interface requiring an ID property.\n- @return Flow emitting all stored entities.\n```\n89: fun findAll(): Flow<T>\n90: }\n96: sealed interface Identifiable {\n```\n\n### CONSTANT: `id`\n> Signature: `val id: Int`\n> Lines: 98-98\n- @brief Unique entity identifier. */\n```\n98: val id: Int\n```\n\n### ENUM: `Color`\n> Signature: `enum class Color(val hex: String)`\n> Lines: 107-123\n- @brief Color enum with hex value property and companion factory.\n- @brief Red color channel.\n- @brief Green color channel.\n```\n107: enum class Color(val hex: String) {\n109: RED(\"#FF0000\"),\n111: GREEN(\"#00FF00\"),\n113: BLUE(\"#0000FF\");\n115: companion object {\n121: fun fromHex(hex: String): Color? = values().find { it.hex == hex }\n122: }\n123: }\n```\n\n### MODULE: `companion object`\n> Signature: `companion object`\n> Lines: 115-122\n- @brief Blue color channel. */\n- @brief Parse a color from its hex string.\n- @param hex Hex color code including '#' prefix.\n- @return Matching Color or null.\n```\n115: companion object {\n121: fun fromHex(hex: String): Color? = values().find { it.hex == hex }\n122: }\n```\n\n### FUNCTION: `fromHex`\n> Signature: `fun fromHex(hex: String): Color? = values().find { it.hex == hex }`\n> Lines: 121-121\n- @brief Parse a color from its hex string.\n- @param hex Hex color code including '#' prefix.\n- @return Matching Color or null.\n```\n121: fun fromHex(hex: String): Color? = values().find { it.hex == hex }\n```\n\n### CLASS: `Entity`\n> Signature: `data class Entity(`\n> Lines: 134-155\n- @brief Data class combining Identifiable with named properties.\n- @param id Unique identifier.\n- @param name Entity display name.\n- @param status Current lifecycle status.\n```\n134: data class Entity(\n135: override val id: Int,\n136: val name: String,\n137: val status: String = \"active\",\n138: ) : Identifiable\n147: @JvmInline\n148: value class EmailAddress(val value: String) {\n149: init {\n150: require(value.contains('@')) { \"Invalid email: $value\" }\n151: }\n154: val domain: String get() = value.substringAfter('@')\n155: }\n```\n\n### CONSTANT: `name`\n> Signature: `val name: String,`\n> Lines: 136-136\n```\n136: val name: String,\n```\n\n### CONSTANT: `status`\n> Signature: `val status: String = \"active\",`\n> Lines: 137-137\n```\n137: val status: String = \"active\",\n```\n\n### DECORATOR: `JvmInline`\n> Lines: 147-147\n- @brief Inline value class wrapping a validated email string.\n- @param value The raw email address string.\n```\n147: @JvmInline\n```\n\n### CONSTANT: `domain`\n> Signature: `val domain: String get() = value.substringAfter('@')`\n> Lines: 154-154\n- @brief Extract the domain part of the email. */\n```\n154: val domain: String get() = value.substringAfter('@')\n```\n\n### FUNCTION: `greet`\n> Signature: `fun greet(name: String): String`\n> Lines: 165-167\n- @brief Greet a person by name.\n- @param name The person's name.\n- @return Greeting message string.\n```\n165: fun greet(name: String): String {\n166: return \"Hello $name\"\n167: }\n```\n\n### FUNCTION: `fetchData`\n> Signature: `suspend fun fetchData(): String`\n> Lines: 174-177\n- @brief Suspend function simulating async data retrieval.\n- @return Retrieved data as a string.\n```\n174: suspend fun fetchData(): String {\n176: return \"data\"\n177: }\n```\n\n### FUNCTION: `processItems`\n> Signature: `fun processItems(items: List<String>, transform: (String) -> String): List<String>`\n> Lines: 186-188\n- @brief Higher-order function with trailing lambda syntax.\n- @param items List of strings to process.\n- @param transform Function applied to each item.\n- @return List of transformed results.\n```\n186: fun processItems(items: List<String>, transform: (String) -> String): List<String> {\n187: return items.map(transform)\n188: }\n```\n\n### CONSTANT: `String`\n> Signature: `val String.lastChar: Char?`\n> Lines: 205-205\n- @brief Extension property returning the last character or null.\n@receiver String The string to inspect.\n```\n205: val String.lastChar: Char?\n```\n\n### CLASS: `Vector2`\n> Signature: `data class Vector2(val x: Double, val y: Double)`\n> Lines: 229-249\n- @brief 2D vector with operator overloading for arithmetic.\n- @brief Add two vectors component-wise.\n- @param x Horizontal component.\n- @param y Vertical component.\n- @param other The vector to add.\n- @return Resulting sum vector.\n```\n229: data class Vector2(val x: Double, val y: Double) {\n235: operator fun plus(other: Vector2) = Vector2(x + other.x, y + other.y)\n241: operator fun unaryMinus() = Vector2(-x, -y)\n248: operator fun times(other: Vector2) = x * other.x + y * other.y\n249: }\n```\n\n### CONSTANT: `PI`\n> Signature: `val PI = 3.14159265`\n> Lines: 254-254\n- @brief Mathematical constant Pi. */\n```\n254: val PI = 3.14159265\n```\n\n### VARIABLE: `counter`\n> Signature: `var counter = 0`\n> Lines: 257-257\n- @brief Mutable package-level counter. */\n```\n257: var counter = 0\n```\n\n### MODULE: `Singleton`\n> Signature: `object Singleton`\n> Lines: 265-286\n- @brief Application-wide singleton for configuration management.\n- @brief Mutable configuration map.\n```\n265: object Singleton {\n267: private val config = mutableMapOf<String, Any>()\n274: fun set(key: String, value: Any) {\n275: config[key] = value\n276: }\n284: @Suppress(\"UNCHECKED_CAST\")\n285: fun <T> get(key: String): T? = config[key] as? T\n286: }\n```\n\n### FUNCTION: `set`\n> Signature: `fun set(key: String, value: Any)`\n> Lines: 274-276\n- @brief Store a configuration value.\n- @param key Configuration key.\n- @param value Configuration value.\n```\n274: fun set(key: String, value: Any) {\n275: config[key] = value\n276: }\n```\n\n### DECORATOR: `Suppress`\n> Lines: 284-284\n- @brief Retrieve a typed configuration value.\n@tparam T Expected value type.\n- @param key Configuration key.\n- @return The value cast to T, or null.\n```\n284: @Suppress(\"UNCHECKED_CAST\")\n```\n\n### FUNCTION: `get`\n> Signature: `fun <T> get(key: String): T? = config[key] as? T`\n> Lines: 285-292\n- @brief Companion object pattern for factory construction.\n```\n285: fun <T> get(key: String): T? = config[key] as? T\n286: }\n292: companion object Factory {\n```\n\n### MODULE: `Factory`\n> Signature: `companion object Factory`\n> Lines: 292-293\n- @brief Companion object pattern for factory construction.\n```\n292: companion object Factory {\n293: }\n```\n\n### CLASS: `DelegatingList`\n> Signature: `class DelegatingList<T>(private val inner: MutableList<T>) : List<T> by inner`\n> Lines: 303-316\n- @brief List implementation delegating to an inner mutable list.\n@tparam T Element type.\n- @brief Count of accesses to the delegated list.\n- @param inner The backing list.\n```\n303: class DelegatingList<T>(private val inner: MutableList<T>) : List<T> by inner {\n305: var accessCount = 0\n306: private set\n311: override val size: Int\n312: get() {\n313: accessCount++\n314: return inner.size\n315: }\n316: }\n```\n\n### VARIABLE: `accessCount`\n> Signature: `var accessCount = 0`\n> Lines: 305-305\n- @brief Count of accesses to the delegated list. */\n```\n305: var accessCount = 0\n```\n\n### CLASS: `Service`\n> Signature: `class Service`\n> Lines: 324-339\n- @brief Service class demonstrating lateinit and lazy initialization.\n- @brief Late-initialized dependency, set after construction.\n```\n324: class Service {\n326: lateinit var dependency: Repository<Entity>\n329: val resource: String by lazy {\n331: \"expensive_resource\"\n332: }\n338: fun isReady(): Boolean = ::dependency.isInitialized\n339: }\n```\n\n### CONSTANT: `resource`\n> Signature: `val resource: String by lazy`\n> Lines: 329-329\n- @brief Lazily computed expensive resource. */\n```\n329: val resource: String by lazy {\n```\n\n### FUNCTION: `isReady`\n> Signature: `fun isReady(): Boolean = ::dependency.isInitialized`\n> Lines: 338-347\n- @brief Check if the dependency has been initialized.\n- @return True if dependency is set.\n```\n338: fun isReady(): Boolean = ::dependency.isInitialized\n339: }\n347: class HtmlBuilder {\n```\n\n### CLASS: `HtmlBuilder`\n> Signature: `class HtmlBuilder`\n> Lines: 347-373\n- @brief Simple DSL for building HTML strings.\n- @brief Add a div element with content from a lambda.\n- @param block Lambda providing the div content.\n```\n347: class HtmlBuilder {\n348: private val elements = mutableListOf<String>()\n354: fun div(block: HtmlBuilder.() -> Unit) {\n355: val inner = HtmlBuilder()\n356: inner.block()\n357: elements.add(\"<div>${inner.build()}</div>\")\n358: }\n364: fun text(text: String) {\n365: elements.add(text)\n366: }\n372: fun build(): String = elements.joinToString(\"\")\n373: }\n```\n\n### FUNCTION: `div`\n> Signature: `fun div(block: HtmlBuilder.() -> Unit)`\n> Lines: 354-358\n- @brief Add a div element with content from a lambda.\n- @param block Lambda providing the div content.\n```\n354: fun div(block: HtmlBuilder.() -> Unit) {\n355: val inner = HtmlBuilder()\n356: inner.block()\n357: elements.add(\"<div>${inner.build()}</div>\")\n358: }\n```\n\n### CONSTANT: `inner`\n> Signature: `val inner = HtmlBuilder()`\n> Lines: 355-355\n```\n355: val inner = HtmlBuilder()\n```\n\n### FUNCTION: `text`\n> Signature: `fun text(text: String)`\n> Lines: 364-366\n- @brief Add a text node.\n- @param text The text content.\n```\n364: fun text(text: String) {\n365: elements.add(text)\n366: }\n```\n\n### FUNCTION: `build`\n> Signature: `fun build(): String = elements.joinToString(\"\")`\n> Lines: 372-381\n- @brief Build the accumulated HTML string.\n- @brief DSL entry point for building HTML content.\n- @param block Builder lambda receiving HtmlBuilder scope.\n- @return Concatenated HTML output.\n- @return Complete HTML string.\n```\n372: fun build(): String = elements.joinToString(\"\")\n373: }\n381: fun html(block: HtmlBuilder.() -> Unit): String {\n```\n\n### FUNCTION: `html`\n> Signature: `fun html(block: HtmlBuilder.() -> Unit): String`\n> Lines: 381-385\n- @brief DSL entry point for building HTML content.\n- @param block Builder lambda receiving HtmlBuilder scope.\n- @return Complete HTML string.\n```\n381: fun html(block: HtmlBuilder.() -> Unit): String {\n382: val builder = HtmlBuilder()\n383: builder.block()\n384: return builder.build()\n385: }\n```\n\n### CONSTANT: `builder`\n> Signature: `val builder = HtmlBuilder()`\n> Lines: 382-382\n```\n382: val builder = HtmlBuilder()\n```\n\n### IMPORT: `kotlin.math.max`\n> Lines: 388-388\n```\n388: import kotlin.math.max\n```\n\n### IMPORT: `kotlin.math.min`\n> Lines: 389-389\n```\n389: import kotlin.math.min\n```\n\n### INTERFACE: `Logger`\n> Signature: `interface Logger`\n> Lines: 390-394\n```\n390: interface Logger\n391: interface Parser\n392: interface Emitter\n393: interface Formatter\n394: enum class ModeKt { FAST, SAFE }\n```\n\n### INTERFACE: `Parser`\n> Signature: `interface Parser`\n> Lines: 391-394\n```\n391: interface Parser\n392: interface Emitter\n393: interface Formatter\n394: enum class ModeKt { FAST, SAFE }\n```\n\n### INTERFACE: `Emitter`\n> Signature: `interface Emitter`\n> Lines: 392-394\n```\n392: interface Emitter\n393: interface Formatter\n394: enum class ModeKt { FAST, SAFE }\n```\n\n### INTERFACE: `Formatter`\n> Signature: `interface Formatter`\n> Lines: 393-394\n```\n393: interface Formatter\n394: enum class ModeKt { FAST, SAFE }\n```\n\n### ENUM: `ModeKt`\n> Signature: `enum class ModeKt { FAST, SAFE }`\n> Lines: 394-394\n```\n394: enum class ModeKt { FAST, SAFE }\n```\n\n### ENUM: `PhaseKt`\n> Signature: `enum class PhaseKt { INIT, RUN }`\n> Lines: 395-395\n```\n395: enum class PhaseKt { INIT, RUN }\n```\n\n### ENUM: `StatusKt`\n> Signature: `enum class StatusKt { READY, WAITING }`\n> Lines: 396-396\n```\n396: enum class StatusKt { READY, WAITING }\n```\n\n### ENUM: `SignalKt`\n> Signature: `enum class SignalKt { ON, OFF }`\n> Lines: 397-397\n```\n397: enum class SignalKt { ON, OFF }\n```\n\n### DECORATOR: `Synchronized`\n> Lines: 398-398\n```\n398: @Synchronized\n```\n\n### DECORATOR: `PublishedApi`\n> Lines: 399-399\n```\n399: @PublishedApi\n```\n\n### MODULE: `CacheStore`\n> Signature: `object CacheStore`\n> Lines: 400-400\n```\n400: object CacheStore\n```\n\n### VARIABLE: `retries`\n> Signature: `var retries = 0`\n> Lines: 401-401\n```\n401: var retries = 0\n```\n\n### VARIABLE: `attempts`\n> Signature: `var attempts = 0`\n> Lines: 402-402\n```\n402: var attempts = 0\n```\n\n### VARIABLE: `state`\n> Signature: `var state = \"idle\"`\n> Lines: 403-403\n```\n403: var state = \"idle\"\n```\n\n### FUNCTION: `reqCoverKotlin1`\n> Signature: `fun reqCoverKotlin1(value: Int): Int = value + 1`\n> Lines: 413-413\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n413: fun reqCoverKotlin1(value: Int): Int = value + 1\n```\n\n### FUNCTION: `reqCoverKotlin2`\n> Signature: `fun reqCoverKotlin2(value: Int): Int = value + 2`\n> Lines: 422-422\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n422: fun reqCoverKotlin2(value: Int): Int = value + 2\n```\n\n### FUNCTION: `reqCoverKotlin3`\n> Signature: `fun reqCoverKotlin3(value: Int): Int = value + 3`\n> Lines: 431-431\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n431: fun reqCoverKotlin3(value: Int): Int = value + 3\n```\n\n### FUNCTION: `reqCoverKotlin4`\n> Signature: `fun reqCoverKotlin4(value: Int): Int = value + 4`\n> Lines: 440-440\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n440: fun reqCoverKotlin4(value: Int): Int = value + 4\n```\n\n### FUNCTION: `reqCoverKotlin5`\n> Signature: `fun reqCoverKotlin5(value: Int): Int = value + 5`\n> Lines: 449-449\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n449: fun reqCoverKotlin5(value: Int): Int = value + 5\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_lua.lua | lua\n\n### FUNCTION: `globalFunc`\n> Signature: `function globalFunc(x)`\n> Lines: 14-16\n- @param x number The input value.\n---\n- @return number The input incremented by one.\n```\n14: function globalFunc(x)\n15: return x + 1\n16: end\n```\n\n### FUNCTION: `localFunc`\n> Signature: `local function localFunc(y)`\n> Lines: 22-28\n```\n22: local function localFunc(y)\n23: if type(y) ~= \"number\" then\n24: error(\"expected number, got \" .. type(y))\n25: end\n27: return y * 2\n28: end\n```\n\n### FUNCTION: `sumAll`\n> Signature: `local function sumAll(...)`\n> Lines: 33-41\n- @param ... number Variable number of numeric arguments.\n---\n- @return number Sum of all provided values.\n```\n33: local function sumAll(...)\n34: local total = 0\n35: local args = {...}\n36: for _, v in ipairs(args) do\n38: total = total + v\n39: end\n40: return total\n41: end\n```\n\n### VARIABLE: `total`\n> Signature: `local total = 0`\n> Lines: 34-34\n```\n34: local total = 0\n```\n\n### VARIABLE: `args`\n> Signature: `local args = {...}`\n> Lines: 35-35\n```\n35: local args = {...}\n```\n\n### VARIABLE: `myVar`\n> Signature: `local myVar = 42`\n> Lines: 46-46\n- @brief Module-level constant for retry limits.\n```\n46: local myVar = 42\n```\n\n### VARIABLE: `config`\n> Signature: `local config =`\n> Lines: 49-49\n- @brief Configuration table with default settings.\n```\n49: local config = {\n```\n\n### FUNCTION: `handler`\n> Signature: `local handler = function(event)`\n> Lines: 59-66\n- @param event table Event object containing type and data fields.\n```\n59: local handler = function(event)\n61: if event.type == \"click\" then\n62: print(\"clicked at \" .. event.x .. \",\" .. event.y)\n63: else\n64: print(\"event: \" .. event.type)\n65: end\n66: end\n```\n\n### VARIABLE: `MyModule`\n> Signature: `local MyModule = {}`\n> Lines: 72-72\n- @brief Table-based module using method syntax.\n```\n72: local MyModule = {}\n```\n\n### FUNCTION: `MyModule.new`\n> Signature: `function MyModule.new(name)`\n> Lines: 78-83\n- @param name string Instance identifier.\n---\n- @return table New MyModule instance.\n```\n78: function MyModule.new(name)\n79: local self = setmetatable({}, MyModule)\n80: self.name = name\n81: self._items = {}\n82: return self\n83: end\n```\n\n### VARIABLE: `self`\n> Signature: `local self = setmetatable({}, MyModule)`\n> Lines: 79-79\n```\n79: local self = setmetatable({}, MyModule)\n```\n\n### FUNCTION: `MyModule.method`\n> Signature: `MyModule.method = function(self)`\n> Lines: 88-90\n- @param self table The MyModule instance.\n---\n- @return string The instance name.\n```\n88: MyModule.method = function(self)\n89: return self.name\n90: end\n```\n\n### FUNCTION: `MyModule:addItem`\n> Signature: `function MyModule:addItem(item)`\n> Lines: 94-97\n- @param item any The item to store.\n```\n94: function MyModule:addItem(item)\n96: table.insert(self._items, item)\n97: end\n```\n\n### FUNCTION: `MyModule:count`\n> Signature: `function MyModule:count()`\n> Lines: 101-103\n- @return number Number of items.\n```\n101: function MyModule:count()\n102: return #self._items\n103: end\n```\n\n### VARIABLE: `Animal`\n> Signature: `local Animal = {}`\n> Lines: 109-109\n- @brief Base class using metatables for inheritance.\n```\n109: local Animal = {}\n```\n\n### FUNCTION: `Animal.new`\n> Signature: `function Animal.new(species)`\n> Lines: 115-119\n- @param species string The animal's species.\n---\n- @return table New Animal instance.\n```\n115: function Animal.new(species)\n116: local self = setmetatable({}, Animal)\n117: self.species = species\n118: return self\n119: end\n```\n\n### VARIABLE: `self`\n> Signature: `local self = setmetatable({}, Animal)`\n> Lines: 116-116\n```\n116: local self = setmetatable({}, Animal)\n```\n\n### FUNCTION: `Animal:speak`\n> Signature: `function Animal:speak()`\n> Lines: 123-125\n- @return string Sound description.\n```\n123: function Animal:speak()\n124: return self.species .. \" says ...\"\n125: end\n```\n\n### VARIABLE: `Dog`\n> Signature: `local Dog = setmetatable({}, { __index = Animal })`\n> Lines: 129-129\n- @brief Dog subclass inheriting from Animal.\n```\n129: local Dog = setmetatable({}, { __index = Animal })\n```\n\n### FUNCTION: `Dog.new`\n> Signature: `function Dog.new(name)`\n> Lines: 135-140\n- @param name string The dog's name.\n---\n- @return table New Dog instance.\n```\n135: function Dog.new(name)\n136: local self = Animal.new(\"Dog\")\n137: setmetatable(self, Dog)\n138: self.dogName = name\n139: return self\n140: end\n```\n\n### VARIABLE: `self`\n> Signature: `local self = Animal.new(\"Dog\")`\n> Lines: 136-136\n```\n136: local self = Animal.new(\"Dog\")\n```\n\n### FUNCTION: `Dog:speak`\n> Signature: `function Dog:speak()`\n> Lines: 144-146\n- @return string The dog's vocalization.\n```\n144: function Dog:speak()\n145: return self.dogName .. \" says Woof!\"\n146: end\n```\n\n### FUNCTION: `makeCounter`\n> Signature: `local function makeCounter(step)`\n> Lines: 153-160\n- @param step number Increment amount per call.\n---\n- @return function Closure returning successive counts.\n```\n153: local function makeCounter(step)\n154: local count = 0\n155: return function()\n157: count = count + step\n158: return count\n159: end\n160: end\n```\n\n### VARIABLE: `count`\n> Signature: `local count = 0`\n> Lines: 154-154\n```\n154: local count = 0\n```\n\n### FUNCTION: `fibonacci`\n> Signature: `local function fibonacci(limit)`\n> Lines: 167-176\n- @param limit number Maximum number of values to yield.\n---\n- @return function Coroutine wrap function.\n```\n167: local function fibonacci(limit)\n168: return coroutine.wrap(function()\n169: local a, b = 0, 1\n170: for _ = 1, limit do\n171: coroutine.yield(a)\n173: a, b = b, a + b\n174: end\n175: end)\n176: end\n```\n\n### FUNCTION: `safeCall`\n> Signature: `local function safeCall(fn, ...)`\n> Lines: 184-192\n- @param fn function The function to execute.\n---\n- @param ... any Arguments to pass to fn.\n---\n- @return boolean, any Success flag and result or error message.\n```\n184: local function safeCall(fn, ...)\n185: local ok, result = pcall(fn, ...)\n186: if not ok then\n188: print(\"Error: \" .. tostring(result))\n189: return false, nil\n190: end\n191: return true, result\n192: end\n```\n\n### VARIABLE: `mixedTable`\n> Signature: `local mixedTable =`\n> Lines: 197-197\n- @brief Complex table demonstrating all key types.\n```\n197: local mixedTable = {\n```\n\n### FUNCTION: `range`\n> Signature: `local function range(from, to)`\n> Lines: 219-228\n- @param from number Start of range (inclusive).\n---\n- @param to number End of range (inclusive).\n---\n- @return function Iterator function.\n```\n219: local function range(from, to)\n220: local i = from - 1\n221: return function()\n222: i = i + 1\n223: if i <= to then\n224: return i\n225: end\n227: end\n228: end\n```\n\n### VARIABLE: `i`\n> Signature: `local i = from - 1`\n> Lines: 220-220\n```\n220: local i = from - 1\n```\n\n### FUNCTION: `req_cover_lua_1`\n> Signature: `function req_cover_lua_1(value)`\n> Lines: 236-238\n- @brief Coverage helper construct 1.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n--\n- @param value Input value for helper construct 1.\n--\n- @return Output value for helper construct 1.\n```\n236: function req_cover_lua_1(value)\n237: return value + 1\n238: end\n```\n\n### FUNCTION: `req_cover_lua_2`\n> Signature: `function req_cover_lua_2(value)`\n> Lines: 245-247\n- @brief Coverage helper construct 2.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n--\n- @param value Input value for helper construct 2.\n--\n- @return Output value for helper construct 2.\n```\n245: function req_cover_lua_2(value)\n246: return value + 2\n247: end\n```\n\n### FUNCTION: `req_cover_lua_3`\n> Signature: `function req_cover_lua_3(value)`\n> Lines: 254-256\n- @brief Coverage helper construct 3.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n--\n- @param value Input value for helper construct 3.\n--\n- @return Output value for helper construct 3.\n```\n254: function req_cover_lua_3(value)\n255: return value + 3\n256: end\n```\n\n### FUNCTION: `req_cover_lua_4`\n> Signature: `function req_cover_lua_4(value)`\n> Lines: 263-265\n- @brief Coverage helper construct 4.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n--\n- @param value Input value for helper construct 4.\n--\n- @return Output value for helper construct 4.\n```\n263: function req_cover_lua_4(value)\n264: return value + 4\n265: end\n```\n\n### FUNCTION: `req_cover_lua_5`\n> Signature: `function req_cover_lua_5(value)`\n> Lines: 272-274\n- @brief Coverage helper construct 5.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n--\n- @param value Input value for helper construct 5.\n--\n- @return Output value for helper construct 5.\n```\n272: function req_cover_lua_5(value)\n273: return value + 5\n274: end\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_perl.pl | perl\n\n### MODULE: `MyPackage`\n> Signature: `package MyPackage`\n> Lines: 16-16\n- @brief Comprehensive Perl test fixture for parser validation.\n- @brief Documentation block for the fixture module.\n- @details Covers OOP with bless, Moose-like attributes, closures,\nhere-docs, wantarray, dispatch tables, prototypes, AUTOLOAD,\nand regular expressions.\nSingle line comment\n=pod\n- @details This module demonstrates advanced Perl constructs including\nobject-oriented patterns, closures, and metaprogramming.\n=cut\n```\n16: package MyPackage;\n```\n\n### IMPORT: `strict`\n> Lines: 18-18\n```\n18: use strict;\n```\n\n### IMPORT: `warnings`\n> Lines: 19-19\n```\n19: use warnings;\n```\n\n### IMPORT: `Carp qw(croak confess)`\n> Lines: 20-20\n```\n20: use Carp qw(croak confess);\n```\n\n### IMPORT: `Exporter`\n> Lines: 21-21\n```\n21: require Exporter;\n```\n\n### CONSTANT: `MAX_SIZE`\n> Signature: `use constant MAX_SIZE => 100`\n> Lines: 22-22\n```\n22: use constant MAX_SIZE => 100;\n```\n\n### FUNCTION: `new`\n> Signature: `sub new`\n> Lines: 48-48\n- @brief Create a new MyPackage instance.\n- @param class The class name (implicit first argument).\n- @param %args Named arguments: name (required), age (optional).\n- @return Blessed hashref instance.\n=cut\n```\n48: sub new {\n```\n\n### FUNCTION: `name`\n> Signature: `sub name`\n> Lines: 62-62\n- @brief Accessor for the name attribute.\n- @return The instance name string.\n```\n62: sub name {\n```\n\n### FUNCTION: `is_valid`\n> Signature: `sub is_valid`\n> Lines: 74-74\n- @brief Check if the instance is in a valid state.\n- @return 1 if valid, 0 otherwise.\n```\n74: sub is_valid {\n```\n\n### FUNCTION: `greet`\n> Signature: `sub greet`\n> Lines: 83-83\n- @brief Print a greeting to stdout.\n- @param $name The person's name.\n```\n83: sub greet {\n```\n\n### FUNCTION: `process`\n> Signature: `sub process`\n> Lines: 95-95\n- @brief Process data and return result.\n- @return 1 indicating success.\n```\n95: sub process {\n```\n\n### FUNCTION: `format_output`\n> Signature: `sub format_output`\n> Lines: 102-102\n- @brief Format output depending on context (list vs scalar).\n- @param @items List of items to format.\n- @return In list context: formatted items. In scalar: count.\n```\n102: sub format_output {\n```\n\n### FUNCTION: `helper`\n> Signature: `sub helper`\n> Lines: 115-115\n- @brief Standalone helper for internal use.\n- @return Always returns \"ok\".\n```\n115: sub helper {\n```\n\n### FUNCTION: `extract_emails`\n> Signature: `sub extract_emails`\n> Lines: 124-124\n- @brief Extract all email addresses from text.\n- @param $text Input text to scan.\n- @return List of matched email addresses.\n```\n124: sub extract_emails {\n```\n\n### FUNCTION: `replace_all`\n> Signature: `sub replace_all`\n> Lines: 139-139\n- @brief Replace all occurrences of a pattern in text.\n- @param $text Input text.\n- @param $pattern Regex pattern to find.\n- @param $replacement Replacement string.\n- @return Modified text with substitutions applied.\n```\n139: sub replace_all {\n```\n\n### FUNCTION: `make_multiplier`\n> Signature: `sub make_multiplier`\n> Lines: 150-150\n- @brief Create a multiplier closure.\n- @param $factor The multiplication factor.\n- @return Coderef that multiplies its argument by factor.\n```\n150: sub make_multiplier {\n```\n\n### FUNCTION: `dispatch`\n> Signature: `sub dispatch`\n> Lines: 178-178\n```\n178: sub dispatch {\n```\n\n### FUNCTION: `generate_template`\n> Signature: `sub generate_template`\n> Lines: 190-190\n- @brief Generate a template string using a here-document.\n- @param $name Name to insert into the template.\n- @return Formatted multi-line string.\n```\n190: sub generate_template {\n```\n\n### FUNCTION: `AUTOLOAD`\n> Signature: `sub AUTOLOAD`\n> Lines: 210-210\n- @brief Handle undefined method calls dynamically.\n- @details Methods named get_* return the corresponding attribute.\n- @param @args Arguments passed to the auto-loaded method.\n- @return The attribute value or undef.\n```\n210: sub AUTOLOAD {\n```\n\n### FUNCTION: `safe_execute`\n> Signature: `sub safe_execute`\n> Lines: 230-230\n- @brief Execute a block with error trapping.\n- @param $code Coderef to execute.\n- @return Result of execution or undef on error.\n```\n230: sub safe_execute {\n```\n\n### MODULE: `Extra::One`\n> Signature: `package Extra::One`\n> Lines: 248-248\n```\n248: package Extra::One;\n```\n\n### MODULE: `Extra::Two`\n> Signature: `package Extra::Two`\n> Lines: 249-249\n```\n249: package Extra::Two;\n```\n\n### MODULE: `Extra::Three`\n> Signature: `package Extra::Three`\n> Lines: 250-250\n```\n250: package Extra::Three;\n```\n\n### MODULE: `Extra::Four`\n> Signature: `package Extra::Four`\n> Lines: 251-251\n```\n251: package Extra::Four;\n```\n\n### CONSTANT: `RETRY_LIMIT`\n> Signature: `use constant RETRY_LIMIT => 5`\n> Lines: 252-252\n```\n252: use constant RETRY_LIMIT => 5;\n```\n\n### CONSTANT: `API_HOST`\n> Signature: `use constant API_HOST => 'localhost'`\n> Lines: 253-253\n```\n253: use constant API_HOST => 'localhost';\n```\n\n### CONSTANT: `FEATURE_FLAG`\n> Signature: `use constant FEATURE_FLAG => 1`\n> Lines: 254-254\n```\n254: use constant FEATURE_FLAG => 1;\n```\n\n### CONSTANT: `CACHE_SIZE`\n> Signature: `use constant CACHE_SIZE => 256`\n> Lines: 255-255\n```\n255: use constant CACHE_SIZE => 256;\n```\n\n### CONSTANT: `DEFAULT_USER`\n> Signature: `use constant DEFAULT_USER => 'guest'`\n> Lines: 256-256\n```\n256: use constant DEFAULT_USER => 'guest';\n```\n\n### IMPORT: `lib 'lib'`\n> Lines: 257-257\n```\n257: use lib 'lib';\n```\n\n### FUNCTION: `req_cover_perl_1`\n> Signature: `sub req_cover_perl_1`\n> Lines: 265-265\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n265: sub req_cover_perl_1 {\n```\n\n### FUNCTION: `req_cover_perl_2`\n> Signature: `sub req_cover_perl_2`\n> Lines: 275-275\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n275: sub req_cover_perl_2 {\n```\n\n### FUNCTION: `req_cover_perl_3`\n> Signature: `sub req_cover_perl_3`\n> Lines: 285-285\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n285: sub req_cover_perl_3 {\n```\n\n### FUNCTION: `req_cover_perl_4`\n> Signature: `sub req_cover_perl_4`\n> Lines: 295-295\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n295: sub req_cover_perl_4 {\n```\n\n### FUNCTION: `req_cover_perl_5`\n> Signature: `sub req_cover_perl_5`\n> Lines: 305-305\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n305: sub req_cover_perl_5 {\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_php.php | php\n- @brief Comprehensive PHP test fixture for parser validation.\n- @details Covers enums with methods, union/intersection types, readonly\nproperties, constructor promotion, arrow functions, match expressions,\nfirst-class callables, attributes, fibers, and named arguments.\n\n### NAMESPACE: `App\\Models`\n> Signature: `namespace App\\Models`\n> Lines: 12-15\n```\n12: namespace App\\Models;\n14: use App\\Contracts\\Repository;\n15: use App\\Events\\{ModelCreated, ModelDeleted};\n```\n\n### IMPORT: `App\\Contracts\\Repository`\n> Lines: 14-14\n```\n14: use App\\Contracts\\Repository;\n```\n\n### IMPORT: `App\\Events\\{ModelCreated, ModelDeleted}`\n> Lines: 15-15\n```\n15: use App\\Events\\{ModelCreated, ModelDeleted};\n```\n\n### IMPORT: `Psr\\Log\\LoggerInterface`\n> Lines: 16-16\n```\n16: use Psr\\Log\\LoggerInterface;\n```\n\n### IMPORT: `'config.php'`\n> Lines: 17-17\n```\n17: require_once 'config.php';\n```\n\n### CONSTANT: `VERSION`\n> Signature: `const VERSION = \"1.0\"`\n> Lines: 22-22\n- @brief Application version string. */\n```\n22: const VERSION = \"1.0\";\n```\n\n### CONSTANT: `MAX_PER_PAGE`\n> Signature: `const MAX_PER_PAGE = 50`\n> Lines: 25-25\n- @brief Maximum number of query results per page. */\n```\n25: const MAX_PER_PAGE = 50;\n```\n\n### FUNCTION: `isActive`\n> Signature: `public function isActive(): bool`\n> Lines: 45-47\n- @brief Check if the status represents an active state.\n- @return bool True if the entity is publicly visible.\n```\n45: public function isActive(): bool {\n46: return $this === self::Published;\n47: }\n```\n\n### FUNCTION: `label`\n> Signature: `public function label(): string`\n> Lines: 53-59\n- @brief Get a human-readable label for display.\n- @return string Formatted status label.\n```\n53: public function label(): string {\n54: return match($this) {\n55: self::Draft => 'Draft',\n56: self::Published => 'Published',\n57: self::Archived => 'Archived',\n58: };\n59: }\n```\n\n### CLASS: `BaseModel`\n> Signature: `abstract class BaseModel`\n> Lines: 69-111\n- @brief Abstract base model with common persistence operations.\n- @brief Construct a model with promoted properties.\n- @details Uses constructor promotion for compact field declaration.\n- @param int $id Unique identifier (readonly after construction).\n- @param \\DateTimeImmutable $createdAt Timestamp of creation.\n```\n69: abstract class BaseModel {\n75: public function __construct(\n76: public readonly int $id,\n77: public readonly \\DateTimeImmutable $createdAt = new \\DateTimeImmutable(),\n78: ) {}\n84: public function save(): bool {\n86: if (!$this->validate()) {\n87: return false;\n88: }\n89: return true;\n90: }\n96: abstract protected function validate(): bool;\n102: private static function validateConstraints(): bool {\n103: return true;\n104: }\n110: abstract public function toArray(): array;\n111: }\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 75-78\n- @brief Construct a model with promoted properties.\n- @param int $id Unique identifier (readonly after construction).\n- @param \\DateTimeImmutable $createdAt Timestamp of creation.\n```\n75: public function __construct(\n76: public readonly int $id,\n77: public readonly \\DateTimeImmutable $createdAt = new \\DateTimeImmutable(),\n78: ) {}\n```\n\n### FUNCTION: `save`\n> Signature: `public function save(): bool`\n> Lines: 84-90\n- @brief Persist the model to the data store.\n- @return bool True if save succeeded.\n```\n84: public function save(): bool {\n86: if (!$this->validate()) {\n87: return false;\n88: }\n89: return true;\n90: }\n```\n\n### FUNCTION: `validateConstraints`\n> Signature: `private static function validateConstraints(): bool`\n> Lines: 102-104\n- @brief Internal validation helper with type narrowing.\n- @return bool True if entity passes all constraint checks.\n```\n102: private static function validateConstraints(): bool {\n103: return true;\n104: }\n```\n\n### CLASS: `User`\n> Signature: `final class User extends BaseModel`\n> Lines: 120-179\n- @brief Concrete user entity with union and intersection types.\n- @brief User's display name.\n```\n120: final class User extends BaseModel {\n122: private string $name;\n125: private ?string $email;\n133: public function __construct(\n134: int $id,\n135: string $name,\n136: ?string $email = null,\n137: ) {\n138: parent::__construct($id);\n139: $this->name = $name;\n140: $this->email = $email;\n141: }\n147: public function getName(): string {\n148: return $this->name;\n149: }\n155: public function getIdentifier(): string|int {\n157: return $this->email ?? $this->id;\n158: }\n164: protected function validate(): bool {\n165: return strlen($this->name) > 0;\n166: }\n172: public function toArray(): array {\n173: return [\n174: 'id' => $this->id,\n175: 'name' => $this->name,\n176: 'email' => $this->email,\n177: ];\n178: }\n179: }\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 133-141\n- @brief Construct a User with promoted and explicit properties.\n- @param int $id Unique user ID.\n- @param string $name Display name.\n- @param string|null $email Optional email address.\n```\n133: public function __construct(\n134: int $id,\n135: string $name,\n136: ?string $email = null,\n137: ) {\n138: parent::__construct($id);\n139: $this->name = $name;\n140: $this->email = $email;\n141: }\n```\n\n### FUNCTION: `getName`\n> Signature: `public function getName(): string`\n> Lines: 147-149\n- @brief Get the user's display name.\n- @return string The user name.\n```\n147: public function getName(): string {\n148: return $this->name;\n149: }\n```\n\n### FUNCTION: `getIdentifier`\n> Signature: `public function getIdentifier(): string|int`\n> Lines: 155-158\n- @brief Get a value that may be string or int.\n- @return string|int The identifier in either format.\n```\n155: public function getIdentifier(): string|int {\n157: return $this->email ?? $this->id;\n158: }\n```\n\n### FUNCTION: `validate`\n> Signature: `protected function validate(): bool`\n> Lines: 164-166\n- @brief Validate user-specific constraints.\n- @return bool True if name is non-empty.\n```\n164: protected function validate(): bool {\n165: return strlen($this->name) > 0;\n166: }\n```\n\n### FUNCTION: `toArray`\n> Signature: `public function toArray(): array`\n> Lines: 172-178\n- @brief Serialize user to array.\n- @return array<string, mixed> User data array.\n```\n172: public function toArray(): array {\n173: return [\n174: 'id' => $this->id,\n175: 'name' => $this->name,\n176: 'email' => $this->email,\n177: ];\n178: }\n```\n\n### INTERFACE: `Repo`\n> Signature: `interface Repo`\n> Lines: 187-207\n- @brief Generic repository interface for data access patterns.\n- @brief Retrieve all entities.\n- @return iterable<BaseModel> Collection of models.\n```\n187: interface Repo {\n192: public function findAll(): iterable;\n199: public function findById(int $id): ?BaseModel;\n206: public function count(array $criteria = []): int;\n207: }\n```\n\n### FUNCTION: `findAll`\n> Signature: `public function findAll(): iterable`\n> Lines: 192-215\n- @brief Retrieve all entities.\n- @brief Find a single entity by ID.\n- @param int $id Entity identifier.\n- @return iterable<BaseModel> Collection of models.\n- @return BaseModel|null The found entity or null.\n```\n192: public function findAll(): iterable;\n199: public function findById(int $id): ?BaseModel;\n206: public function count(array $criteria = []): int;\n207: }\n215: trait Cacheable {\n```\n\n### FUNCTION: `findById`\n> Signature: `public function findById(int $id): ?BaseModel`\n> Lines: 199-215\n- @brief Find a single entity by ID.\n- @brief Count entities matching a filter.\n- @param int $id Entity identifier.\n- @param array<string, mixed> $criteria Filter criteria.\n- @return BaseModel|null The found entity or null.\n- @return int Number of matching entities.\n```\n199: public function findById(int $id): ?BaseModel;\n206: public function count(array $criteria = []): int;\n207: }\n215: trait Cacheable {\n```\n\n### FUNCTION: `count`\n> Signature: `public function count(array $criteria = []): int`\n> Lines: 206-215\n- @brief Count entities matching a filter.\n- @param array<string, mixed> $criteria Filter criteria.\n- @return int Number of matching entities.\n```\n206: public function count(array $criteria = []): int;\n207: }\n215: trait Cacheable {\n```\n\n### TRAIT: `Cacheable`\n> Signature: `trait Cacheable`\n> Lines: 215-241\n- @brief Provides caching capabilities for models.\n- @brief Cache TTL in seconds.\n```\n215: trait Cacheable {\n217: protected int $cacheTtl = 3600;\n223: public function cache(): bool {\n225: return true;\n226: }\n232: public function invalidateCache(): void {\n234: }\n240: abstract public function cacheKey(): string;\n241: }\n```\n\n### FUNCTION: `cache`\n> Signature: `public function cache(): bool`\n> Lines: 223-226\n- @brief Store the current object in cache.\n- @return bool True if caching succeeded.\n```\n223: public function cache(): bool {\n225: return true;\n226: }\n```\n\n### FUNCTION: `invalidateCache`\n> Signature: `public function invalidateCache(): void`\n> Lines: 232-234\n- @brief Invalidate the cached version of this object.\n- @return void\n```\n232: public function invalidateCache(): void {\n234: }\n```\n\n### TRAIT: `SoftDeletable`\n> Signature: `trait SoftDeletable`\n> Lines: 247-266\n- @brief Adds soft delete functionality to models.\n- @brief Timestamp of soft deletion or null if active.\n```\n247: trait SoftDeletable {\n249: protected ?\\DateTimeImmutable $deletedAt = null;\n255: public function softDelete(): void {\n256: $this->deletedAt = new \\DateTimeImmutable();\n257: }\n263: public function isDeleted(): bool {\n264: return $this->deletedAt !== null;\n265: }\n266: }\n```\n\n### FUNCTION: `softDelete`\n> Signature: `public function softDelete(): void`\n> Lines: 255-257\n- @brief Mark the entity as soft-deleted.\n- @return void\n```\n255: public function softDelete(): void {\n256: $this->deletedAt = new \\DateTimeImmutable();\n257: }\n```\n\n### FUNCTION: `isDeleted`\n> Signature: `public function isDeleted(): bool`\n> Lines: 263-265\n- @brief Check if the entity is currently deleted.\n- @return bool True if soft-deleted.\n```\n263: public function isDeleted(): bool {\n264: return $this->deletedAt !== null;\n265: }\n```\n\n### CLASS: `CachedUser`\n> Signature: `final class CachedUser extends User`\n> Lines: 275-286\n- @brief User entity with caching and soft-delete capabilities.\n```\n275: final class CachedUser extends User {\n276: use Cacheable;\n277: use SoftDeletable;\n283: public function cacheKey(): string {\n284: return \"user:{$this->id}\";\n285: }\n286: }\n```\n\n### IMPORT: `Cacheable`\n> Lines: 276-276\n```\n276: use Cacheable;\n```\n\n### IMPORT: `SoftDeletable`\n> Lines: 277-277\n```\n277: use SoftDeletable;\n```\n\n### FUNCTION: `cacheKey`\n> Signature: `public function cacheKey(): string`\n> Lines: 283-285\n- @brief Generate a unique cache key for this user.\n- @return string Cache key in format \"user:{id}\".\n```\n283: public function cacheKey(): string {\n284: return \"user:{$this->id}\";\n285: }\n```\n\n### CLASS: `Route`\n> Signature: `class Route`\n> Lines: 295-305\n- @brief PHP attribute for annotating controller methods with routes.\n- @brief Define a route attribute.\n- @param string $path URL path pattern.\n- @param string $method HTTP method (GET, POST, etc.).\n```\n295: class Route {\n301: public function __construct(\n302: public readonly string $path,\n303: public readonly string $method = 'GET',\n304: ) {}\n305: }\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 301-304\n- @brief Define a route attribute.\n- @param string $path URL path pattern.\n- @param string $method HTTP method (GET, POST, etc.).\n```\n301: public function __construct(\n302: public readonly string $path,\n303: public readonly string $method = 'GET',\n304: ) {}\n```\n\n### FUNCTION: `helper`\n> Signature: `function helper(): bool`\n> Lines: 314-316\n- @brief Standalone helper returning a boolean result.\n- @return bool Always returns true.\n```\n314: function helper(): bool {\n315: return true;\n316: }\n```\n\n### FUNCTION: `processData`\n> Signature: `function processData(mixed $data): string`\n> Lines: 324-333\n- @brief Process data using match expression for type dispatching.\n- @param mixed $data Input data of any type.\n- @return string Description of the processed data.\n```\n324: function processData(mixed $data): string {\n326: return match(true) {\n327: is_string($data) => \"string: \" . strlen($data),\n328: is_int($data) => \"int: $data\",\n329: is_array($data) => \"array: \" . count($data),\n330: $data instanceof BaseModel => \"model: \" . $data->id,\n331: default => \"unknown\",\n332: };\n333: }\n```\n\n### FUNCTION: `applyTransform`\n> Signature: `function applyTransform(array $items, callable $fn): array`\n> Lines: 342-344\n- @brief Higher-order function using arrow function syntax.\n- @param array<int> $items Array of integers.\n- @param callable(int): int $fn Transform function.\n- @return array<int> Transformed array.\n```\n342: function applyTransform(array $items, callable $fn): array {\n343: return array_map(fn(int $x): int => $fn($x), $items);\n344: }\n```\n\n### FUNCTION: `createMultiplier`\n> Signature: `function createMultiplier(int $factor): \\Closure`\n> Lines: 352-355\n- @brief Create a closure that multiplies its argument.\n- @param int $factor The multiplication factor.\n- @return \\Closure(int): int A multiplier closure.\n```\n352: function createMultiplier(int $factor): \\Closure {\n354: return fn(int $x): int => $x * $factor;\n355: }\n```\n\n### FUNCTION: `readFileContent`\n> Signature: `function readFileContent(string $path): string|false`\n> Lines: 363-368\n- @brief Read file contents with comprehensive error handling.\n- @param string $path File system path.\n- @return string|false File contents or false on failure.\n```\n363: function readFileContent(string $path): string|false {\n364: if (!file_exists($path)) {\n365: return false;\n366: }\n367: return file_get_contents($path);\n368: }\n```\n\n### NAMESPACE: `App\\Services`\n> Signature: `namespace App\\Services`\n> Lines: 371-375\n```\n371: namespace App\\Services;\n372: namespace App\\Http;\n373: namespace App\\Domain;\n374: namespace App\\Support;\n375: interface ServiceContract {}\n```\n\n### NAMESPACE: `App\\Http`\n> Signature: `namespace App\\Http`\n> Lines: 372-375\n```\n372: namespace App\\Http;\n373: namespace App\\Domain;\n374: namespace App\\Support;\n375: interface ServiceContract {}\n```\n\n### NAMESPACE: `App\\Domain`\n> Signature: `namespace App\\Domain`\n> Lines: 373-375\n```\n373: namespace App\\Domain;\n374: namespace App\\Support;\n375: interface ServiceContract {}\n```\n\n### NAMESPACE: `App\\Support`\n> Signature: `namespace App\\Support`\n> Lines: 374-375\n```\n374: namespace App\\Support;\n375: interface ServiceContract {}\n```\n\n### INTERFACE: `ServiceContract`\n> Signature: `interface ServiceContract {}`\n> Lines: 375-375\n```\n375: interface ServiceContract {}\n```\n\n### INTERFACE: `CacheContract`\n> Signature: `interface CacheContract {}`\n> Lines: 376-376\n```\n376: interface CacheContract {}\n```\n\n### INTERFACE: `LoggerContract`\n> Signature: `interface LoggerContract {}`\n> Lines: 377-377\n```\n377: interface LoggerContract {}\n```\n\n### INTERFACE: `EventContract`\n> Signature: `interface EventContract {}`\n> Lines: 378-378\n```\n378: interface EventContract {}\n```\n\n### TRAIT: `HandlesEvents`\n> Signature: `trait HandlesEvents {}`\n> Lines: 379-379\n```\n379: trait HandlesEvents {}\n```\n\n### TRAIT: `TracksChanges`\n> Signature: `trait TracksChanges {}`\n> Lines: 380-380\n```\n380: trait TracksChanges {}\n```\n\n### TRAIT: `AuthorizesRequests`\n> Signature: `trait AuthorizesRequests {}`\n> Lines: 381-381\n```\n381: trait AuthorizesRequests {}\n```\n\n### CONSTANT: `API_LIMIT`\n> Signature: `const API_LIMIT = 50`\n> Lines: 382-382\n```\n382: const API_LIMIT = 50;\n```\n\n### CONSTANT: `DEFAULT_PAGE`\n> Signature: `const DEFAULT_PAGE = 1`\n> Lines: 383-383\n```\n383: const DEFAULT_PAGE = 1;\n```\n\n### CONSTANT: `TIMEOUT`\n> Signature: `const TIMEOUT = 30`\n> Lines: 384-384\n```\n384: const TIMEOUT = 30;\n```\n\n### CLASS: `ApiClient`\n> Signature: `final class ApiClient {}`\n> Lines: 385-385\n```\n385: final class ApiClient {}\n```\n\n### FUNCTION: `req_cover_php_1`\n> Signature: `function req_cover_php_1(int $value): int { return $value + 1; }`\n> Lines: 395-395\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n395: function req_cover_php_1(int $value): int { return $value + 1; }\n```\n\n### FUNCTION: `req_cover_php_2`\n> Signature: `function req_cover_php_2(int $value): int { return $value + 2; }`\n> Lines: 404-404\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n404: function req_cover_php_2(int $value): int { return $value + 2; }\n```\n\n### FUNCTION: `req_cover_php_3`\n> Signature: `function req_cover_php_3(int $value): int { return $value + 3; }`\n> Lines: 413-413\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n413: function req_cover_php_3(int $value): int { return $value + 3; }\n```\n\n### FUNCTION: `req_cover_php_4`\n> Signature: `function req_cover_php_4(int $value): int { return $value + 4; }`\n> Lines: 422-422\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n422: function req_cover_php_4(int $value): int { return $value + 4; }\n```\n\n### FUNCTION: `req_cover_php_5`\n> Signature: `function req_cover_php_5(int $value): int { return $value + 5; }`\n> Lines: 431-431\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n431: function req_cover_php_5(int $value): int { return $value + 5; }\n```\n",
-  "stderr": ""
-}

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

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ tests/fixtures/fixture_python.py | python\n- @brief Comprehensive Python test fixture for parser validation.\n- @details Covers classes, protocols, decorators, generators, async functions, and rich Doxygen-tagged constructs used to validate extraction workflows and deterministic parser behavior.\n\n### IMPORT: `asyncio  #!< @brief Async IO support. @details Used for async test fixtures. # noqa: F401`\n> Lines: 7-7\n- @brief Async IO support.\n- @details Used for async test fixtures. # noqa: F401\n```\n7: import asyncio\n```\n\n### IMPORT: `os  #!< @brief OS interface module. @details Provides OS-dependent functionality. # noqa: F401`\n> Lines: 8-8\n- @brief OS interface module.\n- @details Provides OS-dependent functionality. # noqa: F401\n```\n8: import os\n```\n\n### IMPORT: `sys  #!< @brief System-specific parameters. @see sys.exit() for exit handling.`\n> Lines: 9-9\n- @brief System-specific parameters.\n- @see sys.exit() for exit handling.\n```\n9: import sys\n```\n\n### IMPORT: `Path  #!< @brief Object-oriented filesystem paths. @note Preferred over os.path. # noqa: F401`\n> Lines: 10-10\n- @brief Object-oriented filesystem paths.\n- @note Preferred over os.path. # noqa: F401\n```\n10: from pathlib import Path\n```\n\n### IMPORT: `(`\n> Lines: 11-11\n```\n11: from typing import (\n```\n\n### IMPORT: `dataclass, field`\n> Lines: 15-15\n```\n15: from dataclasses import dataclass, field\n```\n\n### IMPORT: `ABC, abstractmethod`\n> Lines: 16-16\n```\n16: from abc import ABC, abstractmethod\n```\n\n### IMPORT: `contextmanager`\n> Lines: 17-17\n```\n17: from contextlib import contextmanager\n```\n\n### VARIABLE: `MAX_RETRIES`\n> Signature: `MAX_RETRIES = 3  #!< @brief Maximum retry attempts. @details Applied to network operations. @warning Tune per use case. @satisfies retry-policy`\n> Lines: 19-19\n- @brief Maximum retry attempts.\n- @details Applied to network operations.\n- @warning Tune per use case.\n- @satisfies retry-policy\n```\n19: MAX_RETRIES = 3\n```\n\n### VARIABLE: `DEFAULT_TIMEOUT`\n> Signature: `DEFAULT_TIMEOUT = 30.0  #!< @brief Default timeout in seconds. @note For I/O operations.`\n> Lines: 20-20\n- @brief Default timeout in seconds.\n- @note For I/O operations.\n```\n20: DEFAULT_TIMEOUT = 30.0\n```\n\n### DECORATOR: `dataclass`\n> Lines: 26-26\n```\n26: @dataclass(slots=True)\n```\n\n### CLASS: `Config`\n> Signature: `class Config`\n> Lines: 27-61\n- @brief Stores key-value pairs with optional default fallback.\n- @details Dataclass-based configuration with validation.\n- @note Immutable after creation when frozen=True is used.\n- @see __post_init__() for validation logic.\n```\n27: class Config:\n35:     name: str\n36:     values: Dict[str, str] = field(default_factory=dict)\n37:     debug: bool = False\n39:     def get(self, key: str, default: str = \"\") -> str:\n47:         if key in self.values:\n48:             return self.values[key]\n50:         return default\n52:     def __post_init__(self) -> None:\n58:         if not self.name.strip():\n59:             raise ValueError(\"Config name cannot be empty\")\n```\n\n### FUNCTION: `get`\n> Signature: `def get(self, key: str, default: str = \"\") -> str`\n> Lines: 39-51\n- @brief Stores key-value pairs with optional default fallback.\n- @details Dataclass-based configuration with validation.\n- @param key The configuration key to look up.\n- @param default Fallback value if key is missing.\n- @return The configuration value or default.\n- @note Immutable after creation when frozen=True is used.\n- @see __post_init__() for validation logic.\n```\n39:     def get(self, key: str, default: str = \"\") -> str:\n47:         if key in self.values:\n48:             return self.values[key]\n50:         return default\n```\n\n### FUNCTION: `__post_init__`\n> Signature: `def __post_init__(self) -> None`\n> Lines: 52-61\n- @brief Ensures name is non-empty and normalizes values. @raises ValueError If name is empty or whitespace.\n```\n52:     def __post_init__(self) -> None:\n58:         if not self.name.strip():\n59:             raise ValueError(\"Config name cannot be empty\")\n```\n\n### CLASS: `MyClass`\n> Signature: `class MyClass`\n> Lines: 62-167\n- @brief Base class demonstrating various Python constructs.\n- @details Includes nested classes, properties, and static methods.\n```\n62: class MyClass:\n69:     class InnerHelper:\n74:         def __init__(self, tag: str):\n79:             self.tag = tag\n81:         def describe(self) -> str:\n86:             return f\"Helper({self.tag})\"\n88:     def __init__(self, name: str, retries: int = MAX_RETRIES):\n94:         self._name = name\n95:         self._retries = retries\n97:         self._call_count = 0\n99:     @property\n100:     def name(self) -> str:\n105:         return self._name\n107:     @name.setter\n108:     def name(self, value: str) -> None:\n114:         if not value:\n115:             raise ValueError(\"Name cannot be empty\")\n116:         self._name = value\n118:     @staticmethod\n119:     def create_default() -> \"MyClass\":\n124:         return MyClass(\"default\")\n126:     @classmethod\n127:     def from_dict(cls, data: dict) -> \"MyClass\":\n134:         return cls(\n135:             name=data[\"name\"],\n136:             retries=data.get(\"retries\", MAX_RETRIES),\n137:         )\n139:     def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]:\n146:         self._call_count += 1\n147:         for item in items:\n149:             if not item.strip():\n150:                 continue\n151:             if verbose:\n152:                 print(f\"Processing: {item}\")\n154:             return item if len(item) > 1 else item.upper()\n155:         return None\n157:     def compute(self, x: int, y: int) -> int:\n165:         return (x + y) if (x > 0 and y > 0) else abs(x - y)\n```\n\n### CLASS: `InnerHelper`\n> Signature: `class InnerHelper`\n> Lines: 69-87\n- @brief Base class demonstrating various Python constructs.\n- @brief Handles auxiliary computations within MyClass scope.\n- @details Includes nested classes, properties, and static methods.\n```\n69:     class InnerHelper:\n74:         def __init__(self, tag: str):\n79:             self.tag = tag\n81:         def describe(self) -> str:\n86:             return f\"Helper({self.tag})\"\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self, tag: str)`\n> Lines: 74-80\n- @brief Handles auxiliary computations within MyClass scope.\n- @param tag Short label for categorization.\n```\n74:         def __init__(self, tag: str):\n79:             self.tag = tag\n```\n\n### FUNCTION: `describe`\n> Signature: `def describe(self) -> str`\n> Lines: 81-87\n- @return String combining class name and tag.\n```\n81:         def describe(self) -> str:\n86:             return f\"Helper({self.tag})\"\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self, name: str, retries: int = MAX_RETRIES)`\n> Lines: 88-98\n- @param name Identifier for this instance.\n- @param retries Maximum retry attempts; defaults to MAX_RETRIES.\n```\n88:     def __init__(self, name: str, retries: int = MAX_RETRIES):\n94:         self._name = name\n95:         self._retries = retries\n97:         self._call_count = 0\n```\n\n### DECORATOR: `property`\n> Lines: 99-99\n```\n99:     @property\n```\n\n### FUNCTION: `name`\n> Signature: `def name(self) -> str`\n> Lines: 100-106\n- @return The name string set during initialization.\n```\n100:     def name(self) -> str:\n105:         return self._name\n```\n\n### DECORATOR: `name.setter`\n> Lines: 107-107\n```\n107:     @name.setter\n```\n\n### FUNCTION: `name`\n> Signature: `def name(self, value: str) -> None`\n> Lines: 108-117\n- @param value New name; must be non-empty. @raises ValueError If value is empty.\n```\n108:     def name(self, value: str) -> None:\n114:         if not value:\n115:             raise ValueError(\"Name cannot be empty\")\n116:         self._name = value\n```\n\n### DECORATOR: `staticmethod`\n> Lines: 118-118\n```\n118:     @staticmethod\n```\n\n### FUNCTION: `create_default`\n> Signature: `def create_default() -> \"MyClass\"`\n> Lines: 119-125\n- @return A new MyClass instance with name='default'.\n```\n119:     def create_default() -> \"MyClass\":\n124:         return MyClass(\"default\")\n```\n\n### DECORATOR: `classmethod`\n> Lines: 126-126\n```\n126:     @classmethod\n```\n\n### FUNCTION: `from_dict`\n> Signature: `def from_dict(cls, data: dict) -> \"MyClass\"`\n> Lines: 127-138\n- @param data Dictionary with 'name' and optional 'retries' keys.\n- @return A new instance populated from data. @raises KeyError If 'name' key is missing.\n```\n127:     def from_dict(cls, data: dict) -> \"MyClass\":\n134:         return cls(\n135:             name=data[\"name\"],\n136:             retries=data.get(\"retries\", MAX_RETRIES),\n137:         )\n```\n\n### FUNCTION: `process`\n> Signature: `def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]`\n> Lines: 139-156\n- @param items List of strings to process sequentially.\n- @param verbose Enable detailed logging when True.\n- @return The first valid item found or None if all are empty.\n```\n139:     def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]:\n146:         self._call_count += 1\n147:         for item in items:\n149:             if not item.strip():\n150:                 continue\n151:             if verbose:\n152:                 print(f\"Processing: {item}\")\n154:             return item if len(item) > 1 else item.upper()\n155:         return None\n```\n\n### FUNCTION: `compute`\n> Signature: `def compute(self, x: int, y: int) -> int`\n> Lines: 157-167\n- @param x First operand.\n- @param y Second operand.\n- @return Sum if both positive, difference otherwise.\n```\n157:     def compute(self, x: int, y: int) -> int:\n165:         return (x + y) if (x > 0 and y > 0) else abs(x - y)\n```\n\n### CLASS: `AbstractProcessor`\n> Signature: `class AbstractProcessor(ABC)`\n> Lines: 168-196\n- @brief Defines the interface that concrete processors must implement.\n- @details ABC-based interface with abstract methods.\n- @note Subclasses must implement execute() and execute_async().\n- @see ConcreteProcessor for a working implementation.\n- @sa ABC documentation for abstract base class patterns.\n```\n168: class AbstractProcessor(ABC):\n178:     @abstractmethod\n179:     def execute(self, data: bytes) -> bool:\n185:         ...\n187:     @abstractmethod\n188:     async def execute_async(self, data: bytes) -> bool:\n194:         ...\n```\n\n### DECORATOR: `abstractmethod`\n> Lines: 178-178\n- @brief Defines the interface that concrete processors must implement.\n- @details ABC-based interface with abstract methods.\n- @note Subclasses must implement execute() and execute_async().\n- @see ConcreteProcessor for a working implementation.\n- @sa ABC documentation for abstract base class patterns.\n```\n178:     @abstractmethod\n```\n\n### FUNCTION: `execute`\n> Signature: `def execute(self, data: bytes) -> bool`\n> Lines: 179-186\n- @param data The raw input bytes to process.\n- @return True if processing succeeded, False otherwise.\n```\n179:     def execute(self, data: bytes) -> bool:\n185:         ...\n```\n\n### DECORATOR: `abstractmethod`\n> Lines: 187-187\n```\n187:     @abstractmethod\n```\n\n### FUNCTION: `execute_async`\n> Signature: `async def execute_async(self, data: bytes) -> bool`\n> Lines: 188-196\n- @param data The raw input bytes to process.\n- @return True if processing succeeded.\n```\n188:     async def execute_async(self, data: bytes) -> bool:\n194:         ...\n```\n\n### CLASS: `ConcreteProcessor`\n> Signature: `class ConcreteProcessor(AbstractProcessor)`\n> Lines: 197-231\n- @brief Processes byte data by decoding and validating content.\n- @details Implements synchronous and async execute methods.\n- @note Thread-safe for read operations.\n- @see AbstractProcessor for interface definition.\n```\n197: class ConcreteProcessor(AbstractProcessor):\n206:     def execute(self, data: bytes) -> bool:\n213:         try:\n214:             text = data.decode(\"utf-8\")\n216:             return bool(text.strip())\n217:         except UnicodeDecodeError:\n218:             return False\n219:         finally:\n221:             pass\n223:     async def execute_async(self, data: bytes) -> bool:\n229:         return self.execute(data)\n```\n\n### FUNCTION: `execute`\n> Signature: `def execute(self, data: bytes) -> bool`\n> Lines: 206-222\n- @brief Processes byte data by decoding and validating content.\n- @details Implements synchronous and async execute methods.\n- @param data Raw bytes, expected UTF-8 encoded text.\n- @return True if decoding and validation succeed. @raises UnicodeDecodeError Propagated if data is not valid UTF-8.\n- @note Thread-safe for read operations.\n- @see AbstractProcessor for interface definition.\n```\n206:     def execute(self, data: bytes) -> bool:\n213:         try:\n214:             text = data.decode(\"utf-8\")\n216:             return bool(text.strip())\n217:         except UnicodeDecodeError:\n218:             return False\n219:         finally:\n221:             pass\n```\n\n### FUNCTION: `execute_async`\n> Signature: `async def execute_async(self, data: bytes) -> bool`\n> Lines: 223-231\n- @param data Raw bytes to process asynchronously.\n- @return True if valid content found.\n```\n223:     async def execute_async(self, data: bytes) -> bool:\n229:         return self.execute(data)\n```\n\n### CLASS: `GenericContainer`\n> Signature: `class GenericContainer(Generic[T])`\n> Lines: 232-271\n- @brief Type-safe collection with iteration and lookup support.\n- @details Generic collection with find and iteration. @tparam T The element type stored in this container.\n- @note Implements __iter__ for iteration protocol.\n- @see typing.Generic for generics documentation.\n```\n232: class GenericContainer(Generic[T]):\n242:     def __init__(self) -> None:\n244:         self._items: List[T] = []\n246:     def add(self, item: T) -> None:\n251:         self._items.append(item)\n253:     def __iter__(self) -> Iterator[T]:\n258:         yield from self._items\n260:     def find(self, predicate) -> Optional[T]:\n266:         for item in self._items:\n267:             if predicate(item):\n268:                 return item\n269:         return None\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self) -> None`\n> Lines: 242-245\n- @brief Type-safe collection with iteration and lookup support.\n- @details Generic collection with find and iteration.\n@tparam T The element type stored in this container.\n- @note Implements __iter__ for iteration protocol.\n- @see typing.Generic for generics documentation.\n```\n242:     def __init__(self) -> None:\n244:         self._items: List[T] = []\n```\n\n### FUNCTION: `add`\n> Signature: `def add(self, item: T) -> None`\n> Lines: 246-252\n- @param item Element of type T to add.\n```\n246:     def add(self, item: T) -> None:\n251:         self._items.append(item)\n```\n\n### FUNCTION: `__iter__`\n> Signature: `def __iter__(self) -> Iterator[T]`\n> Lines: 253-259\n- @return Iterator yielding items of type T.\n```\n253:     def __iter__(self) -> Iterator[T]:\n258:         yield from self._items\n```\n\n### FUNCTION: `find`\n> Signature: `def find(self, predicate) -> Optional[T]`\n> Lines: 260-271\n- @param predicate Callable accepting T and returning bool.\n- @return The first matching item or None.\n```\n260:     def find(self, predicate) -> Optional[T]:\n266:         for item in self._items:\n267:             if predicate(item):\n268:                 return item\n269:         return None\n```\n\n### CLASS: `Renderable`\n> Signature: `class Renderable(Protocol)`\n> Lines: 272-285\n- @brief Structural typing interface for render-capable objects.\n```\n272: class Renderable(Protocol):\n278:     def render(self) -> str:\n283:         ...\n```\n\n### FUNCTION: `render`\n> Signature: `def render(self) -> str`\n> Lines: 278-285\n- @brief Structural typing interface for render-capable objects.\n- @return Rendered string output.\n```\n278:     def render(self) -> str:\n283:         ...\n```\n\n### DECORATOR: `property`\n> Lines: 286-286\n```\n286: @property\n```\n\n### FUNCTION: `regular_function`\n> Signature: `def regular_function(x: int) -> int`\n> Lines: 287-295\n- @param x Input integer value.\n- @return The input value unchanged.\n```\n287: def regular_function(x: int) -> int:\n293:     return x\n```\n\n### FUNCTION: `function_with_walrus`\n> Signature: `def function_with_walrus(data: List[int]) -> Optional[int]`\n> Lines: 296-307\n- @param data List of integers to scan.\n- @return The first value greater than 10, or None.\n```\n296: def function_with_walrus(data: List[int]) -> Optional[int]:\n303:     if (n := next((x for x in data if x > 10), None)) is not None:\n304:         return n\n305:     return None\n```\n\n### FUNCTION: `multi_return_paths`\n> Signature: `def multi_return_paths(value: int) -> Union[str, int, None]`\n> Lines: 308-325\n- @param value Integer selector for branching logic.\n- @return A string, integer, or None depending on value.\n```\n308: def multi_return_paths(value: int) -> Union[str, int, None]:\n314:     match value:\n315:         case 0:\n316:             return \"zero\"\n317:         case n if n < 0:\n319:             return abs(n)\n320:         case n if n > 100:\n321:             return None\n322:         case _:\n323:             return str(value)\n```\n\n### FUNCTION: `generator_function`\n> Signature: `def generator_function(limit: int) -> Iterator[int]`\n> Lines: 326-336\n- @param limit Upper bound (exclusive) for generation. @yield Squared integers from 0 to limit-1.\n```\n326: def generator_function(limit: int) -> Iterator[int]:\n332:     for i in range(limit):\n334:         yield i * i\n```\n\n### FUNCTION: `async_generator`\n> Signature: `async def async_generator(items: List[str]) -> AsyncIterator[str]`\n> Lines: 337-347\n- @param items Source strings to process. @yield Upper-cased non-empty strings.\n```\n337: async def async_generator(items: List[str]) -> AsyncIterator[str]:\n343:     for item in items:\n344:         if item.strip():\n345:             yield item.upper()\n```\n\n### DECORATOR: `contextmanager`\n> Lines: 348-348\n- @brief Context manager decorator.\n- @see contextlib.contextmanager\n```\n348: @contextmanager\n```\n\n### FUNCTION: `managed_resource`\n> Signature: `def managed_resource(path: str)`\n> Lines: 349-362\n- @param path File system path to the resource. @yield The opened file handle. @raises IOError If the resource cannot be opened.\n```\n349: def managed_resource(path: str):\n356:     f = open(path, \"r\")\n357:     try:\n358:         yield f\n359:     finally:\n360:         f.close()\n```\n\n### FUNCTION: `closure_factory`\n> Signature: `def closure_factory(multiplier: int)`\n> Lines: 363-379\n- @param multiplier The fixed multiplier for the returned function.\n- @return A callable that multiplies input by multiplier.\n```\n363: def closure_factory(multiplier: int):\n369:     def inner(x: int) -> int:\n376:         return x * multiplier\n377:     return inner\n```\n\n### FUNCTION: `inner`\n> Signature: `def inner(x: int) -> int`\n> Lines: 369-376\n- @param multiplier The fixed multiplier for the returned function.\n- @param x Value to multiply.\n- @return A callable that multiplies input by multiplier.\n- @return Product of x and the captured multiplier.\n```\n369:     def inner(x: int) -> int:\n376:         return x * multiplier\n```\n\n### FUNCTION: `uses_unpacking`\n> Signature: `def uses_unpacking(*args: int, **kwargs: str) -> Dict[str, Union[int, str]]`\n> Lines: 380-393\n- @param args Positional integer arguments.\n- @param kwargs Named string arguments.\n- @return Combined dictionary of all arguments.\n```\n380: def uses_unpacking(*args: int, **kwargs: str) -> Dict[str, Union[int, str]]:\n387:     result: Dict[str, Union[int, str]] = {}\n388:     for i, val in enumerate(args):\n389:         result[f\"arg_{i}\"] = val\n390:     result.update(kwargs)\n391:     return result\n```\n\n### VARIABLE: `EVEN_SQUARES`\n> Signature: `EVEN_SQUARES = [x ** 2 for x in range(20) if x % 2 == 0]`\n> Lines: 398-398\n```\n398: EVEN_SQUARES = [x ** 2 for x in range(20) if x % 2 == 0]\n```\n\n### FUNCTION: `async_function`\n> Signature: `async def async_function()`\n> Lines: 401-408\n- @brief Minimal async function for testing async detection.\n```\n401: async def async_function():\n406:     await asyncio.sleep(0)\n```\n\n### FUNCTION: `deeply_nested_logic`\n> Signature: `def deeply_nested_logic(matrix: List[List[int]]) -> int`\n> Lines: 409-429\n- @param matrix 2D list of integers.\n- @return Cumulative sum of positive even values.\n```\n409: def deeply_nested_logic(matrix: List[List[int]]) -> int:\n415:     total = 0\n416:     for row in matrix:\n417:         for val in row:\n418:             if val > 0:\n419:                 if val % 2 == 0:\n421:                     total += val\n422:                 else:\n423:                     continue\n424:             else:\n426:                 pass\n427:     return total\n```\n\n### FUNCTION: `exception_handling_example`\n> Signature: `def exception_handling_example(path: str) -> Optional[str]`\n> Lines: 430-453\n- @param path File path to attempt reading.\n- @return File contents or None on failure.\n```\n430: def exception_handling_example(path: str) -> Optional[str]:\n436:     try:\n437:         with open(path, \"r\") as f:\n438:             content = f.read()\n439:         if not content:\n440:             raise ValueError(\"Empty file\")\n441:         return content\n442:     except FileNotFoundError:\n444:         return None\n445:     except (PermissionError, OSError) as e:\n447:         sys.exit(1)\n448:     except Exception:\n449:         raise\n450:     finally:\n452:         pass\n```\n\n### VARIABLE: `MAX_BATCH`\n> Signature: `MAX_BATCH = 64  # inline extension comment`\n> Lines: 455-455\n```\n455: MAX_BATCH = 64\n```\n\n### VARIABLE: `CACHE_LIMIT`\n> Signature: `CACHE_LIMIT = 128`\n> Lines: 457-457\n```\n457: CACHE_LIMIT = 128\n```\n\n### VARIABLE: `MAX_USERS`\n> Signature: `MAX_USERS = 500`\n> Lines: 459-459\n```\n459: MAX_USERS = 500\n```\n\n### FUNCTION: `req_cover_py_1`\n> Signature: `def req_cover_py_1(value: int) -> int`\n> Lines: 467-469\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n467: def req_cover_py_1(value: int) -> int:\n468:     return value + 1\n```\n\n### FUNCTION: `req_cover_py_2`\n> Signature: `def req_cover_py_2(value: int) -> int`\n> Lines: 475-477\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n475: def req_cover_py_2(value: int) -> int:\n476:     return value + 2\n```\n\n### FUNCTION: `req_cover_py_3`\n> Signature: `def req_cover_py_3(value: int) -> int`\n> Lines: 483-485\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n483: def req_cover_py_3(value: int) -> int:\n484:     return value + 3\n```\n\n### FUNCTION: `req_cover_py_4`\n> Signature: `def req_cover_py_4(value: int) -> int`\n> Lines: 491-493\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n491: def req_cover_py_4(value: int) -> int:\n492:     return value + 4\n```\n\n### FUNCTION: `req_cover_py_5`\n> Signature: `def req_cover_py_5(value: int) -> int`\n> Lines: 499-501\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n499: def req_cover_py_5(value: int) -> int:\n500:     return value + 5\n```\n",
-  "stderr": ""
-}

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

package/tests/fixtures_attended_results/standalone/files-find-line-numbers/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```\n9: use std::io;\n```\n\n### IMPORT: `std::collections::HashMap`\n> Lines: 10-10\n```\n10: use std::collections::HashMap;\n```\n\n### IMPORT: `std::fmt::{self, Display, Formatter}`\n> Lines: 11-11\n```\n11: use std::fmt::{self, Display, Formatter};\n```\n\n### IMPORT: `std::sync::{Arc, Mutex}`\n> Lines: 12-12\n```\n12: use 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```\n19: #[derive(Debug, Clone, PartialEq)]\n```\n\n### STRUCT: `MyStruct`\n> Signature: `pub struct MyStruct`\n> Lines: 20-23\n- @brief Primary integer field.\n```\n20: pub struct MyStruct {\n22: field: i32,\n23: }\n```\n\n### DECORATOR: `derive(Debug)`\n> Lines: 29-29\n```\n29: #[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```\n30: pub struct BorrowedData<'a> {\n32: content: &'a str,\n34: tag: u64,\n35: }\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```\n41: pub struct TypedMap<K: std::hash::Hash + Eq, V: Clone> {\n43: inner: HashMap<K, V>,\n44: }\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```\n51: pub enum MyEnum {\n53: A,\n55: B(String),\n57: C { x: i32, y: i32 },\n58: }\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```\n65: pub trait MyTrait {\n67: fn do_work(&self);\n73: fn do_work_with_ctx(&self, ctx: &str) -> bool {\n75: println!(\"ctx: {}\", ctx);\n76: self.do_work();\n77: true\n78: }\n79: }\n```\n\n### FUNCTION: `do_work`\n> Signature: `fn do_work(&self)`\n> Lines: 67-78\n```\n67: fn do_work(&self);\n73: fn do_work_with_ctx(&self, ctx: &str) -> bool {\n75: println!(\"ctx: {}\", ctx);\n76: self.do_work();\n77: true\n78: }\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```\n73: fn do_work_with_ctx(&self, ctx: &str) -> bool {\n75: println!(\"ctx: {}\", ctx);\n76: self.do_work();\n77: true\n78: }\n```\n\n### TRAIT: `Parser`\n> Signature: `pub trait Parser<'a>`\n> Lines: 85-94\n- @brief The output type produced by parsing.\n```\n85: pub trait Parser<'a> {\n87: type Output;\n93: fn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>;\n94: }\n```\n\n### TYPE_ALIAS: `Output`\n> Signature: `type Output`\n> Lines: 87-87\n- @brief The output type produced by parsing.\n```\n87: type 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```\n93: fn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>;\n94: }\n96: impl MyStruct {\n```\n\n### IMPL: `MyStruct`\n> Signature: `impl MyStruct`\n> Lines: 96-132\n- @return A MyStruct with field initialized to 0.\n```\n96: impl MyStruct {\n100: fn new() -> Self {\n101: Self { field: 0 }\n102: }\n108: pub fn with_value(val: i32) -> Self {\n109: Self { field: val }\n110: }\n115: pub fn value(&self) -> i32 {\n116: self.field\n117: }\n123: pub fn try_update(&mut self, new_val: i32) -> Option<i32> {\n124: if new_val == self.field {\n125: return None;\n126: }\n127: let old = self.field;\n128: self.field = new_val;\n130: Some(old)\n131: }\n132: }\n```\n\n### FUNCTION: `new`\n> Signature: `fn new() -> Self`\n> Lines: 100-102\n- @return A MyStruct with field initialized to 0.\n```\n100: fn new() -> Self {\n101: Self { field: 0 }\n102: }\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```\n108: pub fn with_value(val: i32) -> Self {\n109: Self { field: val }\n110: }\n```\n\n### FUNCTION: `value`\n> Signature: `pub fn value(&self) -> i32`\n> Lines: 115-117\n- @return The stored integer.\n```\n115: pub fn value(&self) -> i32 {\n116: self.field\n117: }\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```\n123: pub fn try_update(&mut self, new_val: i32) -> Option<i32> {\n124: if new_val == self.field {\n125: return None;\n126: }\n127: let old = self.field;\n128: self.field = new_val;\n130: Some(old)\n131: }\n```\n\n### IMPL: `MyStruct`\n> Signature: `impl MyTrait for MyStruct`\n> Lines: 134-139\n```\n134: impl MyTrait for MyStruct {\n136: fn do_work(&self) {\n137: println!(\"{:?}\", self);\n138: }\n139: }\n```\n\n### FUNCTION: `do_work`\n> Signature: `fn do_work(&self)`\n> Lines: 136-138\n```\n136: fn do_work(&self) {\n137: println!(\"{:?}\", self);\n138: }\n```\n\n### IMPL: `MyStruct`\n> Signature: `impl Display for MyStruct`\n> Lines: 141-149\n- @param f Formatter to write into.\n```\n141: impl Display for MyStruct {\n146: fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\n147: write!(f, \"MyStruct({})\", self.field)\n148: }\n149: }\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```\n146: fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\n147: write!(f, \"MyStruct({})\", self.field)\n148: }\n```\n\n### IMPL: `TypedMap`\n> Signature: `impl<K, V> TypedMap<K, V>`\n> Lines: 153-177\n```\n153: impl<K, V> TypedMap<K, V>\n154: where\n155: K: std::hash::Hash + Eq + Display,\n156: V: Clone + Default,\n157: {\n163: pub fn insert(&mut self, key: K, value: V) -> Option<V> {\n164: self.inner.insert(key, value)\n165: }\n171: pub fn get_or_default(&self, key: &K) -> V {\n172: match self.inner.get(key) {\n173: Some(v) => v.clone(),\n174: None => V::default(),\n175: }\n176: }\n177: }\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```\n163: pub fn insert(&mut self, key: K, value: V) -> Option<V> {\n164: self.inner.insert(key, value)\n165: }\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```\n171: pub fn get_or_default(&self, key: &K) -> V {\n172: match self.inner.get(key) {\n173: Some(v) => v.clone(),\n174: None => V::default(),\n175: }\n176: }\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```\n182: pub mod my_module;\n185: pub(crate) mod internal {\n187: pub(crate) static COUNTER: std::sync::atomic::AtomicUsize =\n188: std::sync::atomic::AtomicUsize::new(0);\n189: }\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```\n185: pub(crate) mod internal {\n187: pub(crate) static COUNTER: std::sync::atomic::AtomicUsize =\n188: std::sync::atomic::AtomicUsize::new(0);\n189: }\n```\n\n### CONSTANT: `COUNTER`\n> Signature: `pub(crate) static COUNTER: std::sync::atomic::AtomicUsize =`\n> Lines: 187-187\n```\n187: pub(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```\n196: macro_rules! hashmap {\n```\n\n### MACRO: `my_macro`\n> Signature: `macro_rules! my_macro`\n> Lines: 205-205\n```\n205: macro_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```\n217: const 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```\n220: static 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```\n223: static 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```\n229: pub 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```\n232: pub 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```\n240: pub fn my_function(input: Option<&str>) -> String {\n242: let text = match input {\n243: Some(s) if !s.is_empty() => s,\n244: Some(_) => return String::from(\"empty\"),\n245: None => return String::from(\"none\"),\n246: };\n248: text.to_uppercase()\n249: }\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```\n254: pub async fn async_function() -> String {\n256: String::from(\"hello async\")\n257: }\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```\n264: pub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>\n265: where\n266: F: Fn(&i32) -> bool,\n267: {\n268: items.iter().copied().filter(|x| predicate(x)).collect()\n269: }\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```\n275: pub fn create_worker(use_struct: bool) -> Box<dyn MyTrait> {\n276: if use_struct {\n277: Box::new(MyStruct::new())\n278: } else {\n279: panic!(\"No alternative implementation available\");\n280: }\n281: }\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```\n288: pub unsafe fn read_raw(ptr: *const i32) -> i32 {\n290: *ptr\n291: }\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```\n297: pub extern \"C\" fn ffi_double(x: i32) -> i32 {\n298: x * 2\n299: }\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```\n305: pub fn describe_enum(val: &MyEnum) -> String {\n306: match val {\n307: MyEnum::A => String::from(\"unit\"),\n308: MyEnum::B(s) => format!(\"string: {}\", s),\n309: MyEnum::C { x, y } => {\n311: let mag = ((x * x + y * y) as f64).sqrt();\n312: format!(\"point({}, {}) mag={:.2}\", x, y, mag)\n313: }\n314: }\n315: }\n```\n\n### IMPORT: `std::time::Duration`\n> Lines: 318-318\n```\n318: use 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```\n319: pub 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```\n320: mod 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```\n321: pub mod ext_api { pub fn pong() -> i32 { 3 } }\n```\n\n### DECORATOR: `inline`\n> Lines: 322-322\n```\n322: #[inline]\n```\n\n### DECORATOR: `allow(dead_code)`\n> Lines: 323-323\n```\n323: #[allow(dead_code)]\n```\n\n### DECORATOR: `cfg(test)`\n> Lines: 324-324\n```\n324: #[cfg(test)]\n```\n\n### ENUM: `Status`\n> Signature: `pub enum Status { Ready, Busy }`\n> Lines: 325-325\n```\n325: pub enum Status { Ready, Busy }\n```\n\n### ENUM: `Mode`\n> Signature: `pub enum Mode { Alpha, Beta }`\n> Lines: 326-326\n```\n326: pub enum Mode { Alpha, Beta }\n```\n\n### ENUM: `Signal`\n> Signature: `pub enum Signal { On, Off }`\n> Lines: 327-327\n```\n327: pub enum Signal { On, Off }\n```\n\n### ENUM: `ErrorKind`\n> Signature: `pub enum ErrorKind { Io, Parse }`\n> Lines: 328-328\n```\n328: pub enum ErrorKind { Io, Parse }\n```\n\n### STRUCT: `ExtraNode`\n> Signature: `pub struct ExtraNode { pub id: i32 }`\n> Lines: 329-329\n```\n329: pub struct ExtraNode { pub id: i32 }\n```\n\n### STRUCT: `InnerNode`\n> Signature: `struct InnerNode { id: i32 }`\n> Lines: 330-330\n```\n330: struct InnerNode { id: i32 }\n```\n\n### TRAIT: `Inspectable`\n> Signature: `pub trait Inspectable { fn inspect(&self) -> i32; }`\n> Lines: 331-331\n```\n331: pub 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```\n332: trait 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```\n333: pub 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```\n334: impl 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```\n335: impl 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```\n336: impl 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```\n337: macro_rules! ext_macro { () => { 42 } }\n```\n\n### MACRO: `trace_macro`\n> Signature: `macro_rules! trace_macro { ($v:expr) => { $v }; }`\n> Lines: 338-338\n```\n338: macro_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```\n339: macro_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```\n340: pub const LIMIT: usize = 8;\n```\n\n### TYPE_ALIAS: `ItemId`\n> Signature: `pub type ItemId = u64`\n> Lines: 341-341\n```\n341: pub type ItemId = u64;\n```\n\n### TYPE_ALIAS: `AliasValue`\n> Signature: `type AliasValue = i32`\n> Lines: 342-342\n```\n342: type 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```\n350: fn 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```\n357: fn 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```\n364: fn 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```\n371: fn 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```\n378: fn req_cover_rust_5(value: i32) -> i32 { value + 5 }\n```\n",
-  "stderr": ""
-}

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

package/tests/fixtures_attended_results/standalone/files-find-line-numbers/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```\n12: MY_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```\n15: export 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```\n18: readonly 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```\n21: declare -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```\n24: DEBUG_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```\n29: declare -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```\n32: declare -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```\n44: function 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```\n56: cleanup() {\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```\n68: parse_args() {\n```\n\n### VARIABLE: `VERBOSE`\n> Signature: `VERBOSE=1`\n> Lines: 74-74\n```\n74: VERBOSE=1\n```\n\n### VARIABLE: `DEBUG_MODE`\n> Signature: `DEBUG_MODE=1`\n> Lines: 78-78\n```\n78: DEBUG_MODE=1\n```\n\n### VARIABLE: `INPUT_FILE`\n> Signature: `INPUT_FILE=\"$OPTARG\"`\n> Lines: 82-82\n```\n82: INPUT_FILE=\"$OPTARG\"\n```\n\n### VARIABLE: `OUTPUT_FILE`\n> Signature: `OUTPUT_FILE=\"$OPTARG\"`\n> Lines: 86-86\n```\n86: OUTPUT_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```\n105: process_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```\n139: retry_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```\n162: log_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```\n172: make_temp() {\n```\n\n### FUNCTION: `generate_config`\n> Signature: `generate_config()`\n> Lines: 189-189\n- @brief Generate a configuration file using heredoc.\n```\n189: generate_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```\n203: factorial() {\n```\n\n### IMPORT: `./config.sh`\n> Lines: 218-218\n- @brief Load external configuration script if present.\n```\n218: source ./config.sh\n```\n\n### IMPORT: `./env.sh`\n> Lines: 222-222\n```\n222: source ./env.sh\n```\n\n### IMPORT: `./shared.sh`\n> Lines: 224-224\n```\n224: source ./shared.sh\n```\n\n### IMPORT: `./runtime.sh`\n> Lines: 226-226\n```\n226: source ./runtime.sh\n```\n\n### IMPORT: `./network.sh`\n> Lines: 228-228\n```\n228: source ./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```\n236: req_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```\n245: req_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```\n254: req_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```\n263: req_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```\n272: req_cover_shell_5() {\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find-line-numbers/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```\n8: import Foundation\n```\n\n### IMPORT: `Combine`\n> Lines: 9-9\n```\n9: import 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```\n16: class Animal {\n18: var species: String\n21: var legs: Int = 4 {\n22: willSet {\n24: print(\"Legs changing from \\(legs) to \\(newValue)\")\n25: }\n26: didSet {\n28: if legs < 0 { legs = 0 }\n29: }\n30: }\n33: var description: String {\n34: return \"\\(species) with \\(legs) legs\"\n35: }\n39: init(species: String) {\n40: self.species = species\n41: }\n44: func speak() {\n45: print(\"...\")\n46: }\n50: class func createDefault() -> Animal {\n51: return Animal(species: \"Unknown\")\n52: }\n55: deinit {\n56: print(\"\\(species) deallocated\")\n57: }\n58: }\n```\n\n### VARIABLE: `species`\n> Signature: `var species: String`\n> Lines: 18-18\n- @brief Species name identifier.\n```\n18: var 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```\n21: var 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```\n33: var description: String {\n```\n\n### FUNCTION: `speak`\n> Signature: `func speak()`\n> Lines: 44-46\n- @brief Produce a sound; subclasses should override.\n```\n44: func speak() {\n45: print(\"...\")\n46: }\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```\n50: class func createDefault() -> Animal {\n51: return Animal(species: \"Unknown\")\n52: }\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```\n63: class Dog: Animal {\n65: let name: String\n69: init(name: String) {\n70: self.name = name\n71: super.init(species: \"Dog\")\n72: }\n75: override func speak() {\n76: print(\"\\(name) says: Woof!\")\n77: }\n78: }\n```\n\n### CONSTANT: `name`\n> Signature: `let name: String`\n> Lines: 65-65\n- @brief Dog's name.\n```\n65: let 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```\n75: override func speak() {\n76: print(\"\\(name) says: Woof!\")\n77: }\n```\n\n### STRUCT: `Point`\n> Signature: `struct Point: Equatable`\n> Lines: 85-102\n- @brief Value type representing a coordinate pair.\n```\n85: struct Point: Equatable {\n86: var x: Double = 0.0\n87: var y: Double = 0.0\n93: static func + (lhs: Point, rhs: Point) -> Point {\n94: return Point(x: lhs.x + rhs.x, y: lhs.y + rhs.y)\n95: }\n99: var magnitude: Double {\n100: return (x * x + y * y).squareRoot()\n101: }\n102: }\n```\n\n### VARIABLE: `x`\n> Signature: `var x: Double = 0.0`\n> Lines: 86-86\n```\n86: var x: Double = 0.0\n```\n\n### VARIABLE: `y`\n> Signature: `var y: Double = 0.0`\n> Lines: 87-87\n```\n87: var 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```\n99: var 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```\n107: struct Matrix {\n109: private var data: [[Double]]\n112: let rows: Int\n114: let cols: Int\n119: init(rows: Int, cols: Int) {\n120: self.rows = rows\n121: self.cols = cols\n122: data = Array(repeating: Array(repeating: 0.0, count: cols), count: rows)\n123: }\n129: subscript(row: Int, col: Int) -> Double {\n130: get { return data[row][col] }\n131: set { data[row][col] = newValue }\n132: }\n133: }\n```\n\n### VARIABLE: `data`\n> Signature: `private var data: [[Double]]`\n> Lines: 109-109\n- @brief Flat storage for matrix values.\n```\n109: private var data: [[Double]]\n```\n\n### CONSTANT: `rows`\n> Signature: `let rows: Int`\n> Lines: 112-112\n- @brief Number of rows.\n```\n112: let rows: Int\n```\n\n### CONSTANT: `cols`\n> Signature: `let cols: Int`\n> Lines: 114-114\n- @brief Number of columns.\n```\n114: let 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```\n140: enum Direction: String, CaseIterable {\n141: case up = \"UP\"\n142: case down = \"DOWN\"\n143: case left = \"LEFT\"\n144: case right = \"RIGHT\"\n148: var opposite: Direction {\n149: switch self {\n150: case .up: return .down\n151: case .down: return .up\n152: case .left: return .right\n153: case .right: return .left\n154: }\n155: }\n156: }\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```\n148: var 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```\n162: enum AppResult<T> {\n164: case success(T)\n166: case failure(Error)\n171: func map<U>(_ transform: (T) -> U) -> AppResult<U> {\n172: switch self {\n173: case .success(let value):\n174: return .success(transform(value))\n175: case .failure(let error):\n176: return .failure(error)\n177: }\n178: }\n179: }\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```\n171: func map<U>(_ transform: (T) -> U) -> AppResult<U> {\n172: switch self {\n173: case .success(let value):\n174: return .success(transform(value))\n175: case .failure(let error):\n176: return .failure(error)\n177: }\n178: }\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```\n186: protocol Drawable {\n189: func draw() -> String\n192: var renderPriority: Int { get }\n193: }\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```\n189: func draw() -> String\n192: var 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```\n192: var 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```\n198: protocol Container {\n200: associatedtype Item\n204: mutating func add(_ item: Item)\n207: var count: Int { get }\n208: }\n```\n\n### VARIABLE: `count`\n> Signature: `var count: Int { get }`\n> Lines: 207-207\n- @brief Number of elements in the container.\n```\n207: var 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```\n212: extension Drawable {\n214: var renderPriority: Int { return 0 }\n218: func debugDraw() -> String {\n219: return \"[\\(renderPriority)] \\(draw())\"\n220: }\n221: }\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```\n214: var 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```\n218: func debugDraw() -> String {\n219: return \"[\\(renderPriority)] \\(draw())\"\n220: }\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```\n226: extension Animal: Drawable {\n229: func draw() -> String {\n230: return description\n231: }\n235: func describe() -> String {\n236: return \"Animal: \\(species)\"\n237: }\n238: }\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```\n229: func draw() -> String {\n230: return description\n231: }\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```\n235: func describe() -> String {\n236: return \"Animal: \\(species)\"\n237: }\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```\n247: struct Clamped<Value: Comparable> {\n249: let min: Value\n251: let max: Value\n253: private var value: Value\n256: var wrappedValue: Value {\n257: get { return value }\n258: set { value = Swift.min(Swift.max(newValue, min), max) }\n259: }\n262: init(wrappedValue: Value, min: Value, max: Value) {\n263: self.min = min\n264: self.max = max\n266: self.value = Swift.min(Swift.max(wrappedValue, min), max)\n267: }\n268: }\n```\n\n### CONSTANT: `min`\n> Signature: `let min: Value`\n> Lines: 249-249\n- @brief Minimum allowed value.\n```\n249: let min: Value\n```\n\n### CONSTANT: `max`\n> Signature: `let max: Value`\n> Lines: 251-251\n- @brief Maximum allowed value.\n```\n251: let max: Value\n```\n\n### VARIABLE: `value`\n> Signature: `private var value: Value`\n> Lines: 253-253\n- @brief Current stored value.\n```\n253: private 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```\n256: var wrappedValue: Value {\n```\n\n### VARIABLE: `value`\n> Signature: `private var value: Int = 0`\n> Lines: 277-277\n- @brief Current count value.\n```\n277: private 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```\n281: func increment() -> Int {\n282: value += 1\n283: return value\n284: }\n```\n\n### FUNCTION: `reset`\n> Signature: `func reset()`\n> Lines: 287-289\n- @brief Reset the counter to zero.\n```\n287: func reset() {\n288: value = 0\n289: }\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```\n296: public func greet(name: String) {\n297: print(\"Hello \\(name)\")\n298: }\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```\n302: func makeDrawable() -> some Drawable {\n303: return Animal(species: \"Cat\")\n304: }\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```\n311: func contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable {\n312: return items.contains(target)\n313: }\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```\n318: func deferred(_ action: @escaping () -> Void) -> () -> Void {\n319: return {\n321: action()\n322: }\n323: }\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```\n328: let 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```\n331: private 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```\n334: let defaultConfig: [String: Any] = {\n```\n\n### VARIABLE: `config`\n> Signature: `var config: [String: Any] = [:]`\n> Lines: 335-335\n```\n335: var config: [String: Any] = [:]\n```\n\n### IMPORT: `SwiftUI`\n> Lines: 342-342\n```\n342: import SwiftUI\n```\n\n### IMPORT: `Combine`\n> Lines: 343-343\n```\n343: import Combine\n```\n\n### IMPORT: `Foundation`\n> Lines: 344-344\n```\n344: import Foundation\n```\n\n### IMPORT: `Dispatch`\n> Lines: 345-345\n```\n345: import Dispatch\n```\n\n### IMPORT: `UIKit`\n> Lines: 346-346\n```\n346: import UIKit\n```\n\n### CLASS: `ServiceController`\n> Signature: `class ServiceController {}`\n> Lines: 347-347\n```\n347: class ServiceController {}\n```\n\n### CLASS: `CacheStore`\n> Signature: `final class CacheStore {}`\n> Lines: 348-348\n```\n348: final class CacheStore {}\n```\n\n### STRUCT: `Vector2`\n> Signature: `struct Vector2 { let x: Int; let y: Int }`\n> Lines: 349-349\n```\n349: struct Vector2 { let x: Int; let y: Int }\n```\n\n### STRUCT: `Limits`\n> Signature: `struct Limits { let max: Int }`\n> Lines: 350-350\n```\n350: struct Limits { let max: Int }\n```\n\n### ENUM: `ModeSwift`\n> Signature: `enum ModeSwift { case fast, safe }`\n> Lines: 351-351\n```\n351: enum ModeSwift { case fast, safe }\n```\n\n### ENUM: `PhaseSwift`\n> Signature: `enum PhaseSwift { case initState, done }`\n> Lines: 352-352\n```\n352: enum PhaseSwift { case initState, done }\n```\n\n### ENUM: `SignalSwift`\n> Signature: `enum SignalSwift { case on, off }`\n> Lines: 353-353\n```\n353: enum SignalSwift { case on, off }\n```\n\n### PROTOCOL: `RunnerSwift`\n> Signature: `protocol RunnerSwift { func run() }`\n> Lines: 354-354\n```\n354: protocol RunnerSwift { func run() }\n```\n\n### PROTOCOL: `LoggerSwift`\n> Signature: `protocol LoggerSwift { func log(_ msg: String) }`\n> Lines: 355-355\n```\n355: protocol LoggerSwift { func log(_ msg: String) }\n```\n\n### PROTOCOL: `ParserSwift`\n> Signature: `protocol ParserSwift { func parse(_ input: String) -> String }`\n> Lines: 356-356\n```\n356: protocol 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```\n357: extension 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```\n358: extension 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```\n359: extension 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```\n367: func 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```\n374: func 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```\n381: func 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```\n388: func 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```\n395: func reqCoverSwift5(_ value: Int) -> Int { value + 5 }\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/standalone/files-find-line-numbers/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```\n10: import { Component } from 'react';\n```\n\n### IMPORT: `type { ReactNode } from 'react';`\n> Lines: 11-11\n```\n11: import 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```\n19: interface User {\n21: name: string;\n23: age: number;\n25: email?: string;\n27: readonly id: string;\n28: }\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```\n35: interface Repository<T> {\n37: findById(id: string): Promise<T | null>;\n39: save(entity: T): Promise<T>;\n41: delete(id: string): Promise<boolean>;\n42: }\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```\n48: interface Serializable {\n50: toJSON(): string;\n51: }\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```\n56: type 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```\n59: type 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```\n64: type 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```\n67: type 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```\n70: type 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```\n76: type 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```\n86: const enum Direction {\n87: Up = 'UP',\n88: Down = 'DOWN',\n89: Left = 'LEFT',\n90: Right = 'RIGHT',\n91: }\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```\n97: enum Color {\n99: Red,\n101: Blue,\n103: Green = 10,\n104: }\n```\n\n### ENUM: `HttpStatus`\n> Signature: `enum HttpStatus`\n> Lines: 110-114\n- @brief String enum mapping HTTP status codes.\n```\n110: enum HttpStatus {\n111: OK = '200',\n112: NotFound = '404',\n113: ServerError = '500',\n114: }\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```\n122: export abstract class Base {\n127: abstract render(): void;\n132: execute(): void {\n134: console.log('before render');\n135: this.render();\n137: console.log('after render');\n138: }\n139: }\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```\n148: class Derived extends Base {\n150: value: number = 0;\n153: label?: string;\n158: render(): void {\n159: console.log(this.value);\n160: }\n161: }\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```\n168: class TypedContainer<T extends Serializable> {\n170: private items: T[] = [];\n176: add(item: T): void {\n177: this.items.push(item);\n178: }\n184: toJSON(): string {\n185: return `[${this.items.map(i => i.toJSON()).join(',')}]`;\n186: }\n193: find(predicate: (item: T) => boolean): T | undefined {\n194: for (const item of this.items) {\n195: if (predicate(item)) {\n196: return item;\n197: }\n198: }\n199: return undefined;\n200: }\n201: }\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```\n210: class UserEntity implements User, Serializable {\n211: readonly id: string;\n212: name: string;\n213: age: number;\n215: constructor(id: string, name: string, age: number) {\n216: this.id = id;\n217: this.name = name;\n218: this.age = age;\n219: }\n225: toJSON(): string {\n226: return JSON.stringify({ id: this.id, name: this.name, age: this.age });\n227: }\n228: }\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```\n237: export function greet(name: string): void {\n238: console.log(`Hello, ${name}`);\n239: }\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```\n249: function parse(input: string): number;\n250: function parse(input: number): string;\n251: function parse(input: string | number): string | number {\n252: if (typeof input === 'string') {\n253: return parseInt(input, 10);\n254: }\n255: return input.toString();\n256: }\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: number): string`\n> Lines: 250-256\n```\n250: function parse(input: number): string;\n251: function parse(input: string | number): string | number {\n252: if (typeof input === 'string') {\n253: return parseInt(input, 10);\n254: }\n255: return input.toString();\n256: }\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: string | number): string | number`\n> Lines: 251-256\n```\n251: function parse(input: string | number): string | number {\n252: if (typeof input === 'string') {\n253: return parseInt(input, 10);\n254: }\n255: return input.toString();\n256: }\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```\n266: const add = (a: number): number => a + 1;\n275: const transform = <T extends { toString(): string }>(value: T): string => {\n276: return value.toString();\n277: };\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```\n288: async function fetchEntity<T>(url: string): Promise<T> {\n289: const response = await fetch(url);\n291: return response.json() as Promise<T>;\n292: }\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```\n300: export namespace MyNS {\n302: export const x = 1;\n309: export function double(val: number): number {\n310: return val * 2;\n311: }\n312: }\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```\n309: export function double(val: number): number {\n310: return val * 2;\n311: }\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```\n320: declare module MyMod {\n322: export const version: string;\n323: }\n```\n\n### DECORATOR: `Component`\n> Lines: 331-331\n- @brief Class using a decorator annotation.\n```\n331: @Component\n```\n\n### CLASS: `Decorated`\n> Signature: `class Decorated`\n> Lines: 332-335\n- @brief Template string for rendering.\n```\n332: class Decorated {\n334: template: string = '<div></div>';\n335: }\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```\n345: function isUser(value: unknown): value is User {\n346: if (typeof value !== 'object' || value === null) {\n347: return false;\n348: }\n349: const obj = value as Record<string, unknown>;\n350: return typeof obj.name === 'string' && typeof obj.age === 'number';\n351: }\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```\n373: function makeOptional<T extends object>(obj: T): Partial<T> {\n374: return { ...obj };\n375: }\n```\n\n### IMPORT: `{ Injectable } from 'inversify';`\n> Lines: 378-378\n```\n378: import { Injectable } from 'inversify';\n```\n\n### IMPORT: `{ Observable } from 'rxjs';`\n> Lines: 379-379\n```\n379: import { Observable } from 'rxjs';\n```\n\n### IMPORT: `{ FC } from 'react';`\n> Lines: 380-380\n```\n380: import { FC } from 'react';\n```\n\n### DECORATOR: `injectable`\n> Lines: 381-381\n```\n381: @injectable\n```\n\n### DECORATOR: `sealed`\n> Lines: 382-382\n```\n382: @sealed\n```\n\n### DECORATOR: `track`\n> Lines: 383-383\n```\n383: @track\n```\n\n### DECORATOR: `memoized`\n> Lines: 384-384\n```\n384: @memoized\n```\n\n### INTERFACE: `CacheEntry`\n> Signature: `interface CacheEntry { key: string; value: string }`\n> Lines: 385-385\n```\n385: interface CacheEntry { key: string; value: string }\n```\n\n### INTERFACE: `Runner`\n> Signature: `export interface Runner { run(): Promise<void> }`\n> Lines: 386-386\n```\n386: export interface Runner { run(): Promise<void> }\n```\n\n### ENUM: `ModeTs`\n> Signature: `enum ModeTs { Fast, Safe }`\n> Lines: 387-387\n```\n387: enum ModeTs { Fast, Safe }\n```\n\n### ENUM: `StatusTs`\n> Signature: `enum StatusTs { Ready, Busy }`\n> Lines: 388-388\n```\n388: enum StatusTs { Ready, Busy }\n```\n\n### NAMESPACE: `ExtNSOne`\n> Signature: `namespace ExtNSOne { export const v = 1; }`\n> Lines: 389-389\n```\n389: namespace ExtNSOne { export const v = 1; }\n```\n\n### NAMESPACE: `ExtNSTwo`\n> Signature: `namespace ExtNSTwo { export const v = 2; }`\n> Lines: 390-390\n```\n390: namespace ExtNSTwo { export const v = 2; }\n```\n\n### NAMESPACE: `ExtNSThree`\n> Signature: `namespace ExtNSThree { export const v = 3; }`\n> Lines: 391-391\n```\n391: namespace ExtNSThree { export const v = 3; }\n```\n\n### NAMESPACE: `ExtNSFour`\n> Signature: `namespace ExtNSFour { export const v = 4; }`\n> Lines: 392-392\n```\n392: namespace ExtNSFour { export const v = 4; }\n```\n\n### MODULE: `ExtOne`\n> Signature: `declare module ExtOne { export const one: number; }`\n> Lines: 393-393\n```\n393: declare module ExtOne { export const one: number; }\n```\n\n### MODULE: `ExtTwo`\n> Signature: `module ExtTwo { export const two = 2; }`\n> Lines: 394-394\n```\n394: module ExtTwo { export const two = 2; }\n```\n\n### MODULE: `ExtThree`\n> Signature: `module ExtThree { export const three = 3; }`\n> Lines: 395-395\n```\n395: module ExtThree { export const three = 3; }\n```\n\n### MODULE: `ExtFour`\n> Signature: `module ExtFour { export const four = 4; }`\n> Lines: 396-396\n```\n396: module 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```\n404: function 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```\n411: function 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```\n418: function 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```\n425: function 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```\n432: function reqCoverTs5(value: number): number { return value + 5; }\n```\n",
-  "stderr": ""
-}