diff --git a/.config/npm-packages.json b/.config/npm-packages.json
new file mode 100644
index 0000000..6a030e9
--- /dev/null
+++ b/.config/npm-packages.json
@@ -0,0 +1,6 @@
+{
+  "chart.js": "4.5.1",
+  "chartjs-chart-geo": "4.3.6",
+  "luxon": "3.7.2",
+  "world-atlas": "2.0.2"
+}
\ No newline at end of file
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 15e41ef..ba59dae 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -1,9 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
-    <ItemGroup>
-        <PackageVersion Include="DotMake.CommandLine" Version="3.1.0" />
-        <PackageVersion Include="NuGet.Versioning" Version="7.0.1" />
-        <PackageVersion Include="System.Text.Encodings.Web" Version="10.0.2" />
-        <PackageVersion Include="System.Text.Json" Version="10.0.2" />
-    </ItemGroup>
-</Project>
+  <ItemGroup>
+    <PackageVersion Include="DotMake.CommandLine" Version="3.1.0" />
+    <PackageVersion Include="Microsoft.Extensions.Http" Version="10.0.2" />
+    <PackageVersion Include="NuGet.Versioning" Version="7.0.1" />
+    <PackageVersion Include="System.Text.Encodings.Web" Version="10.0.2" />
+    <PackageVersion Include="System.Text.Json" Version="10.0.2" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/MissingMethodException.slnx b/MissingMethodException.slnx
index 3fb3aa6..6f71738 100644
--- a/MissingMethodException.slnx
+++ b/MissingMethodException.slnx
@@ -33,4 +33,10 @@
         <File Path=".config/npm-packages.json" />
     </Folder>
     <Project Path="DataTypes/DataTypes.csproj" />
+    <Project Path="NpmRegistry.Wrapper/NpmRegistry.Wrapper.csproj">
+        <BuildType Solution="CompileModels|*" Project="Release" />
+        <BuildType Solution="CompileSimulationModels|*" Project="Release" />
+        <BuildType Solution="CreateData|*" Project="Release" />
+        <BuildType Solution="Simulation|*" Project="Release" />
+    </Project>
 </Solution>
diff --git a/NpmRegistry.Wrapper/Models/Attestations.cs b/NpmRegistry.Wrapper/Models/Attestations.cs
new file mode 100644
index 0000000..d2e163b
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/Attestations.cs
@@ -0,0 +1,13 @@
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+public class Attestations
+{
+    [JsonPropertyName("url")]
+#pragma warning disable CA1056 // URI-like properties should not be strings
+    public string Url { get; set; } = string.Empty;
+#pragma warning restore CA1056 // URI-like properties should not be strings
+
+    [JsonPropertyName("provenance")]
+    public Provenance Provenance { get; set; } = new Provenance();
+}
diff --git a/NpmRegistry.Wrapper/Models/BinScript.cs b/NpmRegistry.Wrapper/Models/BinScript.cs
new file mode 100644
index 0000000..5aff3df
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/BinScript.cs
@@ -0,0 +1,6 @@
+namespace NpmRegistry.Wrapper.Models;
+public class BinScript
+{
+    public string Name { get; set; } = string.Empty;
+    public string Path { get; set; } = string.Empty;
+}
diff --git a/NpmRegistry.Wrapper/Models/BinScriptCollection.cs b/NpmRegistry.Wrapper/Models/BinScriptCollection.cs
new file mode 100644
index 0000000..0cf8b6e
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/BinScriptCollection.cs
@@ -0,0 +1,11 @@
+namespace NpmRegistry.Wrapper.Models;
+#pragma warning disable CA1711 // Identifiers should not have incorrect suffix
+public class BinScriptCollection
+#pragma warning restore CA1711 // Identifiers should not have incorrect suffix
+{
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2227 // Collection properties should be read only
+    public List<BinScript> BinScripts { get; set; } = [];
+#pragma warning restore CA2227 // Collection properties should be read only
+#pragma warning restore CA1002 // Do not expose generic lists
+}
diff --git a/NpmRegistry.Wrapper/Models/Dependency.cs b/NpmRegistry.Wrapper/Models/Dependency.cs
new file mode 100644
index 0000000..6730ad5
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/Dependency.cs
@@ -0,0 +1,6 @@
+namespace NpmRegistry.Wrapper.Models;
+public class Dependency
+{
+    public string Name { get; set; } = string.Empty;
+    public string Version { get; set; } = string.Empty;
+}
diff --git a/NpmRegistry.Wrapper/Models/DependencyList.cs b/NpmRegistry.Wrapper/Models/DependencyList.cs
new file mode 100644
index 0000000..8e66feb
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/DependencyList.cs
@@ -0,0 +1,9 @@
+namespace NpmRegistry.Wrapper.Models;
+public class DependencyList
+{
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2227 // Collection properties should be read only
+    public List<Dependency> Dependencies { get; set; } = [];
+#pragma warning restore CA2227 // Collection properties should be read only
+#pragma warning restore CA1002 // Do not expose generic lists
+}
diff --git a/NpmRegistry.Wrapper/Models/Dist.cs b/NpmRegistry.Wrapper/Models/Dist.cs
new file mode 100644
index 0000000..bd347e0
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/Dist.cs
@@ -0,0 +1,34 @@
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+public class Dist
+{
+    [JsonPropertyName("integrity")]
+    public string Integrity { get; set; } = string.Empty;
+
+    [JsonPropertyName("shasum")]
+    public string Shasum { get; set; } = string.Empty;
+
+    [JsonPropertyName("tarball")]
+    public string Tarball { get; set; } = string.Empty;
+
+    [JsonPropertyName("fileCount")]
+    public int FileCount { get; set; }
+
+    [JsonPropertyName("unpackedSize")]
+    public int UnpackedSize { get; set; }
+
+    [JsonPropertyName("signatures")]
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2227 // Collection properties should be read only
+    public List<Signature> Signatures { get; set; } = [];
+#pragma warning restore CA2227 // Collection properties should be read only
+#pragma warning restore CA1002 // Do not expose generic lists
+
+    [JsonPropertyName("npm-signature")]
+    public string NpmSignature { get; set; } = string.Empty;
+
+    [JsonPropertyName("attestations")]
+    public Attestations? Attestations { get; set; }
+}
diff --git a/NpmRegistry.Wrapper/Models/DistTags.cs b/NpmRegistry.Wrapper/Models/DistTags.cs
new file mode 100644
index 0000000..48dce50
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/DistTags.cs
@@ -0,0 +1,11 @@
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+public class DistTags
+{
+    [JsonPropertyName("next")]
+    public string Next { get; set; } = string.Empty;
+    [JsonPropertyName("latest")]
+    public string Latest { get; set; } = string.Empty;
+}
diff --git a/NpmRegistry.Wrapper/Models/ModelsSerializerContext.cs b/NpmRegistry.Wrapper/Models/ModelsSerializerContext.cs
new file mode 100644
index 0000000..a276877
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/ModelsSerializerContext.cs
@@ -0,0 +1,28 @@
+using NpmRegistry.Wrapper.Serialization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+//[JsonSerializable(typeof(VersionList))]
+//[JsonSerializable(typeof(Person))]
+//[JsonSerializable(typeof(DistTags))]
+//[JsonSerializable(typeof(NpmPackage))]
+//[JsonSourceGenerationOptions(AllowTrailingCommas = true,
+//                             Converters = [typeof(VersionListJsonConverter), typeof(PersonJsonConverter)],                            
+//                             GenerationMode = JsonSourceGenerationMode.Default,
+//                             IgnoreReadOnlyFields = false,
+//                             IgnoreReadOnlyProperties = false,
+//                             IncludeFields = false,
+//                             MaxDepth = 15,
+//                             NumberHandling = JsonNumberHandling.Strict,
+//                             PreferredObjectCreationHandling = JsonObjectCreationHandling.Replace,
+//                             ReadCommentHandling = JsonCommentHandling.Skip,
+//                             RespectNullableAnnotations = true,                        
+//                             UnknownTypeHandling = JsonUnknownTypeHandling.JsonElement,
+//                             UnmappedMemberHandling = JsonUnmappedMemberHandling.Skip,
+//                             UseStringEnumConverter = true,
+//                             WriteIndented = false)]
+//internal sealed partial class ModelsSerializerContext : JsonSerializerContext
+//{
+//}
diff --git a/NpmRegistry.Wrapper/Models/NpmOperationalInternal.cs b/NpmRegistry.Wrapper/Models/NpmOperationalInternal.cs
new file mode 100644
index 0000000..b18b72c
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/NpmOperationalInternal.cs
@@ -0,0 +1,12 @@
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+public class NpmOperationalInternal
+{
+    [JsonPropertyName("host")]
+    public string Host { get; set; } = string.Empty;
+
+    [JsonPropertyName("tmp")]
+    public string Tmp { get; set; } = string.Empty;
+}
diff --git a/NpmRegistry.Wrapper/Models/NpmPackage.cs b/NpmRegistry.Wrapper/Models/NpmPackage.cs
new file mode 100644
index 0000000..febd489
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/NpmPackage.cs
@@ -0,0 +1,47 @@
+using NpmRegistry.Wrapper.Serialization;
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+
+public class NpmPackage
+{
+    [JsonPropertyName("_id")]
+    public string Id { get; set; } = string.Empty;
+
+    [JsonPropertyName("name")]
+    public string Name { get; set; } = string.Empty;
+
+    [JsonPropertyName("dist-tags")]
+    public DistTags? DistTags { get; set; }
+
+    [JsonPropertyName("versions")]
+    [JsonConverter(typeof(VersionListJsonConverter))]
+    public VersionList? Versions { get; set; }
+
+    [JsonPropertyName("time")]
+    public NpmTime? Time { get; set; }
+
+    [JsonPropertyName("maintainers")]
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2227 // Collection properties should be read only
+    public List<Person> Maintainers { get; set; } = [];
+#pragma warning restore CA2227 // Collection properties should be read only
+#pragma warning restore CA1002 // Do not expose generic lists
+
+    [JsonPropertyName("description")]
+    public string Description { get; set; } = string.Empty;
+
+    [JsonPropertyName("author")]
+    [JsonConverter(typeof(PersonJsonConverter))]
+    public Person? Author { get; set; }
+
+    [JsonPropertyName("license")]
+    public string License { get; set; } = string.Empty;
+
+    [JsonPropertyName("readme")]
+    public string Readme { get; set; } = string.Empty;
+
+    [JsonPropertyName("readmeFilename")]
+    public string ReadmeFilename { get; set; } = string.Empty;
+}
diff --git a/NpmRegistry.Wrapper/Models/NpmTime.cs b/NpmRegistry.Wrapper/Models/NpmTime.cs
new file mode 100644
index 0000000..0ee8ba9
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/NpmTime.cs
@@ -0,0 +1,28 @@
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+public class NpmTime
+{
+    [JsonPropertyName("created")]
+    public string Created { get; set; } = string.Empty;
+
+    [JsonPropertyName("modified")]
+    public string Modified { get; set; } = string.Empty;
+
+    [JsonPropertyName("unpublished")]
+    public UnpublishedTime? Unpublished { get; set; }
+}
+
+public class UnpublishedTime
+{
+    [JsonPropertyName("time")]
+    public string Time { get; set; } = string.Empty;
+
+    [JsonPropertyName("versions")]
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2227 // Collection properties should be read only
+    public List<string> Versions { get; set; } = [];
+#pragma warning restore CA1002 // Do not expose generic lists
+#pragma warning restore CA2227 // Collection properties should be read only
+}
diff --git a/NpmRegistry.Wrapper/Models/PackageVersion.cs b/NpmRegistry.Wrapper/Models/PackageVersion.cs
new file mode 100644
index 0000000..02ee6ca
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/PackageVersion.cs
@@ -0,0 +1,66 @@
+using NpmRegistry.Wrapper.Serialization;
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+public class PackageVersion
+{
+    [JsonPropertyName("name")]
+    public string Name { get; set; } = string.Empty;
+
+    [JsonPropertyName("version")]
+    public string Version { get; set; } = string.Empty;
+
+    [JsonPropertyName("description")]
+    public string Description { get; set; } = string.Empty;
+
+    [JsonPropertyName("main")]
+    public string Main { get; set; } = string.Empty;
+
+    [JsonPropertyName("bin")]
+    [JsonConverter(typeof(BinScriptConverter))]
+    public BinScriptCollection? BinScripts { get; set; }
+
+    [JsonPropertyName("scripts")]
+    [JsonConverter(typeof(ScriptListJsonConverter))]
+    public ScriptList? Scripts { get; set; }
+
+    [JsonPropertyName("author")]
+    [JsonConverter(typeof(PersonJsonConverter))]
+    public Person? Author { get; set; }
+
+    [JsonPropertyName("license")]
+    public string License { get; set; } = string.Empty;
+
+    [JsonPropertyName("_id")]
+    public string Id { get; set; } = string.Empty;
+
+    [JsonPropertyName("_nodeVersion")]
+    public string NodeVersion { get; set; } = string.Empty;
+
+    [JsonPropertyName("_npmVersion")]
+    public string NpmVersion { get; set; } = string.Empty;
+
+    [JsonPropertyName("dist")]
+    public Dist? Dist { get; set; }
+
+    [JsonPropertyName("_npmUser")]
+    public Person? NpmUser { get; set; }
+
+    [JsonPropertyName("maintainers")]
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2227 // Collection properties should be read only
+    public List<Person> Maintainers { get; set; } = [];
+#pragma warning restore CA1002 // Do not expose generic lists
+#pragma warning restore CA2227 // Collection properties should be read only
+
+    [JsonPropertyName("_npmOperationalInternal")]
+    public NpmOperationalInternal? NpmOperationalInternal { get; set; }
+
+    [JsonPropertyName("_hasShrinkwrap")]
+    public bool HasShrinkwrap { get; set; }
+
+    [JsonPropertyName("dependencies")]
+    [JsonConverter(typeof(DependencyListJsonConverter))]
+    public DependencyList Dependencies { get; set; } = new();
+}
diff --git a/NpmRegistry.Wrapper/Models/Person.cs b/NpmRegistry.Wrapper/Models/Person.cs
new file mode 100644
index 0000000..e1f2009
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/Person.cs
@@ -0,0 +1,12 @@
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+public class Person
+{
+    [JsonPropertyName("name")]
+    public string Name { get; set; } = string.Empty;
+
+    [JsonPropertyName("email")]
+    public string Email { get; set; } = string.Empty;
+}
diff --git a/NpmRegistry.Wrapper/Models/Provenance.cs b/NpmRegistry.Wrapper/Models/Provenance.cs
new file mode 100644
index 0000000..1b5e6c3
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/Provenance.cs
@@ -0,0 +1,8 @@
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+public class Provenance
+{
+    [JsonPropertyName("predicateType")]
+    public string PredicateType { get; set; } = string.Empty;
+}
diff --git a/NpmRegistry.Wrapper/Models/Script.cs b/NpmRegistry.Wrapper/Models/Script.cs
new file mode 100644
index 0000000..fcd77df
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/Script.cs
@@ -0,0 +1,7 @@
+namespace NpmRegistry.Wrapper.Models;
+
+public class Script
+{
+    public string Operation { get; set; } = string.Empty;
+    public string Content { get; set; } = string.Empty;
+}
diff --git a/NpmRegistry.Wrapper/Models/ScriptList.cs b/NpmRegistry.Wrapper/Models/ScriptList.cs
new file mode 100644
index 0000000..f564180
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/ScriptList.cs
@@ -0,0 +1,10 @@
+namespace NpmRegistry.Wrapper.Models;
+
+public class ScriptList
+{
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2227 // Collection properties should be read only
+    public List<Script> PackageScripts { get; set; } = [];
+#pragma warning restore CA1002 // Do not expose generic lists
+#pragma warning restore CA2227 // Collection properties should be read only
+}
diff --git a/NpmRegistry.Wrapper/Models/Signature.cs b/NpmRegistry.Wrapper/Models/Signature.cs
new file mode 100644
index 0000000..c235c2e
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/Signature.cs
@@ -0,0 +1,12 @@
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Models;
+
+public class Signature
+{
+    [JsonPropertyName("keyid")]
+    public string Keyid { get; set; } = string.Empty;
+
+    [JsonPropertyName("sig")]
+    public string Sig { get; set; } = string.Empty;
+}
\ No newline at end of file
diff --git a/NpmRegistry.Wrapper/Models/VersionList.cs b/NpmRegistry.Wrapper/Models/VersionList.cs
new file mode 100644
index 0000000..798ce37
--- /dev/null
+++ b/NpmRegistry.Wrapper/Models/VersionList.cs
@@ -0,0 +1,10 @@
+namespace NpmRegistry.Wrapper.Models;
+
+public class VersionList
+{
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2227 // Collection properties should be read only
+    public List<PackageVersion> PackageVersions { get; set; } = [];
+#pragma warning restore CA1002 // Do not expose generic lists
+#pragma warning restore CA2227 // Collection properties should be read only
+}
diff --git a/NpmRegistry.Wrapper/NpmRegistry.Wrapper.csproj b/NpmRegistry.Wrapper/NpmRegistry.Wrapper.csproj
new file mode 100644
index 0000000..6d84556
--- /dev/null
+++ b/NpmRegistry.Wrapper/NpmRegistry.Wrapper.csproj
@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>net10.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+		<GenerateDocumentationFile>true</GenerateDocumentationFile>
+		<NoWarn>$(NoWarn);1591</NoWarn>
+		<IsAotCompatible>True</IsAotCompatible>
+	</PropertyGroup>
+
+	<PropertyGroup>
+		<PackageId>Fiedler.NpmRegistry.Wrapper</PackageId>
+		<Authors>Dan Fiedler</Authors>
+		<Version>1.0.0</Version>
+		<PackageTags>npm</PackageTags>
+		<Description>Client library API wrapper for https://registry.npmjs.org/</Description>
+		<PackageProjectUrl>https://github.com/DanFiedler/NpmRegistry.Wrapper</PackageProjectUrl>
+		<PackageLicenseExpression>MIT</PackageLicenseExpression>
+		<PackageReadmeFile>README.md</PackageReadmeFile>
+	</PropertyGroup>
+
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+	  <IsTrimmable>False</IsTrimmable>
+	</PropertyGroup>
+
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+	  <IsTrimmable>False</IsTrimmable>
+	</PropertyGroup>
+	<ItemGroup>
+		<None Include="README.md" Pack="true" PackagePath="\" />
+	</ItemGroup>
+	<ItemGroup>
+	  <PackageReference Include="Microsoft.Extensions.Http" />
+	</ItemGroup>
+	<ItemGroup>
+	  <ProjectReference Include="..\DataTypes\DataTypes.csproj" />
+	</ItemGroup>
+
+    <PropertyGroup>
+        <JsonSerializerIsReflectionEnabledByDefault>false</JsonSerializerIsReflectionEnabledByDefault>
+    </PropertyGroup>
+</Project>
diff --git a/NpmRegistry.Wrapper/NpmRegistryClient.cs b/NpmRegistry.Wrapper/NpmRegistryClient.cs
new file mode 100644
index 0000000..27364c4
--- /dev/null
+++ b/NpmRegistry.Wrapper/NpmRegistryClient.cs
@@ -0,0 +1,189 @@
+using Microsoft.Extensions.Logging;
+using NpmRegistry.Wrapper.Models;
+using System.Diagnostics.CodeAnalysis;
+using System.Net.Http.Json;
+using System.Text;
+using System.Text.Encodings.Web;
+using System.Text.Json;
+
+namespace NpmRegistry.Wrapper;
+
+public interface INpmRegistryClient
+{
+    /// <summary>
+    /// Retrieve package metadata from https://registry.npmjs.org/ by package name and namespace.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <param name="ns"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    Task<NpmPackage?> GetPackageData(string name, string? ns, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Retrieve package metadata from https://registry.npmjs.org/ by package name, namespace, and version.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <param name="ns"></param>
+    /// <param name="version"></param>
+    /// <param name="cancellationToken"></param>
+    Task<PackageVersion?> GetVersionData(string name, string? ns, string version, CancellationToken cancellationToken);
+}
+
+public class NpmRegistryClient(ILogger<NpmRegistryClient> logger, IHttpClientFactory httpClientFactory) : INpmRegistryClient
+{
+    private readonly ILogger<NpmRegistryClient> _logger = logger;
+    private readonly IHttpClientFactory _httpClientFactory = httpClientFactory;
+
+    [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "<Pending>")]
+
+#pragma warning disable CA1822 // Mark members as static
+    public async Task<NpmPackage?> FetchPackageAsync(
+#pragma warning restore CA1822 // Mark members as static
+        HttpClient httpClient,
+#pragma warning disable CA1054 // URI-like parameters should not be strings
+        string url,
+#pragma warning restore CA1054 // URI-like parameters should not be strings
+        CancellationToken cancellationToken)
+    {
+#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
+#pragma warning disable CA2234 // Pass system uri objects instead of strings
+        using var response = await httpClient.GetAsync(
+                url,
+                HttpCompletionOption.ResponseHeadersRead,
+                cancellationToken);
+#pragma warning restore CA2234 // Pass system uri objects instead of strings
+#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
+
+        response.EnsureSuccessStatusCode();
+
+        var content = response.Content;
+
+        // Try to preallocate based on Content-Length
+        var contentLength = content.Headers.ContentLength;
+
+        // If Content-Length is unknown, choose a reasonable fallback
+        var bufferSize = contentLength.HasValue
+            ? checked((int)contentLength.Value)
+            : 32 * 1024; // 32 KB fallback
+
+        byte[] buffer = new byte[bufferSize];
+
+        int totalRead = 0;
+
+#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
+        await using (var stream = await content.ReadAsStreamAsync(cancellationToken))
+        {
+            while (true)
+            {
+                int read = await stream.ReadAsync(
+                    buffer.AsMemory(totalRead),
+                    cancellationToken);
+
+                if (read == 0)
+                    break;
+
+                totalRead += read;
+
+                // If fallback buffer was too small, grow it
+                if (totalRead == buffer.Length)
+                {
+                    Array.Resize(ref buffer, buffer.Length * 2);
+                }
+            }
+        }
+#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
+
+        // Deserialize only the used portion of the buffer
+        var span = new ReadOnlySpan<byte>(buffer, 0, totalRead);
+
+        return JsonSerializer.Deserialize<NpmPackage>(span);
+    }
+
+
+    public async Task<NpmPackage?> GetPackageData(string name, string? ns, CancellationToken cancellationToken)
+    {
+#pragma warning disable CA2000 // Dispose objects before losing scope
+        var httpClient = _httpClientFactory.CreateClient();
+#pragma warning restore CA2000 // Dispose objects before losing scope
+        var url = BuildUrl(name, null, ns);
+
+#pragma warning disable CA1031 // Do not catch general exception types
+        try
+        {
+            //return await httpClient.GetFromJsonAsync<NpmPackage>(url, cancellationToken);
+#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
+            //return await httpClient.GetFromJsonAsync(url, ModelsSerializerContext.Default.NpmPackage, cancellationToken);
+            return await FetchPackageAsync(httpClient, url, cancellationToken);
+#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
+        }
+#pragma warning disable CA1727 // Use PascalCase for named placeholders
+        catch (HttpRequestException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
+        {
+            _logger.LogWarning("NPM Registry returned 404. Package not found at: {url}", url);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError("Error requesting package data from NPM registry: {ex}", ex);
+        }
+#pragma warning restore CA1031 // Do not catch general exception types
+#pragma warning restore CA1727 // Use PascalCase for named placeholders
+
+        return null;
+    }
+
+    public async Task<PackageVersion?> GetVersionData(string name, string? ns, string version, CancellationToken cancellationToken)
+    {
+#pragma warning disable CA2000 // Dispose objects before losing scope
+        var httpClient = _httpClientFactory.CreateClient();
+#pragma warning restore CA2000 // Dispose objects before losing scope
+        var url = BuildUrl(name, version, ns);
+
+#pragma warning disable CA1031 // Do not catch general exception types
+        try
+        {
+#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            return await httpClient.GetFromJsonAsync<PackageVersion>(url, cancellationToken);
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
+        }
+#pragma warning disable CA1727 // Use PascalCase for named placeholders
+        catch (HttpRequestException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
+        {
+            _logger.LogWarning("NPM Registry returned 404. Package not found at: {url}", url);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError("Error requesting package data from NPM registry: {ex}", ex);
+        }
+#pragma warning restore CA1031 // Do not catch general exception types
+#pragma warning restore CA1727 // Use PascalCase for named placeholders
+
+        return null;
+    }
+
+    private static string BuildUrl(string name, string? version, string? ns)
+    {
+        string encodedName = UrlEncoder.Default.Encode(name);
+
+        var sb = new StringBuilder("https://registry.npmjs.org/");
+
+        if(!string.IsNullOrEmpty(ns))
+        {
+            string encodedNs = UrlEncoder.Default.Encode($"@{ns}");
+            sb.Append(encodedNs);
+            sb.Append('/');
+        }
+
+        sb.Append(encodedName);
+
+        if (!string.IsNullOrEmpty(version))
+        {
+            string encodedVersion = UrlEncoder.Default.Encode(version);
+            sb.Append('/');
+            sb.Append(encodedVersion);
+        }
+
+        return sb.ToString();
+    }
+}
diff --git a/NpmRegistry.Wrapper/Properties/launchSettings.json b/NpmRegistry.Wrapper/Properties/launchSettings.json
new file mode 100644
index 0000000..92478db
--- /dev/null
+++ b/NpmRegistry.Wrapper/Properties/launchSettings.json
@@ -0,0 +1,7 @@
+{
+  "profiles": {
+    "NpmRegistry.Wrapper": {
+      "commandName": "Project"
+    }
+  }
+}
\ No newline at end of file
diff --git a/NpmRegistry.Wrapper/README.md b/NpmRegistry.Wrapper/README.md
new file mode 100644
index 0000000..dea2e2c
--- /dev/null
+++ b/NpmRegistry.Wrapper/README.md
@@ -0,0 +1,33 @@
+# NpmRegistry.Wrapper
+
+## Introduction
+
+A C#/.NET API wrapper for the [npm registry](https://registry.npmjs.org/).
+
+The primary goal of this library is to provide strong types and corresponding support for deserialization of the npm registry's particular format of JSON responses.
+
+## Usage 
+
+Use `INpmRegistryClient` to retrieve data about specific packages. 
+This package assumes usage of [.NET dependency injection](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection)
+and requires registration of [IHttpClientFactory](https://learn.microsoft.com/en-us/dotnet/core/extensions/httpclient-factory).
+
+Basic usage is demonstrated in the `samples\NpmRegistry.Wrapper.Sample` project and in the code block below:
+
+```csharp
+    // Sample DI setup 
+    var builder = Host.CreateApplicationBuilder(args);    
+    builder.Services.AddHttpClient();
+    builder.Services.AddSingleton<INpmRegistryClient, NpmRegistryClient>();
+    var host = builder.Build();
+
+    // Sample usage to get information of a specific package version
+    var npmRegistryClient = host.Services.GetRequiredService<INpmRegistryClient>();
+    var cts = new CancellationTokenSource();
+    var packageData = await npmRegistryClient.GetPackageData("my-package", "1.2.3", cts.Token);
+    Console.WriteLine($"Package:'{packageData.Name}' by author:'{packageData.Author?.Name}'");
+```
+
+# Documentation
+
+For more information, please refer to the package's [GitHub repository](https://github.com/DanFiedler/NpmRegistry.Wrapper).
diff --git a/NpmRegistry.Wrapper/Serialization/BinScriptConverter.cs b/NpmRegistry.Wrapper/Serialization/BinScriptConverter.cs
new file mode 100644
index 0000000..8da0299
--- /dev/null
+++ b/NpmRegistry.Wrapper/Serialization/BinScriptConverter.cs
@@ -0,0 +1,34 @@
+using NpmRegistry.Wrapper.Models;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Serialization;
+public class BinScriptConverter : JsonConverter<BinScriptCollection>
+{
+    public override BinScriptCollection? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        using var document = JsonDocument.ParseValue(ref reader);
+
+        var collection = new BinScriptCollection();
+
+        var root = document.RootElement; // "bin" {
+        foreach (var jsonElement in root.EnumerateObject()) // "webpack" {
+        {
+            string name = jsonElement.Name;
+            string path = jsonElement.Value.ToString();
+            var script = new BinScript
+            {
+                Name = name,
+                Path = path
+            };
+            collection.BinScripts.Add(script);
+        }
+
+        return collection;
+    }
+
+    public override void Write(Utf8JsonWriter writer, BinScriptCollection value, JsonSerializerOptions options)
+    {
+        throw new NotImplementedException();
+    }
+}
diff --git a/NpmRegistry.Wrapper/Serialization/DependencyListJsonConverter.cs b/NpmRegistry.Wrapper/Serialization/DependencyListJsonConverter.cs
new file mode 100644
index 0000000..42062fe
--- /dev/null
+++ b/NpmRegistry.Wrapper/Serialization/DependencyListJsonConverter.cs
@@ -0,0 +1,33 @@
+using NpmRegistry.Wrapper.Models;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Serialization;
+public class DependencyListJsonConverter : JsonConverter<DependencyList>
+{
+    public override DependencyList? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var dependencies = new DependencyList();
+
+        using var document = JsonDocument.ParseValue(ref reader);
+        var root = document.RootElement; // "dependencies" {
+        foreach (var jsonElement in root.EnumerateObject()) // "left-pad" {
+        {
+            string name = jsonElement.Name;
+            string version = jsonElement.Value.ToString();
+            var dependency = new Dependency
+            {
+                Name = name,
+                Version = version
+            };
+            dependencies.Dependencies.Add(dependency);
+        }
+
+        return dependencies;
+    }
+
+    public override void Write(Utf8JsonWriter writer, DependencyList value, JsonSerializerOptions options)
+    {
+        throw new NotImplementedException();
+    }
+}
diff --git a/NpmRegistry.Wrapper/Serialization/PersonJsonConverter.cs b/NpmRegistry.Wrapper/Serialization/PersonJsonConverter.cs
new file mode 100644
index 0000000..2d94ed5
--- /dev/null
+++ b/NpmRegistry.Wrapper/Serialization/PersonJsonConverter.cs
@@ -0,0 +1,37 @@
+using NpmRegistry.Wrapper.Models;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Serialization;
+
+public class PersonJsonConverter : JsonConverter<Person>
+{
+    public override Person? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        using var document = JsonDocument.ParseValue(ref reader);
+
+        var root = document.RootElement;
+        if(root.ValueKind == JsonValueKind.String)
+        {
+            var person = new Person();
+            string? name = root.GetString();
+            if(!string.IsNullOrEmpty(name))
+            {
+                person.Name = name;
+            }
+            return person;
+        }
+        else if(root.ValueKind == JsonValueKind.Object)
+        {
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            return root.Deserialize<Person>();
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+        }
+
+        return new Person();
+    }
+
+    public override void Write(Utf8JsonWriter writer, Person value, JsonSerializerOptions options)
+    {
+    }
+}
diff --git a/NpmRegistry.Wrapper/Serialization/ScriptListJsonConverter.cs b/NpmRegistry.Wrapper/Serialization/ScriptListJsonConverter.cs
new file mode 100644
index 0000000..7db6ab4
--- /dev/null
+++ b/NpmRegistry.Wrapper/Serialization/ScriptListJsonConverter.cs
@@ -0,0 +1,35 @@
+using NpmRegistry.Wrapper.Models;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NpmRegistry.Wrapper.Serialization;
+
+public class ScriptListJsonConverter : JsonConverter<ScriptList>
+{
+    public override ScriptList Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        using var document = JsonDocument.ParseValue(ref reader);
+
+        var scriptList = new ScriptList();
+
+        var root = document.RootElement; // "scripts" {
+        foreach (var jsonElement in root.EnumerateObject()) // "preinstall" {
+        {
+            string operation = jsonElement.Name;
+            string content = jsonElement.Value.ToString();
+            var script = new Script
+            {
+                Operation = operation,
+                Content = content
+            };
+            scriptList.PackageScripts.Add(script);
+        }
+
+        return scriptList;
+    }
+
+    public override void Write(Utf8JsonWriter writer, ScriptList value, JsonSerializerOptions options)
+    {
+
+    }
+}
diff --git a/NpmRegistry.Wrapper/Serialization/VersionListJsonConverter.cs b/NpmRegistry.Wrapper/Serialization/VersionListJsonConverter.cs
new file mode 100644
index 0000000..0fca26e
--- /dev/null
+++ b/NpmRegistry.Wrapper/Serialization/VersionListJsonConverter.cs
@@ -0,0 +1,36 @@
+using NpmRegistry.Wrapper.Models;
+using System.Text.Json.Serialization;
+using System.Text.Json;
+
+namespace NpmRegistry.Wrapper.Serialization;
+
+// The custom JsonConverter is necessary because the NPM registry uses properties for the collection of versions
+// (rather than using the more conventional JSON array)
+public class VersionListJsonConverter : JsonConverter<VersionList>
+{
+    public override VersionList Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        using var document = JsonDocument.ParseValue(ref reader);
+
+        var versionList = new VersionList();
+
+        var root = document.RootElement; // "versions" {
+        foreach (var jsonElement in root.EnumerateObject()) // "1.2.3" {
+        {
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            var version = jsonElement.Value.Deserialize<PackageVersion>();
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            if (version != null)
+            {
+                versionList.PackageVersions.Add(version);
+            }
+        }
+
+        return versionList;
+    }
+
+    public override void Write(Utf8JsonWriter writer, VersionList value, JsonSerializerOptions options)
+    {
+
+    }
+}
diff --git a/Tools/Tasks/BaseTask.cs b/Tools/Tasks/BaseTask.cs
index 6a91e7a..32c7506 100644
--- a/Tools/Tasks/BaseTask.cs
+++ b/Tools/Tasks/BaseTask.cs
@@ -331,7 +331,7 @@ private void OnAppDomainAssemblyLoad(object? sender,
         {
             if (EnableDebugLogging)
             {
-                Log.LogMessage($@"DEBUG: Loaded assembly {args.LoadedAssembly.FullName}");
+                Log.LogMessage(MessageImportance.High, $@"DEBUG: Loaded assembly {args.LoadedAssembly.FullName}");
             }
         }
 
@@ -362,6 +362,7 @@ private void OnAppDomainAssemblyLoad(object? sender,
                 {
                     if (File.Exists(assemblyLocation))
                     {
+                        Log.LogMessage(MessageImportance.High, $@"Loading Assembly '{assemblyLocation}'");
                         assembly = Assembly.LoadFrom(assemblyLocation);
                     }
                     else
@@ -386,10 +387,10 @@ public sealed override bool Execute()
             AppDomain.CurrentDomain.AssemblyResolve += OnAppDomainAssemblyResolve;
 
             // Log the version that was used to build the assembly and what is used to run it
-            Log.LogMessage($@"Task assembly built for version {NetBuildFramework}");
-            Log.LogMessage($@"Task assembly targeted to version {NetTargetFramework}");
-            Log.LogMessage($@"Running on .NET version {Environment.Version} (application {Path.GetFileName(Environment.ProcessPath)})");
-            Log.LogMessage($@"Running as a {(Environment.Is64BitProcess ? @"64" : @"32")}-bit process");
+            Log.LogMessage(MessageImportance.High, $@"Task assembly built for version {NetBuildFramework}");
+            Log.LogMessage(MessageImportance.High, $@"Task assembly targeted to version {NetTargetFramework}");
+            Log.LogMessage(MessageImportance.High, $@"Running on .NET version {Environment.Version} (application {Path.GetFileName(Environment.ProcessPath)})");
+            Log.LogMessage(MessageImportance.High, $@"Running as a {(Environment.Is64BitProcess ? @"64" : @"32")}-bit process");
 
             result = PerformTask();
 
diff --git a/Tools/Tasks/Tasks.csproj b/Tools/Tasks/Tasks.csproj
index f35f3dd..72d454a 100644
--- a/Tools/Tasks/Tasks.csproj
+++ b/Tools/Tasks/Tasks.csproj
@@ -13,7 +13,6 @@
     <!-- NuGet package references -->
     <ItemGroup>
         <PackageReference Include="DotMake.CommandLine" />
-        <PackageReference Include="Fiedler.NpmRegistry.Wrapper" />
         <PackageReference Include="Microsoft.Build" />
         <PackageReference Include="Microsoft.Build.Utilities.Core" />
         <PackageReference Include="NuGet.Versioning" />
@@ -22,6 +21,7 @@
     <!-- Project references -->
     <ItemGroup>
         <ProjectReference Include="$(SolutionDir)DataTypes/DataTypes.csproj" />
+        <ProjectReference Include="..\..\NpmRegistry.Wrapper\NpmRegistry.Wrapper.csproj" />
     </ItemGroup>
 
     <!-- Add the attributes containing the version numbers so they can be retrieved in the tasks -->
@@ -41,13 +41,8 @@
     </ItemGroup>
 
     <!-- Target to restore all dotnet tools -->
-    <Target Name="RestoreDotnetTools"
-            BeforeTargets="PrepareForRun">
-        <Exec Command="dotnet tool restore"
-              EchoOff="False"
-              IgnoreExitCode="False"
-              UseUtf8Encoding="Always"
-              WorkingDirectory="$(SolutionDir)" />
+    <Target Name="RestoreDotnetTools" BeforeTargets="PrepareForRun">
+        <Exec Command="dotnet tool restore" EchoOff="False" IgnoreExitCode="False" UseUtf8Encoding="Always" WorkingDirectory="$(SolutionDir)" />
     </Target>
 
 </Project>
diff --git a/Tools/Tasks/UpdateNpmPackages.cs b/Tools/Tasks/UpdateNpmPackages.cs
index c454ac3..622a1a1 100644
--- a/Tools/Tasks/UpdateNpmPackages.cs
+++ b/Tools/Tasks/UpdateNpmPackages.cs
@@ -12,6 +12,7 @@
 using System.Linq;
 using System.Text.Json;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace MissingMethodException.Tools.Tasks
 {
@@ -90,8 +91,8 @@ protected sealed override bool PerformTask()
                                         Distinct().
                                         ToDictionary(npi => npi.Name,
                                                      npi => npi);
-            Log.LogMessage(@"Passed arguments:");
-            Log.LogMessage($@"- NpmPackages: {string.Join(", ", m_npmPackages.Select(np => np.Key).OrderBy(s => s, StringComparer.OrdinalIgnoreCase))}");
+            Log.LogMessage(MessageImportance.High, @"Passed arguments:");
+            Log.LogMessage(MessageImportance.High, $@"- NpmPackages: {string.Join(", ", m_npmPackages.Select(np => np.Key).OrderBy(s => s, StringComparer.OrdinalIgnoreCase))}");
 
             using (Mutex updateGuard = CreateNamedMutex(typeof(UpdateNpmPackages)))
             {
@@ -112,12 +113,31 @@ protected sealed override bool PerformTask()
                 bool downloadedNewVersion = false;
                 foreach (NpmPackageInformation npmPackageInfo in m_npmPackages.Values)
                 {
-                    NpmPackage? npmPackage = RegistryClient.GetPackageData(npmPackageInfo.Name,
+                    Task<NpmPackage?> dl_npmpack = RegistryClient.GetPackageData(npmPackageInfo.Name,
                                                                            null/*ns*/,
-                                                                           CancellationToken.None).
-                                                            Result;
+                                                                           CancellationToken.None);
+                    dl_npmpack.Wait();
+
+                    NpmPackage? npmPackage = dl_npmpack.Result;
+
                     if (null != npmPackage)
                     {
+                        Log.LogMessage(MessageImportance.High, npmPackage.Id);
+                        Log.LogMessage(MessageImportance.High, npmPackage.Name);
+                        Log.LogMessage(MessageImportance.High, npmPackage.Description);
+                        if (npmPackage.Time!= null)
+                        {
+                            Log.LogMessage(MessageImportance.High, npmPackage.Time.Modified.ToString());
+                        }
+                        if (npmPackage.Author != null)
+                        {
+                            Log.LogMessage(MessageImportance.High, npmPackage.Author.Name);
+                        }
+                        if (npmPackage.DistTags != null)
+                        {
+                            Log.LogMessage(MessageImportance.High, npmPackage.DistTags.Next);
+                            Log.LogMessage(MessageImportance.High, npmPackage.DistTags.Latest);
+                        }
                         // Get the latest version information
                         string? latestVersionString = npmPackage.DistTags?.Latest;
                         if (null != latestVersionString)
@@ -140,20 +160,20 @@ protected sealed override bool PerformTask()
                                         if (DownloadRelease(packageVersion,
                                                             SavePackageFile).Result)
                                         {
-                                            Log.LogMessage($@"File {npmPackageInfo.JscriptLibFileName} version {latestVersionString} saved");
+                                            Log.LogMessage(MessageImportance.High, $@"File {npmPackageInfo.JscriptLibFileName} version {latestVersionString} saved");
                                             packageVersions[npmPackageInfo.Name] = latestVersion;
                                             downloadedNewVersion = true;
                                         }
                                     }
                                     else
                                     {
-                                        Log.LogError($@"Unable to retrieve information of version {latestVersionString} of {npmPackageInfo.Name}");
+                                        Log.LogMessage(MessageImportance.High, $@"Unable to retrieve information of version {latestVersionString} of {npmPackageInfo.Name}");
                                         result = false;
                                     }
                                 }
                                 else
                                 {
-                                    Log.LogMessage($@"Version {latestVersionString} of {npmPackageInfo.Name} already downloaded");
+                                    Log.LogMessage(MessageImportance.High, $@"Version {latestVersionString} of {npmPackageInfo.Name} already downloaded");
                                 }
                             }
                             else