@@ -19,6 +19,8 @@
     <NoWarn>$(NoWarn);MA0002;MA0004;MA0006;MA0011;MA0048;MA0051</NoWarn>
   </PropertyGroup>
   <ItemGroup>
+    <!-- Analyze every schema extension, including methods outside the smoke test's runtime paths. -->
+    <TrimmerRootAssembly Include="RepoDb.Schema.Core" RootMode="All" />
     <ProjectReference Include="..\..\RepoDb.Sqlite.Microsoft\RepoDb.Sqlite.Microsoft\RepoDb.Sqlite.Microsoft.csproj" />
     <ProjectReference Include="..\..\..\Schema\RepoDb.Schema.Sqlite.Microsoft\RepoDb.Schema.Sqlite.Microsoft\RepoDb.Schema.Sqlite.Microsoft.csproj" />
   </ItemGroup>
 
@@ -12,20 +12,28 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using Microsoft.Data.Sqlite;
+using RepoDb.Attributes;
 using RepoDb.Schema;
 using RepoDb.Schema.Enumerations;
+using RepoDb.Schema.Models;
 using RepoDb.Schema.Sqlite.Microsoft;
 
 namespace RepoDb.NativeAotTests
 {
     public static partial class Program
     {
+        [Map("Invoice")]
+        private sealed class SchemaInvoice
+        {
+            public long Id { get; set; }
+        }
+
         /// <summary>
         /// Exercises the async exporters with real catalog reads and reflection-based JSON serialization disabled.
         /// </summary>
         private static async Task TestSchemaDefinitionsAsync()
         {
-            await RunAsync("Async schema definitions (JSON, XML, YAML; every relationship behavior)", async () =>
+            await RunAsync("Schema save/read/copy extensions (sync/async; every relationship behavior)", async () =>
             {
                 if (JsonSerializer.IsReflectionEnabledByDefault) throw new Exception("Reflection-based JSON serialization must be disabled.");
                 using var connection = new SqliteConnection("Data Source=:memory:");
@@ -58,7 +66,48 @@ Amount decimal(18,4) NOT NULL DEFAULT 0, Name nvarchar(100),
                             else await connection.SaveDefinitionAsYamlAsync("Invoice", filename, behavior);
                             if (!expected.SequenceEqual(File.ReadAllBytes(filename)))
                                 throw new Exception("Async schema definition differs from synchronous output: " + format + "/" + behavior);
+                            SchemaDefinitionResult synchronous;
+                            SchemaDefinitionResult asynchronous;
+                            if (format == "json")
+                            {
+                                synchronous = connection.ReadDefinitionFromJson(filename);
+                                asynchronous = await connection.ReadDefinitionFromJsonAsync(filename);
+                            }
+                            else if (format == "xml")
+                            {
+                                synchronous = connection.ReadDefinitionFromXml(filename);
+                                asynchronous = await connection.ReadDefinitionFromXmlAsync(filename);
+                            }
+                            else
+                            {
+                                synchronous = connection.ReadDefinitionFromYaml(filename);
+                                asynchronous = await connection.ReadDefinitionFromYamlAsync(filename);
+                            }
+                            var count = behavior == RelatedTableBehavior.TableOnly ? 1
+                                : behavior == RelatedTableBehavior.ParentsAndChildren ? 3 : 2;
+                            if (synchronous.Tables.Count != count || asynchronous.Tables.Count != count ||
+                                !System.Text.Json.Nodes.JsonNode.DeepEquals(synchronous.Definition, asynchronous.Definition))
+                                throw new Exception("Schema readers did not preserve the saved definition.");
+                            var invoice = asynchronous.Tables.Single(table => table.Table.Name == "Invoice");
+                            if (invoice.Columns.Count != 4 || invoice.PrimaryKey == null || invoice.Indexes.Count != 1 ||
+                                invoice.CheckConstraints.Count != 1 || invoice.ForeignKeys.Count != (behavior == RelatedTableBehavior.TableOnly ? 0 : 1))
+                                throw new Exception("Schema readers did not reconstruct the table metadata.");
                         }
+
+                        SchemaComposerMapper.Add<SqliteConnection>(new SqliteSchemaComposer(), true);
+                        using var target = new SqliteConnection("Data Source=:memory:");
+                        await target.OpenAsync();
+                        var copy = connection.CopyTableSchemaTo<SchemaInvoice>(target, relationshipBehavior: behavior);
+                        var copyAsync = await connection.CopyTableSchemaToAsync<SchemaInvoice>(target,
+                            tableExistenceBehavior: TableExistsBehavior.Drop, relationshipBehavior: behavior);
+                        if (copy.Errors.Count != 0 || copyAsync.Errors.Count != 0 || copy.Items.Count != copyAsync.Items.Count)
+                            throw new Exception("Generic schema copy failed.");
+                        var multiple = connection.CopyTableSchemaTo(new[] { "Invoice" }, target,
+                            tableExistenceBehavior: TableExistsBehavior.Skip, relationshipBehavior: behavior);
+                        var multipleAsync = await connection.CopyTableSchemaToAsync(new[] { "Invoice" }, target,
+                            tableExistenceBehavior: TableExistsBehavior.Skip, relationshipBehavior: behavior);
+                        if (multiple.Errors.Count != 0 || multipleAsync.Errors.Count != 0)
+                            throw new Exception("Multiple-table schema copy failed.");
                     }
                 }
                 finally
 
@@ -34,7 +34,7 @@ await connection.SaveDefinitionAsJsonAsync("sales.Invoice", "invoice.json",
 
 The async methods use `ISchemaReader`'s asynchronous catalog operations sequentially, forwarding cancellation and the scoped query settings. Provider readers use asynchronous trace callbacks. Definition construction and serialization run in memory; file writes and flushing use asynchronous IO. Cancellation is checked before committing the complete temporary file. Query, serialization, write, or cancellation failures leave an existing destination intact and remove the temporary file. Replacement itself is a synchronous filesystem operation; cancellation after the commit is not reported as a failed save.
 
-The exporters use explicit JSON nodes and XML construction, without reflection-based object serialization, runtime code generation, or `Task.Run`. The NativeAOT smoke project at `src/Providers/RepoDb.Core/RepoDb.NativeAotTests` exercises all three async exporters and every relationship behavior against SQLite, with `JsonSerializerIsReflectionEnabledByDefault=false`, and compares the output with synchronous saves. Publish it with `dotnet publish -c Release -r win-x64` from that project directory, then run the published executable. Native publishing requires the platform's native toolchain (on Windows, the Visual C++ build tools and Windows SDK). Application-level NativeAOT compatibility also depends on the selected database provider and any custom schema reader or trace implementation.
+The exporters use explicit JSON nodes and XML construction, without reflection-based object serialization, runtime code generation, or `Task.Run`. The NativeAOT smoke project at `src/Providers/RepoDb.Core/RepoDb.NativeAotTests` roots the entire schema core assembly for compilation and exercises synchronous/asynchronous saves, reads, and generic and multiple-table copies against SQLite, for every relationship behavior. It disables reflection-based JSON serialization and compares async saves with synchronous output. Schema creation binds dictionary parameters instead of reflecting over anonymous objects. Publish the smoke project with `dotnet publish -c Release -r win-x64` from that project directory, then run the published executable. Native publishing requires the platform's native toolchain (on Windows, the Visual C++ build tools and Windows SDK). Application-level NativeAOT compatibility also depends on the selected database provider and any custom schema reader or trace implementation.
 
 The provider's reader determines which catalog objects are available. The format captures columns, primary keys, indexes, unique constraints, checks, defaults, identity settings, computed expressions, column comments, collations, and foreign keys. Objects not exposed by `ISchemaReader`, such as triggers and sequence definitions, are outside version 1.
 
 
@@ -7,7 +7,9 @@
 #endregion
 
 using System;
+using System.Collections.Generic;
 using System.Data;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -47,6 +49,7 @@ internal static class CreateSchemaExtension
         /// <param name="transaction">The transaction to be used.</param>
         /// <returns><c>true</c> if the schema was created; <c>false</c> if it already existed.</returns>
         /// <exception cref="ArgumentNullException">The connection or the name of the schema is <c>null</c> (or white space).</exception>
+        [UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode", Justification = "Parameters are a Dictionary<string, object>, and the non-query has no parameters; neither path reflects over an object.")]
         public static bool CreateSchema(IDbConnection connection,
             string schemaName,
             string parameterPrefix,
@@ -60,7 +63,7 @@ public static bool CreateSchema(IDbConnection connection,
         {
             Validate(connection, schemaName);
             var exists = connection.ExecuteScalar(string.Format(CultureInfo.InvariantCulture, existsSql, parameterPrefix + ParameterName),
-                new { SchemaName = schemaName },
+                new Dictionary<string, object> { [ParameterName] = schemaName },
                 commandTimeout: commandTimeout,
                 traceKey: traceKey,
                 transaction: transaction,
@@ -93,6 +96,7 @@ public static bool CreateSchema(IDbConnection connection,
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe while waiting for the task to complete.</param>
         /// <returns>A task that represents the asynchronous operation. The task result is <c>true</c> if the schema was created; <c>false</c> if it already existed.</returns>
         /// <exception cref="ArgumentNullException">The connection or the name of the schema is <c>null</c> (or white space).</exception>
+        [UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode", Justification = "Parameters are a Dictionary<string, object>, and the non-query has no parameters; neither path reflects over an object.")]
         public static async Task<bool> CreateSchemaAsync(IDbConnection connection,
             string schemaName,
             string parameterPrefix,
@@ -107,7 +111,7 @@ public static async Task<bool> CreateSchemaAsync(IDbConnection connection,
         {
             Validate(connection, schemaName);
             var exists = await connection.ExecuteScalarAsync(string.Format(CultureInfo.InvariantCulture, existsSql, parameterPrefix + ParameterName),
-                new { SchemaName = schemaName },
+                new Dictionary<string, object> { [ParameterName] = schemaName },
                 commandTimeout: commandTimeout,
                 traceKey: traceKey,
                 transaction: transaction,