Squashed commit of the following:

commit 9a835fe12c9586ab8dd44d7c96fef4a2d6017e4b
Author: vnugent <public@vaughnnugent.com>
Date:   Fri May 17 18:27:03 2024 -0400

    chore: Update mimmaloc v2.1.6, update fPIC & cleanup

commit 3b7004b88acfc7f7baa3a8857a5a2f7cf3dd560e
Author: vnugent <public@vaughnnugent.com>
Date:   Fri May 17 16:03:28 2024 -0400

    feat: Added ReadFileDataAsync function

commit 9a964795757bf0da4dd7fcab15ad304f4ea3fdf1
Author: vnugent <public@vaughnnugent.com>
Date:   Wed May 15 21:57:39 2024 -0400

    refactor: Harden some argon2 password hashing

commit 4035c838c1508af0aa7e767a97431a692958ce1c
Author: vnugent <public@vaughnnugent.com>
Date:   Sun May 12 16:55:32 2024 -0400

    perf: Utils + http perf mods

commit f4f0d4f74250257991c57bfae74c4852c7e1ae46
Author: vnugent <public@vaughnnugent.com>
Date:   Thu May 2 15:22:53 2024 -0400

    feat: Buff middleware handlers
    |
    |  Added implicit support for middleware post processing of files before the filehandler closes the connection. Also cleaned up some project file stuff

commit f0b7dca107659df1d7d4631fdbd2aae9d716d053
Merge: 8c4a45e 107b058
Author: vnugent <public@vaughnnugent.com>
Date:   Sat Apr 20 12:24:05 2024 -0400

    Merge branch 'main' into develop

commit 8c4a45e384accf92b1b6d748530e8d46f7de40d6
Author: vnugent <public@vaughnnugent.com>
Date:   Sat Apr 20 11:10:30 2024 -0400

    refactor: Overhaul C libraries and fix builds

commit 42ff77080d10b0fc9fecbbc46141e8e23a1d066a
Author: vnugent <public@vaughnnugent.com>
Date:   Sat Apr 20 00:45:57 2024 -0400

    fix!: Middlware array, multiple cookie set, and cookie check

commit 97e82b9d66f387f9e6d21d88ddc7a8ab8693149c
Merge: 4ca5791 e07537a
Author: vnugent <public@vaughnnugent.com>
Date:   Tue Apr 2 13:34:22 2024 -0400

    Merge branch 'main' into develop

commit 4ca5791ed67b9834bdbd010206b30373e4705e9b
Author: vnugent <public@vaughnnugent.com>
Date:   Tue Apr 2 13:32:12 2024 -0400

    fix: Missed ! on null pointer check

commit 9b4036377c52200c6488c98180d69a0e63321f97
Author: vnugent <public@vaughnnugent.com>
Date:   Tue Apr 2 13:22:29 2024 -0400

    fix: Fix _In_ macro for compression public api

commit 53a7b4b5c5b67b4a4e06e1d9098cac4bcd6afd7c
Merge: 448a93b 21130c8
Author: vnugent <public@vaughnnugent.com>
Date:   Sun Mar 31 17:01:15 2024 -0400

    Merge branch 'main' into develop

commit 448a93bb1d18d032087afe2476ffccb98634a54c
Author: vnugent <public@vaughnnugent.com>
Date:   Sun Mar 31 16:56:51 2024 -0400

    ci: fix third-party dir cleanup

commit 9afed1427472da1ea13079f98dbe27339e55ee7d
Author: vnugent <public@vaughnnugent.com>
Date:   Sun Mar 31 16:43:15 2024 -0400

    perf: Deprecate unsafememoryhandle span extensions

commit 3ff90da4f02af47ea6d233fdd4445337ebe36452
Author: vnugent <public@vaughnnugent.com>
Date:   Sat Mar 30 21:36:18 2024 -0400

    refactor: Updates, advanced tracing, http optimizations

commit 8d6b79b5ae309b36f265ba81529bcef8bfcd7414
Merge: 6c1667b 5585915
Author: vnugent <public@vaughnnugent.com>
Date:   Sun Mar 24 21:01:31 2024 -0400

    Merge branch 'main' into develop

commit 6c1667be23597513537f8190e2f55d65eb9b7c7a
Author: vnugent <public@vaughnnugent.com>
Date:   Fri Mar 22 12:01:53 2024 -0400

    refactor: Overhauled native library loading and lazy init

commit ebf688f2f974295beabf7b5def7e6f6f150551d0
Author: vnugent <public@vaughnnugent.com>
Date:   Wed Mar 20 22:16:17 2024 -0400

    refactor: Update compression header files and macros + Ci build

commit 9c7b564911080ccd5cbbb9851a0757b05e1e9047
Author: vnugent <public@vaughnnugent.com>
Date:   Tue Mar 19 21:54:49 2024 -0400

    refactor: JWK overhaul & add length getter to FileUpload

commit 6d8c3444e09561e5957491b3cc1ae858e0abdd14
Author: vnugent <public@vaughnnugent.com>
Date:   Mon Mar 18 16:13:20 2024 -0400

    feat: Add FNV1a software checksum and basic correction tests

commit 00d182088cecefc08ca80b1faee9bed3f215f40b
Author: vnugent <public@vaughnnugent.com>
Date:   Fri Mar 15 01:05:27 2024 -0400

    chore: #6 Use utils filewatcher instead of built-in

commit d513c10d9895c6693519ef1d459c6a5a76929436
Author: vnugent <public@vaughnnugent.com>
Date:   Sun Mar 10 21:58:14 2024 -0400

    source tree project location updated

1 files changed, 187 insertions, 0 deletions

diff --git a/lib/Plugins.Essentials/src/Endpoints/SemiConsistentVeTable.cs b/lib/Plugins.Essentials/src/Endpoints/SemiConsistentVeTable.cs
new file mode 100644
index 0000000..09ab151
--- /dev/null
+++ b/lib/Plugins.Essentials/src/Endpoints/SemiConsistentVeTable.cs
@@ -0,0 +1,187 @@
+/*
+* Copyright (c) 2024 Vaughn Nugent
+* 
+* Library: VNLib
+* Package: VNLib.Plugins.Essentials
+* File: SemiConsistentVeTable.cs 
+*
+* SemiConsistentVeTable.cs is part of VNLib.Plugins.Essentials which 
+* is part of the larger VNLib collection of libraries and utilities.
+*
+* VNLib.Plugins.Essentials is free software: you can redistribute it and/or modify 
+* it under the terms of the GNU Affero General Public License as 
+* published by the Free Software Foundation, either version 3 of the
+* License, or (at your option) any later version.
+*
+* VNLib.Plugins.Essentials is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see https://www.gnu.org/licenses/.
+*/
+
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Frozen;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+using VNLib.Net.Http;
+
+namespace VNLib.Plugins.Essentials.Endpoints
+{
+    internal sealed class SemiConsistentVeTable : IVirtualEndpointTable
+    {
+
+        /*
+        * The VE table is read-only for the processor and my only 
+        * be updated by the application via the methods below
+        * 
+        * Since it would be very inefficient to track endpoint users
+        * using locks, we can assume any endpoint that is currently 
+        * processing requests cannot be stopped, so we just focus on
+        * swapping the table when updates need to be made.
+        * 
+        * This means calls to modify the table will read the table 
+        * (clone it), modify the local copy, then exhange it for 
+        * the active table so new requests will be processed on the 
+        * new table.
+        * 
+        * To make the calls to modify the table thread safe, a lock is 
+        * held while modification operations run, then the updated
+        * copy is published. Any threads reading the old table
+        * will continue to use a stale endpoint. 
+       */
+
+        /// <summary>
+        /// A "lookup table" that represents virtual endpoints to be processed when an
+        /// incomming connection matches its path parameter
+        /// </summary>
+        private FrozenDictionary<string, IVirtualEndpoint<HttpEntity>> VirtualEndpoints =
+            new Dictionary<string, IVirtualEndpoint<HttpEntity>>(StringComparer.OrdinalIgnoreCase)
+            .ToFrozenDictionary();
+
+        private bool _isEmpty = true;
+
+        /*
+         * A lock that is held by callers that intend to 
+         * modify the vep table at the same time
+         */
+        private readonly object VeUpdateLock = new();
+
+        ///<inheritdoc/>
+        public bool IsEmpty => _isEmpty;
+
+
+        ///<inheritdoc/>
+        public void AddEndpoint(params IEndpoint[] endpoints)
+        {
+            //Check
+            ArgumentNullException.ThrowIfNull(endpoints);
+            //Make sure all endpoints specify a path
+            if (endpoints.Any(static e => string.IsNullOrWhiteSpace(e?.Path)))
+            {
+                throw new ArgumentException("Endpoints array contains one or more empty endpoints");
+            }
+
+            if (endpoints.Length == 0)
+            {
+                return;
+            }
+
+            //Get virtual endpoints
+            IEnumerable<IVirtualEndpoint<HttpEntity>> eps = endpoints
+                                        .Where(static e => e is IVirtualEndpoint<HttpEntity>)
+                                        .Select(static e => (IVirtualEndpoint<HttpEntity>)e);
+
+            //Get http event endpoints and create wrapper classes for conversion
+            IEnumerable<IVirtualEndpoint<HttpEntity>> evs = endpoints
+                                        .Where(static e => e is IVirtualEndpoint<IHttpEvent>)
+                                        .Select(static e => new EvEndpointWrapper((e as IVirtualEndpoint<IHttpEvent>)!));
+
+            //Uinion endpoints by their paths to combine them
+            IEnumerable<IVirtualEndpoint<HttpEntity>> allEndpoints = eps.UnionBy(evs, static s => s.Path);
+
+            //Only allow 1 thread at a time to mutate the table
+            lock (VeUpdateLock)
+            {
+                //Clone the current dictonary
+                Dictionary<string, IVirtualEndpoint<HttpEntity>> newTable = new(VirtualEndpoints, StringComparer.OrdinalIgnoreCase);
+                //Insert the new eps, and/or overwrite old eps
+                foreach (IVirtualEndpoint<HttpEntity> ep in allEndpoints)
+                {
+                    newTable.Add(ep.Path, ep);
+                }
+
+                //Update is-empty flag
+                _isEmpty = newTable.Count == 0;
+
+                //Create the new table and store the entire table
+                _ = Interlocked.Exchange(ref VirtualEndpoints, newTable.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase));
+            }
+        }
+
+        ///<inheritdoc/>
+        public void RemoveEndpoint(params IEndpoint[] eps)
+        {
+            ArgumentNullException.ThrowIfNull(eps);
+            //Call remove on path
+            RemoveEndpoint(eps.Select(static s => s.Path).ToArray());
+        }
+
+        ///<inheritdoc/>
+        public void RemoveEndpoint(params string[] paths)
+        {
+            ArgumentNullException.ThrowIfNull(paths);
+
+            //Make sure all endpoints specify a path
+            if (paths.Any(static e => string.IsNullOrWhiteSpace(e)))
+            {
+                throw new ArgumentException("Paths array contains one or more empty strings");
+            }
+
+            if (paths.Length == 0)
+            {
+                return;
+            }
+
+            //take update lock
+            lock (VeUpdateLock)
+            {
+                //Clone the current dictonary
+                Dictionary<string, IVirtualEndpoint<HttpEntity>> newTable = new(VirtualEndpoints, StringComparer.OrdinalIgnoreCase);
+
+                foreach (string eps in paths)
+                {
+                    _ = newTable.Remove(eps);
+                }
+
+                //Update is-empty flag
+                _isEmpty = newTable.Count == 0;
+
+                //Store the new table
+                _ = Interlocked.Exchange(ref VirtualEndpoints, newTable.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase));
+            }
+        }
+
+        ///<inheritdoc/>
+        public bool TryGetEndpoint(string path, [NotNullWhen(true)] out IVirtualEndpoint<HttpEntity>? endpoint)
+            => VirtualEndpoints.TryGetValue(path, out endpoint);
+
+
+        /* 
+         * Wrapper class for converting IHttpEvent endpoints to 
+         * httpEntityEndpoints
+         */
+        private sealed class EvEndpointWrapper(IVirtualEndpoint<IHttpEvent> Wrapped) : IVirtualEndpoint<HttpEntity>
+        {
+            string IEndpoint.Path => Wrapped.Path;
+
+            ValueTask<VfReturnType> IVirtualEndpoint<HttpEntity>.Process(HttpEntity entity) => Wrapped.Process(entity);
+        }
+    }
+}
\ No newline at end of file