diff --git a/src/AnnotationReader.php b/src/AnnotationReader.php
index c075d6b63..43521ffd7 100644
--- a/src/AnnotationReader.php
+++ b/src/AnnotationReader.php
@@ -24,12 +24,15 @@
 use TheCodingMachine\GraphQLite\Annotations\SourceFieldInterface;
 use TheCodingMachine\GraphQLite\Annotations\Type;
 use TheCodingMachine\GraphQLite\Annotations\TypeInterface;
+use TheCodingMachine\GraphQLite\Directives\InputObjectTypeDirective;
+use TheCodingMachine\GraphQLite\Directives\ObjectTypeDirective;
 
 use function array_diff_key;
 use function array_filter;
 use function array_key_exists;
 use function array_map;
 use function array_merge;
+use function array_values;
 use function assert;
 use function count;
 use function get_class;
@@ -326,6 +329,34 @@ static function (array $parameterAnnotations): ParameterAnnotations {
         );
     }
 
+    /**
+     * The {@see ObjectTypeDirective}s on a class.
+     *
+     * @param ReflectionClass<T> $refClass
+     *
+     * @return list<ObjectTypeDirective>
+     *
+     * @template T of object
+     */
+    public function getObjectTypeDirectives(ReflectionClass $refClass): array
+    {
+        return array_values($this->getClassAnnotations($refClass, ObjectTypeDirective::class, false));
+    }
+
+    /**
+     * The {@see InputObjectTypeDirective}s on a class.
+     *
+     * @param ReflectionClass<T> $refClass
+     *
+     * @return list<InputObjectTypeDirective>
+     *
+     * @template T of object
+     */
+    public function getInputObjectTypeDirectives(ReflectionClass $refClass): array
+    {
+        return array_values($this->getClassAnnotations($refClass, InputObjectTypeDirective::class, false));
+    }
+
     public function getMiddlewareAnnotations(ReflectionMethod|ReflectionProperty $reflection): MiddlewareAnnotations
     {
         if ($reflection instanceof ReflectionMethod) {
diff --git a/src/Directives/BehavioralFieldDirective.php b/src/Directives/BehavioralFieldDirective.php
new file mode 100644
index 000000000..154b1c547
--- /dev/null
+++ b/src/Directives/BehavioralFieldDirective.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Type\Definition\FieldDefinition;
+use TheCodingMachine\GraphQLite\Middlewares\FieldHandlerInterface;
+use TheCodingMachine\GraphQLite\QueryFieldDescriptor;
+
+/**
+ * A {@see FieldDirective} that also runs behavior. The {@see applyToField} hooks run in declaration
+ * order, chained ahead of the rest of the field pipe.
+ */
+interface BehavioralFieldDirective extends FieldDirective
+{
+    public function applyToField(QueryFieldDescriptor $descriptor, FieldHandlerInterface $next): FieldDefinition|null;
+}
diff --git a/src/Directives/BehavioralInputFieldDirective.php b/src/Directives/BehavioralInputFieldDirective.php
new file mode 100644
index 000000000..4ed2cb8ee
--- /dev/null
+++ b/src/Directives/BehavioralInputFieldDirective.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use TheCodingMachine\GraphQLite\InputField;
+use TheCodingMachine\GraphQLite\InputFieldDescriptor;
+use TheCodingMachine\GraphQLite\Middlewares\InputFieldHandlerInterface;
+
+/**
+ * An {@see InputFieldDirective} that also runs behavior, dispatched through the input-field pipe.
+ */
+interface BehavioralInputFieldDirective extends InputFieldDirective
+{
+    public function applyToInputField(InputFieldDescriptor $descriptor, InputFieldHandlerInterface $next): InputField|null;
+}
diff --git a/src/Directives/BehavioralInputObjectTypeDirective.php b/src/Directives/BehavioralInputObjectTypeDirective.php
new file mode 100644
index 000000000..bc9e20c24
--- /dev/null
+++ b/src/Directives/BehavioralInputObjectTypeDirective.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use TheCodingMachine\GraphQLite\InputObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Middlewares\InputObjectTypeHandlerInterface;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+
+/**
+ * An {@see InputObjectTypeDirective} that also runs behavior, e.g. `@oneOf` flipping a flag on the
+ * built input type.
+ */
+interface BehavioralInputObjectTypeDirective extends InputObjectTypeDirective
+{
+    public function applyToInputObjectType(InputObjectTypeDescriptor $descriptor, InputObjectTypeHandlerInterface $next): MutableInputObjectType;
+}
diff --git a/src/Directives/BehavioralObjectTypeDirective.php b/src/Directives/BehavioralObjectTypeDirective.php
new file mode 100644
index 000000000..4df2d4a99
--- /dev/null
+++ b/src/Directives/BehavioralObjectTypeDirective.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use TheCodingMachine\GraphQLite\Middlewares\ObjectTypeHandlerInterface;
+use TheCodingMachine\GraphQLite\ObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableObjectType;
+
+/**
+ * An {@see ObjectTypeDirective} that also runs behavior, usually tweaking the built
+ * {@see MutableObjectType}. Dispatched through the object-type pipe in
+ * {@see \TheCodingMachine\GraphQLite\TypeGenerator}.
+ */
+interface BehavioralObjectTypeDirective extends ObjectTypeDirective
+{
+    public function applyToObjectType(ObjectTypeDescriptor $descriptor, ObjectTypeHandlerInterface $next): MutableObjectType;
+}
diff --git a/src/Directives/BuiltIn/OneOf.php b/src/Directives/BuiltIn/OneOf.php
new file mode 100644
index 000000000..0407bb31c
--- /dev/null
+++ b/src/Directives/BuiltIn/OneOf.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives\BuiltIn;
+
+use Attribute;
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+use TheCodingMachine\GraphQLite\Directives\BehavioralInputObjectTypeDirective;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\InputObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Middlewares\InputObjectTypeHandlerInterface;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+
+/**
+ * Binds `#[OneOf]` to webonyx's built-in `@oneOf` directive. Putting it on an `#[Input]` class sets
+ * the input object's `isOneOf` flag, which makes validation require one field and gets webonyx to
+ * print `@oneOf` in the SDL.
+ *
+ * webonyx already defines `@oneOf`, so we don't register our own definition for it
+ * ({@see DirectiveDefinition::$builtIn} is `true`).
+ */
+#[Attribute(Attribute::TARGET_CLASS)]
+final class OneOf implements BehavioralInputObjectTypeDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: WebonyxDirective::ONE_OF_NAME,
+            locations: [DirectiveLocation::INPUT_OBJECT],
+            builtIn: true,
+        );
+    }
+
+    public function applyToInputObjectType(InputObjectTypeDescriptor $descriptor, InputObjectTypeHandlerInterface $next): MutableInputObjectType
+    {
+        $type = $next->handle($descriptor);
+        $type->isOneOf = true;
+        return $type;
+    }
+}
diff --git a/src/Directives/DirectiveAstBuilder.php b/src/Directives/DirectiveAstBuilder.php
new file mode 100644
index 000000000..84d828ffb
--- /dev/null
+++ b/src/Directives/DirectiveAstBuilder.php
@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Language\AST\ArgumentNode;
+use GraphQL\Language\AST\DirectiveNode;
+use GraphQL\Language\AST\FieldDefinitionNode;
+use GraphQL\Language\AST\InputObjectTypeDefinitionNode;
+use GraphQL\Language\AST\InputValueDefinitionNode;
+use GraphQL\Language\AST\NamedTypeNode;
+use GraphQL\Language\AST\NameNode;
+use GraphQL\Language\AST\NodeList;
+use GraphQL\Language\AST\ObjectTypeDefinitionNode;
+use GraphQL\Utils\AST;
+use ReflectionClass;
+
+/**
+ * Builds the AST nodes that let directive applications show up in printed SDL.
+ *
+ * webonyx reads applications from `astNode->directives` on the definition node (FieldDefinitionNode,
+ * InputValueDefinitionNode, etc.). GraphQLite doesn't otherwise set `astNode`, so this builds just
+ * enough of the node to carry the directives, with arguments encoded via {@see AST::astFromValue}.
+ *
+ * @internal
+ */
+final class DirectiveAstBuilder
+{
+    public function __construct(private readonly DirectiveRegistry $registry)
+    {
+    }
+
+    /**
+     * @param list<DirectiveInterface> $directives Directive instances applied to this element.
+     *
+     * @return list<DirectiveNode>
+     */
+    public function buildDirectiveNodes(array $directives): array
+    {
+        $nodes = [];
+        foreach ($directives as $directive) {
+            $definition = $this->registry->definitionFor($directive::class);
+            if ($definition === null) {
+                continue;
+            }
+            $nodes[] = $this->buildDirectiveNode($directive, $definition);
+        }
+        return $nodes;
+    }
+
+    private function buildDirectiveNode(DirectiveInterface $directive, DirectiveDefinition $definition): DirectiveNode
+    {
+        $arguments = $this->registry->argumentsFor($directive::class);
+        $reflection = new ReflectionClass($directive);
+
+        $argumentNodes = [];
+        foreach ($arguments as $argument) {
+            if (! $reflection->hasProperty($argument->name)) {
+                continue;
+            }
+            $property = $reflection->getProperty($argument->name);
+            $value = $property->getValue($directive);
+
+            $argumentNodes[] = new ArgumentNode([
+                'name' => new NameNode(['value' => $argument->name]),
+                'value' => AST::astFromValue($value, $argument->type),
+            ]);
+        }
+
+        return new DirectiveNode([
+            'name' => new NameNode(['value' => $definition->name]),
+            'arguments' => new NodeList($argumentNodes),
+        ]);
+    }
+
+    /** @param list<DirectiveNode> $directiveNodes */
+    public static function buildFieldDefinitionNode(string $name, array $directiveNodes): FieldDefinitionNode
+    {
+        return new FieldDefinitionNode([
+            'name' => new NameNode(['value' => $name]),
+            'type' => new NamedTypeNode(['name' => new NameNode(['value' => 'Unknown'])]),
+            'arguments' => new NodeList([]),
+            'directives' => new NodeList($directiveNodes),
+        ]);
+    }
+
+    /** @param list<DirectiveNode> $directiveNodes */
+    public static function buildInputValueDefinitionNode(string $name, array $directiveNodes): InputValueDefinitionNode
+    {
+        return new InputValueDefinitionNode([
+            'name' => new NameNode(['value' => $name]),
+            'type' => new NamedTypeNode(['name' => new NameNode(['value' => 'Unknown'])]),
+            'directives' => new NodeList($directiveNodes),
+        ]);
+    }
+
+    /** @param list<DirectiveNode> $directiveNodes */
+    public static function buildObjectTypeDefinitionNode(string $name, array $directiveNodes): ObjectTypeDefinitionNode
+    {
+        return new ObjectTypeDefinitionNode([
+            'name' => new NameNode(['value' => $name]),
+            'interfaces' => new NodeList([]),
+            'directives' => new NodeList($directiveNodes),
+            'fields' => new NodeList([]),
+        ]);
+    }
+
+    /** @param list<DirectiveNode> $directiveNodes */
+    public static function buildInputObjectTypeDefinitionNode(string $name, array $directiveNodes): InputObjectTypeDefinitionNode
+    {
+        return new InputObjectTypeDefinitionNode([
+            'name' => new NameNode(['value' => $name]),
+            'directives' => new NodeList($directiveNodes),
+            'fields' => new NodeList([]),
+        ]);
+    }
+}
diff --git a/src/Directives/DirectiveDefinition.php b/src/Directives/DirectiveDefinition.php
new file mode 100644
index 000000000..51ee64e17
--- /dev/null
+++ b/src/Directives/DirectiveDefinition.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+/**
+ * Metadata for a directive: name, valid locations, and an optional description. Returned by
+ * {@see DirectiveInterface::definition()}. Repeatability isn't here; it's read from the directive
+ * class's `#[Attribute]` flags (see {@see DirectiveValidator::isRepeatable()}).
+ *
+ * Argument types aren't listed here; they're read from the directive class's constructor when it's
+ * registered.
+ *
+ * Set {@see $builtIn} to true when the attribute binds behavior to a directive webonyx already
+ * defines (`@oneOf`, `@deprecated`, ...). Those still run their apply hook, but we don't register a
+ * second definition for them since webonyx already declares them on the schema.
+ */
+final class DirectiveDefinition
+{
+    /** @param list<DirectiveLocation> $locations */
+    public function __construct(
+        public readonly string $name,
+        public readonly array $locations,
+        public readonly string|null $description = null,
+        public readonly bool $builtIn = false,
+    ) {
+    }
+}
diff --git a/src/Directives/DirectiveInterface.php b/src/Directives/DirectiveInterface.php
new file mode 100644
index 000000000..39a2e87a6
--- /dev/null
+++ b/src/Directives/DirectiveInterface.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+/**
+ * Base marker for any GraphQLite custom directive. The one requirement is the static
+ * {@see definition} method returning the directive's metadata.
+ */
+interface DirectiveInterface
+{
+    public static function definition(): DirectiveDefinition;
+}
diff --git a/src/Directives/DirectiveLocation.php b/src/Directives/DirectiveLocation.php
new file mode 100644
index 000000000..abb251f38
--- /dev/null
+++ b/src/Directives/DirectiveLocation.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+/**
+ * GraphQL directive locations from the spec, both type-system and executable.
+ *
+ * Only FIELD_DEFINITION, INPUT_FIELD_DEFINITION, OBJECT and INPUT_OBJECT have apply hooks so far;
+ * the rest are listed but not yet wired. Backing values match the spec strings, so they line up
+ * with webonyx's location strings without conversion.
+ */
+enum DirectiveLocation: string
+{
+    // Executable locations
+    case QUERY = 'QUERY';
+    case MUTATION = 'MUTATION';
+    case SUBSCRIPTION = 'SUBSCRIPTION';
+    case FIELD = 'FIELD';
+    case FRAGMENT_DEFINITION = 'FRAGMENT_DEFINITION';
+    case FRAGMENT_SPREAD = 'FRAGMENT_SPREAD';
+    case INLINE_FRAGMENT = 'INLINE_FRAGMENT';
+    case VARIABLE_DEFINITION = 'VARIABLE_DEFINITION';
+
+    // Type-system locations
+    case SCHEMA = 'SCHEMA';
+    case SCALAR = 'SCALAR';
+    case OBJECT = 'OBJECT';
+    case FIELD_DEFINITION = 'FIELD_DEFINITION';
+    case ARGUMENT_DEFINITION = 'ARGUMENT_DEFINITION';
+    case INTERFACE = 'INTERFACE';
+    case UNION = 'UNION';
+    case ENUM = 'ENUM';
+    case ENUM_VALUE = 'ENUM_VALUE';
+    case INPUT_OBJECT = 'INPUT_OBJECT';
+    case INPUT_FIELD_DEFINITION = 'INPUT_FIELD_DEFINITION';
+
+    public function isExecutable(): bool
+    {
+        return match ($this) {
+            self::QUERY, self::MUTATION, self::SUBSCRIPTION, self::FIELD,
+            self::FRAGMENT_DEFINITION, self::FRAGMENT_SPREAD, self::INLINE_FRAGMENT,
+            self::VARIABLE_DEFINITION => true,
+            default => false,
+        };
+    }
+
+    public function isTypeSystem(): bool
+    {
+        return ! $this->isExecutable();
+    }
+}
diff --git a/src/Directives/DirectiveReflection.php b/src/Directives/DirectiveReflection.php
new file mode 100644
index 000000000..894d2fd2a
--- /dev/null
+++ b/src/Directives/DirectiveReflection.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use Attribute;
+use ReflectionClass;
+
+/**
+ * Reads the flags from a directive class's `#[Attribute(...)]` declaration (the `TARGET_*` bits and
+ * `IS_REPEATABLE`). Shared by {@see DirectiveValidator} and {@see DirectiveResolver} so neither has
+ * to know how the flags are stored.
+ *
+ * @internal
+ */
+final class DirectiveReflection
+{
+    /** @param ReflectionClass<TypeSystemDirective> $reflection */
+    public static function attributeFlags(ReflectionClass $reflection): int
+    {
+        $attributes = $reflection->getAttributes(Attribute::class);
+        if ($attributes === []) {
+            return Attribute::TARGET_ALL;
+        }
+
+        $args = $attributes[0]->getArguments();
+
+        return $args[0] ?? $args['flags'] ?? Attribute::TARGET_ALL;
+    }
+}
diff --git a/src/Directives/DirectiveRegistry.php b/src/Directives/DirectiveRegistry.php
new file mode 100644
index 000000000..1b6420440
--- /dev/null
+++ b/src/Directives/DirectiveRegistry.php
@@ -0,0 +1,157 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\OneOf;
+use TheCodingMachine\GraphQLite\Directives\Discovery\DirectiveClassFinder;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+
+use function array_key_exists;
+use function assert;
+use function in_array;
+use function method_exists;
+
+/**
+ * Holds the custom directives for a schema, built once in
+ * {@see \TheCodingMachine\GraphQLite\SchemaFactory::createSchema()}. For each discovered class it
+ * runs {@see DirectiveValidator}, caches what {@see DirectiveResolver} produces, and enforces name
+ * uniqueness across the set.
+ *
+ * The dispatcher middlewares query it at apply time for a directive's argument shape, which the AST
+ * builder needs to encode each arg as a GraphQL value.
+ */
+final class DirectiveRegistry
+{
+    /** @var array<class-string<DirectiveInterface>, ResolvedDirective> */
+    private array $resolvedByClass = [];
+
+    /** @var array<string, class-string<DirectiveInterface>> */
+    private array $classByName = [];
+
+    /**
+     * Names of webonyx-built-in directives. Custom (non-built-in) directives cannot reuse them.
+     */
+    private const RESERVED_NAMES = ['skip', 'include', 'deprecated', 'oneOf'];
+
+    /**
+     * Attribute classes that bind PHP behavior to webonyx's pre-existing built-in directives.
+     * Registered after user discovery so a user-provided override (a class with the same name and
+     * `builtIn: true`) wins.
+     */
+    private const BUILT_IN_ATTRIBUTES = [
+        OneOf::class,
+    ];
+
+    public function __construct(
+        private readonly DirectiveClassFinder $classFinder,
+    ) {
+    }
+
+    /** Run discovery + validation once. Idempotent. */
+    public function discover(): void
+    {
+        // User classes first: an override of a built-in (same name, builtIn: true) needs to land
+        // before our bundled copy registers.
+        foreach ($this->classFinder->findDirectives() as $directiveClass) {
+            $this->register($directiveClass);
+        }
+        foreach (self::BUILT_IN_ATTRIBUTES as $directiveClass) {
+            $this->register($directiveClass);
+        }
+    }
+
+    /**
+     * @param class-string<TypeSystemDirective> $directiveClass
+     *
+     * @throws InvalidDirectiveException
+     */
+    private function register(string $directiveClass): void
+    {
+        // Registering the same class twice is a no-op; discovery and the built-in list share this
+        // registry, so duplicates are expected.
+        if (isset($this->resolvedByClass[$directiveClass])) {
+            return;
+        }
+
+        if (! method_exists($directiveClass, 'definition')) {
+            throw InvalidDirectiveException::noDefinitionMethod($directiveClass);
+        }
+
+        $definition = $directiveClass::definition();
+        assert($definition instanceof DirectiveDefinition);
+
+        DirectiveValidator::validate($directiveClass, $definition);
+
+        if (! $definition->builtIn && in_array($definition->name, self::RESERVED_NAMES, true)) {
+            throw InvalidDirectiveException::reservedName($definition->name, $directiveClass);
+        }
+
+        if (array_key_exists($definition->name, $this->classByName)) {
+            // A name clash is fine when this side is also built-in: the user supplied their own
+            // implementation and we defer to it. Two custom directives sharing a name is an error.
+            if ($definition->builtIn) {
+                return;
+            }
+            throw InvalidDirectiveException::duplicateName(
+                $definition->name,
+                $this->classByName[$definition->name],
+                $directiveClass,
+            );
+        }
+
+        $this->resolvedByClass[$directiveClass] = DirectiveResolver::resolve($directiveClass, $definition);
+        $this->classByName[$definition->name] = $directiveClass;
+    }
+
+    public function hasAny(): bool
+    {
+        foreach ($this->resolvedByClass as $resolved) {
+            if ($resolved->webonyxDirective !== null) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /** @return list<WebonyxDirective> */
+    public function webonyxDirectives(): array
+    {
+        $directives = [];
+        foreach ($this->resolvedByClass as $resolved) {
+            if ($resolved->webonyxDirective === null) {
+                continue;
+            }
+            $directives[] = $resolved->webonyxDirective;
+        }
+
+        return $directives;
+    }
+
+    /**
+     * The argument shape for a directive class.
+     *
+     * @param class-string<DirectiveInterface> $directiveClass
+     *
+     * @return list<ResolvedDirectiveArgument>
+     */
+    public function argumentsFor(string $directiveClass): array
+    {
+        $resolved = $this->resolvedByClass[$directiveClass] ?? null;
+
+        return $resolved === null ? [] : $resolved->arguments;
+    }
+
+    /**
+     * The metadata for a directive class, or null if it isn't registered.
+     *
+     * @param class-string<DirectiveInterface> $directiveClass
+     */
+    public function definitionFor(string $directiveClass): DirectiveDefinition|null
+    {
+        return ($this->resolvedByClass[$directiveClass] ?? null)?->definition;
+    }
+}
diff --git a/src/Directives/DirectiveResolver.php b/src/Directives/DirectiveResolver.php
new file mode 100644
index 000000000..1e42c9f85
--- /dev/null
+++ b/src/Directives/DirectiveResolver.php
@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use Attribute;
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+use GraphQL\Type\Definition\NonNull;
+use GraphQL\Type\Definition\Type;
+use ReflectionClass;
+use ReflectionNamedType;
+use ReflectionParameter;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+
+use function array_map;
+
+/**
+ * Turns a validated directive class into the pieces the registry caches: its constructor arguments,
+ * and (for non-built-in directives) the webonyx {@see WebonyxDirective} to register on the schema.
+ *
+ * Repeatability comes straight from the class's `#[Attribute]` flags, not {@see DirectiveDefinition}.
+ *
+ * @internal
+ */
+final class DirectiveResolver
+{
+    /**
+     * @param class-string<TypeSystemDirective> $directiveClass
+     *
+     * @throws InvalidDirectiveException when a constructor argument can't map to a GraphQL input type.
+     */
+    public static function resolve(string $directiveClass, DirectiveDefinition $definition): ResolvedDirective
+    {
+        $reflection = new ReflectionClass($directiveClass);
+        $arguments = self::resolveArguments($directiveClass, $reflection);
+
+        // Built-in directives are declared by webonyx, so there's no directive to register for them.
+        $webonyxDirective = $definition->builtIn
+            ? null
+            : self::buildWebonyxDirective($definition, $arguments, self::isRepeatable($reflection));
+
+        return new ResolvedDirective($definition, $arguments, $webonyxDirective);
+    }
+
+    /**
+     * @param class-string<TypeSystemDirective> $directiveClass
+     * @param ReflectionClass<TypeSystemDirective> $reflection
+     *
+     * @return list<ResolvedDirectiveArgument>
+     */
+    private static function resolveArguments(string $directiveClass, ReflectionClass $reflection): array
+    {
+        $constructor = $reflection->getConstructor();
+        if ($constructor === null) {
+            return [];
+        }
+
+        $arguments = [];
+        foreach ($constructor->getParameters() as $parameter) {
+            $arguments[] = self::resolveArgument($directiveClass, $parameter);
+        }
+
+        return $arguments;
+    }
+
+    private static function resolveArgument(string $directiveClass, ReflectionParameter $parameter): ResolvedDirectiveArgument
+    {
+        $type = $parameter->getType();
+        if (! $type instanceof ReflectionNamedType) {
+            throw InvalidDirectiveException::unsupportedArgumentType(
+                $directiveClass,
+                $parameter->getName(),
+                'union/intersection types are not supported',
+            );
+        }
+
+        if ($type->isBuiltin() === false) {
+            throw InvalidDirectiveException::unsupportedArgumentType(
+                $directiveClass,
+                $parameter->getName(),
+                'only scalar types (string, int, float, bool) are supported in this release',
+            );
+        }
+
+        $graphQlType = match ($type->getName()) {
+            'string' => Type::string(),
+            'int' => Type::int(),
+            'float' => Type::float(),
+            'bool' => Type::boolean(),
+            default => throw InvalidDirectiveException::unsupportedArgumentType(
+                $directiveClass,
+                $parameter->getName(),
+                'PHP type "' . $type->getName() . '" cannot be mapped to a GraphQL scalar',
+            ),
+        };
+
+        $nullable = $type->allowsNull();
+        $finalType = $nullable ? $graphQlType : new NonNull($graphQlType);
+
+        $hasDefault = $parameter->isDefaultValueAvailable();
+        $default = $hasDefault ? $parameter->getDefaultValue() : null;
+
+        return new ResolvedDirectiveArgument(
+            name: $parameter->getName(),
+            type: $finalType,
+            hasDefaultValue: $hasDefault,
+            defaultValue: $default,
+        );
+    }
+
+    /** @param ReflectionClass<TypeSystemDirective> $reflection */
+    private static function isRepeatable(ReflectionClass $reflection): bool
+    {
+        return (DirectiveReflection::attributeFlags($reflection) & Attribute::IS_REPEATABLE) === Attribute::IS_REPEATABLE;
+    }
+
+    /** @param list<ResolvedDirectiveArgument> $arguments */
+    private static function buildWebonyxDirective(DirectiveDefinition $definition, array $arguments, bool $repeatable): WebonyxDirective
+    {
+        $argsConfig = [];
+        foreach ($arguments as $argument) {
+            $config = ['type' => $argument->type];
+            if ($argument->hasDefaultValue) {
+                $config['defaultValue'] = $argument->defaultValue;
+            }
+            if ($argument->description !== null) {
+                $config['description'] = $argument->description;
+            }
+            $argsConfig[$argument->name] = $config;
+        }
+
+        $config = [
+            'name' => $definition->name,
+            'locations' => array_map(static fn (DirectiveLocation $loc) => $loc->value, $definition->locations),
+            'isRepeatable' => $repeatable,
+            'args' => $argsConfig,
+        ];
+        if ($definition->description !== null) {
+            $config['description'] = $definition->description;
+        }
+
+        return new WebonyxDirective($config);
+    }
+}
diff --git a/src/Directives/DirectiveValidator.php b/src/Directives/DirectiveValidator.php
new file mode 100644
index 000000000..a0588c6b9
--- /dev/null
+++ b/src/Directives/DirectiveValidator.php
@@ -0,0 +1,100 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use Attribute;
+use ReflectionClass;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+
+use function in_array;
+
+/**
+ * Validates a discovered directive class. Checks:
+ *
+ *   1. The `#[Attribute(...)]` PHP target covers every declared GraphQL location.
+ *   2. Each family interface has a matching location declared, and vice versa.
+ *
+ * Producing the arguments, repeatability, and webonyx directive is {@see DirectiveResolver}'s job;
+ * name uniqueness is checked in {@see DirectiveRegistry}.
+ *
+ * @internal
+ */
+final class DirectiveValidator
+{
+    /**
+     * @param class-string<TypeSystemDirective> $directiveClass
+     *
+     * @throws InvalidDirectiveException
+     */
+    public static function validate(string $directiveClass, DirectiveDefinition $definition): void
+    {
+        $reflection = new ReflectionClass($directiveClass);
+
+        if ($reflection->getAttributes(Attribute::class) === []) {
+            throw InvalidDirectiveException::notAttribute($directiveClass);
+        }
+
+        self::checkPhpTargets($directiveClass, $definition, DirectiveReflection::attributeFlags($reflection));
+        self::checkInterfaceAndLocationAgreement($directiveClass, $definition, $reflection);
+    }
+
+    private static function checkPhpTargets(string $directiveClass, DirectiveDefinition $definition, int $phpFlags): void
+    {
+        foreach ($definition->locations as $location) {
+            foreach (self::requiredPhpTargetsFor($location) as $requiredTarget => $label) {
+                if (($phpFlags & $requiredTarget) === $requiredTarget) {
+                    continue;
+                }
+
+                throw InvalidDirectiveException::phpTargetMissingForLocation($directiveClass, $location, $label);
+            }
+        }
+    }
+
+    /** @param ReflectionClass<TypeSystemDirective> $reflection */
+    private static function checkInterfaceAndLocationAgreement(string $directiveClass, DirectiveDefinition $definition, ReflectionClass $reflection): void
+    {
+        $locations = $definition->locations;
+        $interfacePairs = [
+            FieldDirective::class => DirectiveLocation::FIELD_DEFINITION,
+            InputFieldDirective::class => DirectiveLocation::INPUT_FIELD_DEFINITION,
+            ObjectTypeDirective::class => DirectiveLocation::OBJECT,
+            InputObjectTypeDirective::class => DirectiveLocation::INPUT_OBJECT,
+        ];
+
+        foreach ($interfacePairs as $interface => $expectedLocation) {
+            $implements = $reflection->implementsInterface($interface);
+            $declaresLocation = in_array($expectedLocation, $locations, true);
+
+            if ($implements && ! $declaresLocation) {
+                throw InvalidDirectiveException::interfaceWithoutMatchingLocation($directiveClass, $interface, $locations);
+            }
+
+            if (! $implements && $declaresLocation) {
+                throw InvalidDirectiveException::locationWithoutMatchingInterface($directiveClass, $expectedLocation, $interface);
+            }
+        }
+    }
+
+    /** @return array<int, string> map of Attribute::TARGET_* flag → human-readable label */
+    private static function requiredPhpTargetsFor(DirectiveLocation $location): array
+    {
+        return match ($location) {
+            DirectiveLocation::FIELD_DEFINITION => [
+                Attribute::TARGET_METHOD => 'TARGET_METHOD',
+                Attribute::TARGET_PROPERTY => 'TARGET_PROPERTY',
+            ],
+            DirectiveLocation::INPUT_FIELD_DEFINITION => [
+                Attribute::TARGET_METHOD => 'TARGET_METHOD',
+                Attribute::TARGET_PROPERTY => 'TARGET_PROPERTY',
+                Attribute::TARGET_PARAMETER => 'TARGET_PARAMETER',
+            ],
+            DirectiveLocation::OBJECT => [Attribute::TARGET_CLASS => 'TARGET_CLASS'],
+            DirectiveLocation::INPUT_OBJECT => [Attribute::TARGET_CLASS => 'TARGET_CLASS'],
+            // Other locations don't have apply hooks yet, so there's nothing to enforce.
+            default => [],
+        };
+    }
+}
diff --git a/src/Directives/Discovery/DirectiveClassFinder.php b/src/Directives/Discovery/DirectiveClassFinder.php
new file mode 100644
index 000000000..d0f9d0958
--- /dev/null
+++ b/src/Directives/Discovery/DirectiveClassFinder.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives\Discovery;
+
+use ReflectionClass;
+use TheCodingMachine\GraphQLite\Directives\TypeSystemDirective;
+use TheCodingMachine\GraphQLite\Discovery\Cache\ClassFinderComputedCache;
+use TheCodingMachine\GraphQLite\Discovery\ClassFinder;
+
+use function array_reduce;
+
+/**
+ * Finds the classes in the configured namespaces that implement {@see TypeSystemDirective}.
+ *
+ * Same pattern as {@see \TheCodingMachine\GraphQLite\Mappers\ClassFinderTypeMapper}: map each class
+ * from {@see ClassFinder} to a {@see GlobDirectivesCache} entry (or null), then collect the FQCNs.
+ * {@see ClassFinderComputedCache} handles cache invalidation in dev mode.
+ *
+ * @internal
+ */
+final class DirectiveClassFinder
+{
+    /** @var list<class-string<TypeSystemDirective>>|null */
+    private array|null $cache = null;
+
+    public function __construct(
+        private readonly ClassFinder $classFinder,
+        private readonly ClassFinderComputedCache $classFinderComputedCache,
+    ) {
+    }
+
+    /** @return list<class-string<TypeSystemDirective>> */
+    public function findDirectives(): array
+    {
+        if ($this->cache !== null) {
+            return $this->cache;
+        }
+
+        /** @var list<class-string<TypeSystemDirective>> $result */
+        $result = $this->classFinderComputedCache->compute(
+            $this->classFinder,
+            'customDirectives',
+            static function (ReflectionClass $refClass): GlobDirectivesCache|null {
+                if ($refClass->isAbstract() || $refClass->isInterface() || $refClass->isEnum()) {
+                    return null;
+                }
+
+                if (! $refClass->implementsInterface(TypeSystemDirective::class)) {
+                    return null;
+                }
+
+                /** @var class-string<TypeSystemDirective> $directiveClass */
+                $directiveClass = $refClass->getName();
+                return new GlobDirectivesCache($directiveClass);
+            },
+            static fn (array $entries): array => array_reduce(
+                $entries,
+                static function (array $carry, GlobDirectivesCache|null $entry): array {
+                    if ($entry === null) {
+                        return $carry;
+                    }
+                    $carry[] = $entry->directiveClass;
+                    return $carry;
+                },
+                [],
+            ),
+        );
+
+        $this->cache = $result;
+        return $result;
+    }
+}
diff --git a/src/Directives/Discovery/GlobDirectivesCache.php b/src/Directives/Discovery/GlobDirectivesCache.php
new file mode 100644
index 000000000..d587eaba1
--- /dev/null
+++ b/src/Directives/Discovery/GlobDirectivesCache.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives\Discovery;
+
+use TheCodingMachine\GraphQLite\Directives\TypeSystemDirective;
+
+/**
+ * Cache entry for one file scanned by {@see DirectiveClassFinder}, holding the FQCN of the directive
+ * class it found. Files with no directive class get no entry.
+ *
+ * @internal
+ */
+final class GlobDirectivesCache
+{
+    /** @param class-string<TypeSystemDirective> $directiveClass */
+    public function __construct(public readonly string $directiveClass)
+    {
+    }
+}
diff --git a/src/Directives/Exceptions/InvalidDirectiveException.php b/src/Directives/Exceptions/InvalidDirectiveException.php
new file mode 100644
index 000000000..9542cfe63
--- /dev/null
+++ b/src/Directives/Exceptions/InvalidDirectiveException.php
@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives\Exceptions;
+
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\GraphQLRuntimeException;
+
+use function array_map;
+use function implode;
+use function sprintf;
+
+/**
+ * Thrown at schema build time when a directive declaration is invalid, e.g. a bad PHP target, a
+ * missing interface/location, an unsupported argument type, or a name clash.
+ */
+final class InvalidDirectiveException extends GraphQLRuntimeException
+{
+    public static function phpTargetMissingForLocation(string $directiveClass, DirectiveLocation $location, string $requiredTarget): self
+    {
+        return new self(sprintf(
+            'Directive "%s" declares location %s but its PHP #[Attribute(...)] target does not include %s. ' .
+            'Add the missing target to make the directive usable.',
+            $directiveClass,
+            $location->value,
+            $requiredTarget,
+        ));
+    }
+
+    /** @param list<DirectiveLocation> $locations */
+    public static function interfaceWithoutMatchingLocation(string $directiveClass, string $interface, array $locations): self
+    {
+        $locationsList = implode(', ', array_map(static fn (DirectiveLocation $l) => $l->value, $locations));
+
+        return new self(sprintf(
+            'Directive "%s" implements %s but its declared locations [%s] do not include the corresponding GraphQL location. ' .
+            'Either remove the interface or add the location to DirectiveDefinition::$locations.',
+            $directiveClass,
+            $interface,
+            $locationsList,
+        ));
+    }
+
+    public static function locationWithoutMatchingInterface(string $directiveClass, DirectiveLocation $location, string $expectedInterface): self
+    {
+        return new self(sprintf(
+            'Directive "%s" declares location %s but does not implement %s. ' .
+            'Either remove the location or implement the corresponding interface.',
+            $directiveClass,
+            $location->value,
+            $expectedInterface,
+        ));
+    }
+
+    public static function notAttribute(string $directiveClass): self
+    {
+        return new self(sprintf(
+            'Directive "%s" must declare a #[Attribute(...)] declaration so it can be applied to PHP code.',
+            $directiveClass,
+        ));
+    }
+
+    public static function unsupportedArgumentType(string $directiveClass, string $parameterName, string $reason): self
+    {
+        return new self(sprintf(
+            'Directive "%s" constructor parameter "$%s" cannot be mapped to a GraphQL input type: %s. ' .
+            'Supported types are scalars (string, int, float, bool), backed enums, and arrays/lists of those.',
+            $directiveClass,
+            $parameterName,
+            $reason,
+        ));
+    }
+
+    public static function duplicateName(string $name, string $existingClass, string $newClass): self
+    {
+        return new self(sprintf(
+            'Two directives declare the GraphQL name "@%s": %s and %s. Directive names must be unique.',
+            $name,
+            $existingClass,
+            $newClass,
+        ));
+    }
+
+    public static function reservedName(string $name, string $directiveClass): self
+    {
+        return new self(sprintf(
+            'Directive "%s" declares the name "@%s" which is reserved for a webonyx built-in directive (@skip, @include, @deprecated). Pick a different name.',
+            $directiveClass,
+            $name,
+        ));
+    }
+
+    public static function noDefinitionMethod(string $directiveClass): self
+    {
+        return new self(sprintf(
+            'Directive "%s" implements DirectiveInterface but does not declare a static `definition(): DirectiveDefinition` method.',
+            $directiveClass,
+        ));
+    }
+}
diff --git a/src/Directives/FieldDirective.php b/src/Directives/FieldDirective.php
new file mode 100644
index 000000000..14126d5f9
--- /dev/null
+++ b/src/Directives/FieldDirective.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use TheCodingMachine\GraphQLite\Annotations\MiddlewareAnnotationInterface;
+
+/**
+ * Marker for a directive on a field, query, mutation or subscription (`FIELD_DEFINITION` location).
+ *
+ * This alone registers the directive and prints it on the field, but adds no behavior. Implement
+ * {@see BehavioralFieldDirective} to wrap the resolver or otherwise act on the field.
+ *
+ * It extends {@see MiddlewareAnnotationInterface}, so instances are picked up by
+ * {@see \TheCodingMachine\GraphQLite\AnnotationReader::getMiddlewareAnnotations()}.
+ */
+interface FieldDirective extends TypeSystemDirective, MiddlewareAnnotationInterface
+{
+}
diff --git a/src/Directives/InputFieldDirective.php b/src/Directives/InputFieldDirective.php
new file mode 100644
index 000000000..26a20a7c2
--- /dev/null
+++ b/src/Directives/InputFieldDirective.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use TheCodingMachine\GraphQLite\Annotations\MiddlewareAnnotationInterface;
+
+/**
+ * Marker for a directive on an input object field (`INPUT_FIELD_DEFINITION` location). Metadata
+ * only; implement {@see BehavioralInputFieldDirective} to act on the input field at build time.
+ */
+interface InputFieldDirective extends TypeSystemDirective, MiddlewareAnnotationInterface
+{
+}
diff --git a/src/Directives/InputObjectTypeDirective.php b/src/Directives/InputObjectTypeDirective.php
new file mode 100644
index 000000000..637a368ed
--- /dev/null
+++ b/src/Directives/InputObjectTypeDirective.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+/**
+ * Marker for a directive on an input object type (`INPUT_OBJECT` location). Metadata only;
+ * implement {@see BehavioralInputObjectTypeDirective} to change the built input type (e.g. its
+ * `isOneOf` flag).
+ */
+interface InputObjectTypeDirective extends TypeSystemDirective
+{
+}
diff --git a/src/Directives/ObjectTypeDirective.php b/src/Directives/ObjectTypeDirective.php
new file mode 100644
index 000000000..d9ca7ade4
--- /dev/null
+++ b/src/Directives/ObjectTypeDirective.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+/**
+ * Marker for a directive on an object type (`OBJECT` location). This alone is metadata only;
+ * implement {@see BehavioralObjectTypeDirective} to act on the type at build time.
+ */
+interface ObjectTypeDirective extends TypeSystemDirective
+{
+}
diff --git a/src/Directives/ResolvedDirective.php b/src/Directives/ResolvedDirective.php
new file mode 100644
index 000000000..7f9736d30
--- /dev/null
+++ b/src/Directives/ResolvedDirective.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+
+/**
+ * What {@see DirectiveResolver} produces for one directive class: its metadata, its resolved
+ * constructor arguments, and the webonyx directive to register on the schema. The directive is null
+ * for built-ins, which webonyx already declares.
+ *
+ * @internal
+ */
+final class ResolvedDirective
+{
+    /** @param list<ResolvedDirectiveArgument> $arguments */
+    public function __construct(
+        public readonly DirectiveDefinition $definition,
+        public readonly array $arguments,
+        public readonly WebonyxDirective|null $webonyxDirective,
+    ) {
+    }
+}
diff --git a/src/Directives/ResolvedDirectiveArgument.php b/src/Directives/ResolvedDirectiveArgument.php
new file mode 100644
index 000000000..9113e72fa
--- /dev/null
+++ b/src/Directives/ResolvedDirectiveArgument.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Type\Definition\InputType;
+use GraphQL\Type\Definition\Type;
+
+/**
+ * One directive argument, resolved from a constructor parameter of the directive class. The
+ * parameter name doubles as the GraphQL argument name.
+ *
+ * {@see DirectiveRegistry} builds one per parameter and uses the list to construct the webonyx
+ * {@see \GraphQL\Type\Definition\Directive}.
+ *
+ * @internal
+ */
+final class ResolvedDirectiveArgument
+{
+    public function __construct(
+        public readonly string $name,
+        public readonly InputType&Type $type,
+        public readonly bool $hasDefaultValue,
+        public readonly mixed $defaultValue,
+        public readonly string|null $description = null,
+    ) {
+    }
+}
diff --git a/src/Directives/TypeSystemDirective.php b/src/Directives/TypeSystemDirective.php
new file mode 100644
index 000000000..02819de62
--- /dev/null
+++ b/src/Directives/TypeSystemDirective.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+/**
+ * Marker for directives that annotate the schema, rather than executable directives used in client
+ * queries. The four family interfaces ({@see FieldDirective}, {@see InputFieldDirective},
+ * {@see ObjectTypeDirective}, {@see InputObjectTypeDirective}) extend it so discovery can find them
+ * with one interface check.
+ */
+interface TypeSystemDirective extends DirectiveInterface
+{
+}
diff --git a/src/InputObjectTypeDescriptor.php b/src/InputObjectTypeDescriptor.php
new file mode 100644
index 000000000..3b5baa15e
--- /dev/null
+++ b/src/InputObjectTypeDescriptor.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite;
+
+use ReflectionClass;
+use TheCodingMachine\GraphQLite\Directives\InputObjectTypeDirective;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+use TheCodingMachine\GraphQLite\Utils\Cloneable;
+
+/**
+ * Carries a {@see MutableInputObjectType} through the
+ * {@see Middlewares\InputObjectTypeMiddlewarePipe} so {@see Directives\InputObjectTypeDirective}s can
+ * decorate the type before it's registered.
+ *
+ * Both `#[Input]` types (`InputType`) and `#[Factory]` types (`ResolvableMutableInputObjectType`)
+ * extend `MutableInputObjectType`, so either works here.
+ */
+class InputObjectTypeDescriptor
+{
+    use Cloneable;
+
+    /**
+     * @param ReflectionClass<object> $reflectionClass
+     * @param list<InputObjectTypeDirective> $directives
+     */
+    public function __construct(
+        private readonly ReflectionClass $reflectionClass,
+        private readonly MutableInputObjectType $type,
+        private readonly array $directives = [],
+    ) {
+    }
+
+    /** @return ReflectionClass<object> */
+    public function getReflectionClass(): ReflectionClass
+    {
+        return $this->reflectionClass;
+    }
+
+    public function getType(): MutableInputObjectType
+    {
+        return $this->type;
+    }
+
+    /** @return list<InputObjectTypeDirective> */
+    public function getDirectives(): array
+    {
+        return $this->directives;
+    }
+
+    /** @param list<InputObjectTypeDirective> $directives */
+    public function withDirectives(array $directives): self
+    {
+        return $this->with(directives: $directives);
+    }
+}
diff --git a/src/InputTypeGenerator.php b/src/InputTypeGenerator.php
index d2bc24797..80f010b93 100644
--- a/src/InputTypeGenerator.php
+++ b/src/InputTypeGenerator.php
@@ -6,11 +6,15 @@
 
 use GraphQL\Type\Definition\InputObjectType;
 use Psr\Container\ContainerInterface;
+use ReflectionClass;
 use ReflectionFunctionAbstract;
 use ReflectionMethod;
+use TheCodingMachine\GraphQLite\Middlewares\InputObjectTypeHandlerInterface;
+use TheCodingMachine\GraphQLite\Middlewares\InputObjectTypeMiddlewareInterface;
 use TheCodingMachine\GraphQLite\Reflection\DocBlock\DocBlockFactory;
 use TheCodingMachine\GraphQLite\Types\InputType;
 use TheCodingMachine\GraphQLite\Types\InputTypeValidatorInterface;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
 use TheCodingMachine\GraphQLite\Types\ResolvableMutableInputInterface;
 use TheCodingMachine\GraphQLite\Types\ResolvableMutableInputObjectType;
 use TheCodingMachine\GraphQLite\Utils\DescriptionResolver;
@@ -36,6 +40,7 @@ public function __construct(
         private AnnotationReader|null $annotationReader = null,
         private DocBlockFactory|null $docBlockFactory = null,
         private DescriptionResolver $descriptionResolver = new DescriptionResolver(true),
+        private InputObjectTypeMiddlewareInterface|null $inputObjectTypeMiddleware = null,
     ) {
     }
 
@@ -52,7 +57,7 @@ public function mapFactoryMethod(string $factory, string $methodName, ContainerI
         [$inputName, $className] = $this->inputTypeUtils->getInputTypeNameAndClassName($method);
 
         if (! isset($this->factoryCache[$inputName])) {
-            $this->factoryCache[$inputName] = new ResolvableMutableInputObjectType(
+            $type = new ResolvableMutableInputObjectType(
                 $inputName,
                 $this->fieldsBuilder,
                 $object,
@@ -60,6 +65,12 @@ public function mapFactoryMethod(string $factory, string $methodName, ContainerI
                 $this->resolveFactoryDescription($method),
                 $this->canBeInstantiatedWithoutParameter($method, false),
             );
+
+            /** @var class-string $factoryClass */
+            $factoryClass = $factory;
+            $decorated = $this->runInputObjectMiddleware(new ReflectionClass($factoryClass), $type);
+            assert($decorated instanceof ResolvableMutableInputObjectType);
+            $this->factoryCache[$inputName] = $decorated;
         }
 
         return $this->factoryCache[$inputName];
@@ -96,7 +107,7 @@ private function resolveFactoryDescription(ReflectionMethod $method): string|nul
     public function mapInput(string $className, string $inputName, string|null $description, bool $isUpdate): InputType
     {
         if (! isset($this->inputCache[$inputName])) {
-            $this->inputCache[$inputName] = new InputType(
+            $type = new InputType(
                 $className,
                 $inputName,
                 $description,
@@ -104,11 +115,40 @@ public function mapInput(string $className, string $inputName, string|null $desc
                 $this->fieldsBuilder,
                 $this->inputTypeValidator,
             );
+
+            $decorated = $this->runInputObjectMiddleware(new ReflectionClass($className), $type);
+            assert($decorated instanceof InputType);
+            $this->inputCache[$inputName] = $decorated;
         }
 
         return $this->inputCache[$inputName];
     }
 
+    /** @param ReflectionClass<object> $refClass */
+    private function runInputObjectMiddleware(ReflectionClass $refClass, MutableInputObjectType $type): MutableInputObjectType
+    {
+        if ($this->inputObjectTypeMiddleware === null || $this->annotationReader === null) {
+            return $type;
+        }
+
+        $directives = $this->annotationReader->getInputObjectTypeDirectives($refClass);
+        if ($directives === []) {
+            return $type;
+        }
+
+        $descriptor = new InputObjectTypeDescriptor($refClass, $type, $directives);
+
+        return $this->inputObjectTypeMiddleware->process(
+            $descriptor,
+            new class implements InputObjectTypeHandlerInterface {
+                public function handle(InputObjectTypeDescriptor $descriptor): MutableInputObjectType
+                {
+                    return $descriptor->getType();
+                }
+            },
+        );
+    }
+
     public static function canBeInstantiatedWithoutParameter(ReflectionFunctionAbstract $refMethod, bool $skipFirstArgument): bool
     {
         $nbParams = $refMethod->getNumberOfRequiredParameters();
diff --git a/src/Middlewares/DirectiveFieldMiddleware.php b/src/Middlewares/DirectiveFieldMiddleware.php
new file mode 100644
index 000000000..cb6f86f60
--- /dev/null
+++ b/src/Middlewares/DirectiveFieldMiddleware.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use GraphQL\Type\Definition\FieldDefinition;
+use TheCodingMachine\GraphQLite\Directives\BehavioralFieldDirective;
+use TheCodingMachine\GraphQLite\Directives\DirectiveAstBuilder;
+use TheCodingMachine\GraphQLite\Directives\FieldDirective;
+use TheCodingMachine\GraphQLite\QueryFieldDescriptor;
+
+use function array_filter;
+use function array_reverse;
+use function array_values;
+
+/**
+ * Dispatches the {@see FieldDirective}s on a field. The ones implementing
+ * {@see BehavioralFieldDirective} run their `applyToField` hook; metadata-only directives don't run
+ * anything but still get their `astNode` so they show up in SDL.
+ *
+ * @internal
+ */
+final readonly class DirectiveFieldMiddleware implements FieldMiddlewareInterface
+{
+    public function __construct(private DirectiveAstBuilder $astBuilder)
+    {
+    }
+
+    public function process(QueryFieldDescriptor $queryFieldDescriptor, FieldHandlerInterface $fieldHandler): FieldDefinition|null
+    {
+        /** @var list<FieldDirective> $directives */
+        $directives = $queryFieldDescriptor
+            ->getMiddlewareAnnotations()
+            ->getAnnotationsByType(FieldDirective::class);
+
+        if ($directives === []) {
+            return $fieldHandler->handle($queryFieldDescriptor);
+        }
+
+        $behavioralDirectives = array_values(array_filter(
+            $directives,
+            static fn (FieldDirective $directive): bool => $directive instanceof BehavioralFieldDirective,
+        ));
+
+        $handler = $fieldHandler;
+        foreach (array_reverse($behavioralDirectives) as $directive) {
+            $handler = new class ($directive, $handler) implements FieldHandlerInterface {
+                public function __construct(
+                    private readonly BehavioralFieldDirective $directive,
+                    private readonly FieldHandlerInterface $next,
+                ) {
+                }
+
+                public function handle(QueryFieldDescriptor $fieldDescriptor): FieldDefinition|null
+                {
+                    return $this->directive->applyToField($fieldDescriptor, $this->next);
+                }
+            };
+        }
+
+        $result = $handler->handle($queryFieldDescriptor);
+        if ($result === null) {
+            return null;
+        }
+
+        $result->astNode = DirectiveAstBuilder::buildFieldDefinitionNode(
+            $result->name,
+            $this->astBuilder->buildDirectiveNodes($directives),
+        );
+
+        return $result;
+    }
+}
diff --git a/src/Middlewares/DirectiveInputFieldMiddleware.php b/src/Middlewares/DirectiveInputFieldMiddleware.php
new file mode 100644
index 000000000..4ff9217ea
--- /dev/null
+++ b/src/Middlewares/DirectiveInputFieldMiddleware.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use TheCodingMachine\GraphQLite\Directives\BehavioralInputFieldDirective;
+use TheCodingMachine\GraphQLite\Directives\DirectiveAstBuilder;
+use TheCodingMachine\GraphQLite\Directives\InputFieldDirective;
+use TheCodingMachine\GraphQLite\InputField;
+use TheCodingMachine\GraphQLite\InputFieldDescriptor;
+
+use function array_filter;
+use function array_reverse;
+use function array_values;
+
+/**
+ * Dispatches the {@see InputFieldDirective}s on an input field. The ones implementing
+ * {@see BehavioralInputFieldDirective} run their `applyToInputField` hook; metadata-only directives
+ * still get their `astNode` so they show up in SDL.
+ *
+ * @internal
+ */
+final readonly class DirectiveInputFieldMiddleware implements InputFieldMiddlewareInterface
+{
+    public function __construct(private DirectiveAstBuilder $astBuilder)
+    {
+    }
+
+    public function process(InputFieldDescriptor $inputFieldDescriptor, InputFieldHandlerInterface $inputFieldHandler): InputField|null
+    {
+        /** @var list<InputFieldDirective> $directives */
+        $directives = $inputFieldDescriptor
+            ->getMiddlewareAnnotations()
+            ->getAnnotationsByType(InputFieldDirective::class);
+
+        if ($directives === []) {
+            return $inputFieldHandler->handle($inputFieldDescriptor);
+        }
+
+        $behavioralDirectives = array_values(array_filter(
+            $directives,
+            static fn (InputFieldDirective $directive): bool => $directive instanceof BehavioralInputFieldDirective,
+        ));
+
+        $handler = $inputFieldHandler;
+        foreach (array_reverse($behavioralDirectives) as $directive) {
+            $handler = new class ($directive, $handler) implements InputFieldHandlerInterface {
+                public function __construct(
+                    private readonly BehavioralInputFieldDirective $directive,
+                    private readonly InputFieldHandlerInterface $next,
+                ) {
+                }
+
+                public function handle(InputFieldDescriptor $inputFieldDescriptor): InputField|null
+                {
+                    return $this->directive->applyToInputField($inputFieldDescriptor, $this->next);
+                }
+            };
+        }
+
+        $result = $handler->handle($inputFieldDescriptor);
+        if ($result === null) {
+            return null;
+        }
+
+        $astNode = DirectiveAstBuilder::buildInputValueDefinitionNode(
+            $result->name,
+            $this->astBuilder->buildDirectiveNodes($directives),
+        );
+
+        // InputObjectType reconstructs each field from $field->config (see InputType.php:51),
+        // so mutating only the astNode property would not survive. Update the config too.
+        $result->astNode = $astNode;
+        $result->config['astNode'] = $astNode;
+
+        return $result;
+    }
+}
diff --git a/src/Middlewares/DirectiveInputObjectTypeMiddleware.php b/src/Middlewares/DirectiveInputObjectTypeMiddleware.php
new file mode 100644
index 000000000..c72afb90c
--- /dev/null
+++ b/src/Middlewares/DirectiveInputObjectTypeMiddleware.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use TheCodingMachine\GraphQLite\Directives\BehavioralInputObjectTypeDirective;
+use TheCodingMachine\GraphQLite\Directives\DirectiveAstBuilder;
+use TheCodingMachine\GraphQLite\InputObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+
+use function array_filter;
+use function array_reverse;
+use function array_values;
+
+/**
+ * Dispatches the {@see \TheCodingMachine\GraphQLite\Directives\InputObjectTypeDirective}s on an
+ * `#[Input]` (or `#[Factory]`) class. The ones implementing {@see BehavioralInputObjectTypeDirective}
+ * run their `applyToInputObjectType` hook; metadata-only directives still get an `astNode` for SDL.
+ *
+ * @internal
+ */
+final readonly class DirectiveInputObjectTypeMiddleware implements InputObjectTypeMiddlewareInterface
+{
+    public function __construct(private DirectiveAstBuilder $astBuilder)
+    {
+    }
+
+    public function process(InputObjectTypeDescriptor $descriptor, InputObjectTypeHandlerInterface $next): MutableInputObjectType
+    {
+        $directives = $descriptor->getDirectives();
+
+        if ($directives === []) {
+            return $next->handle($descriptor);
+        }
+
+        $behavioralDirectives = array_values(array_filter(
+            $directives,
+            static fn ($directive): bool => $directive instanceof BehavioralInputObjectTypeDirective,
+        ));
+
+        $handler = $next;
+        foreach (array_reverse($behavioralDirectives) as $directive) {
+            $handler = new class ($directive, $handler) implements InputObjectTypeHandlerInterface {
+                public function __construct(
+                    private readonly BehavioralInputObjectTypeDirective $directive,
+                    private readonly InputObjectTypeHandlerInterface $next,
+                ) {
+                }
+
+                public function handle(InputObjectTypeDescriptor $descriptor): MutableInputObjectType
+                {
+                    return $this->directive->applyToInputObjectType($descriptor, $this->next);
+                }
+            };
+        }
+
+        $type = $handler->handle($descriptor);
+
+        $type->astNode = DirectiveAstBuilder::buildInputObjectTypeDefinitionNode(
+            $type->name,
+            $this->astBuilder->buildDirectiveNodes($directives),
+        );
+
+        return $type;
+    }
+}
diff --git a/src/Middlewares/DirectiveObjectTypeMiddleware.php b/src/Middlewares/DirectiveObjectTypeMiddleware.php
new file mode 100644
index 000000000..06bcd8c11
--- /dev/null
+++ b/src/Middlewares/DirectiveObjectTypeMiddleware.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use TheCodingMachine\GraphQLite\Directives\BehavioralObjectTypeDirective;
+use TheCodingMachine\GraphQLite\Directives\DirectiveAstBuilder;
+use TheCodingMachine\GraphQLite\ObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableObjectType;
+
+use function array_filter;
+use function array_reverse;
+use function array_values;
+
+/**
+ * Dispatches the {@see \TheCodingMachine\GraphQLite\Directives\ObjectTypeDirective}s on a `#[Type]`
+ * class. The ones implementing {@see BehavioralObjectTypeDirective} run their `applyToObjectType`
+ * hook; metadata-only directives still get an `astNode` for SDL.
+ *
+ * @internal
+ */
+final readonly class DirectiveObjectTypeMiddleware implements ObjectTypeMiddlewareInterface
+{
+    public function __construct(private DirectiveAstBuilder $astBuilder)
+    {
+    }
+
+    public function process(ObjectTypeDescriptor $descriptor, ObjectTypeHandlerInterface $next): MutableObjectType
+    {
+        $directives = $descriptor->getDirectives();
+
+        if ($directives === []) {
+            return $next->handle($descriptor);
+        }
+
+        $behavioralDirectives = array_values(array_filter(
+            $directives,
+            static fn ($directive): bool => $directive instanceof BehavioralObjectTypeDirective,
+        ));
+
+        $handler = $next;
+        foreach (array_reverse($behavioralDirectives) as $directive) {
+            $handler = new class ($directive, $handler) implements ObjectTypeHandlerInterface {
+                public function __construct(
+                    private readonly BehavioralObjectTypeDirective $directive,
+                    private readonly ObjectTypeHandlerInterface $next,
+                ) {
+                }
+
+                public function handle(ObjectTypeDescriptor $descriptor): MutableObjectType
+                {
+                    return $this->directive->applyToObjectType($descriptor, $this->next);
+                }
+            };
+        }
+
+        $type = $handler->handle($descriptor);
+
+        $type->astNode = DirectiveAstBuilder::buildObjectTypeDefinitionNode(
+            $type->name,
+            $this->astBuilder->buildDirectiveNodes($directives),
+        );
+
+        return $type;
+    }
+}
diff --git a/src/Middlewares/InputObjectTypeHandlerInterface.php b/src/Middlewares/InputObjectTypeHandlerInterface.php
new file mode 100644
index 000000000..fa8181400
--- /dev/null
+++ b/src/Middlewares/InputObjectTypeHandlerInterface.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use TheCodingMachine\GraphQLite\InputObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+
+/** @unstable See https://graphqlite.thecodingmachine.io/docs/semver.html */
+interface InputObjectTypeHandlerInterface
+{
+    public function handle(InputObjectTypeDescriptor $descriptor): MutableInputObjectType;
+}
diff --git a/src/Middlewares/InputObjectTypeMiddlewareInterface.php b/src/Middlewares/InputObjectTypeMiddlewareInterface.php
new file mode 100644
index 000000000..3d252f674
--- /dev/null
+++ b/src/Middlewares/InputObjectTypeMiddlewareInterface.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use TheCodingMachine\GraphQLite\InputObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+
+/**
+ * A middleware in the {@see InputObjectTypeMiddlewarePipe} that decorates
+ * {@see MutableInputObjectType} instances right after they're built (both `#[Input]` and
+ * `#[Factory]` types).
+ *
+ * @unstable See https://graphqlite.thecodingmachine.io/docs/semver.html
+ */
+interface InputObjectTypeMiddlewareInterface
+{
+    public function process(InputObjectTypeDescriptor $descriptor, InputObjectTypeHandlerInterface $next): MutableInputObjectType;
+}
diff --git a/src/Middlewares/InputObjectTypeMiddlewarePipe.php b/src/Middlewares/InputObjectTypeMiddlewarePipe.php
new file mode 100644
index 000000000..b7c0a90d7
--- /dev/null
+++ b/src/Middlewares/InputObjectTypeMiddlewarePipe.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use SplQueue;
+use TheCodingMachine\GraphQLite\InputObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+
+final class InputObjectTypeMiddlewarePipe implements InputObjectTypeMiddlewareInterface
+{
+    private SplQueue $pipeline;
+
+    public function __construct()
+    {
+        $this->pipeline = new SplQueue();
+    }
+
+    public function process(InputObjectTypeDescriptor $descriptor, InputObjectTypeHandlerInterface $next): MutableInputObjectType
+    {
+        return (new InputObjectTypeNext($this->pipeline, $next))->handle($descriptor);
+    }
+
+    public function pipe(InputObjectTypeMiddlewareInterface $middleware): void
+    {
+        $this->pipeline->enqueue($middleware);
+    }
+}
diff --git a/src/Middlewares/InputObjectTypeNext.php b/src/Middlewares/InputObjectTypeNext.php
new file mode 100644
index 000000000..92dab70d9
--- /dev/null
+++ b/src/Middlewares/InputObjectTypeNext.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use SplQueue;
+use TheCodingMachine\GraphQLite\InputObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+
+use function assert;
+
+/**
+ * Iterates the queue of input-object-type middlewares and dispatches each one.
+ */
+final class InputObjectTypeNext implements InputObjectTypeHandlerInterface
+{
+    private SplQueue $queue;
+
+    public function __construct(SplQueue $queue, private readonly InputObjectTypeHandlerInterface $fallbackHandler)
+    {
+        $this->queue = clone $queue;
+    }
+
+    public function handle(InputObjectTypeDescriptor $descriptor): MutableInputObjectType
+    {
+        if ($this->queue->isEmpty()) {
+            return $this->fallbackHandler->handle($descriptor);
+        }
+
+        $middleware = $this->queue->dequeue();
+        assert($middleware instanceof InputObjectTypeMiddlewareInterface);
+        return $middleware->process($descriptor, $this);
+    }
+}
diff --git a/src/Middlewares/ObjectTypeHandlerInterface.php b/src/Middlewares/ObjectTypeHandlerInterface.php
new file mode 100644
index 000000000..97dd2a21d
--- /dev/null
+++ b/src/Middlewares/ObjectTypeHandlerInterface.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use TheCodingMachine\GraphQLite\ObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableObjectType;
+
+/** @unstable See https://graphqlite.thecodingmachine.io/docs/semver.html */
+interface ObjectTypeHandlerInterface
+{
+    public function handle(ObjectTypeDescriptor $descriptor): MutableObjectType;
+}
diff --git a/src/Middlewares/ObjectTypeMiddlewareInterface.php b/src/Middlewares/ObjectTypeMiddlewareInterface.php
new file mode 100644
index 000000000..ff8e814d9
--- /dev/null
+++ b/src/Middlewares/ObjectTypeMiddlewareInterface.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use TheCodingMachine\GraphQLite\ObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableObjectType;
+
+/**
+ * A middleware in the {@see ObjectTypeMiddlewarePipe} used to decorate {@see MutableObjectType}
+ * instances right after construction.
+ *
+ * @unstable See https://graphqlite.thecodingmachine.io/docs/semver.html
+ */
+interface ObjectTypeMiddlewareInterface
+{
+    public function process(ObjectTypeDescriptor $descriptor, ObjectTypeHandlerInterface $next): MutableObjectType;
+}
diff --git a/src/Middlewares/ObjectTypeMiddlewarePipe.php b/src/Middlewares/ObjectTypeMiddlewarePipe.php
new file mode 100644
index 000000000..f1210d798
--- /dev/null
+++ b/src/Middlewares/ObjectTypeMiddlewarePipe.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use SplQueue;
+use TheCodingMachine\GraphQLite\ObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableObjectType;
+
+final class ObjectTypeMiddlewarePipe implements ObjectTypeMiddlewareInterface
+{
+    private SplQueue $pipeline;
+
+    public function __construct()
+    {
+        $this->pipeline = new SplQueue();
+    }
+
+    public function process(ObjectTypeDescriptor $descriptor, ObjectTypeHandlerInterface $next): MutableObjectType
+    {
+        return (new ObjectTypeNext($this->pipeline, $next))->handle($descriptor);
+    }
+
+    public function pipe(ObjectTypeMiddlewareInterface $middleware): void
+    {
+        $this->pipeline->enqueue($middleware);
+    }
+}
diff --git a/src/Middlewares/ObjectTypeNext.php b/src/Middlewares/ObjectTypeNext.php
new file mode 100644
index 000000000..923f28bc8
--- /dev/null
+++ b/src/Middlewares/ObjectTypeNext.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Middlewares;
+
+use SplQueue;
+use TheCodingMachine\GraphQLite\ObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Types\MutableObjectType;
+
+use function assert;
+
+/**
+ * Iterates the queue of object-type middlewares and dispatches each one.
+ */
+final class ObjectTypeNext implements ObjectTypeHandlerInterface
+{
+    private SplQueue $queue;
+
+    public function __construct(SplQueue $queue, private readonly ObjectTypeHandlerInterface $fallbackHandler)
+    {
+        $this->queue = clone $queue;
+    }
+
+    public function handle(ObjectTypeDescriptor $descriptor): MutableObjectType
+    {
+        if ($this->queue->isEmpty()) {
+            return $this->fallbackHandler->handle($descriptor);
+        }
+
+        $middleware = $this->queue->dequeue();
+        assert($middleware instanceof ObjectTypeMiddlewareInterface);
+        return $middleware->process($descriptor, $this);
+    }
+}
diff --git a/src/ObjectTypeDescriptor.php b/src/ObjectTypeDescriptor.php
new file mode 100644
index 000000000..79bdf38ae
--- /dev/null
+++ b/src/ObjectTypeDescriptor.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite;
+
+use ReflectionClass;
+use TheCodingMachine\GraphQLite\Directives\ObjectTypeDirective;
+use TheCodingMachine\GraphQLite\Types\MutableObjectType;
+use TheCodingMachine\GraphQLite\Utils\Cloneable;
+
+/**
+ * Carries a {@see MutableObjectType} through the {@see Middlewares\ObjectTypeMiddlewarePipe} so
+ * {@see Directives\ObjectTypeDirective}s can decorate the type before it's registered.
+ */
+class ObjectTypeDescriptor
+{
+    use Cloneable;
+
+    /**
+     * @param ReflectionClass<object> $reflectionClass
+     * @param list<ObjectTypeDirective> $directives
+     */
+    public function __construct(
+        private readonly ReflectionClass $reflectionClass,
+        private readonly MutableObjectType $type,
+        private readonly array $directives = [],
+    ) {
+    }
+
+    /** @return ReflectionClass<object> */
+    public function getReflectionClass(): ReflectionClass
+    {
+        return $this->reflectionClass;
+    }
+
+    public function getType(): MutableObjectType
+    {
+        return $this->type;
+    }
+
+    /** @return list<ObjectTypeDirective> */
+    public function getDirectives(): array
+    {
+        return $this->directives;
+    }
+
+    /** @param list<ObjectTypeDirective> $directives */
+    public function withDirectives(array $directives): self
+    {
+        return $this->with(directives: $directives);
+    }
+}
diff --git a/src/Schema.php b/src/Schema.php
index f90c7fbbf..3b30354a8 100644
--- a/src/Schema.php
+++ b/src/Schema.php
@@ -4,6 +4,7 @@
 
 namespace TheCodingMachine\GraphQLite;
 
+use GraphQL\Type\Definition\Directive;
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Type\Definition\Type;
 use GraphQL\Type\SchemaConfig;
@@ -18,12 +19,17 @@
  */
 class Schema extends \GraphQL\Type\Schema
 {
+    /**
+     * @param array<Directive> $directives Custom directive definitions to add alongside webonyx's
+     *                                      standard ones.
+     */
     public function __construct(
         QueryProviderInterface $queryProvider,
         RecursiveTypeMapperInterface $recursiveTypeMapper,
         TypeResolver $typeResolver,
         RootTypeMapperInterface $rootTypeMapper,
         SchemaConfig|null $config = null,
+        array $directives = [],
     ) {
         if ($config === null) {
             $config = SchemaConfig::create();
@@ -113,6 +119,16 @@ public function __construct(
             return $rootTypeMapper->mapNameToType($name);
         });
 
+        // Register custom directives so they show up in introspection and SDL. webonyx drops its
+        // standard directives once this list is set, so include them too: whatever the config
+        // already had, or webonyx's defaults.
+        if ($directives !== []) {
+            $config->setDirectives([
+                ...($config->getDirectives() ?? Directive::builtInDirectives()),
+                ...$directives,
+            ]);
+        }
+
         $typeResolver->registerSchema($this);
 
         parent::__construct($config);
diff --git a/src/SchemaFactory.php b/src/SchemaFactory.php
index 20b5e27c1..fecf257c1 100644
--- a/src/SchemaFactory.php
+++ b/src/SchemaFactory.php
@@ -18,6 +18,9 @@
 use TheCodingMachine\GraphQLite\Cache\ClassBoundCache;
 use TheCodingMachine\GraphQLite\Cache\FilesSnapshot;
 use TheCodingMachine\GraphQLite\Cache\SnapshotClassBoundCache;
+use TheCodingMachine\GraphQLite\Directives\DirectiveAstBuilder;
+use TheCodingMachine\GraphQLite\Directives\DirectiveRegistry;
+use TheCodingMachine\GraphQLite\Directives\Discovery\DirectiveClassFinder;
 use TheCodingMachine\GraphQLite\Discovery\Cache\HardClassFinderComputedCache;
 use TheCodingMachine\GraphQLite\Discovery\Cache\SnapshotClassFinderComputedCache;
 use TheCodingMachine\GraphQLite\Discovery\ClassFinder;
@@ -50,10 +53,16 @@
 use TheCodingMachine\GraphQLite\Middlewares\AuthorizationFieldMiddleware;
 use TheCodingMachine\GraphQLite\Middlewares\AuthorizationInputFieldMiddleware;
 use TheCodingMachine\GraphQLite\Middlewares\CostFieldMiddleware;
+use TheCodingMachine\GraphQLite\Middlewares\DirectiveFieldMiddleware;
+use TheCodingMachine\GraphQLite\Middlewares\DirectiveInputFieldMiddleware;
+use TheCodingMachine\GraphQLite\Middlewares\DirectiveInputObjectTypeMiddleware;
+use TheCodingMachine\GraphQLite\Middlewares\DirectiveObjectTypeMiddleware;
 use TheCodingMachine\GraphQLite\Middlewares\FieldMiddlewareInterface;
 use TheCodingMachine\GraphQLite\Middlewares\FieldMiddlewarePipe;
 use TheCodingMachine\GraphQLite\Middlewares\InputFieldMiddlewareInterface;
 use TheCodingMachine\GraphQLite\Middlewares\InputFieldMiddlewarePipe;
+use TheCodingMachine\GraphQLite\Middlewares\InputObjectTypeMiddlewarePipe;
+use TheCodingMachine\GraphQLite\Middlewares\ObjectTypeMiddlewarePipe;
 use TheCodingMachine\GraphQLite\Middlewares\SecurityFieldMiddleware;
 use TheCodingMachine\GraphQLite\Middlewares\SecurityInputFieldMiddleware;
 use TheCodingMachine\GraphQLite\Reflection\DocBlock\CachedDocBlockFactory;
@@ -400,6 +409,12 @@ public function createSchema(): Schema
         $expressionLanguage = $this->expressionLanguage ?: new ExpressionLanguage($symfonyCache);
         $expressionLanguage->registerProvider(new SecurityExpressionLanguageProvider());
 
+        $directiveRegistry = new DirectiveRegistry(
+            new DirectiveClassFinder($classFinder, $classFinderComputedCache),
+        );
+        $directiveRegistry->discover();
+        $directiveAstBuilder = new DirectiveAstBuilder($directiveRegistry);
+
         $fieldMiddlewarePipe = new FieldMiddlewarePipe();
         foreach ($this->fieldMiddlewares as $fieldMiddleware) {
             $fieldMiddlewarePipe->pipe($fieldMiddleware);
@@ -408,6 +423,7 @@ public function createSchema(): Schema
         $fieldMiddlewarePipe->pipe(new SecurityFieldMiddleware($expressionLanguage, $authenticationService, $authorizationService));
         $fieldMiddlewarePipe->pipe(new AuthorizationFieldMiddleware($authenticationService, $authorizationService));
         $fieldMiddlewarePipe->pipe(new CostFieldMiddleware());
+        $fieldMiddlewarePipe->pipe(new DirectiveFieldMiddleware($directiveAstBuilder));
 
         $inputFieldMiddlewarePipe = new InputFieldMiddlewarePipe();
         foreach ($this->inputFieldMiddlewares as $inputFieldMiddleware) {
@@ -416,6 +432,13 @@ public function createSchema(): Schema
         // TODO: add a logger to the SchemaFactory and make use of it everywhere (and most particularly in SecurityInputFieldMiddleware)
         $inputFieldMiddlewarePipe->pipe(new SecurityInputFieldMiddleware($expressionLanguage, $authenticationService, $authorizationService));
         $inputFieldMiddlewarePipe->pipe(new AuthorizationInputFieldMiddleware($authenticationService, $authorizationService));
+        $inputFieldMiddlewarePipe->pipe(new DirectiveInputFieldMiddleware($directiveAstBuilder));
+
+        $objectTypeMiddlewarePipe = new ObjectTypeMiddlewarePipe();
+        $objectTypeMiddlewarePipe->pipe(new DirectiveObjectTypeMiddleware($directiveAstBuilder));
+
+        $inputObjectTypeMiddlewarePipe = new InputObjectTypeMiddlewarePipe();
+        $inputObjectTypeMiddlewarePipe->pipe(new DirectiveInputObjectTypeMiddleware($directiveAstBuilder));
 
         $compositeTypeMapper = new CompositeTypeMapper();
         $recursiveTypeMapper = new RecursiveTypeMapper($compositeTypeMapper, $namingStrategy, $namespacedCache, $typeRegistry, $annotationReader);
@@ -481,9 +504,9 @@ classBoundCache: $classBoundCache,
         $parameterMiddlewarePipe->pipe(new ContainerParameterHandler($this->container));
         $parameterMiddlewarePipe->pipe(new InjectUserParameterHandler($authenticationService));
 
-        $typeGenerator = new TypeGenerator($annotationReader, $namingStrategy, $typeRegistry, $this->container, $recursiveTypeMapper, $fieldsBuilder, $docBlockFactory, $descriptionResolver);
+        $typeGenerator = new TypeGenerator($annotationReader, $namingStrategy, $typeRegistry, $this->container, $recursiveTypeMapper, $fieldsBuilder, $docBlockFactory, $descriptionResolver, $objectTypeMiddlewarePipe);
         $inputTypeUtils = new InputTypeUtils($annotationReader, $namingStrategy);
-        $inputTypeGenerator = new InputTypeGenerator($inputTypeUtils, $fieldsBuilder, $this->inputTypeValidator, $annotationReader, $docBlockFactory, $descriptionResolver);
+        $inputTypeGenerator = new InputTypeGenerator($inputTypeUtils, $fieldsBuilder, $this->inputTypeValidator, $annotationReader, $docBlockFactory, $descriptionResolver, $inputObjectTypeMiddlewarePipe);
 
         if ($this->namespaces) {
             $compositeTypeMapper->addTypeMapper(new ClassFinderTypeMapper(
@@ -558,7 +581,14 @@ classBoundCache: $classBoundCache,
 
         $aggregateQueryProvider = new AggregateQueryProvider($queryProviders);
 
-        return new Schema($aggregateQueryProvider, $recursiveTypeMapper, $typeResolver, $topRootTypeMapper, $this->schemaConfig);
+        return new Schema(
+            $aggregateQueryProvider,
+            $recursiveTypeMapper,
+            $typeResolver,
+            $topRootTypeMapper,
+            $this->schemaConfig,
+            $directiveRegistry->webonyxDirectives(),
+        );
     }
 
     private function createClassFinder(): ClassFinder
diff --git a/src/TypeGenerator.php b/src/TypeGenerator.php
index 1220fa679..cc560618e 100644
--- a/src/TypeGenerator.php
+++ b/src/TypeGenerator.php
@@ -11,6 +11,8 @@
 use TheCodingMachine\GraphQLite\Annotations\ExtendType;
 use TheCodingMachine\GraphQLite\Annotations\Type as TypeAnnotation;
 use TheCodingMachine\GraphQLite\Mappers\RecursiveTypeMapperInterface;
+use TheCodingMachine\GraphQLite\Middlewares\ObjectTypeHandlerInterface;
+use TheCodingMachine\GraphQLite\Middlewares\ObjectTypeMiddlewareInterface;
 use TheCodingMachine\GraphQLite\Reflection\DocBlock\DocBlockFactory;
 use TheCodingMachine\GraphQLite\Types\MutableInterface;
 use TheCodingMachine\GraphQLite\Types\MutableInterfaceType;
@@ -49,6 +51,7 @@ public function __construct(
         private FieldsBuilder $fieldsBuilder,
         private DocBlockFactory|null $docBlockFactory = null,
         private DescriptionResolver $descriptionResolver = new DescriptionResolver(true),
+        private ObjectTypeMiddlewareInterface|null $objectTypeMiddleware = null,
     )
     {
     }
@@ -125,6 +128,22 @@ public function mapAnnotatedObject(string $annotatedObjectClassName): MutableInt
             $type->description = $resolvedDescription;
         }
 
+        if ($type instanceof MutableObjectType && $this->objectTypeMiddleware !== null) {
+            $directives = $this->annotationReader->getObjectTypeDirectives($refTypeClass);
+            if ($directives !== []) {
+                $descriptor = new ObjectTypeDescriptor($refTypeClass, $type, $directives);
+                $type = $this->objectTypeMiddleware->process(
+                    $descriptor,
+                    new class implements ObjectTypeHandlerInterface {
+                        public function handle(ObjectTypeDescriptor $descriptor): MutableObjectType
+                        {
+                            return $descriptor->getType();
+                        }
+                    },
+                );
+            }
+        }
+
         return $type;
     }
 
diff --git a/tests/Directives/BuiltInDirectivesTest.php b/tests/Directives/BuiltInDirectivesTest.php
new file mode 100644
index 000000000..685ece3f6
--- /dev/null
+++ b/tests/Directives/BuiltInDirectivesTest.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Psr16Cache;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\OneOf;
+use TheCodingMachine\GraphQLite\Directives\Discovery\DirectiveClassFinder;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\CustomOneOfOverride;
+use TheCodingMachine\GraphQLite\Discovery\Cache\HardClassFinderComputedCache;
+use TheCodingMachine\GraphQLite\Discovery\StaticClassFinder;
+
+use function array_map;
+
+final class BuiltInDirectivesTest extends TestCase
+{
+    public function testRegistryAlwaysRegistersBuiltInAttributesEvenWithEmptyClassFinder(): void
+    {
+        $registry = self::buildRegistry([]);
+        $registry->discover();
+
+        $this->assertNotNull($registry->definitionFor(OneOf::class));
+    }
+
+    public function testBuiltInDirectivesAreNotEmittedAsCustomDirectives(): void
+    {
+        $registry = self::buildRegistry([]);
+        $registry->discover();
+
+        // @oneOf is a webonyx built-in, so the registry shouldn't add it to the custom list.
+        $names = array_map(static fn (WebonyxDirective $d) => $d->name, $registry->webonyxDirectives());
+
+        $this->assertSame([], $names);
+        $this->assertFalse($registry->hasAny());
+    }
+
+    public function testOneOfDefinitionMarksItselfAsBuiltIn(): void
+    {
+        $definition = OneOf::definition();
+
+        $this->assertSame('oneOf', $definition->name);
+        $this->assertTrue($definition->builtIn);
+        $this->assertSame([DirectiveLocation::INPUT_OBJECT], $definition->locations);
+    }
+
+    public function testDiscoveryFindingTheBundledBuiltInClassIsIdempotent(): void
+    {
+        // If discovery finds our own built-in class (same FQCN as BUILT_IN_ATTRIBUTES), registering
+        // it twice shouldn't throw.
+        $registry = self::buildRegistry([OneOf::class]);
+        $registry->discover();
+
+        $this->assertNotNull($registry->definitionFor(OneOf::class));
+    }
+
+    public function testUserOverrideOfBuiltInWinsOverBundled(): void
+    {
+        // User binds their own class to @oneOf (builtIn: true); ours should defer to it.
+        $registry = self::buildRegistry([CustomOneOfOverride::class]);
+        $registry->discover();
+
+        $this->assertNotNull($registry->definitionFor(CustomOneOfOverride::class));
+        $this->assertNull($registry->definitionFor(OneOf::class));
+    }
+
+    /** @param list<class-string<TypeSystemDirective>> $classes */
+    private static function buildRegistry(array $classes): DirectiveRegistry
+    {
+        $finder = new DirectiveClassFinder(
+            new StaticClassFinder($classes),
+            new HardClassFinderComputedCache(new Psr16Cache(new ArrayAdapter())),
+        );
+
+        return new DirectiveRegistry($finder);
+    }
+}
diff --git a/tests/Directives/DirectiveDefinitionTest.php b/tests/Directives/DirectiveDefinitionTest.php
new file mode 100644
index 000000000..3fa2000f4
--- /dev/null
+++ b/tests/Directives/DirectiveDefinitionTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use PHPUnit\Framework\TestCase;
+
+final class DirectiveDefinitionTest extends TestCase
+{
+    public function testStoresProvidedFields(): void
+    {
+        $definition = new DirectiveDefinition(
+            name: 'audit',
+            locations: [DirectiveLocation::FIELD_DEFINITION, DirectiveLocation::INPUT_FIELD_DEFINITION],
+            description: 'Audit log marker',
+        );
+
+        $this->assertSame('audit', $definition->name);
+        $this->assertSame([DirectiveLocation::FIELD_DEFINITION, DirectiveLocation::INPUT_FIELD_DEFINITION], $definition->locations);
+        $this->assertSame('Audit log marker', $definition->description);
+    }
+
+    public function testDefaultsDescriptionToNull(): void
+    {
+        $definition = new DirectiveDefinition(
+            name: 'noop',
+            locations: [DirectiveLocation::OBJECT],
+        );
+
+        $this->assertNull($definition->description);
+    }
+}
diff --git a/tests/Directives/DirectiveLocationTest.php b/tests/Directives/DirectiveLocationTest.php
new file mode 100644
index 000000000..bccc7f239
--- /dev/null
+++ b/tests/Directives/DirectiveLocationTest.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use PHPUnit\Framework\TestCase;
+
+final class DirectiveLocationTest extends TestCase
+{
+    public function testEnumExposesAllNineteenSpecLocations(): void
+    {
+        $this->assertCount(19, DirectiveLocation::cases());
+    }
+
+    public function testBackingValuesMatchSpecStrings(): void
+    {
+        $this->assertSame('FIELD_DEFINITION', DirectiveLocation::FIELD_DEFINITION->value);
+        $this->assertSame('OBJECT', DirectiveLocation::OBJECT->value);
+        $this->assertSame('INPUT_OBJECT', DirectiveLocation::INPUT_OBJECT->value);
+        $this->assertSame('INPUT_FIELD_DEFINITION', DirectiveLocation::INPUT_FIELD_DEFINITION->value);
+    }
+
+    public function testIsExecutableClassifiesQueryDocumentLocations(): void
+    {
+        $this->assertTrue(DirectiveLocation::QUERY->isExecutable());
+        $this->assertTrue(DirectiveLocation::FIELD->isExecutable());
+        $this->assertTrue(DirectiveLocation::FRAGMENT_DEFINITION->isExecutable());
+        $this->assertTrue(DirectiveLocation::INLINE_FRAGMENT->isExecutable());
+        $this->assertTrue(DirectiveLocation::VARIABLE_DEFINITION->isExecutable());
+    }
+
+    public function testIsTypeSystemClassifiesSchemaLocations(): void
+    {
+        $this->assertTrue(DirectiveLocation::FIELD_DEFINITION->isTypeSystem());
+        $this->assertTrue(DirectiveLocation::OBJECT->isTypeSystem());
+        $this->assertTrue(DirectiveLocation::INPUT_OBJECT->isTypeSystem());
+        $this->assertTrue(DirectiveLocation::INPUT_FIELD_DEFINITION->isTypeSystem());
+        $this->assertTrue(DirectiveLocation::ENUM->isTypeSystem());
+        $this->assertTrue(DirectiveLocation::SCHEMA->isTypeSystem());
+    }
+
+    public function testIsExecutableAndIsTypeSystemArePartitions(): void
+    {
+        foreach (DirectiveLocation::cases() as $location) {
+            $this->assertNotSame($location->isExecutable(), $location->isTypeSystem(), "Location {$location->value} should be executable or type-system, not both.");
+        }
+    }
+}
diff --git a/tests/Directives/DirectiveRegistryTest.php b/tests/Directives/DirectiveRegistryTest.php
new file mode 100644
index 000000000..15c0cd0ff
--- /dev/null
+++ b/tests/Directives/DirectiveRegistryTest.php
@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Psr16Cache;
+use TheCodingMachine\GraphQLite\Directives\Discovery\DirectiveClassFinder;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\AuditFieldDirective;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\Invalid\ReservedNameDirective;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\VersionedInputObjectDirective;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\UppercaseFieldDirective;
+use TheCodingMachine\GraphQLite\Discovery\Cache\HardClassFinderComputedCache;
+use TheCodingMachine\GraphQLite\Discovery\StaticClassFinder;
+
+final class DirectiveRegistryTest extends TestCase
+{
+    public function testDiscoversAndRegistersValidDirectives(): void
+    {
+        $registry = self::buildRegistry([
+            UppercaseFieldDirective::class,
+            AuditFieldDirective::class,
+            VersionedInputObjectDirective::class,
+        ]);
+        $registry->discover();
+
+        $this->assertTrue($registry->hasAny());
+
+        $webonyx = $registry->webonyxDirectives();
+        $this->assertCount(3, $webonyx);
+
+        $byName = [];
+        foreach ($webonyx as $directive) {
+            $byName[$directive->name] = $directive;
+        }
+
+        $this->assertArrayHasKey('uppercase', $byName);
+        $this->assertArrayHasKey('audit', $byName);
+        $this->assertArrayHasKey('versioned', $byName);
+
+        $audit = $byName['audit'];
+        $this->assertTrue($audit->isRepeatable);
+        $this->assertSame('Marks a field as needing audit-log treatment.', $audit->description);
+        $this->assertCount(1, $audit->args);
+        $this->assertSame('reason', $audit->args[0]->name);
+    }
+
+    public function testRejectsCustomDirectiveUsingReservedName(): void
+    {
+        $registry = self::buildRegistry([ReservedNameDirective::class]);
+
+        $this->expectException(InvalidDirectiveException::class);
+        $this->expectExceptionMessageMatches('/reserved/');
+
+        $registry->discover();
+    }
+
+    public function testEmptyRegistryReportsNoDirectives(): void
+    {
+        $registry = self::buildRegistry([]);
+        $registry->discover();
+
+        $this->assertFalse($registry->hasAny());
+        $this->assertSame([], $registry->webonyxDirectives());
+    }
+
+    public function testWebonyxDirectivesIsolatedFromBuiltins(): void
+    {
+        // The built directives shouldn't include webonyx's built-ins; those get merged in at the
+        // Schema layer, not here.
+        $registry = self::buildRegistry([UppercaseFieldDirective::class]);
+        $registry->discover();
+
+        $names = array_map(static fn (WebonyxDirective $d) => $d->name, $registry->webonyxDirectives());
+        $this->assertNotContains('skip', $names);
+        $this->assertNotContains('include', $names);
+        $this->assertNotContains('deprecated', $names);
+        $this->assertNotContains('oneOf', $names);
+    }
+
+    /** @param list<class-string<TypeSystemDirective>> $classes */
+    private static function buildRegistry(array $classes): DirectiveRegistry
+    {
+        $finder = new DirectiveClassFinder(
+            new StaticClassFinder($classes),
+            new HardClassFinderComputedCache(new Psr16Cache(new ArrayAdapter())),
+        );
+
+        return new DirectiveRegistry($finder);
+    }
+}
diff --git a/tests/Directives/DirectiveResolverTest.php b/tests/Directives/DirectiveResolverTest.php
new file mode 100644
index 000000000..ca380ddc3
--- /dev/null
+++ b/tests/Directives/DirectiveResolverTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+use GraphQL\Type\Definition\NonNull;
+use GraphQL\Type\Definition\StringType;
+use PHPUnit\Framework\TestCase;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\AuditFieldDirective;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\Invalid\UnsupportedArgumentTypeDirective;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\UppercaseFieldDirective;
+
+final class DirectiveResolverTest extends TestCase
+{
+    public function testResolvesNoArgsToEmptyList(): void
+    {
+        $resolved = DirectiveResolver::resolve(UppercaseFieldDirective::class, UppercaseFieldDirective::definition());
+
+        $this->assertSame([], $resolved->arguments);
+    }
+
+    public function testResolvesScalarArgumentWithCorrectTypeAndNullability(): void
+    {
+        $resolved = DirectiveResolver::resolve(AuditFieldDirective::class, AuditFieldDirective::definition());
+
+        $this->assertCount(1, $resolved->arguments);
+        $this->assertSame('reason', $resolved->arguments[0]->name);
+        $this->assertInstanceOf(NonNull::class, $resolved->arguments[0]->type);
+        $this->assertInstanceOf(StringType::class, $resolved->arguments[0]->type->getWrappedType());
+        $this->assertFalse($resolved->arguments[0]->hasDefaultValue);
+    }
+
+    public function testInfersRepeatableFromAttributeFlags(): void
+    {
+        $audit = DirectiveResolver::resolve(AuditFieldDirective::class, AuditFieldDirective::definition())->webonyxDirective;
+        $uppercase = DirectiveResolver::resolve(UppercaseFieldDirective::class, UppercaseFieldDirective::definition())->webonyxDirective;
+
+        $this->assertInstanceOf(WebonyxDirective::class, $audit);
+        $this->assertTrue($audit->isRepeatable);
+
+        $this->assertInstanceOf(WebonyxDirective::class, $uppercase);
+        $this->assertFalse($uppercase->isRepeatable);
+    }
+
+    public function testRejectsUnsupportedArgumentType(): void
+    {
+        $this->expectException(InvalidDirectiveException::class);
+        $this->expectExceptionMessageMatches('/scalar types/');
+
+        DirectiveResolver::resolve(UnsupportedArgumentTypeDirective::class, UnsupportedArgumentTypeDirective::definition());
+    }
+}
diff --git a/tests/Directives/DirectiveValidatorTest.php b/tests/Directives/DirectiveValidatorTest.php
new file mode 100644
index 000000000..e28b6b1ce
--- /dev/null
+++ b/tests/Directives/DirectiveValidatorTest.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use PHPUnit\Framework\TestCase;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\Invalid\InterfaceWithoutLocationDirective;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\Invalid\MissingPhpTargetDirective;
+
+final class DirectiveValidatorTest extends TestCase
+{
+    public function testRejectsDirectiveMissingRequiredPhpTarget(): void
+    {
+        $this->expectException(InvalidDirectiveException::class);
+        $this->expectExceptionMessageMatches('/TARGET_METHOD/');
+
+        DirectiveValidator::validate(MissingPhpTargetDirective::class, MissingPhpTargetDirective::definition());
+    }
+
+    public function testRejectsInterfaceWithoutMatchingLocation(): void
+    {
+        $this->expectException(InvalidDirectiveException::class);
+        $this->expectExceptionMessageMatches('/FieldDirective/');
+
+        DirectiveValidator::validate(InterfaceWithoutLocationDirective::class, InterfaceWithoutLocationDirective::definition());
+    }
+}
diff --git a/tests/Fixtures/Directives/AuditFieldDirective.php b/tests/Fixtures/Directives/AuditFieldDirective.php
new file mode 100644
index 000000000..c2b894cd6
--- /dev/null
+++ b/tests/Fixtures/Directives/AuditFieldDirective.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\FieldDirective;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
+final class AuditFieldDirective implements FieldDirective
+{
+    public function __construct(public readonly string $reason)
+    {
+    }
+
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'audit',
+            locations: [DirectiveLocation::FIELD_DEFINITION],
+            description: 'Marks a field as needing audit-log treatment.',
+        );
+    }
+}
diff --git a/tests/Fixtures/Directives/CustomOneOfOverride.php b/tests/Fixtures/Directives/CustomOneOfOverride.php
new file mode 100644
index 000000000..3cbece707
--- /dev/null
+++ b/tests/Fixtures/Directives/CustomOneOfOverride.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\BehavioralInputObjectTypeDirective;
+use TheCodingMachine\GraphQLite\InputObjectTypeDescriptor;
+use TheCodingMachine\GraphQLite\Middlewares\InputObjectTypeHandlerInterface;
+use TheCodingMachine\GraphQLite\Types\MutableInputObjectType;
+
+/**
+ * Stands in for a user-supplied replacement of the bundled `OneOf`. Same `@oneOf` name, marked
+ * `builtIn: true`, so the registry uses it instead of ours.
+ */
+#[Attribute(Attribute::TARGET_CLASS)]
+final class CustomOneOfOverride implements BehavioralInputObjectTypeDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'oneOf',
+            locations: [DirectiveLocation::INPUT_OBJECT],
+            builtIn: true,
+        );
+    }
+
+    public function applyToInputObjectType(InputObjectTypeDescriptor $descriptor, InputObjectTypeHandlerInterface $next): MutableInputObjectType
+    {
+        $type = $next->handle($descriptor);
+        $type->isOneOf = true;
+        return $type;
+    }
+}
diff --git a/tests/Fixtures/Directives/Invalid/InterfaceWithoutLocationDirective.php b/tests/Fixtures/Directives/Invalid/InterfaceWithoutLocationDirective.php
new file mode 100644
index 000000000..0eb38163c
--- /dev/null
+++ b/tests/Fixtures/Directives/Invalid/InterfaceWithoutLocationDirective.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives\Invalid;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\FieldDirective;
+
+/**
+ * Implements FieldDirective but declares no FIELD_DEFINITION location, so the validator's
+ * interface/location check rejects it. Empty locations keeps the PHP-target check from firing first.
+ */
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY)]
+final class InterfaceWithoutLocationDirective implements FieldDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'noLocation',
+            locations: [],
+        );
+    }
+}
diff --git a/tests/Fixtures/Directives/Invalid/MissingPhpTargetDirective.php b/tests/Fixtures/Directives/Invalid/MissingPhpTargetDirective.php
new file mode 100644
index 000000000..85eb29a78
--- /dev/null
+++ b/tests/Fixtures/Directives/Invalid/MissingPhpTargetDirective.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives\Invalid;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\FieldDirective;
+
+/**
+ * Declares FIELD_DEFINITION but the PHP target is TARGET_CLASS only, so the validator rejects it:
+ * the PHP target has to cover the GraphQL locations.
+ */
+#[Attribute(Attribute::TARGET_CLASS)]
+final class MissingPhpTargetDirective implements FieldDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'badTarget',
+            locations: [DirectiveLocation::FIELD_DEFINITION],
+        );
+    }
+}
diff --git a/tests/Fixtures/Directives/Invalid/ReservedNameDirective.php b/tests/Fixtures/Directives/Invalid/ReservedNameDirective.php
new file mode 100644
index 000000000..2c587ba70
--- /dev/null
+++ b/tests/Fixtures/Directives/Invalid/ReservedNameDirective.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives\Invalid;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\InputObjectTypeDirective;
+
+/**
+ * Reuses webonyx's built-in `@oneOf` name, so the registry's reserved-name check rejects it.
+ */
+#[Attribute(Attribute::TARGET_CLASS)]
+final class ReservedNameDirective implements InputObjectTypeDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'oneOf',
+            locations: [DirectiveLocation::INPUT_OBJECT],
+        );
+    }
+}
diff --git a/tests/Fixtures/Directives/Invalid/UnsupportedArgumentTypeDirective.php b/tests/Fixtures/Directives/Invalid/UnsupportedArgumentTypeDirective.php
new file mode 100644
index 000000000..0e319974e
--- /dev/null
+++ b/tests/Fixtures/Directives/Invalid/UnsupportedArgumentTypeDirective.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives\Invalid;
+
+use Attribute;
+use stdClass;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\FieldDirective;
+
+/**
+ * Constructor parameter is a non-scalar object, which the validator rejects (args must map to a
+ * scalar).
+ */
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY)]
+final class UnsupportedArgumentTypeDirective implements FieldDirective
+{
+    public function __construct(public readonly stdClass $thing)
+    {
+    }
+
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'unsupportedArg',
+            locations: [DirectiveLocation::FIELD_DEFINITION],
+        );
+    }
+}
diff --git a/tests/Fixtures/Directives/TaggedObjectTypeDirective.php b/tests/Fixtures/Directives/TaggedObjectTypeDirective.php
new file mode 100644
index 000000000..b70ff2d93
--- /dev/null
+++ b/tests/Fixtures/Directives/TaggedObjectTypeDirective.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\ObjectTypeDirective;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+final class TaggedObjectTypeDirective implements ObjectTypeDirective
+{
+    public function __construct(public readonly string $tag)
+    {
+    }
+
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'tagged',
+            locations: [DirectiveLocation::OBJECT],
+        );
+    }
+}
diff --git a/tests/Fixtures/Directives/TrimInputFieldDirective.php b/tests/Fixtures/Directives/TrimInputFieldDirective.php
new file mode 100644
index 000000000..4b9438d7a
--- /dev/null
+++ b/tests/Fixtures/Directives/TrimInputFieldDirective.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\InputFieldDirective;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final class TrimInputFieldDirective implements InputFieldDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'trim',
+            locations: [DirectiveLocation::INPUT_FIELD_DEFINITION],
+        );
+    }
+}
diff --git a/tests/Fixtures/Directives/UppercaseFieldDirective.php b/tests/Fixtures/Directives/UppercaseFieldDirective.php
new file mode 100644
index 000000000..5d9313f93
--- /dev/null
+++ b/tests/Fixtures/Directives/UppercaseFieldDirective.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives;
+
+use Attribute;
+use GraphQL\Type\Definition\FieldDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\BehavioralFieldDirective;
+use TheCodingMachine\GraphQLite\Middlewares\FieldHandlerInterface;
+use TheCodingMachine\GraphQLite\QueryFieldDescriptor;
+
+use function is_string;
+use function strtoupper;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY)]
+final class UppercaseFieldDirective implements BehavioralFieldDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'uppercase',
+            locations: [DirectiveLocation::FIELD_DEFINITION],
+        );
+    }
+
+    public function applyToField(QueryFieldDescriptor $descriptor, FieldHandlerInterface $next): FieldDefinition|null
+    {
+        $resolver = $descriptor->getResolver();
+        $descriptor = $descriptor->withResolver(static function (...$args) use ($resolver): mixed {
+            $value = $resolver(...$args);
+            return is_string($value) ? strtoupper($value) : $value;
+        });
+
+        return $next->handle($descriptor);
+    }
+}
diff --git a/tests/Fixtures/Directives/VersionedInputObjectDirective.php b/tests/Fixtures/Directives/VersionedInputObjectDirective.php
new file mode 100644
index 000000000..35c2b3e4b
--- /dev/null
+++ b/tests/Fixtures/Directives/VersionedInputObjectDirective.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\InputObjectTypeDirective;
+
+/**
+ * A custom input-object directive with a constructor argument. Metadata only (no apply method),
+ * used to exercise the `INPUT_OBJECT` path: definition, argument encoding, and SDL output.
+ */
+#[Attribute(Attribute::TARGET_CLASS)]
+final class VersionedInputObjectDirective implements InputObjectTypeDirective
+{
+    public function __construct(public readonly int $version)
+    {
+    }
+
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'versioned',
+            locations: [DirectiveLocation::INPUT_OBJECT],
+        );
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Controllers/WidgetController.php b/tests/Fixtures/DirectivesIntegration/Controllers/WidgetController.php
new file mode 100644
index 000000000..93b7aad75
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Controllers/WidgetController.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Controllers;
+
+use TheCodingMachine\GraphQLite\Annotations\Query;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives\UppercaseDirective;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Inputs\OneOfLookup;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Inputs\WidgetLookup;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Models\Widget;
+
+final class WidgetController
+{
+    #[Query]
+    #[UppercaseDirective]
+    public function tagline(): string
+    {
+        return 'hello world';
+    }
+
+    #[Query]
+    public function findWidget(WidgetLookup $lookup): Widget
+    {
+        return new Widget($lookup->sku ?? ('id-' . ($lookup->id ?? 0)));
+    }
+
+    #[Query]
+    public function findOneOf(OneOfLookup $lookup): Widget
+    {
+        return new Widget($lookup->sku ?? ('id-' . ($lookup->id ?? 0)));
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Directives/AuditDirective.php b/tests/Fixtures/DirectivesIntegration/Directives/AuditDirective.php
new file mode 100644
index 000000000..7104860cc
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Directives/AuditDirective.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\FieldDirective;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
+final class AuditDirective implements FieldDirective
+{
+    public function __construct(public readonly string $reason)
+    {
+    }
+
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'audit',
+            locations: [DirectiveLocation::FIELD_DEFINITION],
+            description: 'Marks a field for audit-log tracking.',
+        );
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Directives/SanitizedDirective.php b/tests/Fixtures/DirectivesIntegration/Directives/SanitizedDirective.php
new file mode 100644
index 000000000..17d8a4073
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Directives/SanitizedDirective.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\InputFieldDirective;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final class SanitizedDirective implements InputFieldDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'sanitized',
+            locations: [DirectiveLocation::INPUT_FIELD_DEFINITION],
+        );
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Directives/TaggedDirective.php b/tests/Fixtures/DirectivesIntegration/Directives/TaggedDirective.php
new file mode 100644
index 000000000..e95ae2344
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Directives/TaggedDirective.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\ObjectTypeDirective;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+final class TaggedDirective implements ObjectTypeDirective
+{
+    public function __construct(public readonly string $name)
+    {
+    }
+
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'tagged',
+            locations: [DirectiveLocation::OBJECT],
+        );
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Directives/UppercaseDirective.php b/tests/Fixtures/DirectivesIntegration/Directives/UppercaseDirective.php
new file mode 100644
index 000000000..89c62dfee
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Directives/UppercaseDirective.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives;
+
+use Attribute;
+use GraphQL\Type\Definition\FieldDefinition;
+use TheCodingMachine\GraphQLite\Directives\BehavioralFieldDirective;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Middlewares\FieldHandlerInterface;
+use TheCodingMachine\GraphQLite\QueryFieldDescriptor;
+
+use function is_string;
+use function strtoupper;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY)]
+final class UppercaseDirective implements BehavioralFieldDirective
+{
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'uppercase',
+            locations: [DirectiveLocation::FIELD_DEFINITION],
+        );
+    }
+
+    public function applyToField(QueryFieldDescriptor $descriptor, FieldHandlerInterface $next): FieldDefinition|null
+    {
+        $resolver = $descriptor->getResolver();
+        $descriptor = $descriptor->withResolver(static function (...$args) use ($resolver): mixed {
+            $value = $resolver(...$args);
+            return is_string($value) ? strtoupper($value) : $value;
+        });
+
+        return $next->handle($descriptor);
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Directives/VersionedDirective.php b/tests/Fixtures/DirectivesIntegration/Directives/VersionedDirective.php
new file mode 100644
index 000000000..d6ba8affe
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Directives/VersionedDirective.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives;
+
+use Attribute;
+use TheCodingMachine\GraphQLite\Directives\DirectiveDefinition;
+use TheCodingMachine\GraphQLite\Directives\DirectiveLocation;
+use TheCodingMachine\GraphQLite\Directives\InputObjectTypeDirective;
+
+/**
+ * Marks an input object with a schema version. A custom input-object directive used in the
+ * integration test to check the custom path runs alongside the bundled `#[OneOf]`.
+ */
+#[Attribute(Attribute::TARGET_CLASS)]
+final class VersionedDirective implements InputObjectTypeDirective
+{
+    public function __construct(public readonly int $version)
+    {
+    }
+
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: 'versioned',
+            locations: [DirectiveLocation::INPUT_OBJECT],
+            description: 'Marks an input with a schema version for backwards-compat tracking.',
+        );
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Inputs/OneOfLookup.php b/tests/Fixtures/DirectivesIntegration/Inputs/OneOfLookup.php
new file mode 100644
index 000000000..ad6b39986
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Inputs/OneOfLookup.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Inputs;
+
+use TheCodingMachine\GraphQLite\Annotations\Field;
+use TheCodingMachine\GraphQLite\Annotations\Input;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\OneOf;
+
+/**
+ * Uses the built-in `@oneOf` directive, which sets webonyx's `isOneOf` flag so callers pass either
+ * `sku` or `id`, not both.
+ */
+#[Input]
+#[OneOf]
+final class OneOfLookup
+{
+    public function __construct(
+        #[Field]
+        public string|null $sku = null,
+        #[Field]
+        public int|null $id = null,
+    ) {
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Inputs/WidgetLookup.php b/tests/Fixtures/DirectivesIntegration/Inputs/WidgetLookup.php
new file mode 100644
index 000000000..671fbf54b
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Inputs/WidgetLookup.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Inputs;
+
+use TheCodingMachine\GraphQLite\Annotations\Field;
+use TheCodingMachine\GraphQLite\Annotations\Input;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives\SanitizedDirective;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives\VersionedDirective;
+
+#[Input]
+#[VersionedDirective(version: 2)]
+final class WidgetLookup
+{
+    public function __construct(
+        #[Field]
+        #[SanitizedDirective]
+        public string|null $sku = null,
+        #[Field]
+        public int|null $id = null,
+    ) {
+    }
+}
diff --git a/tests/Fixtures/DirectivesIntegration/Models/Widget.php b/tests/Fixtures/DirectivesIntegration/Models/Widget.php
new file mode 100644
index 000000000..feefe6992
--- /dev/null
+++ b/tests/Fixtures/DirectivesIntegration/Models/Widget.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Models;
+
+use TheCodingMachine\GraphQLite\Annotations\Field;
+use TheCodingMachine\GraphQLite\Annotations\Type;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives\AuditDirective;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives\TaggedDirective;
+use TheCodingMachine\GraphQLite\Fixtures\DirectivesIntegration\Directives\UppercaseDirective;
+
+#[Type]
+#[TaggedDirective(name: 'primary')]
+final class Widget
+{
+    public function __construct(public string $label)
+    {
+    }
+
+    #[Field]
+    #[UppercaseDirective]
+    #[AuditDirective(reason: 'pii')]
+    #[AuditDirective(reason: 'compliance')]
+    public function getLabel(): string
+    {
+        return $this->label;
+    }
+}
diff --git a/tests/Integration/DirectivesEndToEndTest.php b/tests/Integration/DirectivesEndToEndTest.php
new file mode 100644
index 000000000..765bd87ee
--- /dev/null
+++ b/tests/Integration/DirectivesEndToEndTest.php
@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Integration;
+
+use GraphQL\GraphQL;
+use GraphQL\Type\Introspection;
+use GraphQL\Utils\SchemaPrinter;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Psr16Cache;
+use TheCodingMachine\GraphQLite\Containers\BasicAutoWiringContainer;
+use TheCodingMachine\GraphQLite\Containers\EmptyContainer;
+use TheCodingMachine\GraphQLite\Schema;
+use TheCodingMachine\GraphQLite\SchemaFactory;
+
+use function assert;
+use function is_array;
+
+/**
+ * End-to-end test for custom directives. Builds a schema from the
+ * `tests/Fixtures/DirectivesIntegration` namespaces and checks that directive definitions show up
+ * in SDL and introspection, and that behavioral directives wrap their resolver at runtime.
+ *
+ * We don't assert directive applications in SDL (e.g. `tagline: String! @uppercase`): webonyx's
+ * SchemaPrinter doesn't render those, and we follow its behavior. The applications are still on each
+ * element's `astNode->directives` for anyone who wants to print them with their own printer.
+ */
+final class DirectivesEndToEndTest extends TestCase
+{
+    private function buildSchema(): Schema
+    {
+        $cache = new Psr16Cache(new ArrayAdapter());
+        $factory = new SchemaFactory($cache, new BasicAutoWiringContainer(new EmptyContainer()));
+        $factory->prodMode();
+        $factory->addNamespace('TheCodingMachine\\GraphQLite\\Fixtures\\DirectivesIntegration');
+
+        return $factory->createSchema();
+    }
+
+    public function testSchemaPrintsDirectiveDefinitions(): void
+    {
+        $schema = $this->buildSchema();
+        $sdl = SchemaPrinter::doPrint($schema);
+
+        // Definitions: the webonyx printer emits these once the directives are registered on the
+        // schema (see SchemaFactory's wiring of DirectiveRegistry::webonyxDirectives()).
+        $this->assertStringContainsString('directive @uppercase on FIELD_DEFINITION', $sdl);
+        $this->assertStringContainsString('Marks a field for audit-log tracking.', $sdl);
+        $this->assertStringContainsString('directive @audit(reason: String!) repeatable on FIELD_DEFINITION', $sdl);
+        $this->assertStringContainsString('directive @tagged(name: String!) on OBJECT', $sdl);
+        $this->assertStringContainsString('directive @sanitized on INPUT_FIELD_DEFINITION', $sdl);
+        $this->assertStringContainsString('Marks an input with a schema version for backwards-compat tracking.', $sdl);
+        $this->assertStringContainsString('directive @versioned(version: Int!) on INPUT_OBJECT', $sdl);
+
+        // No assertions on directive applications here; webonyx's SchemaPrinter doesn't render them.
+        // See the class docblock.
+
+        // @oneOf is webonyx's built-in: it prints the application from the isOneOf flag, and we
+        // don't re-declare it in the custom list.
+        $this->assertStringNotContainsString('directive @oneOf ', $sdl);
+        $this->assertStringContainsString('input OneOfLookupInput @oneOf', $sdl);
+    }
+
+    public function testIntrospectionExposesEveryDirective(): void
+    {
+        $schema = $this->buildSchema();
+
+        $result = GraphQL::executeQuery($schema, Introspection::getIntrospectionQuery())->toArray();
+        $this->assertArrayNotHasKey('errors', $result);
+
+        $directives = $result['data']['__schema']['directives'];
+        assert(is_array($directives));
+
+        $names = [];
+        foreach ($directives as $directive) {
+            $names[] = $directive['name'];
+        }
+
+        // Built-ins remain present alongside custom directives.
+        $this->assertContains('skip', $names);
+        $this->assertContains('include', $names);
+        $this->assertContains('deprecated', $names);
+
+        // Custom directives present.
+        $this->assertContains('uppercase', $names);
+        $this->assertContains('audit', $names);
+        $this->assertContains('tagged', $names);
+        $this->assertContains('versioned', $names);
+        $this->assertContains('sanitized', $names);
+    }
+
+    public function testFieldDirectiveWrapsResolver(): void
+    {
+        $schema = $this->buildSchema();
+
+        $result = GraphQL::executeQuery($schema, '{ tagline }')->toArray();
+        $this->assertArrayNotHasKey('errors', $result);
+        $this->assertSame('HELLO WORLD', $result['data']['tagline']);
+    }
+
+    public function testInputObjectFieldsResolveWithDirectiveAttached(): void
+    {
+        $schema = $this->buildSchema();
+
+        $result = GraphQL::executeQuery(
+            $schema,
+            '{ findWidget(lookup: { sku: "abc" }) { label } }',
+        )->toArray();
+
+        $this->assertArrayNotHasKey('errors', $result);
+        // getLabel() carries @uppercase, so "abc" comes back uppercased.
+        $this->assertSame('ABC', $result['data']['findWidget']['label']);
+    }
+}