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/Deprecated.php b/src/Directives/BuiltIn/Deprecated.php
new file mode 100644
index 000000000..524bf9286
--- /dev/null
+++ b/src/Directives/BuiltIn/Deprecated.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives\BuiltIn;
+
+use Attribute;
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+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;
+
+/**
+ * Binds `#[Deprecated]` to GraphQL's built-in `deprecated` directive. Putting it on a query,
+ * mutation, or field method/property sets the field's deprecation reason, which webonyx prints in
+ * the SDL as `deprecated(reason: ...)`.
+ *
+ * webonyx already declares the `deprecated` directive, so we don't register our own definition
+ * ({@see DirectiveDefinition::$builtIn} is `true`). The existing docblock deprecation support is
+ * untouched: a bare `#[Deprecated]` keeps the docblock reason when there is one, and passing
+ * `reason:` overrides it.
+ */
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY)]
+final class Deprecated implements BehavioralFieldDirective
+{
+    public function __construct(public readonly string|null $reason = null)
+    {
+    }
+
+    public static function definition(): DirectiveDefinition
+    {
+        return new DirectiveDefinition(
+            name: WebonyxDirective::DEPRECATED_NAME,
+            locations: [DirectiveLocation::FIELD_DEFINITION],
+            builtIn: true,
+        );
+    }
+
+    public function applyToField(QueryFieldDescriptor $descriptor, FieldHandlerInterface $next): FieldDefinition|null
+    {
+        // An explicit reason wins; a bare #[Deprecated] keeps an existing docblock deprecation
+        // reason, falling back to webonyx's default when there's neither.
+        $reason = $this->reason ?? $descriptor->getDeprecationReason() ?? WebonyxDirective::DEFAULT_DEPRECATION_REASON;
+
+        return $next->handle($descriptor->withDeprecationReason($reason));
+    }
+}
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..c4718a47e
--- /dev/null
+++ b/src/Directives/DirectiveRegistry.php
@@ -0,0 +1,133 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use GraphQL\Type\Definition\Directive as WebonyxDirective;
+use ReflectionClass;
+use TheCodingMachine\GraphQLite\AnnotationReader;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\Deprecated;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\OneOf;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+
+/**
+ * Holds the directives known to a schema. In this layer that's the built-ins that bind PHP behavior
+ * to directives webonyx already declares (`@oneOf`, `@deprecated`); a later layer adds user-defined
+ * directives on top.
+ *
+ * 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 = [];
+
+    /** Attribute classes that bind PHP behavior to webonyx's built-in directives. */
+    private const BUILT_IN_ATTRIBUTES = [
+        OneOf::class,
+        Deprecated::class,
+    ];
+
+    public function __construct(
+        private readonly AnnotationReader $annotationReader,
+    ) {
+    }
+
+    /** Resolve the built-in directives once. Idempotent. */
+    public function discover(): void
+    {
+        foreach (self::BUILT_IN_ATTRIBUTES as $directiveClass) {
+            /** @var class-string<TypeSystemDirective> $directiveClass */
+            if (isset($this->resolvedByClass[$directiveClass])) {
+                continue;
+            }
+
+            $this->resolvedByClass[$directiveClass] = DirectiveResolver::resolve($directiveClass, $directiveClass::definition());
+        }
+    }
+
+    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;
+    }
+
+    /**
+     * The object-type directives applied to a class, after checking each is allowed at the OBJECT
+     * location — e.g. rejecting `#[OneOf]` (an INPUT_OBJECT directive) on a `#[Type]`.
+     *
+     * @param ReflectionClass<object> $refClass
+     *
+     * @return list<ObjectTypeDirective>
+     *
+     * @throws InvalidDirectiveException
+     */
+    public function objectTypeDirectives(ReflectionClass $refClass): array
+    {
+        DirectiveValidator::assertDirectivesUsableAt($refClass, DirectiveLocation::OBJECT);
+
+        return $this->annotationReader->getObjectTypeDirectives($refClass);
+    }
+
+    /**
+     * The input-object directives applied to a class, after checking each is allowed at the
+     * INPUT_OBJECT location.
+     *
+     * @param ReflectionClass<object> $refClass
+     *
+     * @return list<InputObjectTypeDirective>
+     *
+     * @throws InvalidDirectiveException
+     */
+    public function inputObjectTypeDirectives(ReflectionClass $refClass): array
+    {
+        DirectiveValidator::assertDirectivesUsableAt($refClass, DirectiveLocation::INPUT_OBJECT);
+
+        return $this->annotationReader->getInputObjectTypeDirectives($refClass);
+    }
+}
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..bf3d700ef
--- /dev/null
+++ b/src/Directives/DirectiveValidator.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use ReflectionClass;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+
+use function in_array;
+use function is_a;
+
+/**
+ * Validates that directives are applied where they're allowed. PHP's `#[Attribute]` targets can't
+ * tell a `#[Type]` class from an `#[Input]` class (both are `TARGET_CLASS`), so a class-level
+ * directive like `#[OneOf]` could be placed on the wrong kind of class. This reports that instead
+ * of letting the interface-based collectors drop the misplaced directive silently.
+ *
+ * @internal
+ */
+final class DirectiveValidator
+{
+    /**
+     * @param ReflectionClass<object> $refClass
+     *
+     * @throws InvalidDirectiveException when a directive on $refClass isn't allowed at $location.
+     */
+    public static function assertDirectivesUsableAt(ReflectionClass $refClass, DirectiveLocation $location): void
+    {
+        foreach ($refClass->getAttributes() as $attribute) {
+            $directiveClass = $attribute->getName();
+            if (! is_a($directiveClass, TypeSystemDirective::class, true)) {
+                continue;
+            }
+
+            $locations = $directiveClass::definition()->locations;
+            if (in_array($location, $locations, true)) {
+                continue;
+            }
+
+            throw InvalidDirectiveException::notUsableAtLocation($directiveClass, $location, $locations);
+        }
+    }
+}
diff --git a/src/Directives/Exceptions/InvalidDirectiveException.php b/src/Directives/Exceptions/InvalidDirectiveException.php
new file mode 100644
index 000000000..e032900b3
--- /dev/null
+++ b/src/Directives/Exceptions/InvalidDirectiveException.php
@@ -0,0 +1,119 @@
+<?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, or when a directive is
+ * applied somewhere it isn't allowed — e.g. a bad PHP target, an unsupported argument type, a name
+ * clash, or `#[OneOf]` on a `#[Type]`.
+ */
+final class InvalidDirectiveException extends GraphQLRuntimeException
+{
+    /**
+     * A directive was applied at a location it doesn't declare — e.g. `#[OneOf]` on a `#[Type]`.
+     *
+     * @param list<DirectiveLocation> $declaredLocations
+     */
+    public static function notUsableAtLocation(string $directiveClass, DirectiveLocation $attempted, array $declaredLocations): self
+    {
+        $declared = implode(', ', array_map(static fn (DirectiveLocation $location) => $location->value, $declaredLocations));
+
+        return new self(sprintf(
+            'Directive "%s" cannot be used on %s; it is declared for %s.',
+            $directiveClass,
+            $attempted->value,
+            $declared === '' ? 'no locations' : $declared,
+        ));
+    }
+
+    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..672423fc0 100644
--- a/src/InputTypeGenerator.php
+++ b/src/InputTypeGenerator.php
@@ -6,11 +6,16 @@
 
 use GraphQL\Type\Definition\InputObjectType;
 use Psr\Container\ContainerInterface;
+use ReflectionClass;
 use ReflectionFunctionAbstract;
 use ReflectionMethod;
+use TheCodingMachine\GraphQLite\Directives\DirectiveRegistry;
+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 +41,8 @@ public function __construct(
         private AnnotationReader|null $annotationReader = null,
         private DocBlockFactory|null $docBlockFactory = null,
         private DescriptionResolver $descriptionResolver = new DescriptionResolver(true),
+        private InputObjectTypeMiddlewareInterface|null $inputObjectTypeMiddleware = null,
+        private DirectiveRegistry|null $directiveRegistry = null,
     ) {
     }
 
@@ -52,7 +59,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 +67,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 +109,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 +117,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->directiveRegistry === null) {
+            return $type;
+        }
+
+        $directives = $this->directiveRegistry->inputObjectTypeDirectives($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..852b696cf 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,13 +19,19 @@
  */
 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,
+        QueryProviderInterface       $queryProvider,
         RecursiveTypeMapperInterface $recursiveTypeMapper,
-        TypeResolver $typeResolver,
-        RootTypeMapperInterface $rootTypeMapper,
-        SchemaConfig|null $config = null,
-    ) {
+        TypeResolver                 $typeResolver,
+        RootTypeMapperInterface      $rootTypeMapper,
+        SchemaConfig|null            $config = null,
+        array                        $directives = [],
+    )
+    {
         if ($config === null) {
             $config = SchemaConfig::create();
         }
@@ -113,6 +120,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..afd261b02 100644
--- a/src/SchemaFactory.php
+++ b/src/SchemaFactory.php
@@ -18,6 +18,8 @@
 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\Discovery\Cache\HardClassFinderComputedCache;
 use TheCodingMachine\GraphQLite\Discovery\Cache\SnapshotClassFinderComputedCache;
 use TheCodingMachine\GraphQLite\Discovery\ClassFinder;
@@ -50,10 +52,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 +408,11 @@ public function createSchema(): Schema
         $expressionLanguage = $this->expressionLanguage ?: new ExpressionLanguage($symfonyCache);
         $expressionLanguage->registerProvider(new SecurityExpressionLanguageProvider());
 
+        $directiveRegistry = new DirectiveRegistry($annotationReader);
+        $directiveRegistry->discover();
+
+        $directiveAstBuilder = new DirectiveAstBuilder($directiveRegistry);
+
         $fieldMiddlewarePipe = new FieldMiddlewarePipe();
         foreach ($this->fieldMiddlewares as $fieldMiddleware) {
             $fieldMiddlewarePipe->pipe($fieldMiddleware);
@@ -408,6 +421,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 +430,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 +502,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, $directiveRegistry);
         $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, $directiveRegistry);
 
         if ($this->namespaces) {
             $compositeTypeMapper->addTypeMapper(new ClassFinderTypeMapper(
@@ -558,7 +579,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..a0054be2a 100644
--- a/src/TypeGenerator.php
+++ b/src/TypeGenerator.php
@@ -10,7 +10,10 @@
 use TheCodingMachine\GraphQLite\Annotations\Exceptions\DuplicateDescriptionOnTypeException;
 use TheCodingMachine\GraphQLite\Annotations\ExtendType;
 use TheCodingMachine\GraphQLite\Annotations\Type as TypeAnnotation;
+use TheCodingMachine\GraphQLite\Directives\DirectiveRegistry;
 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 +52,8 @@ public function __construct(
         private FieldsBuilder $fieldsBuilder,
         private DocBlockFactory|null $docBlockFactory = null,
         private DescriptionResolver $descriptionResolver = new DescriptionResolver(true),
+        private ObjectTypeMiddlewareInterface|null $objectTypeMiddleware = null,
+        private DirectiveRegistry|null $directiveRegistry = null,
     )
     {
     }
@@ -125,6 +130,22 @@ public function mapAnnotatedObject(string $annotatedObjectClassName): MutableInt
             $type->description = $resolvedDescription;
         }
 
+        if ($type instanceof MutableObjectType && $this->objectTypeMiddleware !== null && $this->directiveRegistry !== null) {
+            $directives = $this->directiveRegistry->objectTypeDirectives($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/DirectiveRegistryTest.php b/tests/Directives/DirectiveRegistryTest.php
new file mode 100644
index 000000000..e39bb8711
--- /dev/null
+++ b/tests/Directives/DirectiveRegistryTest.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use TheCodingMachine\GraphQLite\AnnotationReader;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\Deprecated;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\OneOf;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\MisusedOneOfOnType;
+
+final class DirectiveRegistryTest extends TestCase
+{
+    private function registry(): DirectiveRegistry
+    {
+        $registry = new DirectiveRegistry(new AnnotationReader());
+        $registry->discover();
+
+        return $registry;
+    }
+
+    public function testRegistersTheBuiltInDirectives(): void
+    {
+        $registry = $this->registry();
+
+        $this->assertNotNull($registry->definitionFor(OneOf::class));
+        $this->assertNotNull($registry->definitionFor(Deprecated::class));
+    }
+
+    public function testBuiltInsAreNotAddedToTheSchemaDirectiveList(): void
+    {
+        // webonyx already declares @oneOf and @deprecated, so the registry contributes nothing to
+        // SchemaConfig::$directives.
+        $registry = $this->registry();
+
+        $this->assertSame([], $registry->webonyxDirectives());
+        $this->assertFalse($registry->hasAny());
+    }
+
+    public function testResolvesBuiltInArguments(): void
+    {
+        $arguments = $this->registry()->argumentsFor(Deprecated::class);
+
+        $this->assertCount(1, $arguments);
+        $this->assertSame('reason', $arguments[0]->name);
+    }
+
+    public function testDiscoverIsIdempotent(): void
+    {
+        $registry = new DirectiveRegistry(new AnnotationReader());
+        $registry->discover();
+        $registry->discover();
+
+        $this->assertNotNull($registry->definitionFor(OneOf::class));
+    }
+
+    public function testObjectTypeDirectivesRejectsMisplacedDirective(): void
+    {
+        $this->expectException(InvalidDirectiveException::class);
+        $this->expectExceptionMessageMatches('/cannot be used on OBJECT/');
+
+        $this->registry()->objectTypeDirectives(new ReflectionClass(MisusedOneOfOnType::class));
+    }
+}
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/DirectiveUsageTest.php b/tests/Directives/DirectiveUsageTest.php
new file mode 100644
index 000000000..a5faa69c1
--- /dev/null
+++ b/tests/Directives/DirectiveUsageTest.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Directives;
+
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use TheCodingMachine\GraphQLite\Directives\Exceptions\InvalidDirectiveException;
+use TheCodingMachine\GraphQLite\Fixtures\Directives\MisusedOneOfOnType;
+
+final class DirectiveUsageTest extends TestCase
+{
+    public function testRejectsOneOfAppliedToAnObjectType(): void
+    {
+        $this->expectException(InvalidDirectiveException::class);
+        $this->expectExceptionMessageMatches('/cannot be used on OBJECT/');
+
+        DirectiveValidator::assertDirectivesUsableAt(new ReflectionClass(MisusedOneOfOnType::class), DirectiveLocation::OBJECT);
+    }
+}
diff --git a/tests/Fixtures/DirectiveLayerIntegration/DirectiveLayerController.php b/tests/Fixtures/DirectiveLayerIntegration/DirectiveLayerController.php
new file mode 100644
index 000000000..892437b77
--- /dev/null
+++ b/tests/Fixtures/DirectiveLayerIntegration/DirectiveLayerController.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectiveLayerIntegration;
+
+use TheCodingMachine\GraphQLite\Annotations\Query;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\Deprecated;
+
+final class DirectiveLayerController
+{
+    // Built-in @deprecated applied as an attribute, through the directive middleware.
+    #[Query]
+    #[Deprecated(reason: 'Use current instead.')]
+    public function legacy(): string
+    {
+        return 'legacy';
+    }
+
+    #[Query]
+    public function lookup(Lookup $lookup): string
+    {
+        return $lookup->sku ?? (string) $lookup->id;
+    }
+
+    // A bare #[Deprecated] should keep the docblock @deprecated reason rather than overriding it.
+    /** @deprecated Use lookup instead. */
+    #[Query]
+    #[Deprecated]
+    public function legacyDocblock(): string
+    {
+        return 'legacy';
+    }
+}
diff --git a/tests/Fixtures/DirectiveLayerIntegration/Lookup.php b/tests/Fixtures/DirectiveLayerIntegration/Lookup.php
new file mode 100644
index 000000000..3d71d80f5
--- /dev/null
+++ b/tests/Fixtures/DirectiveLayerIntegration/Lookup.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\DirectiveLayerIntegration;
+
+use TheCodingMachine\GraphQLite\Annotations\Field;
+use TheCodingMachine\GraphQLite\Annotations\Input;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\OneOf;
+
+/** Built-in `@oneOf`: callers pass either `sku` or `id`, not both. */
+#[Input]
+#[OneOf]
+final class Lookup
+{
+    public function __construct(
+        #[Field]
+        public string|null $sku = null,
+        #[Field]
+        public int|null $id = null,
+    ) {
+    }
+}
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/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/MisusedOneOfOnType.php b/tests/Fixtures/Directives/MisusedOneOfOnType.php
new file mode 100644
index 000000000..d16a7d42c
--- /dev/null
+++ b/tests/Fixtures/Directives/MisusedOneOfOnType.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Directives;
+
+use TheCodingMachine\GraphQLite\Annotations\Type;
+use TheCodingMachine\GraphQLite\Directives\BuiltIn\OneOf;
+
+/** Misuse: `@oneOf` is an INPUT_OBJECT directive, applied here to an object `#[Type]` class. */
+#[Type]
+#[OneOf]
+final class MisusedOneOfOnType
+{
+}
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/Integration/DirectiveLayerEndToEndTest.php b/tests/Integration/DirectiveLayerEndToEndTest.php
new file mode 100644
index 000000000..7b5631c9a
--- /dev/null
+++ b/tests/Integration/DirectiveLayerEndToEndTest.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Integration;
+
+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;
+
+/**
+ * Checks the built-in directives flow through the directive middleware and reach the SDL: `#[OneOf]`
+ * sets webonyx's `isOneOf` flag, and `#[Deprecated]` sets the field's deprecation reason.
+ */
+final class DirectiveLayerEndToEndTest extends TestCase
+{
+    private function buildSchema(): Schema
+    {
+        $factory = new SchemaFactory(new Psr16Cache(new ArrayAdapter()), new BasicAutoWiringContainer(new EmptyContainer()));
+        $factory->prodMode();
+        $factory->addNamespace('TheCodingMachine\\GraphQLite\\Fixtures\\DirectiveLayerIntegration');
+
+        return $factory->createSchema();
+    }
+
+    public function testOneOfPrintsInSdl(): void
+    {
+        $sdl = SchemaPrinter::doPrint($this->buildSchema());
+
+        $this->assertStringContainsString('input LookupInput @oneOf', $sdl);
+    }
+
+    public function testDeprecatedPrintsInSdl(): void
+    {
+        $sdl = SchemaPrinter::doPrint($this->buildSchema());
+
+        $this->assertStringContainsString('legacy: String! @deprecated(reason: "Use current instead.")', $sdl);
+    }
+
+    public function testBareDeprecatedKeepsTheDocblockReason(): void
+    {
+        $sdl = SchemaPrinter::doPrint($this->buildSchema());
+
+        $this->assertStringContainsString('legacyDocblock: String! @deprecated(reason: "Use lookup instead.")', $sdl);
+    }
+}