Implement type-specific validators

src/Validation/TypeValidators/ArrayValidator.php

···
+<?php
+
+namespace SocialDept\Schema\Validation\TypeValidators;
+
+use SocialDept\Schema\Exceptions\RecordValidationException;
+
+class ArrayValidator
+{
+    /**
+     * Validate an array value against constraints.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function validate(mixed $value, array $definition, string $path): void
+    {
+        if (! is_array($value)) {
+            throw RecordValidationException::invalidType($path, 'array', gettype($value));
+        }
+
+        $count = count($value);
+
+        // MaxItems constraint
+        if (isset($definition['maxItems'])) {
+            if ($count > $definition['maxItems']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Array length ({$count}) exceeds maximum ({$definition['maxItems']})"
+                );
+            }
+        }
+
+        // MinItems constraint
+        if (isset($definition['minItems'])) {
+            if ($count < $definition['minItems']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Array length ({$count}) is below minimum ({$definition['minItems']})"
+                );
+            }
+        }
+
+        // Validate items if item schema is provided
+        if (isset($definition['items']) && is_array($definition['items'])) {
+            $this->validateItems($value, $definition['items'], $path);
+        }
+    }
+
+    /**
+     * Validate array items.
+     *
+     * @param  array<mixed>  $items
+     * @param  array<string, mixed>  $itemDefinition
+     */
+    protected function validateItems(array $items, array $itemDefinition, string $path): void
+    {
+        $itemType = $itemDefinition['type'] ?? null;
+
+        if ($itemType === null) {
+            return;
+        }
+
+        foreach ($items as $index => $item) {
+            $itemPath = "{$path}[{$index}]";
+            $this->validateItem($item, $itemDefinition, $itemPath);
+        }
+    }
+
+    /**
+     * Validate a single array item.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function validateItem(mixed $value, array $definition, string $path): void
+    {
+        $type = $definition['type'] ?? null;
+
+        $validator = match ($type) {
+            'string' => new StringValidator(),
+            'integer' => new IntegerValidator(),
+            'boolean' => new BooleanValidator(),
+            'object' => new ObjectValidator(),
+            'array' => new ArrayValidator(),
+            default => null,
+        };
+
+        if ($validator !== null) {
+            $validator->validate($value, $definition, $path);
+        }
+    }
+}

src/Validation/TypeValidators/BlobValidator.php

···
+<?php
+
+namespace SocialDept\Schema\Validation\TypeValidators;
+
+use SocialDept\Schema\Exceptions\RecordValidationException;
+
+class BlobValidator
+{
+    /**
+     * Validate a blob value against constraints.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function validate(mixed $value, array $definition, string $path): void
+    {
+        // Blob should be an object with specific structure
+        if (! is_array($value)) {
+            throw RecordValidationException::invalidType($path, 'blob', gettype($value));
+        }
+
+        // Check for required blob structure
+        if (! isset($value['$type']) || $value['$type'] !== 'blob') {
+            throw RecordValidationException::invalidValue(
+                $path,
+                'Blob must have $type field set to "blob"'
+            );
+        }
+
+        // Validate ref (CID)
+        if (! isset($value['ref'])) {
+            throw RecordValidationException::invalidValue($path, 'Blob must have ref field');
+        }
+
+        // Validate mimeType
+        if (! isset($value['mimeType']) || ! is_string($value['mimeType'])) {
+            throw RecordValidationException::invalidValue($path, 'Blob must have valid mimeType');
+        }
+
+        // Validate size
+        if (! isset($value['size']) || ! is_int($value['size'])) {
+            throw RecordValidationException::invalidValue($path, 'Blob must have valid size');
+        }
+
+        // Validate MIME type constraint
+        if (isset($definition['accept']) && is_array($definition['accept'])) {
+            $this->validateMimeType($value['mimeType'], $definition['accept'], $path);
+        }
+
+        // Validate size constraints
+        if (isset($definition['maxSize'])) {
+            if ($value['size'] > $definition['maxSize']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Blob size ({$value['size']}) exceeds maximum ({$definition['maxSize']})"
+                );
+            }
+        }
+    }
+
+    /**
+     * Validate MIME type against accepted types.
+     *
+     * @param  array<string>  $acceptedTypes
+     */
+    protected function validateMimeType(string $mimeType, array $acceptedTypes, string $path): void
+    {
+        foreach ($acceptedTypes as $acceptedType) {
+            // Handle wildcards (e.g., image/*)
+            if (str_contains($acceptedType, '*')) {
+                // Quote everything except the asterisk, then replace * with .*
+                $pattern = '/^'.str_replace('\\*', '.*', preg_quote($acceptedType, '/')).'$/';
+                if (preg_match($pattern, $mimeType)) {
+                    return;
+                }
+            } elseif ($mimeType === $acceptedType) {
+                return;
+            }
+        }
+
+        $allowed = implode(', ', $acceptedTypes);
+
+        throw RecordValidationException::invalidValue(
+            $path,
+            "MIME type '{$mimeType}' not accepted. Allowed: {$allowed}"
+        );
+    }
+}

src/Validation/TypeValidators/BooleanValidator.php

···
+<?php
+
+namespace SocialDept\Schema\Validation\TypeValidators;
+
+use SocialDept\Schema\Exceptions\RecordValidationException;
+
+class BooleanValidator
+{
+    /**
+     * Validate a boolean value.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function validate(mixed $value, array $definition, string $path): void
+    {
+        if (! is_bool($value)) {
+            throw RecordValidationException::invalidType($path, 'boolean', gettype($value));
+        }
+
+        // Const constraint
+        if (isset($definition['const'])) {
+            if ($value !== $definition['const']) {
+                $expectedValue = $definition['const'] ? 'true' : 'false';
+
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Value must be {$expectedValue}"
+                );
+            }
+        }
+    }
+}

src/Validation/TypeValidators/IntegerValidator.php

···
+<?php
+
+namespace SocialDept\Schema\Validation\TypeValidators;
+
+use SocialDept\Schema\Exceptions\RecordValidationException;
+
+class IntegerValidator
+{
+    /**
+     * Validate an integer value against constraints.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function validate(mixed $value, array $definition, string $path): void
+    {
+        if (! is_int($value)) {
+            throw RecordValidationException::invalidType($path, 'integer', gettype($value));
+        }
+
+        // Maximum constraint
+        if (isset($definition['maximum'])) {
+            if ($value > $definition['maximum']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Value ({$value}) exceeds maximum ({$definition['maximum']})"
+                );
+            }
+        }
+
+        // Minimum constraint
+        if (isset($definition['minimum'])) {
+            if ($value < $definition['minimum']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Value ({$value}) is below minimum ({$definition['minimum']})"
+                );
+            }
+        }
+
+        // Enum constraint
+        if (isset($definition['enum']) && is_array($definition['enum'])) {
+            if (! in_array($value, $definition['enum'], true)) {
+                $allowed = implode(', ', $definition['enum']);
+
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Value must be one of: {$allowed}"
+                );
+            }
+        }
+
+        // Const constraint
+        if (isset($definition['const'])) {
+            if ($value !== $definition['const']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Value must be {$definition['const']}"
+                );
+            }
+        }
+    }
+}

src/Validation/TypeValidators/ObjectValidator.php

···
+<?php
+
+namespace SocialDept\Schema\Validation\TypeValidators;
+
+use SocialDept\Schema\Exceptions\RecordValidationException;
+
+class ObjectValidator
+{
+    /**
+     * Validate an object value against constraints.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function validate(mixed $value, array $definition, string $path): void
+    {
+        if (! is_array($value)) {
+            throw RecordValidationException::invalidType($path, 'object', gettype($value));
+        }
+
+        $properties = $definition['properties'] ?? [];
+        $required = $definition['required'] ?? [];
+
+        // Validate required fields
+        foreach ($required as $field) {
+            if (! array_key_exists($field, $value)) {
+                throw RecordValidationException::invalidValue(
+                    "{$path}.{$field}",
+                    'Required field is missing'
+                );
+            }
+        }
+
+        // Validate properties
+        foreach ($properties as $name => $propDef) {
+            if (array_key_exists($name, $value)) {
+                $this->validateProperty($value[$name], $propDef, "{$path}.{$name}");
+            }
+        }
+    }
+
+    /**
+     * Validate a single property.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function validateProperty(mixed $value, array $definition, string $path): void
+    {
+        $type = $definition['type'] ?? null;
+
+        $validator = match ($type) {
+            'string' => new StringValidator(),
+            'integer' => new IntegerValidator(),
+            'boolean' => new BooleanValidator(),
+            'object' => new ObjectValidator(),
+            'array' => new ArrayValidator(),
+            default => null,
+        };
+
+        if ($validator !== null) {
+            $validator->validate($value, $definition, $path);
+        }
+    }
+}

src/Validation/TypeValidators/StringValidator.php

···
+<?php
+
+namespace SocialDept\Schema\Validation\TypeValidators;
+
+use SocialDept\Schema\Exceptions\RecordValidationException;
+
+class StringValidator
+{
+    /**
+     * Validate a string value against constraints.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function validate(mixed $value, array $definition, string $path): void
+    {
+        if (! is_string($value)) {
+            throw RecordValidationException::invalidType($path, 'string', gettype($value));
+        }
+
+        // Length constraints
+        if (isset($definition['maxLength'])) {
+            $length = strlen($value);
+            if ($length > $definition['maxLength']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "String length ({$length}) exceeds maximum ({$definition['maxLength']})"
+                );
+            }
+        }
+
+        if (isset($definition['minLength'])) {
+            $length = strlen($value);
+            if ($length < $definition['minLength']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "String length ({$length}) is below minimum ({$definition['minLength']})"
+                );
+            }
+        }
+
+        // Grapheme constraints
+        if (isset($definition['maxGraphemes'])) {
+            $graphemes = grapheme_strlen($value);
+            if ($graphemes > $definition['maxGraphemes']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "String graphemes ({$graphemes}) exceeds maximum ({$definition['maxGraphemes']})"
+                );
+            }
+        }
+
+        if (isset($definition['minGraphemes'])) {
+            $graphemes = grapheme_strlen($value);
+            if ($graphemes < $definition['minGraphemes']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "String graphemes ({$graphemes}) is below minimum ({$definition['minGraphemes']})"
+                );
+            }
+        }
+
+        // Enum constraint
+        if (isset($definition['enum']) && is_array($definition['enum'])) {
+            if (! in_array($value, $definition['enum'], true)) {
+                $allowed = implode(', ', $definition['enum']);
+
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Value must be one of: {$allowed}"
+                );
+            }
+        }
+
+        // Const constraint
+        if (isset($definition['const'])) {
+            if ($value !== $definition['const']) {
+                throw RecordValidationException::invalidValue(
+                    $path,
+                    "Value must be '{$definition['const']}'"
+                );
+            }
+        }
+
+        // Format validation
+        if (isset($definition['format'])) {
+            $this->validateFormat($value, $definition['format'], $path);
+        }
+    }
+
+    /**
+     * Validate string format.
+     */
+    protected function validateFormat(string $value, string $format, string $path): void
+    {
+        $valid = match ($format) {
+            'datetime' => $this->validateDatetime($value),
+            'uri' => $this->validateUri($value),
+            'at-uri' => $this->validateAtUri($value),
+            'did' => $this->validateDid($value),
+            'handle' => $this->validateHandle($value),
+            'at-identifier' => $this->validateAtIdentifier($value),
+            'nsid' => $this->validateNsid($value),
+            'cid' => $this->validateCid($value),
+            'language' => $this->validateLanguage($value),
+            default => true, // Unknown formats pass
+        };
+
+        if (! $valid) {
+            throw RecordValidationException::invalidValue($path, "Invalid format: {$format}");
+        }
+    }
+
+    /**
+     * Validate datetime format.
+     */
+    protected function validateDatetime(string $value): bool
+    {
+        $datetime = \DateTime::createFromFormat(\DateTime::ATOM, $value);
+        if ($datetime !== false) {
+            return true;
+        }
+
+        $datetime = \DateTime::createFromFormat('Y-m-d\TH:i:s.u\Z', $value);
+        if ($datetime !== false) {
+            return true;
+        }
+
+        $datetime = \DateTime::createFromFormat('Y-m-d\TH:i:s\Z', $value);
+
+        return $datetime !== false;
+    }
+
+    /**
+     * Validate URI format.
+     */
+    protected function validateUri(string $value): bool
+    {
+        return filter_var($value, FILTER_VALIDATE_URL) !== false;
+    }
+
+    /**
+     * Validate AT URI format.
+     */
+    protected function validateAtUri(string $value): bool
+    {
+        return str_starts_with($value, 'at://') && strlen($value) > 5;
+    }
+
+    /**
+     * Validate DID format.
+     */
+    protected function validateDid(string $value): bool
+    {
+        return (bool) preg_match('/^did:[a-z]+:[a-zA-Z0-9._:%-]+$/', $value);
+    }
+
+    /**
+     * Validate handle format.
+     */
+    protected function validateHandle(string $value): bool
+    {
+        if (strlen($value) < 3 || strlen($value) > 253) {
+            return false;
+        }
+
+        return (bool) preg_match('/^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/', $value);
+    }
+
+    /**
+     * Validate AT identifier (DID or handle).
+     */
+    protected function validateAtIdentifier(string $value): bool
+    {
+        return $this->validateDid($value) || $this->validateHandle($value);
+    }
+
+    /**
+     * Validate NSID format.
+     */
+    protected function validateNsid(string $value): bool
+    {
+        try {
+            \SocialDept\Schema\Parser\Nsid::parse($value);
+
+            return true;
+        } catch (\Exception) {
+            return false;
+        }
+    }
+
+    /**
+     * Validate CID format.
+     */
+    protected function validateCid(string $value): bool
+    {
+        // CIDv0 or CIDv1
+        if (str_starts_with($value, 'Qm') && strlen($value) === 46) {
+            return (bool) preg_match('/^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/', $value);
+        }
+
+        if ((str_starts_with($value, 'b') || str_starts_with($value, 'bafy')) && strlen($value) > 10) {
+            return (bool) preg_match('/^[a-z2-7]+$/', $value);
+        }
+
+        if (str_starts_with($value, 'z') && strlen($value) > 10) {
+            return (bool) preg_match('/^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/', $value);
+        }
+
+        return false;
+    }
+
+    /**
+     * Validate language code (BCP 47).
+     */
+    protected function validateLanguage(string $value): bool
+    {
+        $pattern = '/^
+            ([a-z]{2,3}|[a-z]{4}|[a-z]{5,8})
+            (-[A-Z][a-z]{3})?
+            (-([A-Z]{2}|[0-9]{3}))?
+            (-([a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*
+            (-[a-z]-[a-z0-9]{2,8})*
+            (-x-[a-z0-9]{1,8})?
+        $/xi';
+
+        if (! preg_match($pattern, $value)) {
+            return false;
+        }
+
+        $primaryLanguage = strtolower(explode('-', $value)[0]);
+        $length = strlen($primaryLanguage);
+
+        return $length >= 2 && $length <= 8;
+    }
+}

src/Validation/TypeValidators/UnionValidator.php

···
+<?php
+
+namespace SocialDept\Schema\Validation\TypeValidators;
+
+use SocialDept\Schema\Exceptions\RecordValidationException;
+
+class UnionValidator
+{
+    /**
+     * Validate a union value against constraints.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function validate(mixed $value, array $definition, string $path): void
+    {
+        $refs = $definition['refs'] ?? [];
+
+        if (empty($refs)) {
+            throw RecordValidationException::invalidValue($path, 'Union must have refs defined');
+        }
+
+        // Check if union is discriminated (closed)
+        $closed = $definition['closed'] ?? false;
+
+        if ($closed) {
+            $this->validateDiscriminatedUnion($value, $refs, $path);
+        } else {
+            $this->validateOpenUnion($value, $refs, $path);
+        }
+    }
+
+    /**
+     * Validate discriminated (closed) union.
+     *
+     * @param  array<string>  $refs
+     */
+    protected function validateDiscriminatedUnion(mixed $value, array $refs, string $path): void
+    {
+        if (! is_array($value)) {
+            throw RecordValidationException::invalidType($path, 'object', gettype($value));
+        }
+
+        // Check for $type discriminator
+        if (! isset($value['$type'])) {
+            throw RecordValidationException::invalidValue(
+                $path,
+                'Discriminated union must have $type field'
+            );
+        }
+
+        $type = $value['$type'];
+
+        // Validate that $type is one of the allowed refs
+        if (! in_array($type, $refs, true)) {
+            $allowed = implode(', ', $refs);
+
+            throw RecordValidationException::invalidValue(
+                $path,
+                "Union type '{$type}' not allowed. Must be one of: {$allowed}"
+            );
+        }
+    }
+
+    /**
+     * Validate open (undiscriminated) union.
+     *
+     * @param  array<string>  $refs
+     */
+    protected function validateOpenUnion(mixed $value, array $refs, string $path): void
+    {
+        // For open unions, we just verify it's valid data
+        // The actual type checking would require schema resolution which is complex
+        // For now, we just ensure it's an object or primitive type
+
+        if (is_null($value)) {
+            throw RecordValidationException::invalidValue($path, 'Union value cannot be null');
+        }
+
+        // Open unions are flexible, so we allow objects and primitives
+        if (! is_array($value) && ! is_string($value) && ! is_int($value) && ! is_bool($value)) {
+            throw RecordValidationException::invalidType($path, 'valid union value', gettype($value));
+        }
+    }
+}

tests/Unit/Validation/TypeValidators/ArrayValidatorTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Validation\TypeValidators;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Exceptions\RecordValidationException;
+use SocialDept\Schema\Validation\TypeValidators\ArrayValidator;
+
+class ArrayValidatorTest extends TestCase
+{
+    protected ArrayValidator $validator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->validator = new ArrayValidator();
+    }
+
+    public function test_it_validates_valid_array(): void
+    {
+        $this->validator->validate([1, 2, 3], ['type' => 'array'], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_non_array(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('not an array', ['type' => 'array'], '$.field');
+    }
+
+    public function test_it_validates_max_items(): void
+    {
+        $this->validator->validate([1, 2, 3], ['type' => 'array', 'maxItems' => 5], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_array_exceeding_max_items(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate([1, 2, 3, 4, 5, 6], ['type' => 'array', 'maxItems' => 5], '$.field');
+    }
+
+    public function test_it_validates_min_items(): void
+    {
+        $this->validator->validate([1, 2, 3], ['type' => 'array', 'minItems' => 2], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_array_below_min_items(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate([1], ['type' => 'array', 'minItems' => 3], '$.field');
+    }
+
+    public function test_it_validates_array_items(): void
+    {
+        $this->validator->validate(
+            ['a', 'b', 'c'],
+            ['type' => 'array', 'items' => ['type' => 'string']],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_invalid_array_item(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            ['a', 123, 'c'],
+            ['type' => 'array', 'items' => ['type' => 'string']],
+            '$.field'
+        );
+    }
+
+    public function test_it_validates_array_of_integers(): void
+    {
+        $this->validator->validate(
+            [1, 2, 3],
+            ['type' => 'array', 'items' => ['type' => 'integer']],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_array_of_objects(): void
+    {
+        $this->validator->validate(
+            [
+                ['name' => 'John'],
+                ['name' => 'Jane'],
+            ],
+            [
+                'type' => 'array',
+                'items' => [
+                    'type' => 'object',
+                    'required' => ['name'],
+                    'properties' => [
+                        'name' => ['type' => 'string'],
+                    ],
+                ],
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_nested_arrays(): void
+    {
+        $this->validator->validate(
+            [[1, 2], [3, 4]],
+            [
+                'type' => 'array',
+                'items' => [
+                    'type' => 'array',
+                    'items' => ['type' => 'integer'],
+                ],
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+}

tests/Unit/Validation/TypeValidators/BlobValidatorTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Validation\TypeValidators;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Exceptions\RecordValidationException;
+use SocialDept\Schema\Validation\TypeValidators\BlobValidator;
+
+class BlobValidatorTest extends TestCase
+{
+    protected BlobValidator $validator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->validator = new BlobValidator();
+    }
+
+    public function test_it_validates_valid_blob(): void
+    {
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'mimeType' => 'image/png',
+                'size' => 1024,
+            ],
+            ['type' => 'blob'],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_non_array_blob(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('not a blob', ['type' => 'blob'], '$.field');
+    }
+
+    public function test_it_rejects_blob_without_type_field(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            [
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'mimeType' => 'image/png',
+                'size' => 1024,
+            ],
+            ['type' => 'blob'],
+            '$.field'
+        );
+    }
+
+    public function test_it_rejects_blob_without_ref(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'mimeType' => 'image/png',
+                'size' => 1024,
+            ],
+            ['type' => 'blob'],
+            '$.field'
+        );
+    }
+
+    public function test_it_rejects_blob_without_mime_type(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'size' => 1024,
+            ],
+            ['type' => 'blob'],
+            '$.field'
+        );
+    }
+
+    public function test_it_rejects_blob_without_size(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'mimeType' => 'image/png',
+            ],
+            ['type' => 'blob'],
+            '$.field'
+        );
+    }
+
+    public function test_it_validates_accepted_mime_type(): void
+    {
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'mimeType' => 'image/png',
+                'size' => 1024,
+            ],
+            ['type' => 'blob', 'accept' => ['image/png', 'image/jpeg']],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_unaccepted_mime_type(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'mimeType' => 'video/mp4',
+                'size' => 1024,
+            ],
+            ['type' => 'blob', 'accept' => ['image/png', 'image/jpeg']],
+            '$.field'
+        );
+    }
+
+    public function test_it_validates_wildcard_mime_type(): void
+    {
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'mimeType' => 'image/webp',
+                'size' => 1024,
+            ],
+            ['type' => 'blob', 'accept' => ['image/*']],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_max_size(): void
+    {
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'mimeType' => 'image/png',
+                'size' => 1024,
+            ],
+            ['type' => 'blob', 'maxSize' => 2048],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_blob_exceeding_max_size(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            [
+                '$type' => 'blob',
+                'ref' => 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi',
+                'mimeType' => 'image/png',
+                'size' => 3000,
+            ],
+            ['type' => 'blob', 'maxSize' => 2048],
+            '$.field'
+        );
+    }
+}

tests/Unit/Validation/TypeValidators/BooleanValidatorTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Validation\TypeValidators;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Exceptions\RecordValidationException;
+use SocialDept\Schema\Validation\TypeValidators\BooleanValidator;
+
+class BooleanValidatorTest extends TestCase
+{
+    protected BooleanValidator $validator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->validator = new BooleanValidator();
+    }
+
+    public function test_it_validates_true(): void
+    {
+        $this->validator->validate(true, ['type' => 'boolean'], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_false(): void
+    {
+        $this->validator->validate(false, ['type' => 'boolean'], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_non_boolean(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('not a boolean', ['type' => 'boolean'], '$.field');
+    }
+
+    public function test_it_rejects_integer_zero(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(0, ['type' => 'boolean'], '$.field');
+    }
+
+    public function test_it_validates_const_true(): void
+    {
+        $this->validator->validate(true, ['type' => 'boolean', 'const' => true], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_const_false(): void
+    {
+        $this->validator->validate(false, ['type' => 'boolean', 'const' => false], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_value_not_matching_const(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(false, ['type' => 'boolean', 'const' => true], '$.field');
+    }
+}

tests/Unit/Validation/TypeValidators/IntegerValidatorTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Validation\TypeValidators;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Exceptions\RecordValidationException;
+use SocialDept\Schema\Validation\TypeValidators\IntegerValidator;
+
+class IntegerValidatorTest extends TestCase
+{
+    protected IntegerValidator $validator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->validator = new IntegerValidator();
+    }
+
+    public function test_it_validates_valid_integer(): void
+    {
+        $this->validator->validate(42, ['type' => 'integer'], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_non_integer(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('not an integer', ['type' => 'integer'], '$.field');
+    }
+
+    public function test_it_validates_maximum_constraint(): void
+    {
+        $this->validator->validate(50, ['type' => 'integer', 'maximum' => 100], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_value_exceeding_maximum(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(150, ['type' => 'integer', 'maximum' => 100], '$.field');
+    }
+
+    public function test_it_validates_minimum_constraint(): void
+    {
+        $this->validator->validate(50, ['type' => 'integer', 'minimum' => 10], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_value_below_minimum(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(5, ['type' => 'integer', 'minimum' => 10], '$.field');
+    }
+
+    public function test_it_validates_enum_constraint(): void
+    {
+        $this->validator->validate(2, ['type' => 'integer', 'enum' => [1, 2, 3]], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_value_not_in_enum(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(5, ['type' => 'integer', 'enum' => [1, 2, 3]], '$.field');
+    }
+
+    public function test_it_validates_const_constraint(): void
+    {
+        $this->validator->validate(42, ['type' => 'integer', 'const' => 42], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_value_not_matching_const(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(100, ['type' => 'integer', 'const' => 42], '$.field');
+    }
+}

tests/Unit/Validation/TypeValidators/ObjectValidatorTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Validation\TypeValidators;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Exceptions\RecordValidationException;
+use SocialDept\Schema\Validation\TypeValidators\ObjectValidator;
+
+class ObjectValidatorTest extends TestCase
+{
+    protected ObjectValidator $validator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->validator = new ObjectValidator();
+    }
+
+    public function test_it_validates_valid_object(): void
+    {
+        $this->validator->validate(
+            ['name' => 'John'],
+            [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                ],
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_non_object(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('not an object', ['type' => 'object'], '$.field');
+    }
+
+    public function test_it_validates_object_with_multiple_properties(): void
+    {
+        $this->validator->validate(
+            ['name' => 'John', 'age' => 30],
+            [
+                'type' => 'object',
+                'required' => ['name', 'age'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                    'age' => ['type' => 'integer'],
+                ],
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_missing_required_field(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            ['name' => 'John'],
+            [
+                'type' => 'object',
+                'required' => ['name', 'age'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                    'age' => ['type' => 'integer'],
+                ],
+            ],
+            '$.field'
+        );
+    }
+
+    public function test_it_validates_optional_properties(): void
+    {
+        $this->validator->validate(
+            ['name' => 'John'],
+            [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                    'age' => ['type' => 'integer'],
+                ],
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_nested_objects(): void
+    {
+        $this->validator->validate(
+            [
+                'user' => [
+                    'name' => 'John',
+                    'profile' => [
+                        'bio' => 'Developer',
+                    ],
+                ],
+            ],
+            [
+                'type' => 'object',
+                'required' => ['user'],
+                'properties' => [
+                    'user' => [
+                        'type' => 'object',
+                        'required' => ['name', 'profile'],
+                        'properties' => [
+                            'name' => ['type' => 'string'],
+                            'profile' => [
+                                'type' => 'object',
+                                'required' => ['bio'],
+                                'properties' => [
+                                    'bio' => ['type' => 'string'],
+                                ],
+                            ],
+                        ],
+                    ],
+                ],
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_invalid_property_type(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            ['name' => 123],
+            [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                ],
+            ],
+            '$.field'
+        );
+    }
+
+    public function test_it_validates_empty_object(): void
+    {
+        $this->validator->validate(
+            [],
+            [
+                'type' => 'object',
+                'required' => [],
+                'properties' => [],
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+}

tests/Unit/Validation/TypeValidators/StringValidatorTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Validation\TypeValidators;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Exceptions\RecordValidationException;
+use SocialDept\Schema\Validation\TypeValidators\StringValidator;
+
+class StringValidatorTest extends TestCase
+{
+    protected StringValidator $validator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->validator = new StringValidator();
+    }
+
+    public function test_it_validates_valid_string(): void
+    {
+        $this->validator->validate('test', ['type' => 'string'], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_non_string(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(123, ['type' => 'string'], '$.field');
+    }
+
+    public function test_it_validates_max_length(): void
+    {
+        $this->validator->validate('test', ['type' => 'string', 'maxLength' => 10], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_string_exceeding_max_length(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('this is too long', ['type' => 'string', 'maxLength' => 5], '$.field');
+    }
+
+    public function test_it_validates_min_length(): void
+    {
+        $this->validator->validate('test', ['type' => 'string', 'minLength' => 3], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_string_below_min_length(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('ab', ['type' => 'string', 'minLength' => 5], '$.field');
+    }
+
+    public function test_it_validates_max_graphemes(): void
+    {
+        $this->validator->validate('😀😁😂', ['type' => 'string', 'maxGraphemes' => 5], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_string_exceeding_max_graphemes(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('😀😁😂😃😄😅', ['type' => 'string', 'maxGraphemes' => 5], '$.field');
+    }
+
+    public function test_it_validates_min_graphemes(): void
+    {
+        $this->validator->validate('😀😁😂😃😄', ['type' => 'string', 'minGraphemes' => 3], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_string_below_min_graphemes(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('😀😁', ['type' => 'string', 'minGraphemes' => 5], '$.field');
+    }
+
+    public function test_it_validates_enum_constraint(): void
+    {
+        $this->validator->validate('active', [
+            'type' => 'string',
+            'enum' => ['active', 'inactive', 'pending'],
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_value_not_in_enum(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('unknown', [
+            'type' => 'string',
+            'enum' => ['active', 'inactive', 'pending'],
+        ], '$.field');
+    }
+
+    public function test_it_validates_const_constraint(): void
+    {
+        $this->validator->validate('post', ['type' => 'string', 'const' => 'post'], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_value_not_matching_const(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('comment', ['type' => 'string', 'const' => 'post'], '$.field');
+    }
+
+    public function test_it_validates_datetime_format(): void
+    {
+        $this->validator->validate('2024-01-01T00:00:00Z', [
+            'type' => 'string',
+            'format' => 'datetime',
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_invalid_datetime(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate('not-a-datetime', [
+            'type' => 'string',
+            'format' => 'datetime',
+        ], '$.field');
+    }
+
+    public function test_it_validates_uri_format(): void
+    {
+        $this->validator->validate('https://example.com', [
+            'type' => 'string',
+            'format' => 'uri',
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_did_format(): void
+    {
+        $this->validator->validate('did:plc:z72i7hdynmk6r22z27h6tvur', [
+            'type' => 'string',
+            'format' => 'did',
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_handle_format(): void
+    {
+        $this->validator->validate('user.bsky.social', [
+            'type' => 'string',
+            'format' => 'handle',
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_nsid_format(): void
+    {
+        $this->validator->validate('app.bsky.feed.post', [
+            'type' => 'string',
+            'format' => 'nsid',
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_cid_format(): void
+    {
+        $this->validator->validate('bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi', [
+            'type' => 'string',
+            'format' => 'cid',
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_language_format(): void
+    {
+        $this->validator->validate('en-US', [
+            'type' => 'string',
+            'format' => 'language',
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_passes_unknown_formats(): void
+    {
+        $this->validator->validate('anything', [
+            'type' => 'string',
+            'format' => 'unknown-format',
+        ], '$.field');
+
+        $this->assertTrue(true);
+    }
+}

tests/Unit/Validation/TypeValidators/UnionValidatorTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Validation\TypeValidators;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Exceptions\RecordValidationException;
+use SocialDept\Schema\Validation\TypeValidators\UnionValidator;
+
+class UnionValidatorTest extends TestCase
+{
+    protected UnionValidator $validator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->validator = new UnionValidator();
+    }
+
+    public function test_it_validates_discriminated_union(): void
+    {
+        $this->validator->validate(
+            ['$type' => 'app.bsky.feed.post'],
+            [
+                'type' => 'union',
+                'refs' => ['app.bsky.feed.post', 'app.bsky.feed.repost'],
+                'closed' => true,
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_discriminated_union_without_type(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            ['text' => 'Hello'],
+            [
+                'type' => 'union',
+                'refs' => ['app.bsky.feed.post', 'app.bsky.feed.repost'],
+                'closed' => true,
+            ],
+            '$.field'
+        );
+    }
+
+    public function test_it_rejects_discriminated_union_with_invalid_type(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            ['$type' => 'app.bsky.feed.invalid'],
+            [
+                'type' => 'union',
+                'refs' => ['app.bsky.feed.post', 'app.bsky.feed.repost'],
+                'closed' => true,
+            ],
+            '$.field'
+        );
+    }
+
+    public function test_it_rejects_non_object_for_discriminated_union(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            'not an object',
+            [
+                'type' => 'union',
+                'refs' => ['app.bsky.feed.post', 'app.bsky.feed.repost'],
+                'closed' => true,
+            ],
+            '$.field'
+        );
+    }
+
+    public function test_it_validates_open_union_with_object(): void
+    {
+        $this->validator->validate(
+            ['data' => 'value'],
+            [
+                'type' => 'union',
+                'refs' => ['app.bsky.feed.post', 'app.bsky.feed.repost'],
+                'closed' => false,
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_open_union_with_string(): void
+    {
+        $this->validator->validate(
+            'some value',
+            [
+                'type' => 'union',
+                'refs' => ['app.bsky.feed.post', 'app.bsky.feed.repost'],
+                'closed' => false,
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_validates_open_union_with_integer(): void
+    {
+        $this->validator->validate(
+            123,
+            [
+                'type' => 'union',
+                'refs' => ['app.bsky.feed.post', 'app.bsky.feed.repost'],
+                'closed' => false,
+            ],
+            '$.field'
+        );
+
+        $this->assertTrue(true);
+    }
+
+    public function test_it_rejects_open_union_with_null(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            null,
+            [
+                'type' => 'union',
+                'refs' => ['app.bsky.feed.post', 'app.bsky.feed.repost'],
+                'closed' => false,
+            ],
+            '$.field'
+        );
+    }
+
+    public function test_it_rejects_union_without_refs(): void
+    {
+        $this->expectException(RecordValidationException::class);
+
+        $this->validator->validate(
+            ['$type' => 'app.bsky.feed.post'],
+            [
+                'type' => 'union',
+                'closed' => true,
+            ],
+            '$.field'
+        );
+    }
+}