add docs for aot-support in all schema docs

Author: gregsdennis

.jekyll-metadata

@@ -158,7 +158,7 @@ var serializerOptions = new()
 };
 ```
 
-If you don't have any custom rules.  You're done.  Congratulations.
+If you don't have any custom rules, you're done.  Congratulations.
 
 If you do have custom rules, you'll want to add `[JsonSerializable]` attributes for those as well.
 

_docs/logic/basics.md

@@ -45,7 +45,7 @@ JSON Schema is expressed as a collection of keywords, each of which provides a s
 
 There are two options when building a schema: defining it inline using the fluent builder and defining it externally and deserializing.  Which method you use depends on your specific requirements.
 
-## Deserialization {#schema-deserialization}
+## Serialization and Deserialization {#schema-deserialization}
 
 *JsonSchema.Net* schemas are fully serializable.
 
@@ -61,6 +61,33 @@ var mySchema = JsonSerializer.Deserialize<JsonSchema>(content);
 
 Done.
 
+### Ahead of Time (AOT) compatibility {#aot}
+
+_JsonSchema.Net_ v6 includes updates to support [Native AOT applications](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/).  In order to take advantage of this, there are a few things you'll need to do.
+
+First, on your `JsonSerializerContext`, add the following attributes:
+
+```c#
+[JsonSerializable(typeof(JsonSchema))]
+[JsonSerializable(typeof(EvaluationResults))]
+```
+
+It's recommended that you create a single `JsonSerializerOptions` object (or a few if you need different configurations) and reuse it rather than creating them ad-hoc.  When you create one, you'll need to configure its `TypeResolverChain` with your serializer context:
+
+```c#
+var serializerOptions = new()
+{
+    TypeInfoResolverChain = { MySerializerContext.Default }
+};
+```
+
+If you don't have any custom keywords, you're done.  Congratulations.
+
+If you do have custom keywords, please see the AOT section on the [Vocabularies docs](/schema/vocabs#aot).
+
+> The vocabulary library extensions for _JsonSchema.Net_ are also AOT-compatible and require no further setup.
+{: .prompt-tip}
+
 ## Inline {#schema-inlining}
 
 There are many reasons why you would want to hard-code your schemas.  This library actually hard-codes all of the meta-schemas.  Whatever your reason, the `JsonSchemaBuilder` class is going to be your friend.

_docs/schema/basics.md

@@ -16,6 +16,9 @@ var schema = schemaBuilder.FromType<MyType>().Build();
 
 Done.
 
+> The validating converter described in this document requires AOT-incompatible reflection to operate, so it will not be usable in a Native AOT context.
+{: .prompt-warning}
+
 ## IMPORTANT {#schema-schemagen-disclaimer}
 
 Ideally, this functionality should be used to create a starting point in authoring a schema.  The schemas output by this library should be reviewed by actual people prior to being put into a production system.

_docs/schema/schemagen/schema-generation.md

@@ -1,7 +1,7 @@
 ---
 layout: page
 title: Enhancing Deserialization with JSON Schema
-bookmark: Serialization
+bookmark: Serialization with Validation
 permalink: /schema/:title/
 icon: fas fa-tag
 order: "01.2"
@@ -15,6 +15,9 @@ Let's walk through it.
 > More on JSON Schema support during deserialization can be found on the `json-everything` [blog](https://blog.json-everything.net/posts/deserialization-with-schemas/).
 {: .prompt-tip }
 
+> The validating converter described in this document requires AOT-incompatible reflection to operate, so it will not be usable in a Native AOT context.
+{: .prompt-warning}
+
 ## Setting up the converter {#schema-deserialization-setup}
 
 Custom JSON converters are added via the `JsonSerializationOptions.Converters` property.  Any converters in this collection will have priority over the default set of converters that ship with .Net.  You can read more about custom converters in their [documentation](https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/converters-how-to?pivots=dotnet-7-0).

_docs/schema/serialization.md

@@ -104,7 +104,7 @@ The keywords must still be registered separately (see "Defining Custom Keywords"
 
 It's not always necessary to have a meta-schema for your vocabulary.  However, if you want to enable `EvaluationOptions.ValidateMetaschema`, you will need to register it.
 
-# Defining Custom Keywords {#schema-vocabs-custom-keywords}
+## Defining Custom Keywords {#schema-vocabs-custom-keywords}
 
 `JsonSchema` has been designed to allow you to create your own keywords.  There are several steps that need to be performed to do this.
 
@@ -122,17 +122,31 @@ And your new keyword is ready to use.
 
 Lastly, remember that the best resource building keywords is [the code](https://github.com/gregsdennis/json-everything/tree/master/JsonSchema) where all of the built-in keywords are defined.
 
-## Evaluation philosophy
+### Evaluation philosophy
 
 Starting with version 5 of _JsonSchema.Net_, schema evaluation occurs in two stages: gathering constraints and processing evaluations.  Constraints represent all of the work that can be performed by the keyword without an instance, while evaluations complete the work.  By separating these stages, _JsonSchema.Net_ can reuse the constraints for subsequent runs, allowing faster run times and fewer memory allocations.
 
 Both stages are defined by implementing the single method on `IJsonSchemaKeyword`.
 
-## 1. Implement `IJsonSchemaKeyword` {#schema-vocabs-custom-keywords-1}
+### Ahead of Time (AOT) compatibility {#aot}
+
+_JsonSchema.Net_ v6 includes updates to support [Native AOT applications](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/).  Please be sure to read the main AOT section on the [overview page](/schema/basics#aot).
+
+Frist, you'll need to add `[JsonSerializable]` attributes for any custom keywords.
+
+```c#
+[JsonSerializable(typeof(MyKeyword))]
+```
+
+Second, you'll need to register your keywords using the `SchemaKeywordRegistry.Register<T>(JsonSerializerContext)` method overload, passing in your serializer context, to provide the library access to the `JsonTypeInfo` for your keyword type.
+
+Lastly, due to the dynamic nature of how rules are serialized, your JSON converter MUST implement `IWeaklyTypedJsonConverter` which is defined by _Json.More.Net_.  The library also defines a `WeaklyTypeJsonConverter<T>` abstract class that you can use as a base.  It's also highly recommended that you take advantage of the `JsonSerializerOptions` [read/write extensions](/more/json-more/#ahead-of-time-aot-compilation-support) provided by _Json.More.Net_.
+
+### 1. Implement `IJsonSchemaKeyword` {#schema-vocabs-custom-keywords-1}
 
 Implementing your keyword will require some initial thought and design around what work the keyword can perform without the instance and what work requires the instance.  To illustrate this, let's look at a couple of the existing keyword implementations.
 
-### `maximum`
+#### `maximum`
 
 The `maximum` keyword is basically all instance.  It asks, "Is the instance a number, and, if so, does it exceed some maximum value?"  As such, there's not really much in the way of pre-processing that can be accomplished here that isn't handled in the background.  Therefore, all of the work is done by an `Evaluator()` method.
 
@@ -174,7 +188,7 @@ For `maximum`, evaluation means we check if the value is a number.  If not, we i
 > `maximum` doesn't have any nested results, but it's still good form to explicitly indicate this.
 {: .prompt-info }
 
-### `properties`
+#### `properties`
 
 The `properties` keyword presents an opportunity to calculate some things before we have the instance.  For example, with this schema
 
@@ -233,7 +247,7 @@ When we move into the evaluation phase, all of the child constraints that align
 > The specification requires that annotations are not reported when validation fails, however this requirement is enforced at the (sub)schema level, not at the keyword level.  Annotations are still generally required for sibling keywords (i.e. within the same subschema) to interoperate correctly.
 {: .prompt-warning }
 
-### Other variations
+#### Other variations
 
 There are a few other variations of keyword interactions, and it may be worth inspecting the code for some of these examples.
 
@@ -254,7 +268,7 @@ There are a few other variations of keyword interactions, and it may be worth in
 
 Understanding the patterns that already exist will help you build your own keyword implementations.
 
-### Saving evaluation results
+#### Saving evaluation results
 
 Once you have validated the instance, you'll need to record the results.  These methods are available on the local result object.
 
@@ -267,7 +281,7 @@ Once you have validated the instance, you'll need to record the results.  These
 
 Set any annotations by using `.SetAnnotation()` on the local result object.  Generally this needs to be done whether the keyword passes or fails validation.  Annotations are stored as a key-value pair, using the keyword name as the key.  The value can be anything, but it _should_ be JSON-serializable in order to be rendered properly in the output.
 
-## 2. Implement one of the schema-container interfaces {#schema-vocabs-custom-keywords-2}
+### 2. Implement one of the schema-container interfaces {#schema-vocabs-custom-keywords-2}
 
 If your keyword contains one or more subschemas, you'll need to implement one of these:
 
@@ -278,7 +292,7 @@ If your keyword contains one or more subschemas, you'll need to implement one of
 
 These will be used at the beginning of the first evaluation and during schema registration to traverse all of the subschemas a provide IDs where none is explicitly declared.  This goes on to help `$ref` and friends to their job while also making that job faster.
 
-## 3. Apply some attributes {#schema-vocabs-custom-keyword-3}
+### 3. Apply some attributes {#schema-vocabs-custom-keyword-3}
 
 *JsonSchema.Net* contains several attributes that you should use to specify some metadata about your keyword.
 
@@ -287,11 +301,11 @@ These will be used at the beginning of the first evaluation and during schema re
 - `SchemaVersion` - Declares a version that supports the keyword.  This can be used multiple times to declare additional drafts.
 - `Vocabulary` - Declares the ID of the vocabulary which defines the the keyword.
 
-## 4. Register your keyword {#schema-vocabs-custom-keywords-4}
+### 4. Register your keyword {#schema-vocabs-custom-keywords-4}
 
 To make *JsonSchema.Net* aware of your keyword, you must register it with `SchemaKeywordRegistry.Register<T>()`.  This will enable deserialization.
 
-### Now make it nice to use {#schema-vocabs-custom-extensions}
+#### Now make it nice to use {#schema-vocabs-custom-extensions}
 
 To enable the fluent construction interface for your keyword, simply create an extension method on `JsonSchemaBuilder` that adds the keyword and returns the builder.  For example, adding a `description` keyword is implemented by this method:
 
@@ -303,7 +317,7 @@ public static JsonSchemaBuilder Description(this JsonSchemaBuilder builder, stri
 }
 ```
 
-## 5. Create a JSON converter {#schema-vocabs-custom-converter}
+### 5. Create a JSON converter {#schema-vocabs-custom-converter}
 
 To enable serialization and deserialization, you'll need to provide the converter for it.