From eb7cdaedc729e86945fdf50957f66c18dcf1d763 Mon Sep 17 00:00:00 2001
From: Houssem Eddine BENABDALLAH <benabdallahhoussemedine@gmail.com>
Date: Fri, 30 Oct 2026 09:57:56 +0100
Subject: [PATCH] Apply the AGENTS.md rules to src/: no nested ternaries, exact
 PHPDoc shapes, recursive structures as readonly objects

---
 src/Builder/ActionStats.php             |   6 +-
 src/Builder/ApiSchemaStats.php          |   6 +-
 src/Builder/BuildState.php              |   2 +-
 src/Builder/BusStats.php                |   6 +-
 src/Builder/CallStats.php               |   2 +-
 src/Builder/ConfigurationEvaluator.php  | 192 ++++++++++++------------
 src/Builder/ContainerServices.php       |  25 ++-
 src/Builder/Generics.php                |   4 +-
 src/Builder/GraphBuilder.php            |  20 ++-
 src/Builder/HttpStats.php               |   6 +-
 src/Builder/InjectionStats.php          |   2 +-
 src/Builder/ServiceInjections.php       |   5 +-
 src/Builder/TypeResolver.php            |  43 +++---
 src/Builder/YamlRoutes.php              |   6 +-
 src/Command/CheckCommand.php            |   5 +-
 src/Command/McpConfigCommand.php        |  18 ++-
 src/Extractor/ApiPlatformResources.php  |   4 +-
 src/Extractor/CachingExtractor.php      |   3 +
 src/Extractor/ConditionalArgument.php   |  16 ++
 src/Extractor/ConditionalClass.php      |  18 +++
 src/Extractor/ConditionalReturn.php     |  41 +++++
 src/Extractor/ConditionalTest.php       |  14 ++
 src/Extractor/ConfigurationHelper.php   |  21 +++
 src/Extractor/ConfigurationHelpers.php  | 127 +++++++++-------
 src/Extractor/DefinitionKind.php        |  15 ++
 src/Extractor/DocTypeResolver.php       |  36 ++---
 src/Extractor/ExtractionVisitor.php     |  78 +++++++---
 src/Extractor/FileExtraction.php        |   6 +-
 src/Extractor/HelperArgument.php        |  21 +++
 src/Extractor/PendingHelperCall.php     |  43 ++++++
 src/Extractor/ServiceArgumentFact.php   |  25 +++
 src/Extractor/ServiceDefinitionFact.php |  20 +++
 src/Extractor/ServiceTagFact.php        |  21 +++
 src/Extractor/SourceFacts.php           |  17 ++-
 src/Extractor/Template.php              |  91 +++++++++++
 src/Extractor/TemplateKind.php          |  19 +++
 src/Extractor/TypeExpr.php              |  22 ++-
 src/Graph/Edge.php                      |  14 +-
 src/Graph/Graph.php                     |   5 +-
 src/Graph/Node.php                      |  18 ++-
 src/Mcp/McpServer.php                   |  15 +-
 src/Presentation/ImpactReport.php       | 111 ++++++++++----
 src/Presentation/OutlineReport.php      | 151 ++++++++++++++-----
 src/Presentation/TextPresenter.php      |  78 ++++++----
 src/Project/ProjectSummary.php          |  34 ++++-
 src/Project/Rules/Pattern.php           |   4 +-
 src/Query/FeatureOutline.php            |  10 +-
 src/Query/GraphQuery.php                |   4 +-
 src/Vendor/ComposerClassLocator.php     |   5 +-
 src/Vendor/VendorSignatures.php         |   7 +-
 tests/CacheTest.php                     |  26 ++++
 tests/ConfigurationHelpersTest.php      |  14 ++
 52 files changed, 1125 insertions(+), 377 deletions(-)
 create mode 100644 src/Extractor/ConditionalArgument.php
 create mode 100644 src/Extractor/ConditionalClass.php
 create mode 100644 src/Extractor/ConditionalReturn.php
 create mode 100644 src/Extractor/ConditionalTest.php
 create mode 100644 src/Extractor/ConfigurationHelper.php
 create mode 100644 src/Extractor/DefinitionKind.php
 create mode 100644 src/Extractor/HelperArgument.php
 create mode 100644 src/Extractor/PendingHelperCall.php
 create mode 100644 src/Extractor/ServiceArgumentFact.php
 create mode 100644 src/Extractor/ServiceDefinitionFact.php
 create mode 100644 src/Extractor/ServiceTagFact.php
 create mode 100644 src/Extractor/Template.php
 create mode 100644 src/Extractor/TemplateKind.php

diff --git a/src/Builder/ActionStats.php b/src/Builder/ActionStats.php
index 92e6662..ffda2be 100644
--- a/src/Builder/ActionStats.php
+++ b/src/Builder/ActionStats.php
@@ -73,7 +73,11 @@ public static function fromArray(array $data): self
     }
 
     /**
-     * @return array<string, int|list<string>>
+     * @return array{
+     *     actions: int, linked: int, toClass: int, unlinkedCount: int, unlinked: list<string>, forwards: int,
+     *     forwardsLinked: int, templates: int, unresolvedTargetCount: int, unresolvedTargets: list<string>,
+     *     citations: int, citingFiles: int, unreadable: list<string>,
+     * }
      */
     public function toArray(): array
     {
diff --git a/src/Builder/ApiSchemaStats.php b/src/Builder/ApiSchemaStats.php
index f4ea831..a0da63a 100644
--- a/src/Builder/ApiSchemaStats.php
+++ b/src/Builder/ApiSchemaStats.php
@@ -70,7 +70,11 @@ public static function fromArray(array $data): self
     }
 
     /**
-     * @return array<string, int|list<string>>
+     * @return array{
+     *     documents: int, operations: int, implemented: int, notImplemented: list<string>, routesCovered: int,
+     *     undocumentedCount: int, undocumented: list<string>, rpcs: int, rpcsImplemented: int,
+     *     rpcsNotImplemented: list<string>, otherApis: int, requests: int,
+     * }
      */
     public function toArray(): array
     {
diff --git a/src/Builder/BuildState.php b/src/Builder/BuildState.php
index 41316a9..ea4e2ed 100644
--- a/src/Builder/BuildState.php
+++ b/src/Builder/BuildState.php
@@ -24,7 +24,7 @@ final class BuildState
      * @param string                                                                               $names       ids every name resolved to
      * @param list<Edge>                                                                           $overrides
      * @param array<string, list<array{?Edge, string, string}>>                                     $calls       file => [edge added, outcome, method] per call site
-     * @param array<string, array{int, int, array<mixed>}>                                          $configuration parsed configuration files: [mtime, size, data]
+     * @param array<string, array{int, int, array{definitions: array<string, string>, parameters: array<string, string>, tags: list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>, arguments: list<array{id: string, tag: ?string, service: ?string, locator?: bool}>}}> $configuration parsed configuration files: [mtime, size, what each declares]
      */
     public function __construct(
         public readonly string $options,
diff --git a/src/Builder/BusStats.php b/src/Builder/BusStats.php
index f2737dc..bc90ac8 100644
--- a/src/Builder/BusStats.php
+++ b/src/Builder/BusStats.php
@@ -56,7 +56,11 @@ public static function fromArray(array $data): self
     }
 
     /**
-     * @return array<string, mixed>
+     * @return array{
+     *     handlers: array<string, int>, sends: array<string, int>, untypedSends: int,
+     *     messagesWithoutHandlerCount: int, messagesWithoutHandler: list<string>,
+     *     messagesNeverSentCount: int, messagesNeverSent: list<string>, contracts: int,
+     * }
      */
     public function toArray(): array
     {
diff --git a/src/Builder/CallStats.php b/src/Builder/CallStats.php
index 02981c9..32ff560 100644
--- a/src/Builder/CallStats.php
+++ b/src/Builder/CallStats.php
@@ -49,7 +49,7 @@ public function total(): int
     }
 
     /**
-     * @return array<string, int>
+     * @return array{total: int, inferred: int, ambiguous: int, outsideProject: int, unknownReceiver: int, chainOutsideProject: int}
      */
     public function toArray(): array
     {
diff --git a/src/Builder/ConfigurationEvaluator.php b/src/Builder/ConfigurationEvaluator.php
index 9395d0e..e4ce068 100644
--- a/src/Builder/ConfigurationEvaluator.php
+++ b/src/Builder/ConfigurationEvaluator.php
@@ -4,7 +4,14 @@
 
 namespace PhpGraph\Builder;
 
+use PhpGraph\Extractor\ConfigurationHelper;
 use PhpGraph\Extractor\ConfigurationHelpers;
+use PhpGraph\Extractor\DefinitionKind;
+use PhpGraph\Extractor\PendingHelperCall;
+use PhpGraph\Extractor\ServiceDefinitionFact;
+use PhpGraph\Extractor\ServiceTagFact;
+use PhpGraph\Extractor\Template;
+use PhpGraph\Extractor\TemplateKind;
 
 /**
  * Evaluates the service configuration written in helpers (see ConfigurationHelpers): each call whose arguments are
@@ -18,10 +25,10 @@ final class ConfigurationEvaluator
 {
     private const MAX_DEPTH = 5;
 
-    /** @var array<string, array{params: list<string>, facts: list<array<string, mixed>>, file: string}> lowercase helper id => helper */
+    /** @var array<string, array{helper: ConfigurationHelper, file: string}> lowercase helper id => helper */
     private array $helpers = [];
 
-    /** @var list<array{caller: ?string, callee: string, args: list<array{?string, ?array<mixed>}>, file: string, service: string}> */
+    /** @var list<array{call: PendingHelperCall, file: string, service: string}> */
     private array $calls = [];
 
     /** @var array{definitions: array<string, array<string, string>>, tags: array<string, list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>>, arguments: array<string, list<array{id: string, tag: ?string, service: ?string, locator?: bool}>>} */
@@ -34,20 +41,14 @@ public function __construct(private readonly \Closure $constant)
     {
     }
 
-    /**
-     * @param array{params: list<string>, facts: list<array<string, mixed>>} $helper
-     */
-    public function addHelper(string $id, array $helper, string $file): void
+    public function addHelper(string $id, ConfigurationHelper $helper, string $file): void
     {
-        $this->helpers[strtolower($id)] = $helper + ['file' => $file];
+        $this->helpers[strtolower($id)] = ['helper' => $helper, 'file' => $file];
     }
 
-    /**
-     * @param array{caller: ?string, callee: string, args: list<array{?string, ?array<mixed>}>, line: int} $call
-     */
-    public function addCall(array $call, string $file, string $service): void
+    public function addCall(PendingHelperCall $call, string $file, string $service): void
     {
-        $this->calls[] = ['caller' => $call['caller'], 'callee' => $call['callee'], 'args' => $call['args'], 'file' => $file, 'service' => $service];
+        $this->calls[] = ['call' => $call, 'file' => $file, 'service' => $service];
     }
 
     /**
@@ -55,12 +56,12 @@ public function addCall(array $call, string $file, string $service): void
      */
     public function evaluate(): array
     {
-        foreach ($this->calls as $call) {
+        foreach ($this->calls as ['call' => $call, 'file' => $file, 'service' => $service]) {
             // The calls whose arguments do not depend on the parameters of a caller: the others run with their caller.
-            if (!isset($this->helpers[strtolower($call['callee'])]) || $this->usesParameters($call['args'])) {
+            if (!isset($this->helpers[strtolower($call->callee)]) || $call->usesParameters()) {
                 continue;
             }
-            $this->run($call['callee'], $this->bind($call['callee'], $call['args'], [], $call['file']), $call['service'], 0);
+            $this->run($call->callee, $this->bind($call, [], $file), $service, 0);
         }
 
         return $this->result;
@@ -76,39 +77,38 @@ private function run(string $callee, array $bindings, string $service, int $dept
             return;
         }
 
-        $value = fn (?array $template): ?string => $template === null ? null : $this->value($template, $bindings, $helper['file']);
-        foreach ($helper['facts'] as $fact) {
-            if ($fact['kind'] === 'set') {
-                $id = $value(\is_array($fact['id']) ? $fact['id'] : null);
-                $class = $value(\is_array($fact['class'] ?? null) ? $fact['class'] : null);
+        $value = fn (?Template $template): ?string => $template === null ? null : $this->value($template, $bindings, $helper['file']);
+        foreach ($helper['helper']->facts as $fact) {
+            if ($fact instanceof ServiceDefinitionFact) {
+                $id = $value($fact->id);
+                $class = $value($fact->class);
                 if ($id !== null) {
                     $this->result['definitions'][$service][$id] ??= $class ?? $id;
                 }
-            } elseif ($fact['kind'] === 'tag' && \is_array($fact['definition'] ?? null)) {
-                [$kind, $template] = $fact['definition'];
-                $target = $value(\is_array($template) ? $template : null);
-                $name = $value(\is_array($fact['name']) ? $fact['name'] : null);
+            } elseif ($fact instanceof ServiceTagFact) {
+                $target = $value($fact->target);
+                $name = $value($fact->name);
                 if ($target === null || $name === null) {
                     continue;
                 }
-                $this->result['tags'][$service][] = match ($kind) {
-                    'instanceof' => ['id' => null, 'instanceof' => ltrim($target, '\\'), 'name' => $name, 'attributes' => []],
-                    'load' => ['id' => rtrim(ltrim($target, '\\'), '\\') . '\\', 'instanceof' => null, 'name' => $name, 'attributes' => []],
-                    default => ['id' => $target, 'instanceof' => null, 'name' => $name, 'attributes' => []],
+                $this->result['tags'][$service][] = match ($fact->kind) {
+                    DefinitionKind::Instanceof => ['id' => null, 'instanceof' => ltrim($target, '\\'), 'name' => $name, 'attributes' => []],
+                    DefinitionKind::Load => ['id' => rtrim(ltrim($target, '\\'), '\\') . '\\', 'instanceof' => null, 'name' => $name, 'attributes' => []],
+                    DefinitionKind::Set => ['id' => $target, 'instanceof' => null, 'name' => $name, 'attributes' => []],
                 };
-            } elseif ($fact['kind'] === 'argument') {
-                $id = $value(\is_array($fact['id']) ? $fact['id'] : null);
-                $tag = $value(\is_array($fact['tag'] ?? null) ? $fact['tag'] : null);
-                $target = $value(\is_array($fact['service'] ?? null) ? $fact['service'] : null);
+            } else {
+                $id = $value($fact->id);
+                $tag = $value($fact->tag);
+                $target = $value($fact->service);
                 if ($id !== null && ($tag !== null || $target !== null)) {
-                    $this->result['arguments'][$service][] = ['id' => $id, 'tag' => $tag, 'service' => $target, 'locator' => ($fact['locator'] ?? false) === true];
+                    $this->result['arguments'][$service][] = ['id' => $id, 'tag' => $tag, 'service' => $target, 'locator' => $fact->locator];
                 }
             }
         }
 
-        foreach ($this->calls as $call) {
-            if ($call['caller'] !== null && strtolower($call['caller']) === strtolower($callee) && $this->usesParameters($call['args'])) {
-                $this->run($call['callee'], $this->bind($call['callee'], $call['args'], $bindings, $helper['file']), $service, $depth + 1);
+        foreach ($this->calls as ['call' => $call]) {
+            if ($call->caller !== null && strtolower($call->caller) === strtolower($callee) && $call->usesParameters()) {
+                $this->run($call->callee, $this->bind($call, $bindings, $helper['file']), $service, $depth + 1);
             }
         }
     }
@@ -116,19 +116,18 @@ private function run(string $callee, array $bindings, string $service, int $dept
     /**
      * The values of a call's arguments, by the callee's parameter names: positional, then named.
      *
-     * @param list<array{?string, ?array<mixed>}> $args
-     * @param array<string, ?string>              $bindings the caller's
+     * @param array<string, ?string> $bindings the caller's
      *
      * @return array<string, ?string>
      */
-    private function bind(string $callee, array $args, array $bindings, string $file): array
+    private function bind(PendingHelperCall $call, array $bindings, string $file): array
     {
-        $params = $this->helpers[strtolower($callee)]['params'] ?? [];
+        $params = $this->helpers[strtolower($call->callee)]['helper']->params ?? [];
         $bound = [];
-        foreach ($args as $position => [$name, $template]) {
-            $param = $name ?? ($params[$position] ?? null);
+        foreach ($call->arguments as $position => $argument) {
+            $param = $argument->name ?? ($params[$position] ?? null);
             if ($param !== null) {
-                $bound[$param] = $template === null ? null : $this->value($template, $bindings, $file);
+                $bound[$param] = $argument->value === null ? null : $this->value($argument->value, $bindings, $file);
             }
         }
 
@@ -136,47 +135,31 @@ private function bind(string $callee, array $args, array $bindings, string $file
     }
 
     /**
-     * @param list<array{?string, ?array<mixed>}> $args
-     */
-    private function usesParameters(array $args): bool
-    {
-        foreach ($args as [, $template]) {
-            if ($template !== null && str_contains(serialize($template), 's:5:"param"')) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * @param array<mixed>           $template
      * @param array<string, ?string> $bindings
      */
-    private function value(array $template, array $bindings, string $file): ?string
+    private function value(Template $template, array $bindings, string $file): ?string
     {
-        $parts = $template[1] ?? null;
-
-        return match ($template[0] ?? null) {
-            'lit' => \is_string($parts) ? $parts : null,
-            'param' => \is_string($parts) ? $bindings[$parts] ?? null : null,
-            'dir' => \dirname($file),
-            'const' => \is_string($parts) ? ($this->constant)($parts, $file) : null,
-            'concat' => \is_array($parts) ? $this->concat($parts, $bindings, $file) : null,
-            'call' => \is_string($parts) && \is_array($template[2] ?? null) ? $this->call($parts, $template[2], $bindings, $file) : null,
-            default => null,
+        return match ($template->kind) {
+            TemplateKind::Literal => $template->value,
+            TemplateKind::Parameter => $bindings[$template->value] ?? null,
+            TemplateKind::Directory => \dirname($file),
+            TemplateKind::Constant => ($this->constant)($template->value, $file),
+            TemplateKind::Concat => $this->concat($template->parts, $bindings, $file),
+            TemplateKind::Call => $this->call($template->value, $template->parts, $bindings, $file),
+            // An array is the argument of a function only.
+            TemplateKind::List => null,
         };
     }
 
     /**
-     * @param array<mixed>           $parts
+     * @param list<Template>         $parts
      * @param array<string, ?string> $bindings
      */
     private function concat(array $parts, array $bindings, string $file): ?string
     {
         $text = '';
         foreach ($parts as $part) {
-            $value = \is_array($part) ? $this->value($part, $bindings, $file) : null;
+            $value = $this->value($part, $bindings, $file);
             if ($value === null) {
                 return null;
             }
@@ -187,7 +170,7 @@ private function concat(array $parts, array $bindings, string $file): ?string
     }
 
     /**
-     * @param array<mixed>           $arguments templates, or ['list', [...]] for an array
+     * @param list<Template>         $arguments
      * @param array<string, ?string> $bindings
      */
     private function call(string $function, array $arguments, array $bindings, string $file): ?string
@@ -198,13 +181,10 @@ private function call(string $function, array $arguments, array $bindings, strin
 
         $values = [];
         foreach ($arguments as $argument) {
-            if (!\is_array($argument)) {
-                return null;
-            }
-            if (($argument[0] ?? null) === 'list' && \is_array($argument[1] ?? null)) {
+            if ($argument->kind === TemplateKind::List) {
                 $list = [];
-                foreach ($argument[1] as $item) {
-                    $list[] = \is_array($item) ? $this->value($item, $bindings, $file) : null;
+                foreach ($argument->parts as $item) {
+                    $list[] = $this->value($item, $bindings, $file);
                 }
                 if (\in_array(null, $list, true)) {
                     return null;
@@ -220,28 +200,46 @@ private function call(string $function, array $arguments, array $bindings, strin
         }
 
         try {
-            $result = match ($function) {
-                'str_replace' => \count($values) === 3 ? str_replace($values[0], $values[1], \is_array($values[2]) ? implode('', $values[2]) : $values[2]) : null,
-                'sprintf' => isset($values[0]) && array_filter($values, 'is_string') === $values ? \sprintf(...$values) : null,
-                'implode' => \count($values) === 2 && \is_string($values[0]) && \is_array($values[1]) ? implode($values[0], $values[1]) : null,
-                default => isset($values[0]) && \is_string($values[0]) && array_filter($values, 'is_string') === $values
-                    ? match ($function) {
-                        'trim' => trim($values[0], ...\array_slice($values, 1, 1)),
-                        'ltrim' => ltrim($values[0], ...\array_slice($values, 1, 1)),
-                        'rtrim' => rtrim($values[0], ...\array_slice($values, 1, 1)),
-                        'strtolower' => strtolower($values[0]),
-                        'strtoupper' => strtoupper($values[0]),
-                        'ucfirst' => ucfirst($values[0]),
-                        'lcfirst' => lcfirst($values[0]),
-                        'dirname' => \dirname($values[0]),
-                        default => basename($values[0]),
-                    }
-                : null,
-            };
+            return $this->apply($function, $values);
         } catch (\Throwable) {
             return null;
         }
+    }
+
+    /**
+     * @param list<string|list<string>> $values
+     */
+    private function apply(string $function, array $values): ?string
+    {
+        if ($function === 'str_replace') {
+            if (\count($values) !== 3) {
+                return null;
+            }
+            $subject = \is_array($values[2]) ? implode('', $values[2]) : $values[2];
 
-        return \is_string($result) ? $result : null;
+            return str_replace($values[0], $values[1], $subject);
+        }
+        $allStrings = array_filter($values, 'is_string') === $values;
+        if ($function === 'sprintf') {
+            return isset($values[0]) && $allStrings ? \sprintf(...$values) : null;
+        }
+        if ($function === 'implode') {
+            return \count($values) === 2 && \is_string($values[0]) && \is_array($values[1]) ? implode($values[0], $values[1]) : null;
+        }
+        if (!isset($values[0]) || !\is_string($values[0]) || !$allStrings) {
+            return null;
+        }
+
+        return match ($function) {
+            'trim' => trim($values[0], ...\array_slice($values, 1, 1)),
+            'ltrim' => ltrim($values[0], ...\array_slice($values, 1, 1)),
+            'rtrim' => rtrim($values[0], ...\array_slice($values, 1, 1)),
+            'strtolower' => strtolower($values[0]),
+            'strtoupper' => strtoupper($values[0]),
+            'ucfirst' => ucfirst($values[0]),
+            'lcfirst' => lcfirst($values[0]),
+            'dirname' => \dirname($values[0]),
+            default => basename($values[0]),
+        };
     }
 }
diff --git a/src/Builder/ContainerServices.php b/src/Builder/ContainerServices.php
index bb000fb..86c96c6 100644
--- a/src/Builder/ContainerServices.php
+++ b/src/Builder/ContainerServices.php
@@ -4,7 +4,6 @@
 
 namespace PhpGraph\Builder;
 
-use PhpGraph\Values;
 use Symfony\Component\Yaml\Exception\ParseException;
 use Symfony\Component\Yaml\Tag\TaggedValue;
 use Symfony\Component\Yaml\Yaml;
@@ -32,7 +31,7 @@ final class ContainerServices
     /** @var list<array{service: string, id: string, tag: ?string, target: ?string, locator: bool}> */
     private array $arguments = [];
 
-    /** @var array<string, array{int, int, array<mixed>}> file => [modification time, size, what it declares] */
+    /** @var array<string, array{int, int, array{definitions: array<string, string>, parameters: array<string, string>, tags: list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>, arguments: list<array{id: string, tag: ?string, service: ?string, locator?: bool}>}}> file => [modification time, size, what it declares] */
     private array $cache = [];
 
     /** @var array<string, string> while reading a file: id => class or `@alias` */
@@ -52,7 +51,7 @@ final class ContainerServices
      * @param array<string, array<string, string>>    $declared definitions collected from PHP, by application service
      * @param array<string, list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>> $declaredTags
      *                                                         tags collected from PHP, by application service
-     * @param array<string, array{int, int, array<mixed>}> $cache files read by the last build of this process
+     * @param array<string, array{int, int, array{definitions: array<string, string>, parameters: array<string, string>, tags: list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>, arguments: list<array{id: string, tag: ?string, service: ?string, locator?: bool}>}}> $cache files read by the last build of this process
      * @param array<string, list<array{id: string, tag: ?string, service: ?string, locator?: bool}>> $declaredArguments
      *                                                         injections collected from PHP, by application service
      */
@@ -90,7 +89,7 @@ public function __construct(string $root, array $files, ServiceMap $services, ar
     /**
      * What each configuration file declared, for the next build of this process.
      *
-     * @return array<string, array{int, int, array<mixed>}>
+     * @return array<string, array{int, int, array{definitions: array<string, string>, parameters: array<string, string>, tags: list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>, arguments: list<array{id: string, tag: ?string, service: ?string, locator?: bool}>}}>
      */
     public function cache(): array
     {
@@ -98,7 +97,7 @@ public function cache(): array
     }
 
     /**
-     * @return array{definitions: array<string, string>, parameters: array<string, string>, tags: list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>}
+     * @return array{definitions: array<string, string>, parameters: array<string, string>, tags: list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>, arguments: list<array{id: string, tag: ?string, service: ?string, locator?: bool}>}
      */
     private function read(string $file, string $content): array
     {
@@ -113,22 +112,20 @@ private function read(string $file, string $content): array
     }
 
     /**
-     * @param array<mixed> $declared as returned by read()
+     * @param array{definitions: array<string, string>, parameters: array<string, string>, tags: list<array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>}>, arguments: list<array{id: string, tag: ?string, service: ?string, locator?: bool}>} $declared as returned by read()
      */
     private function merge(array $declared, string $service): void
     {
-        foreach (\is_array($declared['definitions'] ?? null) ? $declared['definitions'] : [] as $id => $target) {
-            $this->definitions[$service][(string) $id] ??= Values::text($target);
+        foreach ($declared['definitions'] as $id => $target) {
+            $this->definitions[$service][(string) $id] ??= $target;
         }
-        foreach (\is_array($declared['parameters'] ?? null) ? $declared['parameters'] : [] as $name => $value) {
-            $this->parameters[$service][(string) $name] = Values::text($value);
+        foreach ($declared['parameters'] as $name => $value) {
+            $this->parameters[$service][(string) $name] = $value;
         }
-        foreach (\is_array($declared['tags'] ?? null) ? $declared['tags'] : [] as $tag) {
-            /** @var array{id: ?string, instanceof: ?string, name: string, attributes: array<string, string>} $tag */
+        foreach ($declared['tags'] as $tag) {
             $this->tags[] = ['service' => $service] + $tag;
         }
-        foreach (\is_array($declared['arguments'] ?? null) ? $declared['arguments'] : [] as $argument) {
-            /** @var array{id: string, tag: ?string, service: ?string, locator?: bool} $argument */
+        foreach ($declared['arguments'] as $argument) {
             $this->arguments[] = ['service' => $service, 'id' => $argument['id'], 'tag' => $argument['tag'], 'target' => $argument['service'], 'locator' => $argument['locator'] ?? false];
         }
     }
diff --git a/src/Builder/Generics.php b/src/Builder/Generics.php
index a347312..4f9866c 100644
--- a/src/Builder/Generics.php
+++ b/src/Builder/Generics.php
@@ -4,6 +4,8 @@
 
 namespace PhpGraph\Builder;
 
+use PhpGraph\Extractor\ConditionalReturn;
+
 /**
  * What the project's docblocks declare beyond the code, as project ids: the generic types TypeResolver binds, the
  * magic methods (`@method`) and the classes calls are forwarded to (`@mixin`).
@@ -17,7 +19,7 @@
      * @param array<string, string>                      $properties      "Class::property" => GenericType
      * @param array<string, array<string, string>>       $documentedMethods class => lowercase name => id of a `@method`
      * @param array<string, list<string>>                $mixins          class => the classes of its `@mixin` tags
-     * @param array<string, string>                      $conditionals    callable id => conditional return type (JSON)
+     * @param array<string, ConditionalReturn>           $conditionals    callable id => conditional return type
      * @param array<string, array<int|string, list<string>>> $callables   method id => the parameters of the closures it
      *                                                                     takes, by position and name, GenericType strings
      * @param array<string, array<string, array{string, int}>> $binders callable id => how a call binds its templates
diff --git a/src/Builder/GraphBuilder.php b/src/Builder/GraphBuilder.php
index 8849545..0f86218 100644
--- a/src/Builder/GraphBuilder.php
+++ b/src/Builder/GraphBuilder.php
@@ -4,6 +4,7 @@
 
 namespace PhpGraph\Builder;
 
+use PhpGraph\Extractor\ConditionalReturn;
 use PhpGraph\Extractor\FileExtractor;
 use PhpGraph\Extractor\GenericType;
 use PhpGraph\Extractor\HandlerFact;
@@ -154,7 +155,7 @@ public function build(string $root, array $excludePatterns = [], ?array $service
         $documentedMethods = [];
         /** @var array<string, list<string>> $mixins */
         $mixins = [];
-        /** @var array<string, string> $conditionals */
+        /** @var array<string, ConditionalReturn> $conditionals */
         $conditionals = [];
         /** @var array<string, array<int|string, list<string>>> $callables */
         $callables = [];
@@ -291,7 +292,7 @@ public function build(string $root, array $excludePatterns = [], ?array $service
                 $configuration->addHelper($member((string) $helper), $definition, (string) $path);
             }
             foreach ($extraction->configurationCalls as $call) {
-                $configuration->addCall(['caller' => $call['caller'] === null ? null : $member($call['caller']), 'callee' => $member($call['callee'])] + $call, (string) $path, $service);
+                $configuration->addCall($call->withNames($call->caller === null ? null : $member($call->caller), $member($call->callee)), (string) $path, $service);
             }
             foreach ($extraction->routePrefixes as $loader => $prefixes) {
                 $routePrefixes[$service][$loader] = [...$routePrefixes[$service][$loader] ?? [], ...$prefixes];
@@ -738,9 +739,11 @@ private function resolveCall(Graph $graph, TypeResolver $types, array $methodsBy
             }
         }
         if ($found !== []) {
+            $confidence = $complete ? Confidence::Inferred : Confidence::Ambiguous;
+            $outcome = $complete ? 'inferred' : 'ambiguous';
             foreach ($found as $index => $method) {
-                $outcome = $index > 0 ? '' : ($complete ? 'inferred' : 'ambiguous');
-                $results[] = [new Edge($call->source, $method, Relation::Calls, $complete ? Confidence::Inferred : Confidence::Ambiguous, (string) $call->line, self::named($call)), $outcome, $call->method];
+                // The call is counted once, on its first edge.
+                $results[] = [new Edge($call->source, $method, Relation::Calls, $confidence, (string) $call->line, self::named($call)), $index > 0 ? '' : $outcome, $call->method];
             }
 
             return;
@@ -759,9 +762,12 @@ private function resolveCall(Graph $graph, TypeResolver $types, array $methodsBy
         }
 
         $candidates = $methodsByName[$name] ?? [];
-        $results[] = \count($candidates) === 1
-            ? [new Edge($call->source, $candidates[0], Relation::Calls, Confidence::Ambiguous, (string) $call->line, self::named($call)), 'ambiguous', $call->method]
-            : [null, $leftProject ? 'chainOutsideProject' : 'unknownReceiver', $call->method];
+        if (\count($candidates) === 1) {
+            $results[] = [new Edge($call->source, $candidates[0], Relation::Calls, Confidence::Ambiguous, (string) $call->line, self::named($call)), 'ambiguous', $call->method];
+
+            return;
+        }
+        $results[] = [null, $leftProject ? 'chainOutsideProject' : 'unknownReceiver', $call->method];
     }
 
     private static function namespaceOf(string $class): string
diff --git a/src/Builder/HttpStats.php b/src/Builder/HttpStats.php
index 6711d84..0128e13 100644
--- a/src/Builder/HttpStats.php
+++ b/src/Builder/HttpStats.php
@@ -58,7 +58,11 @@ public static function fromArray(array $data): self
     }
 
     /**
-     * @return array<string, int|list<string>>
+     * @return array{
+     *     routes: int, routesWithHandler: int, requests: int, requestsToProject: int, requestsToServices: int,
+     *     routesToDependencies: int, methodMismatchCount: int, methodMismatches: list<string>,
+     *     routesToMissingControllers: int, missingControllers: list<string>,
+     * }
      */
     public function toArray(): array
     {
diff --git a/src/Builder/InjectionStats.php b/src/Builder/InjectionStats.php
index c22477e..88a36df 100644
--- a/src/Builder/InjectionStats.php
+++ b/src/Builder/InjectionStats.php
@@ -42,7 +42,7 @@ public static function fromArray(array $data): self
     }
 
     /**
-     * @return array<string, int|list<string>>
+     * @return array{injections: int, linked: int, edges: int, unlinkedCount: int, unlinked: list<string>}
      */
     public function toArray(): array
     {
diff --git a/src/Builder/ServiceInjections.php b/src/Builder/ServiceInjections.php
index 55680e1..347b1f6 100644
--- a/src/Builder/ServiceInjections.php
+++ b/src/Builder/ServiceInjections.php
@@ -64,7 +64,10 @@ public function resolve(): InjectionStats
             $targets = $argument['tag'] !== null
                 ? $this->tagged->named($argument['tag'])
                 : array_filter([$this->classOf((string) $argument['target'], $argument['service'])]);
-            $via = $argument['tag'] !== null ? ($argument['locator'] ? 'tagged_locator ' : 'tagged_iterator ') . $argument['tag'] : '';
+            $via = '';
+            if ($argument['tag'] !== null) {
+                $via = ($argument['locator'] ? 'tagged_locator ' : 'tagged_iterator ') . $argument['tag'];
+            }
             // A service named by an id rather than its class says which of several services of one class it is: the
             // pipeline of one use case among those built by a helper (`sales_order.estimate.validation_pipeline`).
             // Not when the consumer is such a service itself: its class serves every id, the edge only one.
diff --git a/src/Builder/TypeResolver.php b/src/Builder/TypeResolver.php
index 76a4d08..68f0091 100644
--- a/src/Builder/TypeResolver.php
+++ b/src/Builder/TypeResolver.php
@@ -5,12 +5,15 @@
 namespace PhpGraph\Builder;
 
 use PhpGraph\Builder\Libraries\Libraries;
+use PhpGraph\Extractor\ConditionalArgument;
+use PhpGraph\Extractor\ConditionalClass;
+use PhpGraph\Extractor\ConditionalReturn;
+use PhpGraph\Extractor\ConditionalTest;
 use PhpGraph\Extractor\GenericType;
 use PhpGraph\Extractor\TypeExpr;
 use PhpGraph\Graph\Graph;
 use PhpGraph\Graph\NodeKind;
 use PhpGraph\Graph\Relation;
-use PhpGraph\Values;
 use PhpGraph\Vendor\ClassSignature;
 use PhpGraph\Vendor\VendorSignatures;
 
@@ -590,9 +593,7 @@ private function functionReturn(TypeExpr $call): ?string
                 ? [$this->returnTypes[$id] ?? null, $this->generics->returns[$id] ?? null, $this->generics->conditionals[$id] ?? null, $this->generics->binders[$id] ?? []]
                 : ($this->vendor?->function($name) ?? [null, null, null, []]);
             if ($conditional !== null) {
-                $decided = json_decode($conditional, true);
-
-                return \is_array($decided) ? $this->decide($decided, $call->arguments) : null;
+                return $this->decide($conditional, $call->arguments);
             }
             if ($generic !== null) {
                 $bound = GenericType::substitute($generic, $this->methodBindings($binders, $call), null);
@@ -664,32 +665,35 @@ private function methodBindings(array $binders, TypeExpr $call): array
     }
 
     /**
-     * @param array<mixed> $tree      a conditional return type (DocTypeResolver::RETURN_CONDITIONAL)
+     * The class a branch of a conditional return type gives to a call, by the arguments it passes.
+     *
      * @param list<string> $arguments
      */
-    private function decide(array $tree, array $arguments, int $depth = 0): ?string
+    private function decide(ConditionalReturn|ConditionalClass|ConditionalArgument $branch, array $arguments, int $depth = 0): ?string
     {
         if ($depth > 5) {
             return null;
         }
-        if (\array_key_exists('type', $tree)) {
-            return \is_string($tree['type']) && $tree['type'] !== TypeExpr::STATIC ? $this->names->canonical($tree['type']) : null;
+        if ($branch instanceof ConditionalClass) {
+            return $branch->class !== null && $branch->class !== TypeExpr::STATIC ? $this->names->canonical($branch->class) : null;
         }
-        if (isset($tree['arg'])) {
-            $argument = $arguments[Values::number($tree['arg'])] ?? '';
+        if ($branch instanceof ConditionalArgument) {
+            $argument = $arguments[$branch->position] ?? '';
 
             return str_starts_with($argument, 'class:') ? $this->names->canonical(substr($argument, 6)) : null;
         }
         // Absent, the parameter takes its default: null for the functions written so.
-        $argument = $arguments[Values::number($tree['param'] ?? 0)] ?? 'null';
-        $holds = match ($tree['test'] ?? null) {
-            'null' => $argument === 'null' ? true : ($argument === '?' ? null : false),
-            'class' => str_starts_with($argument, 'class:') ? true : ($argument === '?' ? null : false),
-            default => null,
+        $argument = $arguments[$branch->parameter] ?? 'null';
+        // An argument of unknown type decides nothing.
+        if ($argument === '?') {
+            return null;
+        }
+        $holds = match ($branch->test) {
+            ConditionalTest::IsNull => $argument === 'null',
+            ConditionalTest::IsClass => str_starts_with($argument, 'class:'),
         };
-        $branch = $holds === null ? null : ($holds ? $tree['then'] ?? null : $tree['else'] ?? null);
 
-        return \is_array($branch) ? $this->decide($branch, $arguments, $depth + 1) : null;
+        return $this->decide($holds ? $branch->then : $branch->else, $arguments, $depth + 1);
     }
 
     /**
@@ -704,7 +708,10 @@ private function genericReturn(string $method, string $receiverType, TypeExpr $c
             return null;
         }
         $binders = $this->generics->binders[$method] ?? $this->vendorSignature($owner)->templateBinders[$method] ?? [];
-        $bindings = $this->bindings($receiverType, $owner) + ($binders === [] ? [] : $this->methodBindings($binders, $call));
+        $bindings = $this->bindings($receiverType, $owner);
+        if ($binders !== []) {
+            $bindings += $this->methodBindings($binders, $call);
+        }
         $returned = GenericType::substitute($generic, $bindings, $receiverType);
 
         return $returned === null ? null : $this->canonicalType($returned);
diff --git a/src/Builder/YamlRoutes.php b/src/Builder/YamlRoutes.php
index 0c634cf..55d09c0 100644
--- a/src/Builder/YamlRoutes.php
+++ b/src/Builder/YamlRoutes.php
@@ -180,7 +180,11 @@ private function controller(mixed $controller): array
      */
     private function methods(mixed $methods): array
     {
-        $list = \is_string($methods) ? explode('|', $methods) : (\is_array($methods) ? $methods : []);
+        $list = match (true) {
+            \is_string($methods) => explode('|', $methods),
+            \is_array($methods) => $methods,
+            default => [],
+        };
 
         return array_values(array_map(static fn (mixed $method): string => strtoupper((string) $method), array_filter($list, 'is_string')));
     }
diff --git a/src/Command/CheckCommand.php b/src/Command/CheckCommand.php
index 6321522..b0b415b 100644
--- a/src/Command/CheckCommand.php
+++ b/src/Command/CheckCommand.php
@@ -59,7 +59,10 @@ protected function execute(InputInterface $input, OutputInterface $output): int
         $ruleKeys = array_map(static fn (RuleViolation $violation): string => $violation->key(), $breaches);
 
         if ($input->getOption('generate-baseline')) {
-            $data = ['layerViolations' => $layers] + ($rules->isEmpty() ? [] : ['ruleViolations' => $ruleKeys]);
+            $data = ['layerViolations' => $layers];
+            if (!$rules->isEmpty()) {
+                $data['ruleViolations'] = $ruleKeys;
+            }
             file_put_contents($baseline, json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR) . "\n");
             $output->writeln(sprintf('%d violations written to %s.', \count($layers) + \count($ruleKeys), $baseline));
 
diff --git a/src/Command/McpConfigCommand.php b/src/Command/McpConfigCommand.php
index 704d7fe..2a6c0bf 100644
--- a/src/Command/McpConfigCommand.php
+++ b/src/Command/McpConfigCommand.php
@@ -53,11 +53,21 @@ protected function execute(InputInterface $input, OutputInterface $output): int
         $image = $input->getOption('docker');
         // In Docker, as the current user: graph.json and the cache belong to them, not to root.
         $user = \function_exists('posix_getuid') && \function_exists('posix_getgid') ? ['-u', posix_getuid() . ':' . posix_getgid()] : [];
-        [$command, $arguments] = \is_string($image)
-            ? ['docker', ['run', '--rm', '-i', ...$user, '-v', $project . ':/project', $image, 'serve', '/project']]
-            : [$this->runner()[0], [...$this->runner()[1], 'serve', ...($everyProject ? [] : [$project])]];
+        if (\is_string($image)) {
+            $command = 'docker';
+            $arguments = ['run', '--rm', '-i', ...$user, '-v', $project . ':/project', $image, 'serve', '/project'];
+        } else {
+            [$command, $arguments] = $this->runner();
+            $arguments[] = 'serve';
+            if (!$everyProject) {
+                $arguments[] = $project;
+            }
+        }
 
-        $server = ($agent === 'cursor' ? ['type' => 'stdio'] : []) + ['command' => $command, 'args' => $arguments];
+        $server = ['command' => $command, 'args' => $arguments];
+        if ($agent === 'cursor') {
+            $server = ['type' => 'stdio', ...$server];
+        }
         $json = json_encode(['mcpServers' => ['phpgraph' => $server]], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
 
         $lines = match ($agent) {
diff --git a/src/Extractor/ApiPlatformResources.php b/src/Extractor/ApiPlatformResources.php
index 2c6e6b5..3502121 100644
--- a/src/Extractor/ApiPlatformResources.php
+++ b/src/Extractor/ApiPlatformResources.php
@@ -132,7 +132,7 @@ private function route(string $class, ?string $name, array $operation, array $re
             [$method],
             RouteFact::normalizePath($path),
             $controller ?? $state,
-            $controller !== null ? null : ($state === null ? null : $handler[1]),
+            $controller === null && $state !== null ? $handler[1] : null,
             $this->file,
             $line,
             references: array_values(array_unique($references)),
@@ -239,7 +239,7 @@ private function classes(Expr $expr): array
             )),
             $expr instanceof Expr\New_ => array_map(
                 static fn (AstNode\Arg $argument): Expr => $argument->value,
-                array_values(array_filter($expr->args, static fn ($argument): bool => $argument instanceof AstNode\Arg)),
+                array_values(array_filter($expr->args, static fn (AstNode\Arg|AstNode\ArgPlaceholder|AstNode\VariadicPlaceholder $argument): bool => $argument instanceof AstNode\Arg)),
             ),
             default => [],
         };
diff --git a/src/Extractor/CachingExtractor.php b/src/Extractor/CachingExtractor.php
index 97037b3..16a4e31 100644
--- a/src/Extractor/CachingExtractor.php
+++ b/src/Extractor/CachingExtractor.php
@@ -22,6 +22,9 @@ final class CachingExtractor implements FileExtractor
     private const ALLOWED_CLASSES = [
         FileExtraction::class, Node::class, Edge::class, PendingCall::class, TypeExpr::class, HandlerFact::class,
         PendingDispatch::class, RouteFact::class, PendingRequest::class, NodeKind::class, Relation::class, Confidence::class,
+        ConditionalReturn::class, ConditionalTest::class, ConditionalClass::class, ConditionalArgument::class,
+        ConfigurationHelper::class, ServiceDefinitionFact::class, ServiceTagFact::class, ServiceArgumentFact::class,
+        DefinitionKind::class, Template::class, TemplateKind::class, PendingHelperCall::class, HelperArgument::class,
     ];
 
     /** @var array<string, FileExtraction> loaded from the previous build */
diff --git a/src/Extractor/ConditionalArgument.php b/src/Extractor/ConditionalArgument.php
new file mode 100644
index 0000000..7abd5e0
--- /dev/null
+++ b/src/Extractor/ConditionalArgument.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * A branch of a conditional `@return` returning the class an argument names: `T` in
+ * `($abstract is class-string<T> ? T : mixed)`, `app(Mailer::class)`.
+ */
+final readonly class ConditionalArgument
+{
+    public function __construct(public int $position)
+    {
+    }
+}
diff --git a/src/Extractor/ConditionalClass.php b/src/Extractor/ConditionalClass.php
new file mode 100644
index 0000000..07c8ced
--- /dev/null
+++ b/src/Extractor/ConditionalClass.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * A branch of a conditional `@return` naming its type: `ResponseFactory` in `($content is null ? ResponseFactory : Response)`.
+ */
+final readonly class ConditionalClass
+{
+    /**
+     * @param ?string $class the class, null when the type names none (`mixed`)
+     */
+    public function __construct(public ?string $class)
+    {
+    }
+}
diff --git a/src/Extractor/ConditionalReturn.php b/src/Extractor/ConditionalReturn.php
new file mode 100644
index 0000000..89bc915
--- /dev/null
+++ b/src/Extractor/ConditionalReturn.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * A conditional `@return`, `($content is null ? ResponseFactory : Response)`, decided by the arguments of a call.
+ */
+final readonly class ConditionalReturn
+{
+    /**
+     * @param int $parameter the position of the argument tested
+     */
+    public function __construct(
+        public int $parameter,
+        public ConditionalTest $test,
+        public self|ConditionalClass|ConditionalArgument $then,
+        public self|ConditionalClass|ConditionalArgument $else,
+    ) {
+    }
+
+    /**
+     * Whether a branch gives a class: a condition between `array` and `mixed` says nothing.
+     */
+    public function namesAClass(): bool
+    {
+        foreach ([$this->then, $this->else] as $branch) {
+            $names = match (true) {
+                $branch instanceof self => $branch->namesAClass(),
+                $branch instanceof ConditionalArgument => true,
+                default => $branch->class !== null,
+            };
+            if ($names) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/Extractor/ConditionalTest.php b/src/Extractor/ConditionalTest.php
new file mode 100644
index 0000000..886fd9e
--- /dev/null
+++ b/src/Extractor/ConditionalTest.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * What a conditional `@return` tests of an argument: `$content is null`, `$abstract is class-string<T>`.
+ */
+enum ConditionalTest: string
+{
+    case IsNull = 'null';
+    case IsClass = 'class';
+}
diff --git a/src/Extractor/ConfigurationHelper.php b/src/Extractor/ConfigurationHelper.php
new file mode 100644
index 0000000..70a1809
--- /dev/null
+++ b/src/Extractor/ConfigurationHelper.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * A method or function taking the service configurator, and the services it configures as templates of its parameters.
+ */
+final readonly class ConfigurationHelper
+{
+    /**
+     * @param list<string>                                                      $params its parameters' names, in order
+     * @param list<ServiceDefinitionFact|ServiceTagFact|ServiceArgumentFact> $facts
+     */
+    public function __construct(
+        public array $params,
+        public array $facts,
+    ) {
+    }
+}
diff --git a/src/Extractor/ConfigurationHelpers.php b/src/Extractor/ConfigurationHelpers.php
index 43748ae..1175834 100644
--- a/src/Extractor/ConfigurationHelpers.php
+++ b/src/Extractor/ConfigurationHelpers.php
@@ -20,12 +20,9 @@
  *     }
  *     Wiring::wire($services, 'sales_order', 'App\SalesOrder');
  *
- * The facts of a helper are recorded as templates of its parameters, and the calls with their arguments; the builder
- * evaluates them (ConfigurationEvaluator). Nothing is run: a template is a string expression, and the conditions of
- * the helper are ignored.
- *
- * A template is a nested array: ['lit', 'text'], ['param', 'prefix'], ['dir'] (`__DIR__`), ['const', 'Class::NAME'],
- * ['concat', [...]], ['call', 'str_replace', [...]].
+ * The facts of a helper are recorded as templates of its parameters (Template), and the calls with their arguments;
+ * the builder evaluates them (ConfigurationEvaluator). Nothing is run: a template is a string expression, and the
+ * conditions of the helper are ignored.
  */
 final class ConfigurationHelpers
 {
@@ -34,10 +31,13 @@ final class ConfigurationHelpers
      */
     public const FUNCTIONS = ['str_replace', 'sprintf', 'trim', 'ltrim', 'rtrim', 'strtolower', 'strtoupper', 'ucfirst', 'lcfirst', 'dirname', 'basename', 'implode'];
 
-    /** @var array<string, array{params: list<string>, facts: list<array<string, mixed>>}> helper id => what it declares */
-    private array $helpers = [];
+    /** @var array<string, list<string>> helper id => its parameters */
+    private array $helperParams = [];
+
+    /** @var array<string, list<ServiceDefinitionFact|ServiceTagFact|ServiceArgumentFact>> helper id => what it declares */
+    private array $helperFacts = [];
 
-    /** @var list<array{caller: ?string, callee: string, args: list<array{?string, ?array<mixed>}>, line: int}> */
+    /** @var list<PendingHelperCall> */
     private array $calls = [];
 
     private ?string $helper = null;
@@ -72,7 +72,8 @@ public function enterCallable(string $id, array $params, array $types): void
         foreach ($params as $param) {
             $this->params[] = $param->var instanceof Expr\Variable && \is_string($param->var->name) ? $param->var->name : '';
         }
-        $this->helpers[$id] = ['params' => $this->params, 'facts' => []];
+        $this->helperParams[$id] = $this->params;
+        $this->helperFacts[$id] = [];
     }
 
     public function leaveCallable(): void
@@ -92,18 +93,18 @@ public function onCall(string $callee, array $args, bool $inConfiguration, int $
             return;
         }
         // A helper is passed the configurator: a call without any variable argument is not one.
-        $variables = array_filter($args, static fn ($argument): bool => $argument instanceof AstNode\Arg && $argument->value instanceof Expr\Variable);
+        $variables = array_filter($args, static fn (AstNode\Arg|AstNode\ArgPlaceholder|AstNode\VariadicPlaceholder $argument): bool => $argument instanceof AstNode\Arg && $argument->value instanceof Expr\Variable);
         if ($variables === []) {
             return;
         }
 
-        $templates = [];
+        $arguments = [];
         foreach ($args as $argument) {
             if ($argument instanceof AstNode\Arg && !$argument->unpack) {
-                $templates[] = [$argument->name?->toString(), $this->template($argument->value)];
+                $arguments[] = new HelperArgument($argument->name?->toString(), $this->template($argument->value));
             }
         }
-        $this->calls[] = ['caller' => $this->helper, 'callee' => $callee, 'args' => $templates, 'line' => $line];
+        $this->calls[] = new PendingHelperCall($this->helper, $callee, $arguments, $line);
     }
 
     /**
@@ -122,46 +123,48 @@ public function onMethodCall(Expr\MethodCall $node): void
 
         $template = $first === null ? null : $this->template($first);
         if ($name === 'set' && $template !== null) {
-            $this->fact(['kind' => 'set', 'id' => $template, 'class' => $second === null ? null : $this->template($second)]);
+            $this->fact(new ServiceDefinitionFact($template, $second === null ? null : $this->template($second)));
         } elseif ($name === 'tag' && $template !== null && $definition !== null) {
-            $this->fact(['kind' => 'tag', 'definition' => $definition, 'name' => $template]);
-        } elseif (($name === 'args' || $name === 'arg') && $definition !== null && $definition[0] === 'set') {
-            foreach ($this->injections($name === 'args' ? $first : $second) as $injection) {
-                $this->fact(['kind' => 'argument', 'id' => $definition[1]] + $injection);
+            $this->fact(new ServiceTagFact($definition[0], $definition[1], $template));
+        } elseif (($name === 'args' || $name === 'arg') && $definition !== null && $definition[0] === DefinitionKind::Set) {
+            foreach ($this->injections($definition[1], $name === 'args' ? $first : $second) as $injection) {
+                $this->fact($injection);
             }
         }
     }
 
     /**
-     * @return array<string, array{params: list<string>, facts: list<array<string, mixed>>}>
+     * @return array<string, ConfigurationHelper> helper id => what it declares
      */
     public function helpers(): array
     {
-        return $this->helpers;
+        $helpers = [];
+        foreach ($this->helperParams as $id => $params) {
+            $helpers[$id] = new ConfigurationHelper($params, $this->helperFacts[$id] ?? []);
+        }
+
+        return $helpers;
     }
 
     /**
-     * @return list<array{caller: ?string, callee: string, args: list<array{?string, ?array<mixed>}>, line: int}>
+     * @return list<PendingHelperCall>
      */
     public function calls(): array
     {
         return $this->calls;
     }
 
-    /**
-     * @param array<string, mixed> $fact
-     */
-    private function fact(array $fact): void
+    private function fact(ServiceDefinitionFact|ServiceTagFact|ServiceArgumentFact $fact): void
     {
         if ($this->helper !== null) {
-            $this->helpers[$this->helper]['facts'][] = $fact;
+            $this->helperFacts[$this->helper][] = $fact;
         }
     }
 
     /**
-     * The definition a chain configures: ['set', id], ['load', namespace] or ['instanceof', type], as templates.
+     * The definition a chain configures: a service id, a namespace or a type, as a template.
      *
-     * @return array{string, array<mixed>}|null
+     * @return array{DefinitionKind, Template}|null
      */
     private function definition(Expr $chain): ?array
     {
@@ -169,11 +172,11 @@ private function definition(Expr $chain): ?array
             if (!$chain->name instanceof Identifier) {
                 continue;
             }
-            $name = strtolower($chain->name->toString());
+            $kind = DefinitionKind::tryFrom(strtolower($chain->name->toString()));
             $first = $this->argument($chain->args, 0);
             $template = $first === null ? null : $this->template($first);
-            if ($template !== null && \in_array($name, ['set', 'load', 'instanceof'], true)) {
-                return [$name, $template];
+            if ($template !== null && $kind !== null) {
+                return [$kind, $template];
             }
         }
 
@@ -181,16 +184,16 @@ private function definition(Expr $chain): ?array
     }
 
     /**
-     * `tagged_iterator(...)`, `tagged_locator(...)`, `service(...)`, alone or in an array.
+     * `tagged_iterator(...)`, `tagged_locator(...)`, `service(...)`, alone or in an array, injected into a service.
      *
-     * @return list<array{tag: ?array<mixed>, service: ?array<mixed>, locator?: bool}>
+     * @return list<ServiceArgumentFact>
      */
-    private function injections(?Expr $value): array
+    private function injections(Template $id, ?Expr $value): array
     {
         if ($value instanceof Expr\Array_) {
             $injections = [];
             foreach ($value->items as $item) {
-                array_push($injections, ...$this->injections($item->value));
+                array_push($injections, ...$this->injections($id, $item->value));
             }
 
             return $injections;
@@ -206,29 +209,29 @@ private function injections(?Expr $value): array
         }
 
         return match (strtolower($value->name->getLast())) {
-            'tagged_iterator' => [['tag' => $template, 'service' => null]],
-            'tagged_locator' => [['tag' => $template, 'service' => null, 'locator' => true]],
-            'service' => [['tag' => null, 'service' => $template]],
+            'tagged_iterator' => [new ServiceArgumentFact($id, $template, null)],
+            'tagged_locator' => [new ServiceArgumentFact($id, $template, null, locator: true)],
+            'service' => [new ServiceArgumentFact($id, null, $template)],
             default => [],
         };
     }
 
     /**
-     * @return array<mixed>|null null for an expression a template cannot hold
+     * @return ?Template null for an expression a template cannot hold
      */
-    private function template(Expr $expr): ?array
+    private function template(Expr $expr): ?Template
     {
         if ($expr instanceof Scalar\String_) {
-            return ['lit', $expr->value];
+            return Template::literal($expr->value);
         }
         if ($expr instanceof Scalar\Int_) {
-            return ['lit', (string) $expr->value];
+            return Template::literal((string) $expr->value);
         }
         if ($expr instanceof Scalar\MagicConst\Dir) {
-            return ['dir'];
+            return Template::directory();
         }
         if ($expr instanceof Expr\Variable && \is_string($expr->name) && \in_array($expr->name, $this->params, true)) {
-            return ['param', $expr->name];
+            return Template::parameter($expr->name);
         }
         if ($expr instanceof Expr\ClassConstFetch && $expr->class instanceof Name && $expr->name instanceof Identifier) {
             $class = ($this->resolve)($expr->class);
@@ -236,21 +239,25 @@ private function template(Expr $expr): ?array
                 return null;
             }
 
-            return strtolower($expr->name->toString()) === 'class' ? ['lit', ltrim($class, '\\')] : ['const', $class . '::' . $expr->name->toString()];
+            return strtolower($expr->name->toString()) === 'class' ? Template::literal(ltrim($class, '\\')) : Template::constant($class . '::' . $expr->name->toString());
         }
         if ($expr instanceof Expr\BinaryOp\Concat) {
             $left = $this->template($expr->left);
             $right = $this->template($expr->right);
 
-            return $left === null || $right === null ? null : ['concat', [$left, $right]];
+            return $left === null || $right === null ? null : Template::concat([$left, $right]);
         }
         if ($expr instanceof Scalar\InterpolatedString) {
             $parts = [];
             foreach ($expr->parts as $part) {
-                $parts[] = $part instanceof AstNode\InterpolatedStringPart ? ['lit', $part->value] : $this->template($part);
+                $template = $part instanceof AstNode\InterpolatedStringPart ? Template::literal($part->value) : $this->template($part);
+                if ($template === null) {
+                    return null;
+                }
+                $parts[] = $template;
             }
 
-            return \in_array(null, $parts, true) ? null : ['concat', $parts];
+            return Template::concat($parts);
         }
         if ($expr instanceof Expr\FuncCall && $expr->name instanceof Name && \in_array(strtolower($expr->name->getLast()), self::FUNCTIONS, true)) {
             $arguments = [];
@@ -258,28 +265,34 @@ private function template(Expr $expr): ?array
                 if (!$argument instanceof AstNode\Arg || $argument->unpack || $argument->name !== null) {
                     return null;
                 }
-                $arguments[] = $argument->value instanceof Expr\Array_ ? $this->listTemplate($argument->value) : $this->template($argument->value);
+                $template = $argument->value instanceof Expr\Array_ ? $this->listTemplate($argument->value) : $this->template($argument->value);
+                if ($template === null) {
+                    return null;
+                }
+                $arguments[] = $template;
             }
 
-            return \in_array(null, $arguments, true) ? null : ['call', strtolower($expr->name->getLast()), $arguments];
+            return Template::call(strtolower($expr->name->getLast()), $arguments);
         }
 
         return null;
     }
 
     /**
-     * An array of strings, for str_replace() and implode(): ['list', [...]].
-     *
-     * @return array<mixed>|null
+     * An array of strings, for str_replace() and implode().
      */
-    private function listTemplate(Expr\Array_ $array): ?array
+    private function listTemplate(Expr\Array_ $array): ?Template
     {
         $items = [];
         foreach ($array->items as $item) {
-            $items[] = $item->key === null ? $this->template($item->value) : null;
+            $template = $item->key === null ? $this->template($item->value) : null;
+            if ($template === null) {
+                return null;
+            }
+            $items[] = $template;
         }
 
-        return \in_array(null, $items, true) ? null : ['list', $items];
+        return Template::list($items);
     }
 
     /**
diff --git a/src/Extractor/DefinitionKind.php b/src/Extractor/DefinitionKind.php
new file mode 100644
index 0000000..2d0ab64
--- /dev/null
+++ b/src/Extractor/DefinitionKind.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * How a configurator chain names the services it configures: `->set($id)`, `->load($namespace)`, `->instanceof($type)`.
+ */
+enum DefinitionKind: string
+{
+    case Set = 'set';
+    case Load = 'load';
+    case Instanceof = 'instanceof';
+}
diff --git a/src/Extractor/DocTypeResolver.php b/src/Extractor/DocTypeResolver.php
index ea27872..46341ad 100644
--- a/src/Extractor/DocTypeResolver.php
+++ b/src/Extractor/DocTypeResolver.php
@@ -99,9 +99,8 @@ final class DocTypeResolver extends NodeVisitorAbstract
     public const PARENT_ARGUMENTS = 'phpgraph.parentArguments';
 
     /**
-     * string: a conditional `@return` as JSON, `($content is null ? ResponseFactory : Response)`: a tree of
-     * `{"param": position, "test": "null"|"class", "then": tree, "else": tree}`, `{"type": class}` and
-     * `{"arg": position}` (the class an argument names, `app(Mailer::class)`), evaluated against the arguments of a call.
+     * ConditionalReturn: a conditional `@return`, `($content is null ? ResponseFactory : Response)`, evaluated against
+     * the arguments of a call.
      */
     public const RETURN_CONDITIONAL = 'phpgraph.returnConditional';
 
@@ -206,7 +205,7 @@ public function __construct(private readonly NameContext $names)
         $this->parser = new PhpDocParser($config, $this->typeParser, $expressions);
     }
 
-    public function enterNode(AstNode $node)
+    public function enterNode(AstNode $node): null
     {
         $text = $node->getDocComment()?->getText() ?? $this->inlineVar($node);
         $doc = $text === null ? null : $this->parse($text);
@@ -317,7 +316,7 @@ public function enterNode(AstNode $node)
         return null;
     }
 
-    public function leaveNode(AstNode $node)
+    public function leaveNode(AstNode $node): null
     {
         if ($node instanceof Stmt\ClassLike) {
             array_pop($this->classTemplates);
@@ -361,9 +360,8 @@ private function onCallable(Stmt\ClassMethod|Stmt\Function_ $node, PhpDocNode $d
             }
             $conditional = $this->conditional($returned, $positions);
             // A condition whose branches name no class says nothing: the plain `@return` is read instead.
-            $tree = $conditional === null ? '' : (string) json_encode($conditional);
-            if (str_contains($tree, '"type":"') || str_contains($tree, '"arg":')) {
-                $node->setAttribute(self::RETURN_CONDITIONAL, $tree);
+            if ($conditional?->namesAClass() === true) {
+                $node->setAttribute(self::RETURN_CONDITIONAL, $conditional);
             }
         }
 
@@ -504,7 +502,11 @@ private function repaired(PhpDocTagNode $tag, string $value): PhpDocTagNode
             $open = $match[0][1] + \strlen($match[0][0]) - 1;
             $depth = 0;
             for ($close = $open, $length = \strlen($text); $close < $length; ++$close) {
-                $depth += $text[$close] === '(' ? 1 : ($text[$close] === ')' ? -1 : 0);
+                $depth += match ($text[$close]) {
+                    '(' => 1,
+                    ')' => -1,
+                    default => 0,
+                };
                 if ($depth === 0) {
                     break;
                 }
@@ -1006,10 +1008,8 @@ private function union(array $parts, array $methodTemplates): ?string
      * A conditional return type as a tree, null when the type is none: `($abstract is null ? Application : mixed)`.
      *
      * @param array<string, int> $parameters name => position
-     *
-     * @return array<string, mixed>|null
      */
-    private function conditional(TypeNode $type, array $parameters, int $depth = 0): ?array
+    private function conditional(TypeNode $type, array $parameters, int $depth = 0): ?ConditionalReturn
     {
         if ($depth > 5 || !$type instanceof ConditionalTypeForParameterNode || !isset($parameters[substr($type->parameterName, 1)])) {
             return null;
@@ -1019,23 +1019,23 @@ private function conditional(TypeNode $type, array $parameters, int $depth = 0):
         $template = $target instanceof GenericTypeNode && $target->type->name === 'class-string' && \count($target->genericTypes) === 1
             && $target->genericTypes[0] instanceof IdentifierTypeNode ? $target->genericTypes[0]->name : null;
         $test = match (true) {
-            $target instanceof IdentifierTypeNode && strtolower($target->name) === 'null' => 'null',
-            $template !== null => 'class',
+            $target instanceof IdentifierTypeNode && strtolower($target->name) === 'null' => ConditionalTest::IsNull,
+            $template !== null => ConditionalTest::IsClass,
             default => null,
         };
         if ($test === null) {
             return null;
         }
-        $leaf = function (TypeNode $branch) use ($parameters, $depth, $position, $template): array {
+        $leaf = function (TypeNode $branch) use ($parameters, $depth, $position, $template): ConditionalReturn|ConditionalClass|ConditionalArgument {
             if ($template !== null && $branch instanceof IdentifierTypeNode && $branch->name === $template) {
-                return ['arg' => $position];
+                return new ConditionalArgument($position);
             }
 
-            return $this->conditional($branch, $parameters, $depth + 1) ?? ['type' => $this->resolve($branch)];
+            return $this->conditional($branch, $parameters, $depth + 1) ?? new ConditionalClass($this->resolve($branch));
         };
         [$then, $else] = $type->negated ? [$leaf($type->else), $leaf($type->if)] : [$leaf($type->if), $leaf($type->else)];
 
-        return ['param' => $position, 'test' => $test, 'then' => $then, 'else' => $else];
+        return new ConditionalReturn($position, $test, $then, $else);
     }
 
     /**
diff --git a/src/Extractor/ExtractionVisitor.php b/src/Extractor/ExtractionVisitor.php
index e0937b5..c4f7df4 100644
--- a/src/Extractor/ExtractionVisitor.php
+++ b/src/Extractor/ExtractionVisitor.php
@@ -157,7 +157,7 @@ final class ExtractionVisitor extends NodeVisitorAbstract
     /** @var array<string, list<string>> */
     private array $mixins = [];
 
-    /** @var array<string, string> callable id => its conditional return type, as JSON (DocTypeResolver) */
+    /** @var array<string, ConditionalReturn> callable id => its conditional return type (DocTypeResolver) */
     private array $conditionalReturns = [];
 
     /** @var array<string, array<int|string, list<string>>> method id => the parameters of the closures it takes */
@@ -326,10 +326,7 @@ public function result(): FileExtraction
         );
     }
 
-    /**
-     * @return int|null
-     */
-    public function enterNode(AstNode $node)
+    public function enterNode(AstNode $node): ?int
     {
         if ($this->currentCallable !== null && $this->currentClass !== null && str_contains($this->currentCallable, '::')) {
             $this->onStateAccess($node, $this->currentCallable);
@@ -444,7 +441,7 @@ public function enterNode(AstNode $node)
         return null;
     }
 
-    public function leaveNode(AstNode $node)
+    public function leaveNode(AstNode $node): ?int
     {
         if ($this->routeGroups !== [] && end($this->routeGroups) === spl_object_id($node)) {
             array_pop($this->routeGroups);
@@ -744,7 +741,7 @@ private function onCallable(string $id, string $label, NodeKind $kind, Stmt\Clas
         }
 
         $conditional = $node->getAttribute(DocTypeResolver::RETURN_CONDITIONAL);
-        if (\is_string($conditional)) {
+        if ($conditional instanceof ConditionalReturn) {
             $this->conditionalReturns[$id] = $conditional;
         }
         $assertions = $node->getAttribute(DocTypeResolver::ASSERTIONS);
@@ -991,7 +988,10 @@ private function pinInlineVarTypes(Stmt $node): void
             ) {
                 $name = $node->expr->var->name;
             }
-            $class = \is_string($type) ? $this->documentedClass($type === TypeExpr::STATIC ? 'self' : $type) : null;
+            if ($type === TypeExpr::STATIC) {
+                $type = 'self';
+            }
+            $class = \is_string($type) ? $this->documentedClass($type) : null;
             if (!\is_string($name) || $name === '' || $class === null) {
                 continue;
             }
@@ -1530,7 +1530,11 @@ private static function either(array $left, array $right): array
      */
     private function calledAssertions(Expr\FuncCall|Expr\StaticCall|Expr\MethodCall|Expr\NullsafeMethodCall $call, bool $failed, bool $statement): array
     {
-        $name = $call->name instanceof Name ? $call->name->getLast() : ($call->name instanceof Identifier ? $call->name->toString() : null);
+        $name = match (true) {
+            $call->name instanceof Name => $call->name->getLast(),
+            $call->name instanceof Identifier => $call->name->toString(),
+            default => null,
+        };
         if ($name === null || $this->currentCallable === null && $this->currentClass !== null) {
             return [];
         }
@@ -1818,7 +1822,7 @@ private function onPossibleServiceDefinition(Expr\MethodCall $node): void
             } elseif ($name === 'tag' && ($id !== null || $instanceof !== null) && $first->value instanceof AstNode\Scalar\String_) {
                 $attributes = [];
                 foreach ($second?->value instanceof Expr\Array_ ? $second->value->items : [] as $item) {
-                    $value = $item->value instanceof AstNode\Scalar\String_ ? $item->value->value : $this->classConstant($item->value);
+                    $value = $this->literalOrClass($item->value);
                     if ($item->key instanceof AstNode\Scalar\String_ && $value !== null) {
                         $attributes[$item->key->value] = $value;
                     }
@@ -1852,8 +1856,8 @@ private function onPossibleServiceDefinition(Expr\MethodCall $node): void
             return;
         }
 
-        $id = $first->value instanceof AstNode\Scalar\String_ ? $first->value->value : $this->classConstant($first->value);
-        $target = $second === null ? null : ($second->value instanceof AstNode\Scalar\String_ ? $second->value->value : $this->classConstant($second->value));
+        $id = $this->literalOrClass($first->value);
+        $target = $this->literalOrClass($second?->value);
         if ($id === null) {
             return;
         }
@@ -1925,7 +1929,7 @@ private function onInjectedParameters(string $class, array $params): void
                     $short = substr($name, (int) strrpos('\\' . $name, '\\'));
                     foreach ($attribute->args as $position => $argument) {
                         $key = $argument->name?->toString();
-                        $value = $argument->value instanceof AstNode\Scalar\String_ ? $argument->value->value : $this->classConstant($argument->value);
+                        $value = $this->literalOrClass($argument->value);
                         if ($value === null) {
                             continue;
                         }
@@ -2106,7 +2110,7 @@ private function onPossibleRoutingConfigurator(Expr\MethodCall $chain): void
             }
             $arguments = array_values(array_map(
                 static fn (AstNode\Arg $argument): Expr => $argument->value,
-                array_filter($call->args, static fn ($argument): bool => $argument instanceof AstNode\Arg && !$argument->unpack),
+                array_filter($call->args, static fn (AstNode\Arg|AstNode\ArgPlaceholder|AstNode\VariadicPlaceholder $argument): bool => $argument instanceof AstNode\Arg && !$argument->unpack),
             ));
             array_unshift($calls, [strtolower($call->name->toString()), $arguments]);
             $root = $call->var;
@@ -2171,9 +2175,11 @@ private function isEventsDispatcher(Expr $receiver): bool
     private function callable(Expr $callable): array
     {
         if (($callable instanceof Expr\MethodCall || $callable instanceof Expr\StaticCall) && $callable->isFirstClassCallable() && $callable->name instanceof Identifier) {
-            $class = $callable instanceof Expr\MethodCall
-                ? $this->typeOf($callable->var)?->className
-                : ($callable->class instanceof Name ? $this->resolveName($callable->class) : null);
+            $class = match (true) {
+                $callable instanceof Expr\MethodCall => $this->typeOf($callable->var)?->className,
+                $callable->class instanceof Name => $this->resolveName($callable->class),
+                default => null,
+            };
 
             return $class === null ? [null, null] : [$class, $class . '::' . $callable->name->toString()];
         }
@@ -2224,7 +2230,7 @@ private function definedService(Expr $chain): array
                 continue;
             }
             $argument = $this->argumentNode($chain->args, 0)?->value;
-            $value = $argument instanceof AstNode\Scalar\String_ ? $argument->value : ($argument === null ? null : $this->classConstant($argument));
+            $value = $this->literalOrClass($argument);
             $name = strtolower($chain->name->toString());
             if ($name === 'set' || ($name === 'load' && $value !== null && str_ends_with($value, '\\'))) {
                 return [$value, null];
@@ -2317,7 +2323,7 @@ private function decoratedService(Expr $chain): ?string
         for (; $chain instanceof Expr\MethodCall; $chain = $chain->var) {
             $argument = $this->argumentNode($chain->args, 0)?->value;
             if ($chain->name instanceof Identifier && strtolower($chain->name->toString()) === 'decorate' && $argument !== null) {
-                return $argument instanceof AstNode\Scalar\String_ ? $argument->value : $this->classConstant($argument);
+                return $this->literalOrClass($argument);
             }
         }
 
@@ -2608,7 +2614,7 @@ private function attributes(array $groups): array
                         $routeName = $argument->value->value;
                     }
                     if ($name === 'methods') {
-                        $values = $argument->value instanceof Expr\Array_ ? array_map(static fn ($item) => $item->value, $argument->value->items) : [$argument->value];
+                        $values = $argument->value instanceof Expr\Array_ ? array_map(static fn (AstNode\ArrayItem $item): Expr => $item->value, $argument->value->items) : [$argument->value];
                         foreach ($values as $value) {
                             if ($value instanceof AstNode\Scalar\String_) {
                                 $methods[] = strtoupper($value->value);
@@ -2671,6 +2677,14 @@ private function listenMap(Stmt\Class_ $node): array
         return $map;
     }
 
+    /**
+     * A string written as such or as a class name: `'app.mailer'`, `Mailer::class`.
+     */
+    private function literalOrClass(?Expr $expr): ?string
+    {
+        return $expr instanceof AstNode\Scalar\String_ ? $expr->value : $this->classConstant($expr);
+    }
+
     private function classConstant(?Expr $expr): ?string
     {
         return $expr instanceof Expr\ClassConstFetch && $expr->class instanceof Name && $expr->name instanceof Identifier
@@ -2705,7 +2719,11 @@ private function callArgumentsOf(array $args): array
                 $isClosure => 'fn',
                 default => '?',
             };
-            $type = $isClosure ? $this->closureReturn($value) : ($class === null ? $this->typeOf($value) : null);
+            $type = match (true) {
+                $isClosure => $this->closureReturn($value),
+                $class === null => $this->typeOf($value),
+                default => null,
+            };
             // Bounded: `$html = apply_filters('x', $html, $html)` repeated would nest the type in itself, doubling it.
             if ($type !== null && \strlen($type->key()) <= self::ARGUMENT_KEY) {
                 $types[$position] = $type;
@@ -3191,14 +3209,28 @@ private function includedPath(Expr $expr, int $depth = 0): ?string
             $expr instanceof AstNode\Scalar\String_ => $expr->value,
             $expr instanceof AstNode\Scalar\MagicConst\Dir => "\0" . \dirname($this->path),
             $expr instanceof AstNode\Scalar\MagicConst\File => "\0" . $this->path,
-            $expr instanceof Expr\BinaryOp\Concat => ($left = $this->includedPath($expr->left, $depth + 1)) === null
-                || ($right = $this->includedPath($expr->right, $depth + 1)) === null || str_starts_with($right, "\0") ? null : $left . $right,
+            $expr instanceof Expr\BinaryOp\Concat => $this->concatenatedPath($expr, $depth),
             $expr instanceof Expr\FuncCall && $expr->name instanceof Name && $expr->name->toLowerString() === 'dirname'
                 && ($expr->args[0] ?? null) instanceof AstNode\Arg => $this->dirnameOf($expr, $depth),
             default => null,
         };
     }
 
+    private function concatenatedPath(Expr\BinaryOp\Concat $concat, int $depth): ?string
+    {
+        $left = $this->includedPath($concat->left, $depth + 1);
+        if ($left === null) {
+            return null;
+        }
+        $right = $this->includedPath($concat->right, $depth + 1);
+        // A location of its own on the right (`'x' . __DIR__`) is no path.
+        if ($right === null || str_starts_with($right, "\0")) {
+            return null;
+        }
+
+        return $left . $right;
+    }
+
     private function dirnameOf(Expr\FuncCall $call, int $depth): ?string
     {
         \assert($call->args[0] instanceof AstNode\Arg);
diff --git a/src/Extractor/FileExtraction.php b/src/Extractor/FileExtraction.php
index d108642..89a9ad0 100644
--- a/src/Extractor/FileExtraction.php
+++ b/src/Extractor/FileExtraction.php
@@ -32,9 +32,9 @@
      * @param array<string, array{reads: list<string>, writes: list<string>, constants?: list<string>}> $stateAccess
      *                                             method id => the properties of `$this` it reads and changes, and the
      *                                             class constants it uses
-     * @param array<string, array{params: list<string>, facts: list<array<string, mixed>>}> $configurationHelpers
+     * @param array<string, ConfigurationHelper> $configurationHelpers
      *                                             service configuration written in helpers, as templates (ConfigurationHelpers)
-     * @param list<array{caller: ?string, callee: string, args: list<array{?string, ?array<mixed>}>, line: int}> $configurationCalls
+     * @param list<PendingHelperCall> $configurationCalls
      *                                             calls that may be to such helpers, with their arguments as templates
      * @param array<string, string> $returnElements method id => class of the elements of the collection it returns
      * @param list<array{string, TypeExpr}> $propertyReads method id => a property it reads on a typed object,
@@ -62,7 +62,7 @@
      * @param array<string, array<string, string>> $documentedMethods class => lowercase name => method id of the
      *                                             magic methods it documents (`@method`), not graph nodes
      * @param array<string, list<string>> $mixins class => the classes it forwards unknown calls to (`@mixin`)
-     * @param array<string, string> $conditionalReturns callable id => its conditional return type, as JSON
+     * @param array<string, ConditionalReturn> $conditionalReturns callable id => its conditional return type
      *                                             (DocTypeResolver::RETURN_CONDITIONAL)
      * @param array<string, array<int|string, list<string>>> $callableParameters method id => the parameters of the
      *                                             closures it takes, by position and name (DocTypeResolver::CALLABLE_PARAMETERS)
diff --git a/src/Extractor/HelperArgument.php b/src/Extractor/HelperArgument.php
new file mode 100644
index 0000000..31f8565
--- /dev/null
+++ b/src/Extractor/HelperArgument.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * An argument of a call that may be to a configuration helper.
+ */
+final readonly class HelperArgument
+{
+    /**
+     * @param ?string   $name  the parameter it is passed to by name, null when passed by position
+     * @param ?Template $value null for an expression a template cannot hold
+     */
+    public function __construct(
+        public ?string $name,
+        public ?Template $value,
+    ) {
+    }
+}
diff --git a/src/Extractor/PendingHelperCall.php b/src/Extractor/PendingHelperCall.php
new file mode 100644
index 0000000..14524b8
--- /dev/null
+++ b/src/Extractor/PendingHelperCall.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * A call that may be to a configuration helper, in a helper or in a configuration file: evaluated by the builder when
+ * its arguments are known.
+ */
+final readonly class PendingHelperCall
+{
+    /**
+     * @param ?string              $caller the helper making it, null in a configuration file
+     * @param list<HelperArgument> $arguments
+     */
+    public function __construct(
+        public ?string $caller,
+        public string $callee,
+        public array $arguments,
+        public int $line,
+    ) {
+    }
+
+    public function withNames(?string $caller, string $callee): self
+    {
+        return new self($caller, $callee, $this->arguments, $this->line);
+    }
+
+    /**
+     * Whether an argument depends on a parameter of the caller: the call runs when its caller does.
+     */
+    public function usesParameters(): bool
+    {
+        foreach ($this->arguments as $argument) {
+            if ($argument->value?->usesParameters() === true) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/Extractor/ServiceArgumentFact.php b/src/Extractor/ServiceArgumentFact.php
new file mode 100644
index 0000000..6c60e4c
--- /dev/null
+++ b/src/Extractor/ServiceArgumentFact.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * What a configuration helper injects into a service: `->args([tagged_iterator($prefix . '.rule')])`, `service($id)`.
+ */
+final readonly class ServiceArgumentFact
+{
+    /**
+     * @param Template  $id      the service receiving it
+     * @param ?Template $tag     the tag whose services it receives, null for one service
+     * @param ?Template $service the service it receives, null for a tag
+     * @param bool      $locator `tagged_locator()` rather than `tagged_iterator()`
+     */
+    public function __construct(
+        public Template $id,
+        public ?Template $tag,
+        public ?Template $service,
+        public bool $locator = false,
+    ) {
+    }
+}
diff --git a/src/Extractor/ServiceDefinitionFact.php b/src/Extractor/ServiceDefinitionFact.php
new file mode 100644
index 0000000..9d0ade7
--- /dev/null
+++ b/src/Extractor/ServiceDefinitionFact.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * A service a configuration helper defines: `$services->set($prefix . '.validator', Validator::class)`.
+ */
+final readonly class ServiceDefinitionFact
+{
+    /**
+     * @param ?Template $class null when the id is the class
+     */
+    public function __construct(
+        public Template $id,
+        public ?Template $class,
+    ) {
+    }
+}
diff --git a/src/Extractor/ServiceTagFact.php b/src/Extractor/ServiceTagFact.php
new file mode 100644
index 0000000..ecf55d0
--- /dev/null
+++ b/src/Extractor/ServiceTagFact.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * A tag a configuration helper puts on services: `$services->load($namespace . '\Rules\', ...)->tag($prefix . '.rule')`.
+ */
+final readonly class ServiceTagFact
+{
+    /**
+     * @param Template $target the service id, the namespace or the type the chain configures, as its kind says
+     */
+    public function __construct(
+        public DefinitionKind $kind,
+        public Template $target,
+        public Template $name,
+    ) {
+    }
+}
diff --git a/src/Extractor/SourceFacts.php b/src/Extractor/SourceFacts.php
index 348b897..db96dcc 100644
--- a/src/Extractor/SourceFacts.php
+++ b/src/Extractor/SourceFacts.php
@@ -247,11 +247,7 @@ private function signature(Stmt\ClassMethod $method): string
             $type = $this->type($param->type);
             // A parameter named after its type says nothing more: `Notification`, not `Notification $notification`.
             $named = $type === null || strcasecmp(ltrim($type, '?'), $name) !== 0 || $param->variadic || $param->default !== null;
-            $parameters[] = trim(implode(' ', array_filter([
-                $type,
-                // An optional parameter, its default left out: `$path?`.
-                $named ? ($param->variadic ? '...' : '') . '$' . $name . ($param->default === null ? '' : '?') : null,
-            ])));
+            $parameters[] = trim(implode(' ', array_filter([$type, $named ? self::parameterName($param, $name) : null])));
         }
         $return = $this->documentedReturn($method->getDocComment()?->getText()) ?? $this->type($method->returnType);
 
@@ -259,6 +255,17 @@ private function signature(Stmt\ClassMethod $method): string
             . $method->name->toString() . '(' . implode(', ', $parameters) . ')' . ($return === null ? '' : ': ' . $return);
     }
 
+    /**
+     * An optional parameter, its default left out: `$path?`.
+     */
+    private static function parameterName(AstNode\Param $param, string $name): string
+    {
+        $variadic = $param->variadic ? '...' : '';
+        $optional = $param->default === null ? '' : '?';
+
+        return $variadic . '$' . $name . $optional;
+    }
+
     /**
      * A documented collection says more than `array`: `list<Violation>`.
      */
diff --git a/src/Extractor/Template.php b/src/Extractor/Template.php
new file mode 100644
index 0000000..44599f7
--- /dev/null
+++ b/src/Extractor/Template.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * A string expression of a configuration helper, evaluated by the builder (ConfigurationEvaluator) once the arguments
+ * of a call are known: `$prefix . '.rule'`, `sprintf('%s.%s', $prefix, self::SUFFIX)`, `__DIR__`.
+ */
+final readonly class Template
+{
+    /**
+     * @param string     $value the text, the parameter's name, the constant (`Class::NAME`) or the function called
+     * @param list<self> $parts the parts of a concatenation, the arguments of a call, the items of a list
+     */
+    private function __construct(
+        public TemplateKind $kind,
+        public string $value = '',
+        public array $parts = [],
+    ) {
+    }
+
+    public static function literal(string $text): self
+    {
+        return new self(TemplateKind::Literal, $text);
+    }
+
+    public static function parameter(string $name): self
+    {
+        return new self(TemplateKind::Parameter, $name);
+    }
+
+    /**
+     * `__DIR__`: the directory of the file declaring the helper.
+     */
+    public static function directory(): self
+    {
+        return new self(TemplateKind::Directory);
+    }
+
+    public static function constant(string $constant): self
+    {
+        return new self(TemplateKind::Constant, $constant);
+    }
+
+    /**
+     * @param list<self> $parts
+     */
+    public static function concat(array $parts): self
+    {
+        return new self(TemplateKind::Concat, '', $parts);
+    }
+
+    /**
+     * A call to one of ConfigurationHelpers::FUNCTIONS.
+     *
+     * @param list<self> $arguments
+     */
+    public static function call(string $function, array $arguments): self
+    {
+        return new self(TemplateKind::Call, $function, $arguments);
+    }
+
+    /**
+     * An array of strings, an argument of str_replace() or implode().
+     *
+     * @param list<self> $items
+     */
+    public static function list(array $items): self
+    {
+        return new self(TemplateKind::List, '', $items);
+    }
+
+    /**
+     * Whether the value depends on a parameter of the helper: known only when its caller is evaluated.
+     */
+    public function usesParameters(): bool
+    {
+        if ($this->kind === TemplateKind::Parameter) {
+            return true;
+        }
+        foreach ($this->parts as $part) {
+            if ($part->usesParameters()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/Extractor/TemplateKind.php b/src/Extractor/TemplateKind.php
new file mode 100644
index 0000000..99e8a78
--- /dev/null
+++ b/src/Extractor/TemplateKind.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpGraph\Extractor;
+
+/**
+ * What a template of a configuration helper is: a piece of text, or what builds it once the arguments are known.
+ */
+enum TemplateKind: string
+{
+    case Literal = 'lit';
+    case Parameter = 'param';
+    case Directory = 'dir';
+    case Constant = 'const';
+    case Concat = 'concat';
+    case Call = 'call';
+    case List = 'list';
+}
diff --git a/src/Extractor/TypeExpr.php b/src/Extractor/TypeExpr.php
index 3ba7706..ae272cd 100644
--- a/src/Extractor/TypeExpr.php
+++ b/src/Extractor/TypeExpr.php
@@ -244,9 +244,13 @@ public function map(\Closure $map): self
             return new self(null, null, null, false, false, null, array_map($map, $this->functions), $arguments, null, $argumentTypes);
         }
 
-        return $this->receiver === null
-            ? new self($this->className === null ? null : $map($this->className), null, null, false, false, $this->generic === null ? null : GenericType::mapNames($this->generic, $map))
-            : new self(null, $this->receiver->map($map), $this->member, $this->isProperty, $this->isElement, null, [], $arguments, $this->closure, $argumentTypes);
+        if ($this->receiver !== null) {
+            return new self(null, $this->receiver->map($map), $this->member, $this->isProperty, $this->isElement, null, [], $arguments, $this->closure, $argumentTypes);
+        }
+        $className = $this->className === null ? null : $map($this->className);
+        $generic = $this->generic === null ? null : GenericType::mapNames($this->generic, $map);
+
+        return new self($className, null, null, false, false, $generic);
     }
 
     public function key(): string
@@ -256,7 +260,7 @@ public function key(): string
         }
         if ($this->test !== null) {
             $call = $this->test[3] ?? null;
-            $tested = $call === null ? strtolower(implode('|', $this->test[1])) : $call[0]->key() . '#' . $call[1] . ($call[2] ? ';' : '');
+            $tested = $call === null ? strtolower(implode('|', $this->test[1])) : self::assertionKey($call);
 
             return '(' . $this->test[0]->key() . ($this->test[2] ? ')!is(' : ')is(') . $tested . ')';
         }
@@ -276,6 +280,16 @@ public function key(): string
         return $this->receiver->key() . ($this->isProperty ? '->$' : '->') . $this->member . ($this->isProperty ? '' : '(' . $this->argumentsKey() . ')') . ($this->isElement ? '[]' : '');
     }
 
+    /**
+     * @param array{self, int, bool} $call the asserting call, the position of the argument, whether it is a statement
+     */
+    private static function assertionKey(array $call): string
+    {
+        $statement = $call[2] ? ';' : '';
+
+        return $call[0]->key() . '#' . $call[1] . $statement;
+    }
+
     private function argumentsKey(): string
     {
         $arguments = $this->arguments;
diff --git a/src/Graph/Edge.php b/src/Graph/Edge.php
index d46f341..cfc6f37 100644
--- a/src/Graph/Edge.php
+++ b/src/Graph/Edge.php
@@ -69,16 +69,24 @@ public function addLines(self $other): void
     }
 
     /**
-     * @return array<string, string>
+     * @return array{source: string, target: string, relation: string, confidence: string, lines?: string, via?: string}
      */
     public function toArray(): array
     {
-        return [
+        $data = [
             'source' => $this->source,
             'target' => $this->target,
             'relation' => $this->relation->value,
             'confidence' => $this->confidence->value,
-        ] + ($this->lines === '' ? [] : ['lines' => $this->lines]) + ($this->via === '' ? [] : ['via' => $this->via]);
+        ];
+        if ($this->lines !== '') {
+            $data['lines'] = $this->lines;
+        }
+        if ($this->via !== '') {
+            $data['via'] = $this->via;
+        }
+
+        return $data;
     }
 
     /**
diff --git a/src/Graph/Graph.php b/src/Graph/Graph.php
index 1df8956..93b9c52 100644
--- a/src/Graph/Graph.php
+++ b/src/Graph/Graph.php
@@ -92,7 +92,10 @@ public function edgeCount(): int
     }
 
     /**
-     * @return array{nodes: list<array<string, mixed>>, edges: list<array<string, string>>}
+     * @return array{
+     *     nodes: list<array{id: string, label: string, kind: string, file: ?string, line: ?int, service?: string, modifiers?: list<string>, alias?: string}>,
+     *     edges: list<array{source: string, target: string, relation: string, confidence: string, lines?: string, via?: string}>,
+     * }
      */
     public function toArray(): array
     {
diff --git a/src/Graph/Node.php b/src/Graph/Node.php
index c35d0d9..eb01a98 100644
--- a/src/Graph/Node.php
+++ b/src/Graph/Node.php
@@ -26,18 +26,28 @@ public function __construct(
     }
 
     /**
-     * @return array<string, mixed>
+     * @return array{id: string, label: string, kind: string, file: ?string, line: ?int, service?: string, modifiers?: list<string>, alias?: string}
      */
     public function toArray(): array
     {
-        return [
+        $data = [
             'id' => $this->id,
             'label' => $this->label,
             'kind' => $this->kind->value,
             'file' => $this->file,
             'line' => $this->line,
-        ] + ($this->service === null ? [] : ['service' => $this->service]) + ($this->modifiers === [] ? [] : ['modifiers' => $this->modifiers])
-            + ($this->alias === null ? [] : ['alias' => $this->alias]);
+        ];
+        if ($this->service !== null) {
+            $data['service'] = $this->service;
+        }
+        if ($this->modifiers !== []) {
+            $data['modifiers'] = $this->modifiers;
+        }
+        if ($this->alias !== null) {
+            $data['alias'] = $this->alias;
+        }
+
+        return $data;
     }
 
     /**
diff --git a/src/Mcp/McpServer.php b/src/Mcp/McpServer.php
index 4022ac1..5987c23 100644
--- a/src/Mcp/McpServer.php
+++ b/src/Mcp/McpServer.php
@@ -84,6 +84,9 @@ public function run($input = STDIN, $output = STDOUT): void
     }
 
     /**
+     * The response to a request, null for a notification: one of the shapes of initialize(), tools(), callTool() or
+     * error(). Open, as run() sends whatever a subclass answers (a test answers what JSON cannot encode).
+     *
      * @param array<mixed> $request
      *
      * @return array<string, mixed>|null
@@ -133,20 +136,22 @@ public function handle(array $request): ?array
     /**
      * @param array<mixed> $params
      *
-     * @return array<string, mixed>
+     * @return array{protocolVersion: string, capabilities: array{tools: \stdClass}, serverInfo: array{name: string, version: string}, instructions: string}
      */
     private function initialize(array $params): array
     {
+        $note = $this->provider->projectNote();
+
         return [
             'protocolVersion' => \in_array($params['protocolVersion'] ?? null, self::PROTOCOLS, true) ? $params['protocolVersion'] : self::PROTOCOLS[\count(self::PROTOCOLS) - 1],
             'capabilities' => ['tools' => new \stdClass()],
             'serverInfo' => ['name' => self::NAME, 'version' => $this->version],
-            'instructions' => ($note = $this->provider->projectNote()) === null ? self::INSTRUCTIONS : $note . "\n\n" . self::INSTRUCTIONS,
+            'instructions' => $note === null ? self::INSTRUCTIONS : $note . "\n\n" . self::INSTRUCTIONS,
         ];
     }
 
     /**
-     * @return list<array<string, mixed>>
+     * @return list<array{name: string, description: string, inputSchema: array{type: string, properties: \stdClass|array<string, array{type: string, description: string, enum?: list<string>}>, required?: list<string>}}>
      */
     private function tools(): array
     {
@@ -303,7 +308,7 @@ private function tools(): array
     /**
      * @param array<mixed> $params
      *
-     * @return array<string, mixed>
+     * @return array{content: list<array{type: string, text: string}>, isError: bool}
      */
     private function callTool(array $params): array
     {
@@ -395,7 +400,7 @@ private static function stamp(string $file): string
     }
 
     /**
-     * @return array<string, mixed>
+     * @return array{jsonrpc: string, id: mixed, error: array{code: int, message: string}}
      */
     private function error(mixed $id, int $code, string $message): array
     {
diff --git a/src/Presentation/ImpactReport.php b/src/Presentation/ImpactReport.php
index 787c069..5a2c9c3 100644
--- a/src/Presentation/ImpactReport.php
+++ b/src/Presentation/ImpactReport.php
@@ -59,7 +59,7 @@ public function __construct(
         $modules = array_fill_keys(array_map(static fn (ImpactedClass $class): string => $module($class->class), $this->groups['direct']), true);
         $rank = static fn (ImpactedClass $class): int => $class->confidence === Confidence::Ambiguous ? 1 : 0;
         foreach (['state', 'quietState', 'stateTests', 'quietStateTests'] as $key) {
-            usort($this->groups[$key], static fn ($a, $b): int => [$rank($a), isset($modules[$module($b->class)]), $a->depth] <=> [$rank($b), isset($modules[$module($a->class)]), $b->depth]);
+            usort($this->groups[$key], static fn (ImpactedClass $a, ImpactedClass $b): int => [$rank($a), isset($modules[$module($b->class)]), $a->depth] <=> [$rank($b), isset($modules[$module($a->class)]), $b->depth]);
         }
 
         $files = [];
@@ -116,16 +116,21 @@ private function text(int $limit, ?string $section): string
         if ($wanted('routes') && $g['routes'] !== []) {
             $lines[] = '';
             $lines[] = 'Routes reaching it, ← from their handler:';
-            foreach ($shown = self::sliced($g['routes'], $limit, 0) as $route) {
+            $shown = self::sliced($g['routes'], $limit, 0);
+            foreach ($shown as $route) {
                 $marked = $route->confidence === Confidence::Inferred ? '' : ' [' . $route->confidence->value . ']';
                 $also = \array_slice($route->otherChains, 0, $limit === 0 ? 5 : self::CHAINS);
                 $others = \count($route->otherChains) - \count($also);
+                $hidden = '';
+                if ($others > 0 && $limit !== 0) {
+                    $hidden = \sprintf(' (+%d other chain%s: limit 0)', $others, $others > 1 ? 's' : '');
+                }
                 $lines[] = \sprintf(
                     '  %s%s ← %s%s',
                     $this->query->label($route->class),
                     $marked,
                     $this->chain($route->chain),
-                    $others === 0 || $limit === 0 ? '' : \sprintf(' (+%d other chain%s: limit 0)', $others, $others > 1 ? 's' : ''),
+                    $hidden,
                 );
                 foreach ($also as $chain) {
                     $lines[] = '    also ← ' . $this->chain($chain);
@@ -146,7 +151,8 @@ private function text(int $limit, ?string $section): string
         if ($wanted('operations') && $g['operations'] !== []) {
             $lines[] = '';
             $lines[] = 'API operations behind it (OpenAPI, .proto: the contract its clients rely on), ← what implements them:';
-            foreach ($shown = self::sliced($g['operations'], $limit, 0) as $operation) {
+            $shown = self::sliced($g['operations'], $limit, 0);
+            foreach ($shown as $operation) {
                 $marked = $operation->confidence === Confidence::Inferred ? '' : ' [' . $operation->confidence->value . ']';
                 $implementation = $this->query->graph()->node($operation->chain[0] ?? $operation->node ?? $operation->edge->target);
                 $lines[] = \sprintf(
@@ -168,7 +174,8 @@ private function text(int $limit, ?string $section): string
                 }
                 $lines[] = '';
                 $lines[] = $level === 1 ? 'Direct dependents:' : \sprintf('%d relations away:', $level);
-                foreach ($shown = self::sliced($atDepth, $limit, 0) as $class) {
+                $shown = self::sliced($atDepth, $limit, 0);
+                foreach ($shown as $class) {
                     $lines[] = '  ' . $this->classLine($class, $limit);
                 }
                 $more($atDepth, $shown);
@@ -184,7 +191,8 @@ private function text(int $limit, ?string $section): string
         if ($wanted('state') && $state !== []) {
             $lines[] = '';
             $lines[] = 'Through the state it changes (they call a method reading what it writes and filter on it, compare before and after, or use what it writes):';
-            foreach ($shown = self::sliced($state, $limit, 0) as $class) {
+            $shown = self::sliced($state, $limit, 0);
+            foreach ($shown as $class) {
                 $lines[] = '  ' . $this->classLine($class, $limit);
             }
             $more($state, $shown);
@@ -214,7 +222,8 @@ private function text(int $limit, ?string $section): string
             $lines[] = $title;
             // One test per line, its path below its module: what PHPUnit takes, and unique where names repeat.
             $byModule = [];
-            foreach ($shown = self::sliced($tests, $limit, self::TESTS) as $test) {
+            $shown = self::sliced($tests, $limit, self::TESTS);
+            foreach ($shown as $test) {
                 $file = (string) $this->file($test->class);
                 $module = $this->module($file);
                 $base = $this->prefix . ($module === '' ? '' : $module . '/');
@@ -245,28 +254,12 @@ private function text(int $limit, ?string $section): string
 
     private function json(?string $section): string
     {
-        $class = fn (ImpactedClass $class): array => [
-            'class' => $class->class,
-            'file' => $this->file($class->class),
-            'depth' => $class->depth,
-            'confidence' => $class->confidence->value,
-        ] + ($class->comparesState ? ['comparesState' => true] : []) + ($class->followed ? [] : ['followed' => false]) + [
-            'sites' => array_map(static fn (Edge $edge): array => [
-                'source' => $edge->source,
-                'relation' => $edge->relation->value,
-                'target' => $edge->target,
-            ] + ($edge->lines() === [] ? [] : ['lines' => $edge->lines()]) + ($edge->via() === '' ? [] : ['via' => $edge->via()]), $class->sites),
-        ];
+        $class = $this->classData(...);
         $data = [
             'changed' => ['id' => $this->changed->id, 'kind' => $this->changed->kind->value, 'file' => $this->changed->file, 'line' => $this->changed->line],
             'maxDepth' => $this->impact->maxDepth,
             'truncated' => $this->impact->truncated,
-            'routes' => array_map(fn (ImpactedClass $route): array => [
-                'route' => $this->query->label($route->class),
-                'id' => $route->class,
-                'confidence' => $route->confidence->value,
-                'chain' => $route->chain,
-            ] + (($screens = $this->query->screens($route->class)) === [] ? [] : ['screens' => $screens]), $this->groups['routes']),
+            'routes' => array_map($this->routeData(...), $this->groups['routes']),
             'operations' => array_map(fn (ImpactedClass $operation): array => [
                 'operation' => $this->query->label($operation->class),
                 'id' => $operation->class,
@@ -294,6 +287,67 @@ private function json(?string $section): string
         return (string) json_encode($data, \JSON_PRETTY_PRINT | \JSON_UNESCAPED_SLASHES | \JSON_UNESCAPED_UNICODE);
     }
 
+    /**
+     * @return array{class: string, file: ?string, depth: int, confidence: string, comparesState?: true, followed?: false, sites: list<array<string, string|list<int>>>}
+     */
+    private function classData(ImpactedClass $class): array
+    {
+        $data = [
+            'class' => $class->class,
+            'file' => $this->file($class->class),
+            'depth' => $class->depth,
+            'confidence' => $class->confidence->value,
+        ];
+        if ($class->comparesState) {
+            $data['comparesState'] = true;
+        }
+        if (!$class->followed) {
+            $data['followed'] = false;
+        }
+        $data['sites'] = array_map(self::siteData(...), $class->sites);
+
+        return $data;
+    }
+
+    /**
+     * @return array<string, string|list<int>>
+     */
+    private static function siteData(Edge $edge): array
+    {
+        $data = [
+            'source' => $edge->source,
+            'relation' => $edge->relation->value,
+            'target' => $edge->target,
+        ];
+        if ($edge->lines() !== []) {
+            $data['lines'] = $edge->lines();
+        }
+        if ($edge->via() !== '') {
+            $data['via'] = $edge->via();
+        }
+
+        return $data;
+    }
+
+    /**
+     * @return array{route: string, id: string, confidence: string, chain: list<string>, screens?: array<string, list<int>>}
+     */
+    private function routeData(ImpactedClass $route): array
+    {
+        $data = [
+            'route' => $this->query->label($route->class),
+            'id' => $route->class,
+            'confidence' => $route->confidence->value,
+            'chain' => $route->chain,
+        ];
+        $screens = $this->query->screens($route->class);
+        if ($screens !== []) {
+            $data['screens'] = $screens;
+        }
+
+        return $data;
+    }
+
     /**
      * @param list<ImpactedClass> $entries
      *
@@ -363,13 +417,18 @@ private function classLine(ImpactedClass $class, int $limit): string
         }
 
         $where = $this->where($class->class);
+        $listed = '';
+        if ($shown !== []) {
+            $more = \count($sites) > \count($shown) ? \sprintf('; +%d', \count($sites) - \count($shown)) : '';
+            $listed = ': ' . implode('; ', $shown) . $more;
+        }
 
         return \sprintf(
             '%s%s%s%s',
             $this->query->label($class->class),
             $where === '' || $where === '.' ? '' : ' (' . $where . ')',
             $notes === [] ? '' : ' [' . implode(', ', $notes) . ']',
-            $shown === [] ? '' : ': ' . implode('; ', $shown) . (\count($sites) > \count($shown) ? \sprintf('; +%d', \count($sites) - \count($shown)) : ''),
+            $listed,
         );
     }
 
diff --git a/src/Presentation/OutlineReport.php b/src/Presentation/OutlineReport.php
index b37c6da..b661687 100644
--- a/src/Presentation/OutlineReport.php
+++ b/src/Presentation/OutlineReport.php
@@ -59,6 +59,8 @@ private function text(bool $full, ?string $section): string
         $this->prefix = self::commonDirectory(array_values($files));
         // A section alone lists everything, each line still compact; full also spells out every line.
         $all = $full || $section !== null;
+        // The methods a flow line names, 0 for all.
+        $named = $full ? 0 : 4;
         $more = static fn (array $all, array $shown): string => \count($all) > \count($shown) ? \sprintf(' (+%d)', \count($all) - \count($shown)) : '';
 
         $lines = [
@@ -83,15 +85,7 @@ private function text(bool $full, ?string $section): string
                 $class,
                 $large['methods'],
                 $example === null ? $class . '::<method>' : $class . '::' . substr($example, (int) strrpos($example, ':') + 1),
-                $large['entries'] === [] ? '' : ' Its entry points: ' . implode(', ', array_map(
-                    static fn (string $method, array $entry): string => substr($method, (int) strrpos($method, ':') + 1) . '() ('
-                        . implode(', ', array_filter([
-                            $entry['routes'] > 0 ? \sprintf('%d route%s', $entry['routes'], $entry['routes'] > 1 ? 's' : '') : null,
-                            $entry['callers'] > 0 ? \sprintf('called by %d class%s', $entry['callers'], $entry['callers'] > 1 ? 'es' : '') : null,
-                        ])) . ')',
-                    array_keys($large['entries']),
-                    $large['entries'],
-                )) . '.',
+                $large['entries'] === [] ? '' : ' Its entry points: ' . implode(', ', array_map(self::entryPoint(...), array_keys($large['entries']), $large['entries'])) . '.',
             );
         }
 
@@ -168,7 +162,7 @@ private function text(bool $full, ?string $section): string
             $lines[] = 'Core, by namespace' . ($common === '' ? '' : ' (under ' . rtrim($common, '\\') . ')') . ':';
             foreach ($byNamespace as $namespace => $classes) {
                 $layer = Layers::of(explode('\\', (string) $namespace));
-                $lines[] = '  ' . ((string) $namespace === '' ? '(no namespace)' : (substr((string) $namespace, \strlen($common)) ?: (string) $namespace)) . ($layer === null ? '' : ' [' . $layer['segment'] . ']');
+                $lines[] = '  ' . self::namespaceLabel((string) $namespace, $common) . ($layer === null ? '' : ' [' . $layer['segment'] . ']');
                 foreach ($classes as $class) {
                     array_push($lines, ...$this->classLines($class, $outline->facts[$class] ?? null, $all));
                 }
@@ -200,12 +194,16 @@ private function text(bool $full, ?string $section): string
                 }
                 arsort($modules);
                 $shown = self::limited($all, $modules, \count($modules) > 3 ? 2 : 3);
+                $inModules = '';
+                if ($modules !== []) {
+                    $hidden = \count($modules) > \count($shown) ? \sprintf(' +%d modules', \count($modules) - \count($shown)) : '';
+                    $inModules = ' in ' . implode(', ', array_map(static fn (string $module, int $count): string => $module . ' ' . $count, array_keys($shown), $shown)) . $hidden;
+                }
                 $lines[] = \sprintf(
                     '  %s: %s%s%s',
                     $this->query->label($family['head']),
                     $family['members'] === 0 ? '0 implementations' : $family['members'],
-                    $modules === [] ? '' : ' in ' . implode(', ', array_map(static fn (string $module, int $count): string => $module . ' ' . $count, array_keys($shown), $shown))
-                        . (\count($modules) > \count($shown) ? \sprintf(' +%d modules', \count($modules) - \count($shown)) : ''),
+                    $inModules,
                     $family['receivers'] === [] ? '' : '; received by ' . implode(', ', array_map(fn (string $receiver): string => $this->query->label(explode(' ', $receiver, 2)[0]) . ' ' . (explode(' ', $receiver, 2)[1] ?? ''), $family['receivers'])),
                 );
             }
@@ -242,7 +240,7 @@ private function text(bool $full, ?string $section): string
                     $classes = array_unique(array_map(static fn (string $caller): string => explode('::', $caller)[0], $callers));
                     $from = [];
                     if ($callers !== []) {
-                        $from[] = \count($classes) > 8 && !$full ? \sprintf('%d classes', \count($classes)) : $this->methodList($callers, $full ? 0 : 4);
+                        $from[] = \count($classes) > 8 && !$full ? \sprintf('%d classes', \count($classes)) : $this->methodList($callers, $named);
                     }
                     // The members of a family by name when few, else counted under the family.
                     foreach ($outline->fromFamilies[$method] ?? [] as $head => $members) {
@@ -253,12 +251,12 @@ private function text(bool $full, ?string $section): string
                     }
                     // The callers from the core too, else the line reads as every caller while "Inside" is cut.
                     $fromCore = array_keys(array_filter($outline->inside, static fn (array $callees): bool => \in_array($method, $callees, true)));
-                    $lines[] = \sprintf(
-                        '    %s ← %s%s',
-                        $this->query->label($method),
-                        implode(', ', $from),
-                        $fromCore === [] ? '' : ($from === [] ? 'from the core: ' : '; from the core: ') . $this->methodList(array_map('strval', $fromCore), $full ? 0 : 4),
-                    );
+                    $coreCallers = '';
+                    if ($fromCore !== []) {
+                        $separator = $from === [] ? '' : '; ';
+                        $coreCallers = $separator . 'from the core: ' . $this->methodList(array_map('strval', $fromCore), $named);
+                    }
+                    $lines[] = \sprintf('    %s ← %s%s', $this->query->label($method), implode(', ', $from), $coreCallers);
                 }
                 if (!$all && \count($called) > self::ENTRIES) {
                     $lines[] = \sprintf('    +%d more: section flow', \count($called) - self::ENTRIES);
@@ -281,8 +279,8 @@ private function text(bool $full, ?string $section): string
                         '    %s → %s',
                         $this->query->label($method),
                         implode('; ', array_filter([
-                            $sure === [] ? '' : $this->methodList($sure, $full ? 0 : 4),
-                            $guessed === [] ? '' : 'guessed: ' . $this->methodList($guessed, $full ? 0 : 4),
+                            $sure === [] ? '' : $this->methodList($sure, $named),
+                            $guessed === [] ? '' : 'guessed: ' . $this->methodList($guessed, $named),
                         ])),
                     );
                 }
@@ -592,14 +590,50 @@ private function rpcs(array $core): array
         return $rpcs;
     }
 
+    /**
+     * `save() (2 routes, called by 3 classes)`: an entry point of a large class.
+     *
+     * @param array{routes: int, callers: int} $entry
+     */
+    private static function entryPoint(string $method, array $entry): string
+    {
+        $uses = [];
+        if ($entry['routes'] > 0) {
+            $uses[] = \sprintf('%d route%s', $entry['routes'], $entry['routes'] > 1 ? 's' : '');
+        }
+        if ($entry['callers'] > 0) {
+            $uses[] = \sprintf('called by %d class%s', $entry['callers'], $entry['callers'] > 1 ? 'es' : '');
+        }
+
+        return substr($method, (int) strrpos($method, ':') + 1) . '() (' . implode(', ', $uses) . ')';
+    }
+
+    /**
+     * A namespace of the core below the one common to all, or whole when it is the common one.
+     */
+    private static function namespaceLabel(string $namespace, string $common): string
+    {
+        if ($namespace === '') {
+            return '(no namespace)';
+        }
+        $below = substr($namespace, \strlen($common));
+
+        return $below === '' ? $namespace : $below;
+    }
+
     /**
      * `GET /orders openapi.yaml:3`
      */
     private function operationLabel(string $operation): string
     {
+        $label = $this->query->label($operation);
         $node = $this->query->graph()->node($operation);
+        if ($node?->file === null) {
+            return $label;
+        }
+        $line = $node->line === null ? '' : ':' . $node->line;
 
-        return $this->query->label($operation) . ($node?->file === null ? '' : ' ' . $node->file . ($node->line === null ? '' : ':' . $node->line));
+        return $label . ' ' . $node->file . $line;
     }
 
     /**
@@ -652,23 +686,13 @@ private function overridden(string $method): array
     private function json(): string
     {
         $outline = $this->outline;
-
-        return (string) json_encode([
+        $data = [
             'topic' => $outline->topic,
             'seeds' => $outline->seeds,
-            'core' => array_map(static fn (string $class): array => array_filter([
-                'id' => $class,
-                'kind' => $outline->facts[$class]->kind ?? null,
-                'modifiers' => $outline->facts[$class]->modifiers ?? null,
-                'summary' => $outline->facts[$class]->summary ?? null,
-                'signatures' => $outline->facts[$class]->signatures ?? null,
-                'constants' => $outline->facts[$class]->constants ?? null,
-                'cases' => $outline->facts[$class]->cases ?? null,
-                'properties' => ($properties = array_map(static fn (array $property): string => $property['type'], $outline->facts[$class]->properties ?? [])) === [] ? null : $properties,
-            ], static fn (mixed $value): bool => $value !== null), $outline->core),
+            'core' => array_map($this->coreClassData(...), $outline->core),
             'sourcesRead' => $outline->sourcesRead,
             'families' => $outline->families,
-            'routes' => array_map(fn (array $route): array => ['route' => $this->query->label($route['route']), 'id' => $route['route'], 'chain' => $route['chain']] + (($operations = $this->operations($route['route'])) === [] ? [] : ['operations' => $operations]), $outline->routes),
+            'routes' => array_map($this->routeData(...), $outline->routes),
             'operations' => $this->rpcs($outline->core),
             'entries' => $outline->entries,
             'fromFamilies' => $outline->fromFamilies,
@@ -682,9 +706,60 @@ private function json(): string
             'topTests' => $outline->topTests,
             'uncovered' => $outline->uncovered,
             'unused' => array_keys($outline->unused),
-        ] + ($outline->method === null ? [] : ['method' => $outline->method, 'depths' => $outline->depths, 'hubs' => $outline->hubs, 'guesses' => $outline->guesses, 'guessed' => $outline->guessed])
-            + ($outline->large === null ? [] : ['large' => $outline->large])
-            + ($outline->left === [] ? [] : ['left' => $outline->left]), \JSON_PRETTY_PRINT | \JSON_UNESCAPED_SLASHES | \JSON_UNESCAPED_UNICODE);
+        ];
+        if ($outline->method !== null) {
+            $data['method'] = $outline->method;
+            $data['depths'] = $outline->depths;
+            $data['hubs'] = $outline->hubs;
+            $data['guesses'] = $outline->guesses;
+            $data['guessed'] = $outline->guessed;
+        }
+        if ($outline->large !== null) {
+            $data['large'] = $outline->large;
+        }
+        if ($outline->left !== []) {
+            $data['left'] = $outline->left;
+        }
+
+        return (string) json_encode($data, \JSON_PRETTY_PRINT | \JSON_UNESCAPED_SLASHES | \JSON_UNESCAPED_UNICODE);
+    }
+
+    /**
+     * A class of the core with the facts its source gave, those it gave none of left out.
+     *
+     * @return array{id: string, kind?: string, modifiers?: list<string>, summary?: string, signatures?: list<string>, constants?: array<string, string>, cases?: array<string, string>, properties?: array<string, string>}
+     */
+    private function coreClassData(string $class): array
+    {
+        $facts = $this->outline->facts[$class] ?? null;
+        $properties = array_map(static fn (array $property): string => $property['type'], $facts->properties ?? []);
+
+        return array_filter([
+            'id' => $class,
+            'kind' => $facts?->kind,
+            'modifiers' => $facts?->modifiers,
+            'summary' => $facts?->summary,
+            'signatures' => $facts?->signatures,
+            'constants' => $facts?->constants,
+            'cases' => $facts?->cases,
+            'properties' => $properties === [] ? null : $properties,
+        ], static fn (mixed $value): bool => $value !== null);
+    }
+
+    /**
+     * @param array{route: string, chain: list<string>} $route
+     *
+     * @return array{route: string, id: string, chain: list<string>, operations?: list<string>}
+     */
+    private function routeData(array $route): array
+    {
+        $data = ['route' => $this->query->label($route['route']), 'id' => $route['route'], 'chain' => $route['chain']];
+        $operations = $this->operations($route['route']);
+        if ($operations !== []) {
+            $data['operations'] = $operations;
+        }
+
+        return $data;
     }
 
     /**
diff --git a/src/Presentation/TextPresenter.php b/src/Presentation/TextPresenter.php
index 49b8152..db20dff 100644
--- a/src/Presentation/TextPresenter.php
+++ b/src/Presentation/TextPresenter.php
@@ -134,8 +134,6 @@ public function explain(string $name, Direction $direction = Direction::Both, in
      */
     private function connectionLine(Connection $connection, ?Node $other): string
     {
-        $lines = $connection->edge->lines();
-
         return rtrim(\sprintf(
             '  %s %s [%s%s] [%s]  %s%s',
             $connection->forward ? '-->' : '<--',
@@ -144,10 +142,34 @@ private function connectionLine(Connection $connection, ?Node $other): string
             $connection->edge->via() === '' ? '' : ' ' . $connection->edge->via(),
             $connection->edge->confidence->value,
             $other?->file === null ? '' : $this->location($other),
-            $lines === [] ? '' : ', at L' . implode(', L', \array_slice($lines, 0, 8)) . (\count($lines) > 8 ? ', ...' : ''),
+            self::atLines(', ', $connection->edge->lines()),
         ));
     }
 
+    /**
+     * `, at L12, L20, ...`: the first lines of a relation in the source, nothing when it has none.
+     *
+     * @param list<int> $lines
+     */
+    private static function atLines(string $separator, array $lines): string
+    {
+        if ($lines === []) {
+            return '';
+        }
+        $more = \count($lines) > 8 ? ', ...' : '';
+
+        return $separator . 'at L' . implode(', L', \array_slice($lines, 0, 8)) . $more;
+    }
+
+    private static function notFollowed(ImpactedClass $class): string
+    {
+        return match (true) {
+            $class->followed => '',
+            $class->edge->relation === Relation::Receives => ' (receives it among others: its users are not followed)',
+            default => ' (inherited code shared with other subclasses: its callers are not followed)',
+        };
+    }
+
     public function path(string $from, string $to): string
     {
         $start = $this->query->resolve($from);
@@ -592,29 +614,34 @@ public function overview(): string
             $lines[] = 'Action codes the front end sends, mapped to controller methods by the routing files of phpgraph.yaml: route:<file>#ACTION <code> --handled_by--> method; '
                 . '--references--> the action or template it goes on to (via target, forward <result>); a file quoting the code --references--> the action (AMBIGUOUS). '
                 . 'query_graph("<code> routes") finds one; outline of its method starts its flow from it.';
+            $withoutController = $actions->unlinkedCount - $actions->toClass;
             $lines[] = \sprintf(
                 '- %d actions: %d handled by a controller method%s%s.',
                 $actions->actions,
                 $actions->linked,
                 $actions->toClass > 0 ? \sprintf(', %d by a controller lacking the method', $actions->toClass) : '',
-                $actions->unlinkedCount - $actions->toClass > 0 ? \sprintf(', %d without a controller', $actions->unlinkedCount - $actions->toClass) : '',
+                $withoutController > 0 ? \sprintf(', %d without a controller', $withoutController) : '',
             );
             if ($actions->unlinked !== []) {
                 $lines[] = \sprintf('  Not handled by a method: %s%s.', implode('; ', $actions->unlinked), $actions->unlinkedCount > \count($actions->unlinked) ? '; ...' : '');
             }
             if ($actions->forwards > 0) {
-                $lines[] = \sprintf(
-                    '- %d targets and forwards: %d lead to an action or a file of the project (%d files)%s.',
-                    $actions->forwards,
-                    $actions->forwardsLinked,
-                    $actions->templates,
-                    $actions->unresolvedTargetCount > 0 ? \sprintf(
+                $unresolved = '';
+                if ($actions->unresolvedTargetCount > 0) {
+                    $unresolved = \sprintf(
                         '; %d lead nowhere found, to %d distinct targets (a template of another name or in several places, a page outside the project): %s%s',
                         $actions->forwards - $actions->forwardsLinked,
                         $actions->unresolvedTargetCount,
                         implode(', ', $actions->unresolvedTargets),
                         $actions->unresolvedTargetCount > \count($actions->unresolvedTargets) ? ', ...' : '',
-                    ) : '',
+                    );
+                }
+                $lines[] = \sprintf(
+                    '- %d targets and forwards: %d lead to an action or a file of the project (%d files)%s.',
+                    $actions->forwards,
+                    $actions->forwardsLinked,
+                    $actions->templates,
+                    $unresolved,
                 );
             }
             if ($actions->citingFiles > 0) {
@@ -670,6 +697,16 @@ public function overview(): string
 
         $injections = $summary?->injections;
         if ($injections !== null && $injections->injections > 0) {
+            $unlinked = '';
+            if ($injections->unlinkedCount > 0) {
+                $unlinked = \sprintf(
+                    ', %d name services the project\'s configuration does not define: framework or bundle services, or ids '
+                    . 'computed at runtime. Those that look like the project\'s own first: %s%s',
+                    $injections->unlinkedCount,
+                    implode('; ', $injections->unlinked),
+                    $injections->unlinkedCount > \count($injections->unlinked) ? '; ...' : '',
+                );
+            }
             $lines[] = '';
             $lines[] = '## Container injections';
             $lines[] = 'What the container configuration injects beyond constructor types: service --receives--> each service of a tag '
@@ -679,13 +716,7 @@ public function overview(): string
                 $injections->injections,
                 $injections->linked,
                 $injections->edges,
-                $injections->unlinkedCount > 0 ? \sprintf(
-                    ', %d name services the project\'s configuration does not define: framework or bundle services, or ids '
-                    . 'computed at runtime. Those that look like the project\'s own first: %s%s',
-                    $injections->unlinkedCount,
-                    implode('; ', $injections->unlinked),
-                    $injections->unlinkedCount > \count($injections->unlinked) ? '; ...' : '',
-                ) : '',
+                $unlinked,
             );
         }
 
@@ -949,9 +980,7 @@ private function impactFull(string $name, int $depth = 3, int $limit = 40, ?stri
                         $this->query->label($class->class),
                         $class->confidence->value,
                         $class->through === null ? '' : ' (calls it through ' . $this->query->label($class->through) . ')',
-                        $class->followed ? '' : ($class->edge->relation === \PhpGraph\Graph\Relation::Receives
-                            ? ' (receives it among others: its users are not followed)'
-                            : ' (inherited code shared with other subclasses: its callers are not followed)'),
+                        self::notFollowed($class),
                         $this->classLocation($class->class),
                     );
                     array_push($lines, ...$sites($class));
@@ -1167,9 +1196,8 @@ private function groupedEdges(array $edges): array
     {
         $groups = [];
         foreach ($edges as $edge) {
-            $lines = $edge->lines();
             $groups[$edge->source . "\0" . $edge->relation->value . "\0" . $edge->confidence->value][] = $this->query->label($edge->target)
-                . ($lines === [] ? '' : ' at L' . implode(', L', \array_slice($lines, 0, 8)) . (\count($lines) > 8 ? ', ...' : ''));
+                . self::atLines(' ', $edge->lines());
         }
 
         $text = [];
@@ -1183,15 +1211,13 @@ private function groupedEdges(array $edges): array
 
     private function formatEdge(Edge $edge): string
     {
-        $lines = $edge->lines();
-
         return \sprintf(
             '%s --%s--> %s [%s]%s',
             $this->query->label($edge->source),
             $edge->relation->value,
             $this->query->label($edge->target),
             $edge->confidence->value,
-            $lines === [] ? '' : ' at L' . implode(', L', \array_slice($lines, 0, 8)) . (\count($lines) > 8 ? ', ...' : ''),
+            self::atLines(' ', $edge->lines()),
         );
     }
 
diff --git a/src/Project/ProjectSummary.php b/src/Project/ProjectSummary.php
index e8d932e..0737122 100644
--- a/src/Project/ProjectSummary.php
+++ b/src/Project/ProjectSummary.php
@@ -125,7 +125,39 @@ public static function fromArray(array $data): ?self
     }
 
     /**
-     * @return array<string, mixed>
+     * @return array{
+     *     generatedAt: string, filesParsed: int, filesFailed: int, duplicateCount: int, duplicates: list<string>,
+     *     vendorDirectories: int, vendorFilesRead: int,
+     *     options: array{excludes: list<string>, readVendor: bool, depth: int},
+     *     applicationCalls: array{total: int, inferred: int, ambiguous: int, outsideProject: int, unknownReceiver: int, chainOutsideProject: int},
+     *     testCalls: array{total: int, inferred: int, ambiguous: int, outsideProject: int, unknownReceiver: int, chainOutsideProject: int},
+     *     mostUnresolvedMethods: array<string, int>,
+     *     stack: list<array{directory: string, php: ?string, locked: bool, packages: array<string, array{version: string, role: string}>}>,
+     *     bus: array{
+     *         handlers: array<string, int>, sends: array<string, int>, untypedSends: int,
+     *         messagesWithoutHandlerCount: int, messagesWithoutHandler: list<string>,
+     *         messagesNeverSentCount: int, messagesNeverSent: list<string>, contracts: int,
+     *     },
+     *     services: list<string>,
+     *     http: array{
+     *         routes: int, routesWithHandler: int, requests: int, requestsToProject: int, requestsToServices: int,
+     *         routesToDependencies: int, methodMismatchCount: int, methodMismatches: list<string>,
+     *         routesToMissingControllers: int, missingControllers: list<string>,
+     *     },
+     *     phpFilesNotRead: int,
+     *     injections: array{injections: int, linked: int, edges: int, unlinkedCount: int, unlinked: list<string>},
+     *     otherLanguages: array<string, int>,
+     *     apiSchemas: array{
+     *         documents: int, operations: int, implemented: int, notImplemented: list<string>, routesCovered: int,
+     *         undocumentedCount: int, undocumented: list<string>, rpcs: int, rpcsImplemented: int,
+     *         rpcsNotImplemented: list<string>, otherApis: int, requests: int,
+     *     },
+     *     actions: array{
+     *         actions: int, linked: int, toClass: int, unlinkedCount: int, unlinked: list<string>, forwards: int,
+     *         forwardsLinked: int, templates: int, unresolvedTargetCount: int, unresolvedTargets: list<string>,
+     *         citations: int, citingFiles: int, unreadable: list<string>,
+     *     },
+     * }
      */
     public function toArray(): array
     {
diff --git a/src/Project/Rules/Pattern.php b/src/Project/Rules/Pattern.php
index f5a6474..6c07ad8 100644
--- a/src/Project/Rules/Pattern.php
+++ b/src/Project/Rules/Pattern.php
@@ -23,7 +23,9 @@ public static function matches(string $pattern, string $name): bool
             $pattern .= '**';
         }
 
-        return preg_match(self::$compiled[$pattern] ??= self::compile($pattern), $name) === 1;
+        $regex = self::$compiled[$pattern] ??= self::compile($pattern);
+
+        return preg_match($regex, $name) === 1;
     }
 
     /**
diff --git a/src/Query/FeatureOutline.php b/src/Query/FeatureOutline.php
index 9a57f23..676d512 100644
--- a/src/Query/FeatureOutline.php
+++ b/src/Query/FeatureOutline.php
@@ -89,8 +89,14 @@ public function build(string $topic): ?Outline
         }
         // Most seeds classes about the question: a method elsewhere named after it uses the feature, it is not it
         // (PageContent::base64ImageUriToUploadedImageUrl() beside ImageService). Few: the feature lives in methods.
-        $about = array_filter(array_keys($seeds), fn (int|string $class): bool => isset($routed[$class])
-            || (($node = $this->graph->node((string) $class)) !== null && $this->relevance->score($node, $subgraph->terms) > 0));
+        $about = array_filter(array_keys($seeds), function (int|string $class) use ($routed, $subgraph): bool {
+            if (isset($routed[$class])) {
+                return true;
+            }
+            $node = $this->graph->node((string) $class);
+
+            return $node !== null && $this->relevance->score($node, $subgraph->terms) > 0;
+        });
         // A route named after the question is the application's own word for it: then too.
         if (2 * \count($about) > \count($seeds) || $routed !== []) {
             $seeds = array_fill_keys($about, true);
diff --git a/src/Query/GraphQuery.php b/src/Query/GraphQuery.php
index e2e0524..bcc96b2 100644
--- a/src/Query/GraphQuery.php
+++ b/src/Query/GraphQuery.php
@@ -321,9 +321,11 @@ private function groups(array $namespaces, int $depth, int $levels): array
             // A namespace whose classes all sit in one sub-namespace reads as one: PrestaShop\PrestaShop.
             $name = (string) $name;
             $end = $depth + 1;
-            while (($next = $this->sharedSegment($members, $end)) !== null) {
+            $next = $this->sharedSegment($members, $end);
+            while ($next !== null) {
                 $name .= '\\' . $next;
                 ++$end;
+                $next = $this->sharedSegment($members, $end);
             }
 
             $layers = [];
diff --git a/src/Vendor/ComposerClassLocator.php b/src/Vendor/ComposerClassLocator.php
index 5949435..4fcb2c5 100644
--- a/src/Vendor/ComposerClassLocator.php
+++ b/src/Vendor/ComposerClassLocator.php
@@ -112,9 +112,8 @@ private function readInstalled(string $vendor): void
             if (!\is_array($package) || !\is_array($package['autoload'] ?? null)) {
                 continue;
             }
-            $installPath = \is_string($package['install-path'] ?? null)
-                ? $vendor . '/composer/' . $package['install-path']
-                : $vendor . '/' . (\is_string($package['name'] ?? null) ? $package['name'] : '');
+            $name = \is_string($package['name'] ?? null) ? $package['name'] : '';
+            $installPath = \is_string($package['install-path'] ?? null) ? $vendor . '/composer/' . $package['install-path'] : $vendor . '/' . $name;
 
             // Files loaded on every request: the helper functions of the packages (Laravel's `response()`, `now()`).
             foreach (\is_array($package['autoload']['files'] ?? null) ? $package['autoload']['files'] : [] as $file) {
diff --git a/src/Vendor/VendorSignatures.php b/src/Vendor/VendorSignatures.php
index 9eac533..eb9a0ca 100644
--- a/src/Vendor/VendorSignatures.php
+++ b/src/Vendor/VendorSignatures.php
@@ -4,6 +4,7 @@
 
 namespace PhpGraph\Vendor;
 
+use PhpGraph\Extractor\ConditionalReturn;
 use PhpGraph\Extractor\FileExtractor;
 use PhpGraph\Extractor\PhpFileExtractor;
 use PhpGraph\Graph\NodeKind;
@@ -47,18 +48,18 @@ public function signature(string $class): ?ClassSignature
     /** @var array<string, string>|null lowercase function name => the autoloaded file declaring it */
     private ?array $functionFiles = null;
 
-    /** @var array<string, array{?string, ?string, ?string, array<string, array{string, int}>}> lowercase function name => return type, GenericType, conditional, template binders */
+    /** @var array<string, array{?string, ?string, ?ConditionalReturn, array<string, array{string, int}>}> lowercase function name => return type, GenericType, conditional, template binders */
     private array $functions = [];
 
     /** @var array<string, list<array{string, int, string}>> lowercase function name => what a call tells of its arguments */
     private array $functionAssertions = [];
 
     /**
-     * What a function of the packages returns: its class, its GenericType, its conditional return type (JSON), how a
+     * What a function of the packages returns: its class, its GenericType, its conditional return type, how a
      * call binds its templates. The autoloaded files are scanned for the names they declare; the file declaring it is
      * then read, never run.
      *
-     * @return array{?string, ?string, ?string, array<string, array{string, int}>}|null
+     * @return array{?string, ?string, ?ConditionalReturn, array<string, array{string, int}>}|null
      */
     public function function(string $name): ?array
     {
diff --git a/tests/CacheTest.php b/tests/CacheTest.php
index a97ac6e..2c14eb8 100644
--- a/tests/CacheTest.php
+++ b/tests/CacheTest.php
@@ -88,6 +88,32 @@ public function testAServerKeepsTheExtractionsInMemoryBetweenRebuilds(): void
         self::assertTrue($project->lastBuild()->graph()->hasNode('App\Cart::sum'), 'Unchanged files come from memory, not from the deleted cache file');
     }
 
+    public function testConditionalReturnsAndConfigurationHelpersAreReadBackFromTheCache(): void
+    {
+        $code = '<?php namespace App;'
+            . ' use Symfony\Component\DependencyInjection\Loader\Configurator\ServicesConfigurator;'
+            . ' use function Symfony\Component\DependencyInjection\Loader\Configurator\tagged_locator;'
+            . ' /** @template T @param class-string<T>|null $abstract @return ($abstract is class-string<T> ? T : Container) */'
+            . ' function app(?string $abstract = null) {}'
+            . ' final class Wiring { public const SUFFIX = "pipeline";'
+            . ' public static function wire(ServicesConfigurator $services, string $prefix): void {'
+            . ' $services->load(str_replace(["/"], ["\\\\"], $prefix) . "\\\\Rules\\\\", __DIR__)->tag("{$prefix}.rule");'
+            . ' $services->set(sprintf("%s.%s", $prefix, self::SUFFIX), Pipeline::class)->args([tagged_locator($prefix . ".rule")]);'
+            . ' self::wire($services, "other"); } }';
+        $fresh = (new PhpFileExtractor())->extract($code, 'src/Wiring.php');
+        self::assertNotSame([], $fresh->conditionalReturns, 'the source declares a conditional return');
+        self::assertNotSame([], $fresh->configurationHelpers, 'the source declares a configuration helper');
+
+        $writer = new CachingExtractor(new PhpFileExtractor(), $this->root . '/cache.bin');
+        $writer->extract($code, 'src/Wiring.php');
+        $writer->save();
+        $reader = new CachingExtractor(new PhpFileExtractor(), $this->root . '/cache.bin');
+        $cached = $reader->extract($code, 'src/Wiring.php');
+
+        self::assertSame(['parsed' => 0, 'reused' => 1], $reader->stats(), 'read from the cache, not parsed again');
+        self::assertEquals($fresh, $cached, 'every value class of the extraction is allowed back by unserialize()');
+    }
+
     /**
      * @return array{Graph, array{parsed: int, reused: int}}
      */
diff --git a/tests/ConfigurationHelpersTest.php b/tests/ConfigurationHelpersTest.php
index 4649a82..e1beea7 100644
--- a/tests/ConfigurationHelpersTest.php
+++ b/tests/ConfigurationHelpersTest.php
@@ -66,4 +66,18 @@ public function testArgumentsThatCannotBeEvaluatedDeclareNothing(): void
 
         self::assertFalse($this->hasEdge($result->graph, 'App\Shared\Validator', 'App\Sales\Rules\StockRule', Relation::Receives), 'the prefix is unknown');
     }
+
+    public function testALiteralArgumentSpelledLikeAParameterIsStillALiteral(): void
+    {
+        $result = $this->buildProject([
+            'src/Shared/Wiring.php' => self::WIRING,
+            'src/Shared/Validator.php' => 'namespace App\Shared; class Validator { public function __construct(iterable $rules) {} }',
+            'src/Shared/Pipeline.php' => 'namespace App\Shared; class Pipeline {}',
+            'src/Sales/Rules/StockRule.php' => 'namespace App\Sales\Rules; class StockRule {}',
+            'config/services.php' => 'use App\Shared\Wiring; return static function ($container): void { $services = $container->services();'
+                . ' Wiring::wire($services, "param", __DIR__ . "/../src/Sales", "App\\\\Sales"); };',
+        ]);
+
+        self::assertTrue($this->hasEdge($result->graph, 'App\Shared\Validator', 'App\Sales\Rules\StockRule', Relation::Receives), 'the prefix "param" is a value, not a parameter of a caller');
+    }
 }