diff --git a/CHANGELOG.md b/CHANGELOG.md
index 626cfa3..4e782bd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 Represents the **NuGet** versions.
 
+## v2.3.15
+- *Fixed:* Updated `CoreEx` to version `3.8.0`.
+- *Fixed:* Updated `OnRamp` to version `2.0.0` which necessitated internal change from `Newtonsoft.Json` (now deprecated) to `System.Text.Json`; additionally, the `DataParser` was refactored accordingly.
+
 ## v2.3.14
 - *Fixed:* All related package dependencies updated to latest.
 
diff --git a/Common.targets b/Common.targets
index 992fac6..aad69b9 100644
--- a/Common.targets
+++ b/Common.targets
@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <Version>2.3.14</Version>
+    <Version>2.3.15</Version>
     <LangVersion>preview</LangVersion>
     <Authors>Avanade</Authors>
     <Company>Avanade</Company>
diff --git a/src/DbEx.MySql/DbEx.MySql.csproj b/src/DbEx.MySql/DbEx.MySql.csproj
index ae0cea3..dfe9a9d 100644
--- a/src/DbEx.MySql/DbEx.MySql.csproj
+++ b/src/DbEx.MySql/DbEx.MySql.csproj
@@ -39,7 +39,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CoreEx.Database.MySql" Version="3.6.3" />
+    <PackageReference Include="CoreEx.Database.MySql" Version="3.8.0" />
     <PackageReference Include="dbup-mysql" Version="5.0.37" />
   </ItemGroup>
 
diff --git a/src/DbEx.SqlServer/DbEx.SqlServer.csproj b/src/DbEx.SqlServer/DbEx.SqlServer.csproj
index b7016d2..7084a7e 100644
--- a/src/DbEx.SqlServer/DbEx.SqlServer.csproj
+++ b/src/DbEx.SqlServer/DbEx.SqlServer.csproj
@@ -30,7 +30,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CoreEx.Database.SqlServer" Version="3.6.3" />
+    <PackageReference Include="CoreEx.Database.SqlServer" Version="3.8.0" />
     <PackageReference Include="dbup-sqlserver" Version="5.0.37" />
   </ItemGroup>
 
diff --git a/src/DbEx/Console/MigrationConsoleBase.cs b/src/DbEx/Console/MigrationConsoleBase.cs
index 3684f24..d4bd033 100644
--- a/src/DbEx/Console/MigrationConsoleBase.cs
+++ b/src/DbEx/Console/MigrationConsoleBase.cs
@@ -27,6 +27,7 @@ namespace DbEx.Console
     /// <para>The underlying command line parsing is provided by <see href="https://natemcmaster.github.io/CommandLineUtils/"/>.</para></remarks>
     public abstract class MigrationConsoleBase
     {
+        private static readonly string[] memberNames = ["args"];
         private const string EntryAssemblyOnlyOptionName = "entry-assembly-only";
         private const string AcceptPromptsOptionName = "accept-prompts";
         private CommandArgument<MigrationCommand>? _commandArg;
@@ -62,7 +63,7 @@ public abstract class MigrationConsoleBase
         /// <summary>
         /// Gets the console (command line) options.
         /// </summary>
-        protected Dictionary<string, CommandOption?> ConsoleOptions { get; } = new();
+        protected Dictionary<string, CommandOption?> ConsoleOptions { get; } = [];
 
         /// <summary>
         /// Indicates whether to bypass standard execution of <see cref="OnWriteMasthead"/>, <see cref="OnWriteHeader"/>, <see cref="OnWriteArgs(DatabaseMigrationBase)"/> and <see cref="OnWriteFooter(double)"/>.
@@ -161,7 +162,7 @@ public async Task<int> RunAsync(string[] args, CancellationToken cancellationTok
                     return vr;
 
                 if (_additionalArgs.Values.Count > 0 && !(Args.MigrationCommand.HasFlag(MigrationCommand.CodeGen) || Args.MigrationCommand.HasFlag(MigrationCommand.Script) || Args.MigrationCommand.HasFlag(MigrationCommand.Execute)))
-                    return new ValidationResult($"Additional arguments can only be specified when the command is '{nameof(MigrationCommand.CodeGen)}', '{nameof(MigrationCommand.Script)}' or '{nameof(MigrationCommand.Execute)}'.", new string[] { "args" });
+                    return new ValidationResult($"Additional arguments can only be specified when the command is '{nameof(MigrationCommand.CodeGen)}', '{nameof(MigrationCommand.Script)}' or '{nameof(MigrationCommand.Execute)}'.", memberNames);
 
                 if (Args.MigrationCommand.HasFlag(MigrationCommand.CodeGen) || Args.MigrationCommand.HasFlag(MigrationCommand.Script))
                 {
@@ -178,7 +179,7 @@ public async Task<int> RunAsync(string[] args, CancellationToken cancellationTok
                         if (string.IsNullOrEmpty(_additionalArgs.Values[i]))
                             continue;
 
-                        Args.ExecuteStatements ??= new List<string>();
+                        Args.ExecuteStatements ??= [];
                         Args.ExecuteStatements.Add(_additionalArgs.Values[i]!);
                     }
                 }
@@ -404,7 +405,7 @@ public static void WriteStandardizedArgs(DatabaseMigrationBase migrator, Action<
 
             migrator.Args.Logger.LogInformation("{Content}", $"Command = {migrator.Args.MigrationCommand}");
             migrator.Args.Logger.LogInformation("{Content}", $"Provider = {migrator.Provider}");
-            migrator.Args.Logger.LogInformation("{Content}", $"SchemaOrder = {string.Join(", ", migrator.Args.SchemaOrder.ToArray())}");
+            migrator.Args.Logger.LogInformation("{Content}", $"SchemaOrder = {string.Join(", ", [.. migrator.Args.SchemaOrder])}");
             migrator.Args.Logger.LogInformation("{Content}", $"OutDir = {migrator.Args.OutputDirectory?.FullName}");
 
             additional?.Invoke(migrator.Args.Logger);
diff --git a/src/DbEx/Console/MigrationConsoleBaseT.cs b/src/DbEx/Console/MigrationConsoleBaseT.cs
index 680fa0d..c0f39b2 100644
--- a/src/DbEx/Console/MigrationConsoleBaseT.cs
+++ b/src/DbEx/Console/MigrationConsoleBaseT.cs
@@ -55,7 +55,7 @@ public TSelf Assemblies(params Type[] types)
                 list.Add(t.Assembly);
             }
 
-            Args.AddAssembly(list.ToArray());
+            Args.AddAssembly([.. list]);
             return (TSelf)this;
         }
 
diff --git a/src/DbEx/DatabaseExtensions.cs b/src/DbEx/DatabaseExtensions.cs
index 82706f7..52c2d6d 100644
--- a/src/DbEx/DatabaseExtensions.cs
+++ b/src/DbEx/DatabaseExtensions.cs
@@ -42,7 +42,7 @@ public static async Task<List<DbTableSchema>> SelectSchemaAsync(this IDatabase d
             var refDataPredicate = new Func<DbTableSchema, bool>(t => t.Columns.Any(c => c.Name == refDataCodeColumn && !c.IsPrimaryKey && c.DotNetType == "string") && t.Columns.Any(c => c.Name == refDataTextColumn && !c.IsPrimaryKey && c.DotNetType == "string"));
 
             // Get all the tables and their columns.
-            using var sr = DatabaseMigrationBase.GetRequiredResourcesStreamReader("SelectTableAndColumns.sql", new Assembly[] { typeof(DatabaseExtensions).Assembly });
+            using var sr = DatabaseMigrationBase.GetRequiredResourcesStreamReader("SelectTableAndColumns.sql", [typeof(DatabaseExtensions).Assembly]);
 #if NET7_0_OR_GREATER
             await database.SqlStatement(await sr.ReadToEndAsync(cancellationToken).ConfigureAwait(false)).SelectQueryAsync(dr =>
 #else
@@ -84,7 +84,7 @@ public static async Task<List<DbTableSchema>> SelectSchemaAsync(this IDatabase d
             }
 
             // Configure all the single column primary and unique constraints.
-            using var sr2 = DatabaseMigrationBase.GetRequiredResourcesStreamReader("SelectTablePrimaryKey.sql", new Assembly[] { typeof(DatabaseExtensions).Assembly });
+            using var sr2 = DatabaseMigrationBase.GetRequiredResourcesStreamReader("SelectTablePrimaryKey.sql", [typeof(DatabaseExtensions).Assembly]);
 #if NET7_0_OR_GREATER
             var pks = await database.SqlStatement(await sr2.ReadToEndAsync(cancellationToken).ConfigureAwait(false)).SelectQueryAsync(dr => new
 #else
diff --git a/src/DbEx/DbEx.csproj b/src/DbEx/DbEx.csproj
index 7a48d90..b8897f5 100644
--- a/src/DbEx/DbEx.csproj
+++ b/src/DbEx/DbEx.csproj
@@ -21,8 +21,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CoreEx.Database" Version="3.6.3" />
-    <PackageReference Include="OnRamp" Version="1.0.8" />
+    <PackageReference Include="CoreEx.Database" Version="3.8.0" />
+    <PackageReference Include="OnRamp" Version="2.0.0" />
   </ItemGroup>
 
   <Import Project="..\..\Common.targets" />
diff --git a/src/DbEx/DbSchema/DbTableSchema.cs b/src/DbEx/DbSchema/DbTableSchema.cs
index 6ff3a04..b705fc4 100644
--- a/src/DbEx/DbSchema/DbTableSchema.cs
+++ b/src/DbEx/DbSchema/DbTableSchema.cs
@@ -176,17 +176,17 @@ public DbTableSchema(DbTableSchema table)
         /// <summary>
         /// Gets or sets the <see cref="DbColumnSchema"/> list.
         /// </summary>
-        public List<DbColumnSchema> Columns { get; private set; } = new List<DbColumnSchema>();
+        public List<DbColumnSchema> Columns { get; private set; } = [];
 
         /// <summary>
         /// Gets the primary key <see cref="DbColumnSchema"/> list.
         /// </summary>
-        public List<DbColumnSchema> PrimaryKeyColumns => Columns?.Where(x => x.IsPrimaryKey).ToList() ?? new List<DbColumnSchema>();
+        public List<DbColumnSchema> PrimaryKeyColumns => Columns?.Where(x => x.IsPrimaryKey).ToList() ?? [];
 
         /// <summary>
         /// Gets the standard <see cref="DbColumnSchema"/> list (i.e. not primary key, not created audit, not updated audit, not tenant-id, not row-version, not is-deleted).
         /// </summary>
-        public List<DbColumnSchema> StandardColumns => Columns?.Where(x => !x.IsPrimaryKey && !x.IsCreatedAudit && !x.IsUpdatedAudit && !x.IsTenantId && !x.IsRowVersion && !x.IsIsDeleted).ToList() ?? new List<DbColumnSchema>();
+        public List<DbColumnSchema> StandardColumns => Columns?.Where(x => !x.IsPrimaryKey && !x.IsCreatedAudit && !x.IsUpdatedAudit && !x.IsTenantId && !x.IsRowVersion && !x.IsIsDeleted).ToList() ?? [];
 
         /// <summary>
         /// Gets the tenant idenfifier <see cref="DbColumnSchema"/> (if any).
diff --git a/src/DbEx/Migration/Data/DataConfig.cs b/src/DbEx/Migration/Data/DataConfig.cs
index 10f90c1..a6f82e5 100644
--- a/src/DbEx/Migration/Data/DataConfig.cs
+++ b/src/DbEx/Migration/Data/DataConfig.cs
@@ -1,25 +1,30 @@
 // Copyright (c) Avanade. Licensed under the MIT License. See https://github.com/Avanade/DbEx
 
+using System.Text.Json.Serialization;
+
 namespace DbEx.Migration.Data
 {
     /// <summary>
-    /// Respresents the data configuration.
+    /// Represents the data configuration.
     /// </summary>
     public class DataConfig
     {
         /// <summary>
         /// Gets or sets the pre-condition SQL.
         /// </summary>
+        [JsonPropertyName("preConditionSql")]
         public string? PreConditionSql { get; set; }
 
         /// <summary>
         /// Gets or sets the pre-SQL.
         /// </summary>
+        [JsonPropertyName("preSql")]
         public string? PreSql { get; set; }
 
         /// <summary>
         /// Gets or sets the post-SQL.
         /// </summary>
+        [JsonPropertyName("postSql")]
         public string? PostSql { get; set; }
     }
 }
\ No newline at end of file
diff --git a/src/DbEx/Migration/Data/DataParser.cs b/src/DbEx/Migration/Data/DataParser.cs
index 7eab3a8..8f8cf67 100644
--- a/src/DbEx/Migration/Data/DataParser.cs
+++ b/src/DbEx/Migration/Data/DataParser.cs
@@ -2,14 +2,15 @@
 
 using DbEx.DbSchema;
 using HandlebarsDotNet;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Threading;
 using System.Threading.Tasks;
+using YamlDotNet.Core.Events;
 using YamlDotNet.Serialization;
 
 namespace DbEx.Migration.Data
@@ -19,6 +20,36 @@ namespace DbEx.Migration.Data
     /// </summary>
     public class DataParser
     {
+        private class YamlNodeTypeResolver : INodeTypeResolver
+        {
+            private static readonly string[] boolValues = ["true", "false"];
+
+            /// <inheritdoc/>
+            bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
+            {
+                if (nodeEvent is Scalar scalar && scalar.Style == YamlDotNet.Core.ScalarStyle.Plain)
+                {
+                    if (decimal.TryParse(scalar.Value, out _))
+                    {
+                        if (scalar.Value.Length > 1 && scalar.Value.StartsWith('0')) // Valid JSON does not support a number that starts with a zero.
+                            currentType = typeof(string);
+                        else
+                            currentType = typeof(decimal);
+
+                        return true;
+                    }
+
+                    if (boolValues.Contains(scalar.Value))
+                    {
+                        currentType = typeof(bool);
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="DataParser"/> class.
         /// </summary>
@@ -79,9 +110,9 @@ public Task<List<DataTable>> ParseYamlAsync(Stream s, CancellationToken cancella
         /// <returns>The resulting <see cref="DataTable"/> list.</returns>
         public Task<List<DataTable>> ParseYamlAsync(TextReader tr, CancellationToken cancellationToken = default)
         {
-            var yaml = new DeserializerBuilder().Build().Deserialize(tr)!;
+            var yaml = new DeserializerBuilder().WithNodeTypeResolver(new YamlNodeTypeResolver()).Build().Deserialize(tr)!;
             var json = new SerializerBuilder().JsonCompatible().Build().Serialize(yaml);
-            return ParseJsonAsync(JObject.Parse(json), cancellationToken);
+            return ParseJsonAsync(json, cancellationToken);
         }
 
         /// <summary>
@@ -104,8 +135,8 @@ public Task<List<DataTable>> ParseJsonAsync(string json, CancellationToken cance
         /// <returns>The resulting <see cref="DataTable"/> list.</returns>
         public Task<List<DataTable>> ParseJsonAsync(Stream s, CancellationToken cancellationToken = default)
         {
-            using var sr = new StreamReader(s);
-            return ParseJsonAsync(sr, cancellationToken);
+            using var jd = JsonDocument.Parse(s);
+            return ParseJsonAsync(jd, cancellationToken);
         }
 
         /// <summary>
@@ -116,14 +147,14 @@ public Task<List<DataTable>> ParseJsonAsync(Stream s, CancellationToken cancella
         /// <returns>The resulting <see cref="DataTable"/> list.</returns>
         public Task<List<DataTable>> ParseJsonAsync(TextReader tr, CancellationToken cancellationToken = default)
         {
-            using var jr = new JsonTextReader(tr);
-            return ParseJsonAsync(JObject.Load(jr), cancellationToken);
+            using var jd = JsonDocument.Parse(tr.ReadToEnd());
+            return ParseJsonAsync(jd, cancellationToken);
         }
 
         /// <summary>
-        /// Reads and parses the database using the specified <see cref="JObject"/>.
+        /// Reads and parses the database using the specified <see cref="JsonDocument"/>.
         /// </summary>
-        private async Task<List<DataTable>> ParseJsonAsync(JObject json, CancellationToken cancellationToken)
+        private async Task<List<DataTable>> ParseJsonAsync(JsonDocument json, CancellationToken cancellationToken)
         {
             // Further update/manipulate the schema.
             if (Args.DbSchemaUpdaterAsync != null)
@@ -134,19 +165,22 @@ private async Task<List<DataTable>> ParseJsonAsync(JObject json, CancellationTok
             DataConfig? dataConfig = null;
 
             // Loop through all the schemas.
-            foreach (var js in json.Children<JProperty>())
+            foreach (var js in json.RootElement.EnumerateObject())
             {
                 // Check for data configuration as identified by the * schema - which is a special key notation.
                 if (js.Name == "*")
                 {
-                    dataConfig = js.Children<JObject>().FirstOrDefault()?.ToObject<DataConfig?>();
+                    if (js.Value.ValueKind != JsonValueKind.Object)
+                        throw new DataParserException("Data configuration ('*' schema) is invalid; must be an object.");
+
+                    dataConfig = js.Value.Deserialize<DataConfig>();
                     continue;
                 }
 
                 // Loop through the collection of tables.
-                foreach (var jto in GetChildObjects(js))
+                foreach (var jto in js.Value.EnumerateArray())
                 {
-                    foreach (var jt in jto.Children<JProperty>())
+                    foreach (var jt in jto.EnumerateObject())
                     {
                         await ParseTableJsonAsync(tables, null, js.Name, jt, cancellationToken).ConfigureAwait(false);
                     }
@@ -168,10 +202,10 @@ private async Task<List<DataTable>> ParseJsonAsync(JObject json, CancellationTok
         /// <summary>
         /// Reads and parses the table data.
         /// </summary>
-        private async Task ParseTableJsonAsync(List<DataTable> tables, DataRow? parent, string schema, JProperty jt, CancellationToken cancellationToken)
+        private async Task ParseTableJsonAsync(List<DataTable> tables, DataRow? parent, string schema, JsonProperty jp, CancellationToken cancellationToken)
         {
             // Get existing or create new table.
-            var sdt = new DataTable(this, DatabaseSchemaConfig.SupportsSchema ? schema : string.Empty, jt.Name);
+            var sdt = new DataTable(this, DatabaseSchemaConfig.SupportsSchema ? schema : string.Empty, jp.Name);
             var prev = tables.SingleOrDefault(x => x.Schema == sdt.Schema && x.Name == sdt.Name);
             if (prev is null)
                 tables.Add(sdt);
@@ -179,30 +213,32 @@ private async Task ParseTableJsonAsync(List<DataTable> tables, DataRow? parent,
                 sdt = prev;
 
             // Loop through the collection of rows.
-            foreach (var jro in GetChildObjects(jt))
+            foreach (var jro in jp.Value.EnumerateArray())
             {
                 var row = new DataRow(sdt);
 
-                foreach (var jr in jro.Children<JProperty>())
+                foreach (var jr in jro.EnumerateObject())
                 {
-                    if (jr.Value.Type == JTokenType.Object)
-                    {
-                        throw new DataParserException($"Table '{sdt.Schema}.{sdt.Name}' has unsupported '{jr.Name}' column value; must not be an object: {jr.Value}.");
-                    }
-                    else if (jr.Value.Type == JTokenType.Array)
-                    {
-                        // Try parsing as a further described nested table configuration; i.e. representing a relationship.
-                        await ParseTableJsonAsync(tables, row, sdt.Schema, jr, cancellationToken).ConfigureAwait(false);
-                    }
-                    else
+                    switch (jr.Value.ValueKind)
                     {
-                        if (sdt.IsRefData && jro.Children().Count() == 1)
-                        {
-                            row.AddColumn(Args.RefDataCodeColumnName ?? DatabaseSchemaConfig.RefDataCodeColumnName, GetColumnValue(jr.Name));
-                            row.AddColumn(Args.RefDataTextColumnName ?? DatabaseSchemaConfig.RefDataTextColumnName, GetColumnValue(jr.Value));
-                        }
-                        else
-                            row.AddColumn(jr.Name, GetColumnValue(jr.Value));
+                        case JsonValueKind.Object:
+                            throw new DataParserException($"Table '{sdt.Schema}.{sdt.Name}' has unsupported '{jr.Name}' column value; must not be an object: {jr.Value}.");
+
+                        case JsonValueKind.Array:
+                            // Try parsing as a further described nested table configuration; i.e. representing a relationship.
+                            await ParseTableJsonAsync(tables, row, sdt.Schema, jr, cancellationToken).ConfigureAwait(false);
+                            break;
+
+                        default:
+                            if (sdt.IsRefData && jro.EnumerateObject().Count() == 1)
+                            {
+                                row.AddColumn(Args.RefDataCodeColumnName ?? DatabaseSchemaConfig.RefDataCodeColumnName, jr.Name);
+                                row.AddColumn(Args.RefDataTextColumnName ?? DatabaseSchemaConfig.RefDataTextColumnName, jr.Value.GetString());
+                            }
+                            else
+                                row.AddColumn(jr.Name, GetColumnValue(jr.Value));
+
+                            break;
                     }
                 }
 
@@ -220,38 +256,77 @@ private async Task ParseTableJsonAsync(List<DataTable> tables, DataRow? parent,
                 sdt.AddRow(row);
             }
 
+            //// Loop through the collection of rows.
+            //foreach (var jro in GetChildObjects(jp))
+            //{
+            //    var row = new DataRow(sdt);
+
+            //    foreach (var jr in jro.Children<JProperty>())
+            //    {
+            //        if (jr.Value.Type == JTokenType.Object)
+            //        {
+            //            throw new DataParserException($"Table '{sdt.Schema}.{sdt.Name}' has unsupported '{jr.Name}' column value; must not be an object: {jr.Value}.");
+            //        }
+            //        else if (jr.Value.Type == JTokenType.Array)
+            //        {
+            //            // Try parsing as a further described nested table configuration; i.e. representing a relationship.
+            //            await ParseTableJsonAsync(tables, row, sdt.Schema, jr, cancellationToken).ConfigureAwait(false);
+            //        }
+            //        else
+            //        {
+            //            if (sdt.IsRefData && jro.Children().Count() == 1)
+            //            {
+            //                row.AddColumn(Args.RefDataCodeColumnName ?? DatabaseSchemaConfig.RefDataCodeColumnName, GetColumnValue(jr.Name));
+            //                row.AddColumn(Args.RefDataTextColumnName ?? DatabaseSchemaConfig.RefDataTextColumnName, GetColumnValue(jr.Value));
+            //            }
+            //            else
+            //                row.AddColumn(jr.Name, GetColumnValue(jr.Value));
+            //        }
+            //    }
+
+            //    // Where specified within a hierarchy attempt to be fancy and auto-update from the parent's primary key where same name.
+            //    if (parent is not null)
+            //    {
+            //        foreach (var pktc in parent.Table.DbTable.PrimaryKeyColumns)
+            //        {
+            //            var pkc = parent.Columns.SingleOrDefault(x => x.Name == pktc.Name);
+            //            if (pkc is not null && row.Table.DbTable.Columns.Any(x => x.Name == pktc.Name) && row.Columns.SingleOrDefault(x => x.Name == pktc.Name) is null)
+            //                row.AddColumn(pkc.Name, pkc.Value);
+            //        }
+            //    }
+
+            //    sdt.AddRow(row);
+            //}
+
             if (sdt.Columns.Count > 0)
                 await sdt.PrepareAsync(cancellationToken).ConfigureAwait(false);
         }
 
-        /// <summary>
-        /// Gets the child objects.
-        /// </summary>
-        private static IEnumerable<JObject> GetChildObjects(JToken j)
-        {
-            foreach (var jc in j.Children<JArray>())
-            {
-                return jc.Children<JObject>();
-            }
+        ///// <summary>
+        ///// Gets the child objects.
+        ///// </summary>
+        //private static IEnumerable<JObject> GetChildObjects(JToken j)
+        //{
+        //    foreach (var jc in j.Children<JArray>())
+        //    {
+        //        return jc.Children<JObject>();
+        //    }
 
-            return Array.Empty<JObject>();
-        }
+        //    return Array.Empty<JObject>();
+        //}
 
         /// <summary>
         /// Gets the column value.
         /// </summary>
-        private object? GetColumnValue(JToken j)
+        private object? GetColumnValue(JsonElement j)
         {
-            return j.Type switch
+            return j.ValueKind switch
             {
-                JTokenType.Boolean => j.Value<bool>(),
-                JTokenType.Date => j.Value<DateTime>(),
-                JTokenType.Float => j.Value<float>(),
-                JTokenType.Guid => j.Value<Guid>(),
-                JTokenType.Integer => j.Value<long>(),
-                JTokenType.TimeSpan => j.Value<TimeSpan>(),
-                JTokenType.Uri => j.Value<string>(),
-                JTokenType.String => GetRuntimeParameterValue(j.Value<string>()),
+                JsonValueKind.Null => null,
+                JsonValueKind.True => true,
+                JsonValueKind.False => false,
+                JsonValueKind.Number => j.GetDecimal(),
+                JsonValueKind.String => j.TryGetDateTime(out var dt) ? dt : GetRuntimeParameterValue(j.GetString()),
                 _ => null
             };
         }
@@ -265,7 +340,7 @@ private static IEnumerable<JObject> GetChildObjects(JToken j)
                 return value;
 
             // Get runtime value when formatted like: ^(DateTime.UtcNow)
-            if (value.StartsWith("^(") && value.EndsWith(")"))
+            if (value.StartsWith("^(") && value.EndsWith(')'))
             {
                 var key = value[2..^1];
 
@@ -340,7 +415,7 @@ private static (object? value, string? message) GetSystemPropertyValue(string pa
             var part = parts[0];
             if (part.EndsWith("()"))
             {
-                var mi = type.GetMethod(part[0..^2], Array.Empty<Type>());
+                var mi = type.GetMethod(part[0..^2], []);
                 if (mi == null || mi.GetParameters().Length != 0)
                     return (null, $"Runtime value parameter '{param}' is invalid; specified method '{part}' is invalid.");
 
diff --git a/src/DbEx/Migration/Data/DataParserArgs.cs b/src/DbEx/Migration/Data/DataParserArgs.cs
index 1d754bc..ee5235c 100644
--- a/src/DbEx/Migration/Data/DataParserArgs.cs
+++ b/src/DbEx/Migration/Data/DataParserArgs.cs
@@ -116,7 +116,7 @@ public class DataParserArgs
         /// Gets or sets the reference data column defaults dictionary.
         /// </summary>
         /// <remarks>The list should contain the column name and function that returns the default value (the input to the function is the corresponding row count as specified).</remarks>
-        public Dictionary<string, Func<int, object?>> RefDataColumnDefaults { get; } = new Dictionary<string, Func<int, object?>>();
+        public Dictionary<string, Func<int, object?>> RefDataColumnDefaults { get; } = [];
 
         /// <summary>
         /// Adds a reference data column default to the <see cref="RefDataColumnDefaults"/>.
@@ -134,7 +134,7 @@ public DataParserArgs RefDataColumnDefault(string column, Func<int, object?> @de
         /// Gets or sets the column defaults collection.
         /// </summary>
         /// <remarks>The list should contain the column name and function that returns the default value (the input to the function is the corresponding row count as specified).</remarks>
-        public DataParserColumnDefaultCollection ColumnDefaults { get; } = new DataParserColumnDefaultCollection();
+        public DataParserColumnDefaultCollection ColumnDefaults { get; } = [];
 
         /// <summary>
         /// Adds a <see cref="DataParserColumnDefault"/> to the <see cref="ColumnDefaults"/>.
@@ -153,7 +153,7 @@ public DataParserArgs ColumnDefault(string schema, string table, string column,
         /// <summary>
         /// Gets the runtime parameters.
         /// </summary>
-        public Dictionary<string, object?> Parameters { get; } = new Dictionary<string, object?>();
+        public Dictionary<string, object?> Parameters { get; } = [];
 
         /// <summary>
         /// Adds a parameter to the <see cref="MigrationArgsBase.Parameters"/> where it does not already exist; unless <paramref name="overrideExisting"/> is selected then it will add or override.
@@ -179,7 +179,7 @@ public DataParserArgs Parameter(string key, object? value, bool overrideExisting
         /// <summary>
         /// Gets the <see cref="DataParserTableNameMappings"/>.
         /// </summary>
-        public DataParserTableNameMappings TableNameMappings { get; } = new DataParserTableNameMappings();
+        public DataParserTableNameMappings TableNameMappings { get; } = [];
 
         /// <summary>
         /// Copy and replace from <paramref name="args"/>.
diff --git a/src/DbEx/Migration/Data/DataParserTableNameMappings.cs b/src/DbEx/Migration/Data/DataParserTableNameMappings.cs
index 813147d..b8bcb4d 100644
--- a/src/DbEx/Migration/Data/DataParserTableNameMappings.cs
+++ b/src/DbEx/Migration/Data/DataParserTableNameMappings.cs
@@ -11,7 +11,7 @@ namespace DbEx.Migration.Data
     /// </summary>
     public class DataParserTableNameMappings : IEnumerable<KeyValuePair<(string ParsedSchema, string ParsedTable), (string Schema, string Table, Dictionary<string, string>? ColumnMappings)>>
     {
-        private readonly Dictionary<(string, string), (string, string, Dictionary<string, string>?)> _dict = new();
+        private readonly Dictionary<(string, string), (string, string, Dictionary<string, string>?)> _dict = [];
 
         /// <summary>
         /// Adds a schema, table and column(s) mapping.
diff --git a/src/DbEx/Migration/Data/DataRow.cs b/src/DbEx/Migration/Data/DataRow.cs
index 3704429..81b0f0f 100644
--- a/src/DbEx/Migration/Data/DataRow.cs
+++ b/src/DbEx/Migration/Data/DataRow.cs
@@ -25,7 +25,7 @@ public class DataRow
         /// <summary>
         /// Gets the columns.
         /// </summary>
-        public List<DataColumn> Columns { get; } = new List<DataColumn>();
+        public List<DataColumn> Columns { get; } = [];
 
         /// <summary>
         /// Gets the insert columns.
diff --git a/src/DbEx/Migration/Data/DataTable.cs b/src/DbEx/Migration/Data/DataTable.cs
index b30ef63..50d1bcb 100644
--- a/src/DbEx/Migration/Data/DataTable.cs
+++ b/src/DbEx/Migration/Data/DataTable.cs
@@ -114,7 +114,7 @@ internal DataTable(DataParser parser, string schema, string name)
         /// <summary>
         /// Gets the columns.
         /// </summary>
-        public List<DbColumnSchema> Columns { get; } = new List<DbColumnSchema>();
+        public List<DbColumnSchema> Columns { get; } = [];
 
         /// <summary>
         /// Gets the insert columns.
@@ -144,7 +144,7 @@ internal DataTable(DataParser parser, string schema, string name)
         /// <summary>
         /// Gets the rows.
         /// </summary>
-        public List<DataRow> Rows { get; } = new List<DataRow>();
+        public List<DataRow> Rows { get; } = [];
 
         /// <summary>
         /// Gets the column name mappings (from the <see cref="DataParserArgs.TableNameMappings"/> where specified).
diff --git a/src/DbEx/Migration/DatabaseMigrationBase.cs b/src/DbEx/Migration/DatabaseMigrationBase.cs
index 5e84d02..91dfb71 100644
--- a/src/DbEx/Migration/DatabaseMigrationBase.cs
+++ b/src/DbEx/Migration/DatabaseMigrationBase.cs
@@ -58,7 +58,7 @@ protected DatabaseMigrationBase(MigrationArgsBase args)
             Args.OutputDirectory ??= new DirectoryInfo(CodeGenConsole.GetBaseExeDirectory());
 
             Journal = new DatabaseJournal(this);
-            SchemaObjectTypes = Array.Empty<string>();
+            SchemaObjectTypes = [];
         }
 
         /// <summary>
@@ -173,7 +173,7 @@ public virtual async Task<bool> MigrateAsync(CancellationToken cancellationToken
 
             // Where only executing SQL statement, then execute and get out of here!
             if (Args.MigrationCommand.HasFlag(MigrationCommand.Execute))
-                return await ExecuteSqlStatementsAsync(Args.ExecuteStatements?.ToArray() ?? Array.Empty<string>(), cancellationToken).ConfigureAwait(false);
+                return await ExecuteSqlStatementsAsync(Args.ExecuteStatements?.ToArray() ?? [], cancellationToken).ConfigureAwait(false);
 
             /* The remaining commands are executed in sequence as defined (where selected) to enable multiple in the correct run order. */
 
@@ -829,7 +829,7 @@ private IEnumerable<string> GetNamespacesWithSuffix(string suffix, bool reverse
                 list.Add($"{ns}.{suffix}");
             }
 
-            return list.Count == 0 ? new string[] { "(none)" } : list.ToArray();
+            return list.Count == 0 ? new string[] { "(none)" } : [.. list];
         }
 
         /// <summary>
diff --git a/src/DbEx/Migration/MigrationArgsBase.cs b/src/DbEx/Migration/MigrationArgsBase.cs
index 7f18cbd..9bc7f0c 100644
--- a/src/DbEx/Migration/MigrationArgsBase.cs
+++ b/src/DbEx/Migration/MigrationArgsBase.cs
@@ -43,7 +43,7 @@ public abstract class MigrationArgsBase : OnRamp.CodeGeneratorDbArgsBase
         /// <summary>
         /// Gets the <see cref="Assembly"/> list to use to probe for assembly resource (in defined sequence); will automatically add this (DbEx) assembly also (therefore no need to explicitly specify).
         /// </summary>
-        public List<Assembly> Assemblies { get; } = new List<Assembly> { typeof(MigrationArgs).Assembly };
+        public List<Assembly> Assemblies { get; } = [typeof(MigrationArgs).Assembly];
 
         /// <summary>
         /// Gets the <see cref="Assemblies"/> reversed in order for probe-based sequencing.
@@ -55,7 +55,7 @@ public abstract class MigrationArgsBase : OnRamp.CodeGeneratorDbArgsBase
         /// </summary>
         /// <remarks>The following parameter names are reserved for a specific internal purpose: <see cref="DatabaseNameParamName"/>, <see cref="JournalSchemaParamName"/> and <see cref="JournalTableParamName"/>.
         /// <para><see cref="MigrationCommand.Script"/> and <see cref="MigrationCommand.CodeGen"/> can support additional command-line arguments; these are automatically added as '<c>ParamN</c>' where '<c>N</c>' is the zero-based index; e.g. '<c>Param0</c>'.</para></remarks>
-        public Dictionary<string, object?> Parameters { get; } = new Dictionary<string, object?>();
+        public Dictionary<string, object?> Parameters { get; } = [];
 
         /// <summary>
         /// Gets or sets the <see cref="ILogger"/> to optionally log the underlying database migration progress.
@@ -70,7 +70,7 @@ public abstract class MigrationArgsBase : OnRamp.CodeGeneratorDbArgsBase
         /// <summary>
         /// Gets the schema priority list (used to specify schema precedence; otherwise equal last).
         /// </summary>
-        public List<string> SchemaOrder { get; } = new List<string>();
+        public List<string> SchemaOrder { get; } = [];
 
         /// <summary>
         /// Gets or sets the <see cref="Data.DataParserArgs"/>.
@@ -170,7 +170,7 @@ protected void CopyFrom(MigrationArgsBase args)
                 ExecuteStatements = null;
             else
             {
-                ExecuteStatements = new();
+                ExecuteStatements = [];
                 ExecuteStatements.AddRange(args.ExecuteStatements);
             }
         }
diff --git a/src/DbEx/Migration/StringLogger.cs b/src/DbEx/Migration/StringLogger.cs
index 2a6923c..afe8692 100644
--- a/src/DbEx/Migration/StringLogger.cs
+++ b/src/DbEx/Migration/StringLogger.cs
@@ -12,14 +12,10 @@ namespace DbEx.Migration
     internal class StringLogger : ILogger
     {
         private readonly StringBuilder _stringBuilder = new();
-        private readonly IExternalScopeProvider _scopeProvider = new LoggerExternalScopeProvider();
+        private readonly LoggerExternalScopeProvider _scopeProvider = new();
 
         /// <inheritdoc/>
-#if NET7_0_OR_GREATER
         public IDisposable BeginScope<TState>(TState state) where TState : notnull => _scopeProvider.Push(state);
-#else
-        public IDisposable BeginScope<TState>(TState state) => _scopeProvider.Push(state);
-#endif
 
         /// <inheritdoc/>
         public bool IsEnabled(LogLevel logLevel) => true;
diff --git a/tests/DbEx.Test.OutboxConsole/Config/RootConfig.cs b/tests/DbEx.Test.OutboxConsole/Config/RootConfig.cs
index f097820..06fb226 100644
--- a/tests/DbEx.Test.OutboxConsole/Config/RootConfig.cs
+++ b/tests/DbEx.Test.OutboxConsole/Config/RootConfig.cs
@@ -1,20 +1,20 @@
-using Newtonsoft.Json;
-using OnRamp.Config;
+using OnRamp.Config;
+using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 
 namespace DbEx.Test.OutboxConsole.Config
 {
-    [JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+    [CodeGenClass("CodeGen")]
     public sealed class RootConfig : ConfigRootBase<RootConfig>
     {
-        [JsonProperty("namespaceOutbox", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [JsonPropertyName("namespaceOutbox")]
         [CodeGenProperty("Namespace", Title = "The Namespace (root) for the Outbox-related .NET artefacts.")]
         public string? NamespaceOutbox { get; set; }
 
         /// <summary>
         /// Gets or sets the schema name of the event outbox table.
         /// </summary>
-        [JsonProperty("outboxSchema", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [JsonPropertyName("outboxSchema")]
         [CodeGenProperty("Outbox", Title = "The schema name of the event outbox table.",
             Description = "Defaults to `Outbox` (literal).")]
         public string? OutboxSchema { get; set; }
@@ -22,7 +22,7 @@ public sealed class RootConfig : ConfigRootBase<RootConfig>
         /// <summary>
         /// Gets or sets the name of the event outbox table.
         /// </summary>
-        [JsonProperty("outboxTable", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [JsonPropertyName("outboxTable")]
         [CodeGenProperty("Outbox", Title = "The name of the event outbox table.",
             Description = "Defaults to `EventOutbox` (literal).")]
         public string? OutboxTable { get; set; }
@@ -30,7 +30,7 @@ public sealed class RootConfig : ConfigRootBase<RootConfig>
         /// <summary>
         /// Gets or sets the stored procedure name for the event outbox enqueue.
         /// </summary>
-        [JsonProperty("outboxEnqueueStoredProcedure", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [JsonPropertyName("outboxEnqueueStoredProcedure")]
         [CodeGenProperty("Outbox", Title = "The stored procedure name for the event outbox enqueue.",
             Description = "Defaults to `spEventOutboxEnqueue` (literal).")]
         public string? OutboxEnqueueStoredProcedure { get; set; }
@@ -38,7 +38,7 @@ public sealed class RootConfig : ConfigRootBase<RootConfig>
         /// <summary>
         /// Gets or sets the stored procedure name for the event outbox dequeue.
         /// </summary>
-        [JsonProperty("outboxDequeueStoredProcedure", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [JsonPropertyName("outboxDequeueStoredProcedure")]
         [CodeGenProperty("Outbox", Title = "The stored procedure name for the event outbox dequeue.",
             Description = "Defaults to `spEventOutboxDequeue` (literal).")]
         public string? OutboxDequeueStoredProcedure { get; set; }
diff --git a/tests/DbEx.Test/SqlServerMigrationTest.cs b/tests/DbEx.Test/SqlServerMigrationTest.cs
index 7fdbb71..beed77a 100644
--- a/tests/DbEx.Test/SqlServerMigrationTest.cs
+++ b/tests/DbEx.Test/SqlServerMigrationTest.cs
@@ -64,10 +64,10 @@ public async Task A120_MigrateAll_With_Log_Output()
             var l = UnitTest.GetLogger<SqlServerMigrationTest>();
             var a = new MigrationArgs(MigrationCommand.DropAndAll, cs) { Logger = l }.AddAssembly(typeof(Error.TestError));
             using var m = new SqlServerMigration(a);
-            var r = await m.MigrateAndLogAsync().ConfigureAwait(false);
+            var (Success, Output) = await m.MigrateAndLogAsync().ConfigureAwait(false);
 
-            Assert.IsFalse(r.Success);
-            Assert.IsTrue(r.Output.Length > 0);
+            Assert.IsFalse(Success);
+            Assert.IsTrue(Output.Length > 0);
         }
 
         [Test]
@@ -254,7 +254,7 @@ public async Task B120_Execute_Console_Batch_Error()
         }
 
         [Test]
-        public async Task B120_Execute_Console_Batch_Success()
+        public async Task B130_Execute_Console_Batch_Success()
         {
             var c = await CreateConsoleDb().ConfigureAwait(false);
             var a = new MigrationArgs(MigrationCommand.Execute, c.cs) { Logger = c.l }.AddAssembly(typeof(Console.Program).Assembly);