Add Preview 6 content to .NET 10 what's new pages for libraries, runtime, and SDK

Co-authored-by: BillWagner <493969+BillWagner@users.noreply.github.com>

Author: Copilot

docs/core/whats-new/dotnet-10/libraries.md

@@ -95,7 +95,7 @@ using (MLKem key = MLKem.GenerateKey(MLKemAlgorithm.MLKem768))
 
 These algorithms all continue with the pattern of having a static `IsSupported` property to indicate if the algorithm is supported on the current system.
 
-Currently, the PQC algorithms are only available on systems where the system cryptographic libraries are OpenSSL 3.5 (or newer). Windows CNG support will be added soon. Also, the new classes are all marked as [`[Experimental]`](../../../fundamentals/syslib-diagnostics/experimental-overview.md) under diagnostic `SYSLIB5006` until development is complete.
+.NET 10 includes Windows CNG support for post-quantum cryptography, making these algorithms available on Windows systems with PQC support. The PQC algorithms are available on systems where the system cryptographic libraries are OpenSSL 3.5 (or newer) or Windows CNG with PQC support. Also, the new classes are all marked as [`[Experimental]`](../../../fundamentals/syslib-diagnostics/experimental-overview.md) under diagnostic `SYSLIB5006` until development is complete.
 
 ## Globalization and date/time
 
@@ -165,13 +165,49 @@ This new API is already used in <xref:System.Json.JsonObject> and improves the p
 ## Serialization
 
 - [Allow specifying ReferenceHandler in `JsonSourceGenerationOptions`](#allow-specifying-referencehandler-in-jsonsourcegenerationoptions)
+- [Option to disallow duplicate JSON properties](#option-to-disallow-duplicate-json-properties)
+- [Strict JSON serialization options](#strict-json-serialization-options)
 
 ### Allow specifying ReferenceHandler in `JsonSourceGenerationOptions`
 
 When you use [source generators for JSON serialization](../../../standard/serialization/system-text-json/source-generation.md), the generated context throws when cycles are serialized or deserialized. Now you can customize this behavior by specifying the <xref:System.Text.Json.Serialization.ReferenceHandler> in the <xref:System.Text.Json.Serialization.JsonSourceGenerationOptionsAttribute>. Here's an example using `JsonKnownReferenceHandler.Preserve`:
 
 :::code language="csharp" source="../snippets/dotnet-10/csharp/snippets.cs" id="snippet_selfReference":::
 
+### Option to disallow duplicate JSON properties
+
+The JSON specification doesn't specify how to handle duplicate properties when deserializing a JSON payload. This can lead to unexpected results and security vulnerabilities. .NET 10 introduces the `AllowDuplicateProperties` option to disallow duplicate JSON properties:
+
+```csharp
+string json = """{ "Value": 1, "Value": -1 }""";
+Console.WriteLine(JsonSerializer.Deserialize<MyRecord>(json).Value); // -1
+
+JsonSerializerOptions options = new() { AllowDuplicateProperties = false };
+JsonSerializer.Deserialize<MyRecord>(json, options);                // throws JsonException
+JsonSerializer.Deserialize<JsonObject>(json, options);              // throws JsonException
+JsonSerializer.Deserialize<Dictionary<string, int>>(json, options); // throws JsonException
+
+JsonDocumentOptions docOptions = new() { AllowDuplicateProperties = false };
+JsonDocument.Parse(json, docOptions);   // throws JsonException
+
+record MyRecord(int Value);
+```
+
+Duplicate detection works by checking if a value is assigned multiple times during deserialization, so it works as expected with other options like case-sensitivity and naming policy.
+
+### Strict JSON serialization options
+
+The JSON serializer accepts many options to customize serialization and deserialization, but the defaults may be too relaxed for some applications. .NET 10 adds a new `JsonSerializationOptions.Strict` preset that follows best practices by including the following options:
+
+- Applies the `JsonUnmappedMemberHandling.Disallow` policy
+- Disables `AllowDuplicateProperties`
+- Preserves case sensitive property binding
+- Enables both `RespectNullableAnnotations` and `RespectRequiredConstructorParameters` settings
+
+These options are read-compatible with `JsonSerializationOptions.Default` - an object serialized with `JsonSerializationOptions.Default` can be deserialized with `JsonSerializationOptions.Strict`.
+
+For more information about JSON serialization, see [System.Text.Json overview](/dotnet/standard/serialization/system-text-json/overview).
+
 ## System.Numerics
 
 - [More left-handed matrix transformation methods](#more-left-handed-matrix-transformation-methods)

docs/core/whats-new/dotnet-10/runtime.md

@@ -10,6 +10,24 @@ ai-usage: ai-assisted
 
 This article describes new features and performance improvements in the .NET runtime for .NET 10.
 
+## JIT compiler improvements
+
+The JIT compiler in .NET 10 includes significant enhancements that improve performance through better code generation and optimization strategies.
+
+### Improved code generation for struct arguments
+
+.NET's JIT compiler is capable of an optimization called physical promotion, where the members of a struct are placed in registers rather than on the stack, eliminating memory accesses. This optimization is particularly useful when passing a struct to a method, and the calling convention requires the struct members to be passed in registers.
+
+.NET 10 improves the JIT compiler's internal representation to handle values that share a register. Previously, when struct members needed to be packed into a single register, the JIT would store values to memory first and then load them into a register. Now, the JIT compiler can place the promoted members of struct arguments into shared registers directly, eliminating unnecessary memory operations.
+
+For example, consider a struct with two `int` members. On x64, since `int` values are four bytes wide and registers are eight bytes wide, both members can be packed into one register. The improved code generation eliminates the need for intermediate memory storage, resulting in more efficient assembly code.
+
+### Improved loop inversion
+
+The JIT compiler can hoist the condition of a `while` loop and transform the loop body into a `do-while` loop, improving code layout by removing the need to branch to the top of the loop to test the condition. This transformation is called loop inversion, and it enables numerous other optimizations like loop cloning, loop unrolling, and induction variable optimizations.
+
+.NET 10 enhances loop inversion by switching from a lexical analysis implementation to a graph-based loop recognition implementation. This change brings improved precision by considering all natural loops (loops with a single entry point) and ignoring false positives that were previously considered. This translates into higher optimization potential for .NET programs with `for` and `while` statements.
+
 ## Array interface method devirtualization
 
 One of the [focus areas](https://github.com/dotnet/runtime/issues/108988) for .NET 10 is to reduce the abstraction overhead of popular language features. In pursuit of this goal, the JIT's ability to devirtualize method calls has expanded to cover array interface methods.

docs/core/whats-new/dotnet-10/sdk.md

@@ -11,6 +11,74 @@ ai-usage: ai-assisted
 
 This article describes new features and enhancements in the .NET SDK for .NET 10.
 
+## .NET tools enhancements
+
+### Platform-specific .NET tools
+
+.NET tools can now be published with support for multiple RuntimeIdentifiers (RIDs) in a single package. Tool authors can bundle binaries for all supported platforms, and the .NET CLI will select the correct one at install or run time. This makes cross-platform tool authoring and distribution much easier.
+
+These enhanced tools support various packaging variations:
+
+- **Framework-dependent, platform-agnostic** (classic mode, runs anywhere with .NET 10 installed)
+- **Framework-dependent, platform-specific** (smaller, optimized for each platform)
+- **Self-contained, platform-specific** (includes the runtime, no .NET installation required)
+- **Trimmed, platform-specific** (smaller, trims unused code)
+- **AOT-compiled, platform-specific** (maximum performance and smallest deployment)
+
+These new tools work much like normal published applications, so any publishing options you can use with applications (self-contained, trimmed, AOT, etc.) can apply to tools as well.
+
+### One-shot tool execution
+
+You can now use the `dotnet tool exec` command to execute a .NET tool without installing it globally or locally. This is especially valuable for CI/CD or ephemeral usage.
+
+```bash
+dotnet tool exec --source ./artifacts/package/ toolsay "Hello, World!"
+```
+
+This downloads and runs the specified tool package in one command. By default, users are prompted to confirm the download if the tool doesn't already exist locally. The latest version of the chosen tool package is used unless an explicit version is specified.
+
+One-shot tool execution works seamlessly with local tool manifests. If you run a tool from a location containing a `.config/dotnet-tools.json` nearby, the version of the tool in that configuration will be used instead of the latest version available.
+
+### The new `dnx` tool execution script
+
+The `dnx` script provides a streamlined way to execute tools. It forwards all arguments to the `dotnet` CLI for processing, making tool usage as simple as possible:
+
+```bash
+dnx toolsay "Hello, World!"
+```
+
+The actual implementation of the `dnx` command is in the `dotnet` CLI itself, allowing its behavior to evolve over time.
+
+For more information about managing .NET tools, see [Manage .NET tools](/dotnet/core/tools/global-tools).
+
+### CLI introspection with `--cli-schema`
+
+A new `--cli-schema` option is available on all CLI commands. When used, it outputs a JSON representation of the CLI command tree for the invoked command or subcommand. This is useful for tool authors, shell integration, and advanced scripting.
+
+```bash
+dotnet clean --cli-schema
+```
+
+The output provides a structured, machine-readable description of the command's arguments, options, and subcommands.
+
+## File-based apps enhancements
+
+.NET 10 brings significant updates to the file-based apps experience, including publish support and native AOT capabilities.
+
+### Enhanced file-based apps with publish support and native AOT
+
+File-based apps now support being published to native executables via the `dotnet publish app.cs` command, making it easier to create simple apps that you can redistribute as native executables. All file-based apps now target native AOT by default. If you need to use packages or features that are incompatible with native AOT, you can disable this using the `#:property PublishAot=false` directive in your .cs file.
+
+File-based apps also include enhanced features:
+
+- **Project referencing**: Support for referencing projects via the `#:project` directive
+- **Runtime path access**: App file and directory paths are available at runtime via `System.AppContext.GetData`
+- **Enhanced shebang support**: Direct shell execution with improved shebang handling, including support for extensionless files
+
+These enhancements make file-based apps more powerful while maintaining their simplicity for quick scripting and prototyping scenarios.
+
+For more information about native AOT, see [.NET native AOT](/dotnet/core/deploying/native-aot/).
+
 ## Pruning of framework-provided package references
 
 Starting in .NET 10, the [NuGet Audit](/nuget/concepts/auditing-packages) feature can now [prune framework-provided package references](https://github.com/NuGet/Home/blob/451c27180d14214bca60483caee57f0dc737b8cf/accepted/2024/prune-package-reference.md) that aren't used by the project. This feature is enabled by default for all `net` target frameworks (for example, `net8.0` and `net10.0`) and .NET Standard 2.0 and greater target frameworks. This change helps reduce the number of packages that are restored and analyzed during the build process, which can lead to faster build times and reduced disk space usage. It also can lead to a reduction in false positives from NuGet Audit and other dependency-scanning mechanisms.