diff --git a/VoiceCraft.Tools/AllocHarness/AllocHarness.csproj b/VoiceCraft.Tools/AllocHarness/AllocHarness.csproj
new file mode 100644
index 00000000..b67aacdf
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/AllocHarness.csproj
@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\VoiceCraft.Core\VoiceCraft.Core.csproj" />
+    <ProjectReference Include="..\..\VoiceCraft.Network\VoiceCraft.Network.csproj" />
+    <ProjectReference Include="..\..\VoiceCraft.Server\VoiceCraft.Server.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/VoiceCraft.Tools/AllocHarness/BenchmarkCatalog.cs b/VoiceCraft.Tools/AllocHarness/BenchmarkCatalog.cs
new file mode 100644
index 00000000..7a386c72
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/BenchmarkCatalog.cs
@@ -0,0 +1,176 @@
+internal static class BenchmarkCatalog
+{
+    public static Dictionary<string, BenchmarkDefinition> Build()
+    {
+        return new Dictionary<string, BenchmarkDefinition>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["visibility"] = new(
+                Name: "visibility",
+                Description: "Measures allocations and timing for VisibilitySystem.Update().",
+                ParameterNames: ["Entities", "Effects", "Updates"],
+                DefaultScenarios:
+                [
+                    new Scenario(40, 1, 20),
+                    new Scenario(40, 8, 20),
+                    new Scenario(64, 8, 10)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated update calls after one warm-up run.",
+                SupportsLegacyComparison: true,
+                CreateSampleResult: Measurements.MeasureVisibilitySample),
+
+            ["audio-effects"] = new(
+                Name: "audio-effects",
+                Description: "Measures allocations and timing for audio effect collection reads.",
+                ParameterNames: ["Effects", "Reads", "Unused"],
+                DefaultScenarios:
+                [
+                    new Scenario(1, 10_000, 0),
+                    new Scenario(4, 10_000, 0),
+                    new Scenario(8, 10_000, 0)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated effect collection reads after one warm-up run.",
+                SupportsLegacyComparison: true,
+                CreateSampleResult: Measurements.MeasureAudioEffectsSample),
+
+            ["tcp-frame-read"] = new(
+                Name: "tcp-frame-read",
+                Description: "Measures allocations and timing for TCP frame read and payload parsing.",
+                ParameterNames: ["Packets", "PacketBytes", "Frames"],
+                DefaultScenarios:
+                [
+                    new Scenario(4, 64, 1_000),
+                    new Scenario(8, 256, 1_000),
+                    new Scenario(16, 512, 500)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated TCP frame read/parse operations.",
+                SupportsLegacyComparison: true,
+                CreateSampleResult: Measurements.MeasureTcpFrameReadSample),
+
+            ["tcp-write-payload"] = new(
+                Name: "tcp-write-payload",
+                Description: "Measures allocations and timing for TCP response frame formatting.",
+                ParameterNames: ["Packets", "PacketBytes", "Frames"],
+                DefaultScenarios:
+                [
+                    new Scenario(4, 64, 1_000),
+                    new Scenario(8, 256, 1_000),
+                    new Scenario(16, 512, 500)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated TCP response frame writes into memory.",
+                SupportsLegacyComparison: true,
+                CreateSampleResult: Measurements.MeasureTcpWritePayloadSample),
+
+            ["http-packed-packets"] = new(
+                Name: "http-packed-packets",
+                Description: "Measures allocations and timing for HTTP packed packet decode and encode.",
+                ParameterNames: ["Packets", "PacketBytes", "Requests"],
+                DefaultScenarios:
+                [
+                    new Scenario(4, 64, 1_000),
+                    new Scenario(8, 256, 500),
+                    new Scenario(16, 512, 250)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated HTTP packed-packet decode/encode operations.",
+                SupportsLegacyComparison: false,
+                CreateSampleResult: Measurements.MeasureHttpPackedPacketsSample),
+
+            ["http-auth-path"] = new(
+                Name: "http-auth-path",
+                Description: "Measures allocations and timing for HTTP bearer auth, packet decode, validation, and in-memory dispatch.",
+                ParameterNames: ["Packets", "PacketBytes", "Requests"],
+                DefaultScenarios:
+                [
+                    new Scenario(1, 32, 5_000),
+                    new Scenario(4, 64, 2_000),
+                    new Scenario(8, 128, 1_000)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated HTTP auth-path request handling without sockets.",
+                SupportsLegacyComparison: false,
+                CreateSampleResult: Measurements.MeasureHttpAuthPathSample),
+
+            ["wss-data-tunnel"] = new(
+                Name: "wss-data-tunnel",
+                Description: "Measures allocations and timing for WSS data tunnel decode, packet slicing, and response encoding.",
+                ParameterNames: ["Packets", "PacketBytes", "Commands"],
+                DefaultScenarios:
+                [
+                    new Scenario(4, 64, 1_000),
+                    new Scenario(8, 256, 500),
+                    new Scenario(16, 512, 250)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated WSS data-tunnel command handling.",
+                SupportsLegacyComparison: false,
+                CreateSampleResult: Measurements.MeasureWssDataTunnelSample),
+
+            ["mcapi-broadcast-fanout"] = new(
+                Name: "mcapi-broadcast-fanout",
+                Description: "Measures allocations and timing for McApi packet serialization and broadcast fanout across peers.",
+                ParameterNames: ["Peers", "PacketBytes", "Broadcasts"],
+                DefaultScenarios:
+                [
+                    new Scenario(16, 64, 2_000),
+                    new Scenario(64, 256, 1_000),
+                    new Scenario(256, 512, 250)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated McApi broadcast calls.",
+                SupportsLegacyComparison: false,
+                CreateSampleResult: Measurements.MeasureMcApiBroadcastFanoutSample),
+
+            ["event-handler-burst"] = new(
+                Name: "event-handler-burst",
+                Description: "Measures allocations and timing for EventHandlerSystem task bursts drained through Update().",
+                ParameterNames: ["QueuedTasks", "VisiblePeers", "Bursts"],
+                DefaultScenarios:
+                [
+                    new Scenario(32, 8, 500),
+                    new Scenario(64, 32, 250),
+                    new Scenario(128, 64, 100)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated event-enqueue bursts and queue draining.",
+                SupportsLegacyComparison: false,
+                CreateSampleResult: Measurements.MeasureEventHandlerBurstSample),
+
+            ["entity-create-sync"] = new(
+                Name: "entity-create-sync",
+                Description: "Measures allocations and timing for initial McApi peer sync of effects and entity snapshots.",
+                ParameterNames: ["Entities", "Effects", "Connects"],
+                DefaultScenarios:
+                [
+                    new Scenario(16, 4, 500),
+                    new Scenario(64, 8, 250),
+                    new Scenario(128, 16, 100)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated simulated peer-connect sync runs.",
+                SupportsLegacyComparison: false,
+                CreateSampleResult: Measurements.MeasureEntityCreateSyncSample),
+
+            ["audio-effect-process"] = new(
+                Name: "audio-effect-process",
+                Description: "Measures allocations and timing for applying audio effects across entities and audio buffers.",
+                ParameterNames: ["Effects", "Entities", "Runs"],
+                DefaultScenarios:
+                [
+                    new Scenario(4, 8, 2_000),
+                    new Scenario(8, 32, 1_000),
+                    new Scenario(16, 64, 250)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated audio effect processing passes.",
+                SupportsLegacyComparison: false,
+                CreateSampleResult: Measurements.MeasureAudioEffectProcessSample),
+
+            ["jitter-buffer"] = new(
+                Name: "jitter-buffer",
+                Description: "Measures allocations and timing for JitterBuffer add and drain cycles.",
+                ParameterNames: ["Packets", "PacketBytes", "Runs"],
+                DefaultScenarios:
+                [
+                    new Scenario(128, 160, 100),
+                    new Scenario(512, 160, 50),
+                    new Scenario(1_024, 320, 25)
+                ],
+                MeasurementDescription: "Steady-state allocations and elapsed time across repeated JitterBuffer fill/drain runs.",
+                SupportsLegacyComparison: false,
+                CreateSampleResult: Measurements.MeasureJitterBufferSample)
+        };
+    }
+}
diff --git a/VoiceCraft.Tools/AllocHarness/BenchmarkRunner.cs b/VoiceCraft.Tools/AllocHarness/BenchmarkRunner.cs
new file mode 100644
index 00000000..d5dadaa2
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/BenchmarkRunner.cs
@@ -0,0 +1,39 @@
+internal static class BenchmarkRunner
+{
+    public static BenchmarkRunResult Run(BenchmarkDefinition benchmark, Options options)
+    {
+        if (options.Mode == MeasurementMode.Legacy && !benchmark.SupportsLegacyComparison)
+            throw new ArgumentException($"Benchmark '{benchmark.Name}' does not have a legacy-simulated comparison path.");
+
+        var results = new List<ScenarioResult>();
+        foreach (var scenario in options.Scenarios)
+        {
+            if (options.Mode is MeasurementMode.CheckedOut or MeasurementMode.Both)
+                results.Add(MeasureScenario(benchmark, scenario, ScenarioMode.CheckedOut, options.Samples));
+
+            if (benchmark.SupportsLegacyComparison && options.Mode is (MeasurementMode.Legacy or MeasurementMode.Both))
+                results.Add(MeasureScenario(benchmark, scenario, ScenarioMode.LegacySimulated, options.Samples));
+        }
+
+        ConsoleOutput.PrintHeader(options, benchmark);
+        ConsoleOutput.PrintScenarioTable(results, benchmark);
+        ConsoleOutput.PrintComparisonTable(results, benchmark);
+        ConsoleOutput.PrintFooter(benchmark);
+
+        return new BenchmarkRunResult(benchmark, options, results);
+    }
+
+    private static ScenarioResult MeasureScenario(BenchmarkDefinition benchmark, Scenario scenario, ScenarioMode mode, int samples)
+    {
+        var sampleResults = new List<SampleResult>(samples);
+        for (var sampleIndex = 0; sampleIndex < samples; sampleIndex++)
+            sampleResults.Add(benchmark.CreateSampleResult(scenario, mode));
+
+        return new ScenarioResult(
+            scenario,
+            mode,
+            sampleResults,
+            Stats.BuildLongStats(sampleResults.Select(x => x.AllocatedBytes).ToArray()),
+            Stats.BuildDoubleStats(sampleResults.Select(x => x.Elapsed.TotalMilliseconds).ToArray()));
+    }
+}
diff --git a/VoiceCraft.Tools/AllocHarness/ConsoleOutput.cs b/VoiceCraft.Tools/AllocHarness/ConsoleOutput.cs
new file mode 100644
index 00000000..9353a01e
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/ConsoleOutput.cs
@@ -0,0 +1,272 @@
+using System.Diagnostics;
+using System.Globalization;
+using System.Runtime.InteropServices;
+
+internal static class ConsoleOutput
+{
+    public static void PrintBenchmarkList(IReadOnlyDictionary<string, BenchmarkDefinition> benchmarkDefinitions)
+    {
+        Console.WriteLine("Available benchmarks:");
+        foreach (var benchmark in benchmarkDefinitions.Values.OrderBy(x => x.Name, StringComparer.OrdinalIgnoreCase))
+            Console.WriteLine($"- {benchmark.Name}: {benchmark.Description}");
+    }
+
+    public static void PrintHeader(Options options, BenchmarkDefinition benchmark)
+    {
+        Console.WriteLine("Allocation harness");
+        Console.WriteLine($"Git: {RuntimeMetadata.GetGitDescription()}");
+        Console.WriteLine($".NET: {RuntimeMetadata.GetDotNetVersion()}");
+        Console.WriteLine($"OS: {RuntimeMetadata.GetOsDescription()}");
+        Console.WriteLine($"Benchmark: {benchmark.Name}");
+        Console.WriteLine($"Description: {benchmark.Description}");
+        Console.WriteLine($"Mode: {FormatMode(options.Mode)}");
+        Console.WriteLine($"Samples per scenario: {options.Samples}");
+        Console.WriteLine($"Measurement: {benchmark.MeasurementDescription}");
+        Console.WriteLine();
+    }
+
+    public static void PrintScenarioTable(IReadOnlyList<ScenarioResult> results, BenchmarkDefinition benchmark)
+    {
+        var p1Name = benchmark.ParameterNames[0];
+        var p2Name = benchmark.ParameterNames[1];
+        var p3Name = benchmark.ParameterNames[2];
+        var rows = new List<string[]>
+        {
+            new[]
+            {
+                "Mode",
+                p1Name,
+                p2Name,
+                p3Name,
+                "Samples",
+                "Alloc min",
+                "Alloc med",
+                "Alloc avg",
+                "Alloc max",
+                "B/op med",
+                "Time med (ms)"
+            }
+        };
+
+        rows.AddRange(results.Select(result => new[]
+        {
+            FormatScenarioMode(result.Mode),
+            result.Scenario.P1.ToString(CultureInfo.InvariantCulture),
+            result.Scenario.P2.ToString(CultureInfo.InvariantCulture),
+            result.Scenario.P3.ToString(CultureInfo.InvariantCulture),
+            result.SampleResults.Count.ToString(CultureInfo.InvariantCulture),
+            FormatWholeNumber(result.AllocationStats.Min),
+            FormatWholeNumber(result.AllocationStats.Median),
+            FormatWholeNumber(result.AllocationStats.Average),
+            FormatWholeNumber(result.AllocationStats.Max),
+            FormatWholeNumber(result.AllocationStats.Median / GetOperationCount(result.Scenario, benchmark)),
+            result.ElapsedStats.Median.ToString("0.###", CultureInfo.InvariantCulture)
+        }));
+
+        PrintTable(rows);
+    }
+
+    public static void PrintComparisonTable(IReadOnlyList<ScenarioResult> results, BenchmarkDefinition benchmark)
+    {
+        var grouped = results
+            .GroupBy(x => x.Scenario)
+            .Select(group => new
+            {
+                Scenario = group.Key,
+                CheckedOut = group.FirstOrDefault(x => x.Mode == ScenarioMode.CheckedOut),
+                Legacy = group.FirstOrDefault(x => x.Mode == ScenarioMode.LegacySimulated)
+            })
+            .Where(x => x.CheckedOut is not null && x.Legacy is not null)
+            .ToArray();
+
+        if (grouped.Length == 0) return;
+
+        var p1Name = benchmark.ParameterNames[0];
+        var p2Name = benchmark.ParameterNames[1];
+        var p3Name = benchmark.ParameterNames[2];
+
+        Console.WriteLine();
+        Console.WriteLine("Legacy-simulated vs checked-out");
+
+        var rows = new List<string[]>
+        {
+            new[]
+            {
+                p1Name,
+                p2Name,
+                p3Name,
+                "Alloc ratio (L/C)",
+                "Time ratio (L/C)"
+            }
+        };
+
+        rows.AddRange(grouped.Select(group => new[]
+        {
+            group.Scenario.P1.ToString(CultureInfo.InvariantCulture),
+            group.Scenario.P2.ToString(CultureInfo.InvariantCulture),
+            group.Scenario.P3.ToString(CultureInfo.InvariantCulture),
+            (group.Legacy!.AllocationStats.Median / group.CheckedOut!.AllocationStats.Median).ToString("0.##", CultureInfo.InvariantCulture) + "x",
+            (group.Legacy.ElapsedStats.Median / group.CheckedOut.ElapsedStats.Median).ToString("0.##", CultureInfo.InvariantCulture) + "x"
+        }));
+
+        PrintTable(rows);
+    }
+
+    public static void PrintFooter(BenchmarkDefinition benchmark)
+    {
+        Console.WriteLine();
+        Console.WriteLine("Notes:");
+        Console.WriteLine("- Alloc values are total bytes allocated across the measured loop.");
+        Console.WriteLine("- 'checked-out' means the code that is currently checked out in your worktree.");
+        Console.WriteLine(benchmark.SupportsLegacyComparison
+            ? "- 'legacy-simulated' is the comparison path for the selected benchmark."
+            : "- This benchmark has no legacy-simulated path; '--mode both' runs the checked-out path only.");
+        if (benchmark.Name == "visibility")
+            Console.WriteLine("- visibility legacy-simulated mirrors world.Entities.OfType(...) per entity and AudioEffects materialization inside visibility checks.");
+        else if (benchmark.Name == "audio-effects")
+            Console.WriteLine("- audio-effects legacy-simulated reads the AudioEffects getter, while checked-out reads AudioEffectsSnapshot.");
+        else if (benchmark.Name == "tcp-frame-read")
+            Console.WriteLine("- tcp-frame-read legacy-simulated uses per-frame header/payload arrays; checked-out uses a reused header buffer and pooled payload buffer.");
+        else if (benchmark.Name == "tcp-write-payload")
+            Console.WriteLine("- tcp-write-payload legacy-simulated builds an intermediate payload array before the frame; checked-out writes directly into a pooled frame buffer.");
+        else if (benchmark.Name == "http-packed-packets")
+            Console.WriteLine("- http-packed-packets measures Z85 decode, packet copies, Z85 encode, and UTF-8 response bytes.");
+        else if (benchmark.Name == "http-auth-path")
+            Console.WriteLine("- http-auth-path measures bearer parsing, request-size validation, Z85 decode, packet deserialization, auth check, and lightweight in-memory dispatch.");
+        else if (benchmark.Name == "wss-data-tunnel")
+            Console.WriteLine("- wss-data-tunnel measures Z85 command decode, packet extraction, outbound packing, and response command encoding.");
+        else if (benchmark.Name == "mcapi-broadcast-fanout")
+            Console.WriteLine("- mcapi-broadcast-fanout measures the in-memory cost of serializing one McApi packet and fanning it out across many peers.");
+        else if (benchmark.Name == "event-handler-burst")
+            Console.WriteLine("- event-handler-burst measures actual EventHandlerSystem task enqueue bursts followed by Update() queue draining.");
+        else if (benchmark.Name == "entity-create-sync")
+            Console.WriteLine("- entity-create-sync measures the initial McApi sync path that sends current effects and entity snapshots to a newly connected peer.");
+        else if (benchmark.Name == "audio-effect-process")
+            Console.WriteLine("- audio-effect-process measures repeated effect.Process(...) passes across many target entities and a stereo buffer.");
+        else if (benchmark.Name == "jitter-buffer")
+            Console.WriteLine("- jitter-buffer pre-creates packet payloads and measures buffer add/drain work.");
+        Console.WriteLine("- Use '--list' to see available benchmarks.");
+    }
+
+    public static void PrintReportLocation(string reportPath)
+    {
+        Console.WriteLine();
+        Console.WriteLine($"HTML report: {reportPath}");
+    }
+
+    private static int GetOperationCount(Scenario scenario, BenchmarkDefinition benchmark)
+    {
+        return benchmark.Name switch
+        {
+            "visibility" => scenario.P3,
+            "audio-effects" => scenario.P2,
+            "tcp-frame-read" => scenario.P3,
+            "tcp-write-payload" => scenario.P3,
+            "http-packed-packets" => scenario.P3,
+            "http-auth-path" => scenario.P3,
+            "wss-data-tunnel" => scenario.P3,
+            "mcapi-broadcast-fanout" => scenario.P3,
+            "event-handler-burst" => scenario.P3,
+            "entity-create-sync" => scenario.P3,
+            "audio-effect-process" => scenario.P3,
+            "jitter-buffer" => scenario.P3,
+            _ => 1
+        };
+    }
+
+    private static void PrintTable(IReadOnlyList<string[]> rows)
+    {
+        var widths = new int[rows[0].Length];
+        foreach (var row in rows)
+        {
+            for (var i = 0; i < row.Length; i++)
+                widths[i] = Math.Max(widths[i], row[i].Length);
+        }
+
+        for (var rowIndex = 0; rowIndex < rows.Count; rowIndex++)
+        {
+            var row = rows[rowIndex];
+            Console.WriteLine("| " + string.Join(" | ", row.Select((cell, i) => cell.PadLeft(widths[i]))) + " |");
+
+            if (rowIndex != 0) continue;
+            Console.WriteLine("|-" + string.Join("-|-", widths.Select(width => new string('-', width))) + "-|");
+        }
+    }
+
+    private static string FormatMode(MeasurementMode mode)
+    {
+        return mode switch
+        {
+            MeasurementMode.CheckedOut => "checked-out",
+            MeasurementMode.Legacy => "legacy-simulated",
+            MeasurementMode.Both => "both",
+            _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null)
+        };
+    }
+
+    private static string FormatScenarioMode(ScenarioMode mode)
+    {
+        return mode switch
+        {
+            ScenarioMode.CheckedOut => "checked-out",
+            ScenarioMode.LegacySimulated => "legacy-sim",
+            _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null)
+        };
+    }
+
+    private static string FormatWholeNumber(double value)
+    {
+        return Math.Round(value).ToString("N0", CultureInfo.InvariantCulture);
+    }
+
+}
+
+internal static class RuntimeMetadata
+{
+    public static string GetGitDescription()
+    {
+        try
+        {
+            var commit = RunGit("rev-parse --short HEAD");
+            var branch = RunGit("branch --show-current");
+            return string.IsNullOrWhiteSpace(branch)
+                ? $"{commit} (detached HEAD)"
+                : $"{commit} ({branch})";
+        }
+        catch
+        {
+            return "unknown";
+        }
+    }
+
+    public static string GetDotNetVersion()
+    {
+        return Environment.Version.ToString();
+    }
+
+    public static string GetOsDescription()
+    {
+        return RuntimeInformation.OSDescription;
+    }
+
+    private static string RunGit(string arguments)
+    {
+        using var process = Process.Start(new ProcessStartInfo("git", arguments)
+        {
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            CreateNoWindow = true
+        });
+
+        if (process is null)
+            throw new InvalidOperationException("Failed to start git process.");
+
+        var output = process.StandardOutput.ReadToEnd().Trim();
+        process.WaitForExit();
+        if (process.ExitCode != 0)
+            throw new InvalidOperationException(process.StandardError.ReadToEnd());
+
+        return output;
+    }
+}
diff --git a/VoiceCraft.Tools/AllocHarness/HtmlReportWriter.cs b/VoiceCraft.Tools/AllocHarness/HtmlReportWriter.cs
new file mode 100644
index 00000000..eada47af
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/HtmlReportWriter.cs
@@ -0,0 +1,675 @@
+using System.Globalization;
+using System.Net;
+using System.Text;
+
+internal static class HtmlReportWriter
+{
+    private const string ReportFileName = "report.html";
+    private const string EntriesMarker = "<!-- REPORT_ENTRIES -->";
+    private const string TemplateVersionMarker = "data-report-version=\"4\"";
+
+    public static string Append(HarnessRunReport report)
+    {
+        var reportPath = GetReportPath();
+        var document = LoadOrCreateDocument(reportPath);
+        var entry = BuildReportEntry(report);
+        var updated = document.Replace(EntriesMarker, entry + Environment.NewLine + EntriesMarker, StringComparison.Ordinal);
+        File.WriteAllText(reportPath, updated, Encoding.UTF8);
+        return reportPath;
+    }
+
+    private static string GetReportPath()
+    {
+        var projectDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", ".."));
+        return Path.Combine(projectDirectory, ReportFileName);
+    }
+
+    private static string LoadOrCreateDocument(string reportPath)
+    {
+        if (!File.Exists(reportPath))
+            return BuildDocumentSkeleton();
+
+        var document = File.ReadAllText(reportPath, Encoding.UTF8);
+        return document.Contains(TemplateVersionMarker, StringComparison.Ordinal)
+            ? document
+            : BuildDocumentSkeleton();
+    }
+
+    private static string BuildDocumentSkeleton()
+    {
+        return """
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>AllocHarness Report</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-LN+7fdVzj6u52u30Kp6M/trliBMCMKTyK833zpbD+pXdCLuTusPj697FH4R/5mcr" crossorigin="anonymous">
+    <style>
+        body { background: #09111f; color: #e7eef8; }
+        .page-wrap { max-width: 1560px; }
+        .brand { color: #f8fbff; }
+        .brand small { color: #95a9c2; }
+        .surface, .run-card, .benchmark-card, .metric-card { background: #101a2d; border: 1px solid #22314d; box-shadow: 0 12px 32px rgba(0, 0, 0, 0.22); }
+        .toolbar { position: sticky; top: 0; z-index: 10; backdrop-filter: blur(12px); background: rgba(9, 17, 31, 0.82); }
+        .table { --bs-table-bg: transparent; --bs-table-color: #e7eef8; --bs-table-border-color: #263650; }
+        .table thead th { color: #9eb4cf; font-weight: 600; font-size: 0.82rem; text-transform: uppercase; letter-spacing: 0.03em; white-space: nowrap; }
+        .subtle { color: #9eb4cf; }
+        .pill { display: inline-block; padding: 0.2rem 0.55rem; border-radius: 999px; font-size: 0.8rem; background: #18243a; color: #d7e6f6; border: 1px solid #2b4060; }
+        .ratio-good { color: #78e08f; }
+        .ratio-warn { color: #ffb86b; }
+        .summary-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 0.85rem; }
+        .summary-card { background: #121f34; border: 1px solid #253756; border-radius: 0.9rem; padding: 0.95rem 1rem; }
+        .summary-card .label { color: #8ea4bf; font-size: 0.8rem; text-transform: uppercase; letter-spacing: 0.04em; }
+        .summary-card .value { color: #f8fbff; font-size: 1.35rem; font-weight: 700; }
+        .empty-state { display: none; }
+        .compare-panel { display: none; }
+        .compare-results { display: grid; gap: 1rem; }
+        .compare-table { display: grid; gap: 0; }
+        .compare-grid-head, .compare-run-row { display: grid; grid-template-columns: 72px minmax(260px, 1.4fr) minmax(280px, 1.5fr) repeat(6, minmax(110px, 0.85fr)); gap: 0.75rem; align-items: center; }
+        .compare-grid-head { color: #9eb4cf; font-size: 0.77rem; text-transform: uppercase; letter-spacing: 0.04em; padding-bottom: 0.75rem; }
+        .compare-row-group { border-top: 1px solid #263650; padding: 0.85rem 0; }
+        .compare-run-row { padding: 0.2rem 0; }
+        .compare-scenario-meta { color: #cfe0f2; }
+        .compare-run-meta { color: #d7e6f6; }
+        .compare-divider { margin-top: 0.55rem; border-top: 1px dashed #314665; }
+        .compare-run-chip { display: inline-block; padding: 0.18rem 0.5rem; border-radius: 999px; background: #16233a; border: 1px solid #2b4060; font-size: 0.74rem; color: #d7e6f6; margin-right: 0.35rem; }
+        .delta-better { color: #78e08f; font-weight: 700; }
+        .delta-worse { color: #ff7b72; font-weight: 700; }
+        .delta-flat { color: #c8d5e6; }
+        .run-card[hidden], .benchmark-card[hidden] { display: none !important; }
+        code { color: #a5d8ff; }
+        @media (max-width: 1320px) {
+            .compare-grid-head, .compare-run-row { grid-template-columns: 1fr; }
+        }
+    </style>
+</head>
+<body data-report-version="4">
+    <main class="page-wrap container py-4 py-lg-5">
+        <section class="mb-4">
+            <h1 class="brand h3 mb-1">AllocHarness Report</h1>
+            <small>Append-only run log for allocation and timing measurements, with filters, history, and run-vs-run comparisons.</small>
+        </section>
+
+        <section class="surface toolbar rounded-4 p-3 p-lg-4 mb-4">
+            <div class="row g-3 align-items-end">
+                <div class="col-12 col-md-6 col-xl-3">
+                    <label class="form-label subtle mb-1" for="filter-search">Search</label>
+                    <input id="filter-search" class="form-control bg-dark text-light border-secondary" type="search" placeholder="benchmark, commit, os, dotnet">
+                </div>
+                <div class="col-6 col-md-3 col-xl-2">
+                    <label class="form-label subtle mb-1" for="filter-benchmark">Benchmark</label>
+                    <select id="filter-benchmark" class="form-select bg-dark text-light border-secondary">
+                        <option value="">All benchmarks</option>
+                    </select>
+                </div>
+                <div class="col-6 col-md-3 col-xl-2">
+                    <label class="form-label subtle mb-1" for="filter-mode">Mode</label>
+                    <select id="filter-mode" class="form-select bg-dark text-light border-secondary">
+                        <option value="">All modes</option>
+                    </select>
+                </div>
+                <div class="col-12 col-md-6 col-xl-3">
+                    <label class="form-label subtle mb-1" for="filter-commit">Commit</label>
+                    <select id="filter-commit" class="form-select bg-dark text-light border-secondary">
+                        <option value="">All commits</option>
+                    </select>
+                </div>
+                <div class="col-12 col-md-6 col-xl-2 d-flex gap-2">
+                    <div class="form-check mt-4">
+                        <input class="form-check-input" type="checkbox" value="" id="filter-latest">
+                        <label class="form-check-label subtle" for="filter-latest">Latest run only</label>
+                    </div>
+                    <button id="filter-reset" class="btn btn-outline-light ms-auto mt-3 mt-md-4" type="button">Reset</button>
+                </div>
+            </div>
+            <div class="summary-grid mt-4">
+                <div class="summary-card">
+                    <div class="label">Visible Runs</div>
+                    <div id="summary-runs" class="value">0</div>
+                </div>
+                <div class="summary-card">
+                    <div class="label">Visible Benchmarks</div>
+                    <div id="summary-benchmarks" class="value">0</div>
+                </div>
+                <div class="summary-card">
+                    <div class="label">Unique Commits</div>
+                    <div id="summary-commits" class="value">0</div>
+                </div>
+                <div class="summary-card">
+                    <div class="label">Latest Visible Run</div>
+                    <div id="summary-latest" class="value fs-6">-</div>
+                </div>
+            </div>
+        </section>
+
+        <section class="surface compare-panel rounded-4 p-3 p-lg-4 mb-4" id="compare-panel">
+            <div class="d-flex flex-column flex-lg-row justify-content-between gap-2 mb-3">
+                <div>
+                    <h2 class="h5 mb-1">VS Mode</h2>
+                    <div class="subtle">Choose two runs and optionally a benchmark. Below, each shared benchmark renders as its own comparison block.</div>
+                </div>
+            </div>
+            <div class="row g-3 align-items-end">
+                <div class="col-12 col-md-4">
+                    <label class="form-label subtle mb-1" for="compare-left-run">Run A</label>
+                    <select id="compare-left-run" class="form-select bg-dark text-light border-secondary"></select>
+                </div>
+                <div class="col-12 col-md-4">
+                    <label class="form-label subtle mb-1" for="compare-right-run">Run B</label>
+                    <select id="compare-right-run" class="form-select bg-dark text-light border-secondary"></select>
+                </div>
+                <div class="col-12 col-md-4">
+                    <label class="form-label subtle mb-1" for="compare-benchmark">Benchmark</label>
+                    <select id="compare-benchmark" class="form-select bg-dark text-light border-secondary"></select>
+                </div>
+            </div>
+            <div id="compare-results" class="compare-results mt-4"></div>
+            <div id="compare-empty" class="subtle mt-3">Need at least two runs with shared benchmark scenarios to compare.</div>
+        </section>
+
+        <div id="report-entries">
+            <!-- REPORT_ENTRIES -->
+        </div>
+
+        <section id="empty-state" class="surface rounded-4 p-4 text-center empty-state">
+            <div class="h5 mb-2">No results match the current filters.</div>
+            <div class="subtle">Try clearing the search, switching the commit filter, or disabling latest-only mode.</div>
+        </section>
+    </main>
+
+    <script>
+        (() => {
+            const runCards = Array.from(document.querySelectorAll('.run-card'));
+            const benchmarkCards = Array.from(document.querySelectorAll('.benchmark-card'));
+            const searchInput = document.getElementById('filter-search');
+            const benchmarkSelect = document.getElementById('filter-benchmark');
+            const modeSelect = document.getElementById('filter-mode');
+            const commitSelect = document.getElementById('filter-commit');
+            const latestCheckbox = document.getElementById('filter-latest');
+            const resetButton = document.getElementById('filter-reset');
+            const emptyState = document.getElementById('empty-state');
+            const comparePanel = document.getElementById('compare-panel');
+            const compareLeftRun = document.getElementById('compare-left-run');
+            const compareRightRun = document.getElementById('compare-right-run');
+            const compareBenchmark = document.getElementById('compare-benchmark');
+            const compareResults = document.getElementById('compare-results');
+            const compareEmpty = document.getElementById('compare-empty');
+            const summaryRuns = document.getElementById('summary-runs');
+            const summaryBenchmarks = document.getElementById('summary-benchmarks');
+            const summaryCommits = document.getElementById('summary-commits');
+            const summaryLatest = document.getElementById('summary-latest');
+
+            const uniqueSorted = values => Array.from(new Set(values.filter(Boolean))).sort((a, b) => a.localeCompare(b));
+
+            function appendOptions(select, values, allLabel) {
+                select.innerHTML = '';
+                const allOption = document.createElement('option');
+                allOption.value = '';
+                allOption.textContent = allLabel;
+                select.appendChild(allOption);
+
+                uniqueSorted(values).forEach(value => {
+                    const option = document.createElement('option');
+                    option.value = value;
+                    option.textContent = value;
+                    select.appendChild(option);
+                });
+            }
+
+            appendOptions(benchmarkSelect, benchmarkCards.map(card => card.dataset.benchmarkName), 'All benchmarks');
+            appendOptions(modeSelect, benchmarkCards.map(card => card.dataset.mode), 'All modes');
+            appendOptions(commitSelect, runCards.map(card => card.dataset.commit), 'All commits');
+
+            const runOptions = runCards.map(card => ({
+                id: card.dataset.runId,
+                label: `${card.dataset.timestampLabel} | ${card.dataset.commit}`,
+            }));
+
+            compareLeftRun.innerHTML = runOptions.map(x => `<option value="${x.id}">${x.label}</option>`).join('');
+            compareRightRun.innerHTML = runOptions.map(x => `<option value="${x.id}">${x.label}</option>`).join('');
+            if (runOptions.length > 1) {
+                compareRightRun.selectedIndex = 1;
+            }
+            appendOptions(compareBenchmark, benchmarkCards.map(card => card.dataset.benchmarkName), 'All shared benchmarks');
+
+            function applyFilters() {
+                const search = searchInput.value.trim().toLowerCase();
+                const benchmark = benchmarkSelect.value;
+                const mode = modeSelect.value;
+                const commit = commitSelect.value;
+                const latestOnly = latestCheckbox.checked;
+                const latestRunId = runCards.length > 0 ? runCards[0].dataset.runId : '';
+
+                let visibleBenchmarkCount = 0;
+                let visibleRunCount = 0;
+                const visibleCommits = new Set();
+                let latestVisibleRun = '';
+
+                runCards.forEach(runCard => {
+                    const isLatestRun = !latestOnly || runCard.dataset.runId === latestRunId;
+                    const commitMatches = !commit || runCard.dataset.commit === commit;
+                    const runSearchText = runCard.dataset.search || '';
+
+                    let runHasVisibleBenchmarks = false;
+                    const nestedBenchmarks = Array.from(runCard.querySelectorAll('.benchmark-card'));
+                    nestedBenchmarks.forEach(card => {
+                        const benchmarkMatches = !benchmark || card.dataset.benchmarkName === benchmark;
+                        const modeMatches = !mode || card.dataset.mode === mode;
+                        const textMatches = !search || card.dataset.search.includes(search) || runSearchText.includes(search);
+                        const visible = isLatestRun && commitMatches && benchmarkMatches && modeMatches && textMatches;
+                        card.hidden = !visible;
+                        if (visible) {
+                            runHasVisibleBenchmarks = true;
+                            visibleBenchmarkCount++;
+                        }
+                    });
+
+                    runCard.hidden = !runHasVisibleBenchmarks;
+                    if (runHasVisibleBenchmarks) {
+                        visibleRunCount++;
+                        visibleCommits.add(runCard.dataset.commit);
+                        if (!latestVisibleRun) {
+                            latestVisibleRun = runCard.dataset.timestampLabel || '-';
+                        }
+                    }
+                });
+
+                summaryRuns.textContent = String(visibleRunCount);
+                summaryBenchmarks.textContent = String(visibleBenchmarkCount);
+                summaryCommits.textContent = String(visibleCommits.size);
+                summaryLatest.textContent = latestVisibleRun || '-';
+                emptyState.style.display = visibleBenchmarkCount === 0 ? 'block' : 'none';
+            }
+
+            function getRunCard(runId) {
+                return document.querySelector(`.run-card[data-run-id="${CSS.escape(runId)}"]`);
+            }
+
+            function getBenchmarkCard(runId, benchmarkName) {
+                return document.querySelector(`.run-card[data-run-id="${CSS.escape(runId)}"] .benchmark-card[data-benchmark-name="${CSS.escape(benchmarkName)}"]`);
+            }
+
+            function parseRows(runId, benchmarkName) {
+                return Array.from(document.querySelectorAll(`.run-card[data-run-id="${CSS.escape(runId)}"] .benchmark-card[data-benchmark-name="${CSS.escape(benchmarkName)}"] tbody tr[data-scenario-key]`)).map(row => ({
+                    key: row.dataset.scenarioKey,
+                    label: row.dataset.scenarioLabel,
+                    mode: row.dataset.modeLabel,
+                    samples: Number(row.dataset.samples || '0'),
+                    allocMin: Number(row.dataset.allocMin || '0'),
+                    allocMed: Number(row.dataset.allocMed || '0'),
+                    allocAvg: Number(row.dataset.allocAvg || '0'),
+                    allocMax: Number(row.dataset.allocMax || '0'),
+                    bytesPerOp: Number(row.dataset.bytesPerOp || '0'),
+                    timeMed: Number(row.dataset.timeMed || '0')
+                }));
+            }
+
+            function formatWhole(value) {
+                return Number(value).toLocaleString(undefined, { maximumFractionDigits: 0 });
+            }
+
+            function formatTime(value) {
+                return Number(value).toLocaleString(undefined, { minimumFractionDigits: 0, maximumFractionDigits: 3 });
+            }
+
+            function getValueClass(leftValue, rightValue, side) {
+                if (leftValue === rightValue) {
+                    return 'delta-flat';
+                }
+
+                if (side === 'left') {
+                    return leftValue < rightValue ? 'delta-better' : 'delta-worse';
+                }
+
+                return rightValue < leftValue ? 'delta-better' : 'delta-worse';
+            }
+
+            function renderRunMetric(value, otherValue, formatter, side) {
+                const cssClass = getValueClass(side === 'left' ? value : otherValue, side === 'left' ? otherValue : value, side);
+                return `<div class="${cssClass}">${formatter(value)}</div>`;
+            }
+
+            function buildCompareBlock(runAId, runBId, benchmarkName) {
+                const runACard = getRunCard(runAId);
+                const runBCard = getRunCard(runBId);
+                const benchmarkACard = getBenchmarkCard(runAId, benchmarkName);
+                const benchmarkBCard = getBenchmarkCard(runBId, benchmarkName);
+                if (!runACard || !runBCard || !benchmarkACard || !benchmarkBCard) {
+                    return '';
+                }
+
+                const leftRows = parseRows(runAId, benchmarkName);
+                const rightRows = parseRows(runBId, benchmarkName);
+                const rightMap = new Map(rightRows.map(row => [row.key, row]));
+                const mergedRows = leftRows
+                    .filter(row => rightMap.has(row.key))
+                    .map(row => ({ left: row, right: rightMap.get(row.key) }));
+
+                if (mergedRows.length === 0) {
+                    return '';
+                }
+
+                const description = benchmarkACard.dataset.description || benchmarkName;
+                const measurement = benchmarkACard.dataset.measurement || '';
+                const mode = benchmarkACard.dataset.mode || '';
+                const runALabel = `${runACard.dataset.timestampLabel} | ${runACard.dataset.commit}`;
+                const runBLabel = `${runBCard.dataset.timestampLabel} | ${runBCard.dataset.commit}`;
+
+                const rowsHtml = mergedRows.map(pair => `
+                    <div class="compare-row-group">
+                        <div class="compare-run-row">
+                            <div><span class="compare-run-chip">A</span></div>
+                            <div class="compare-scenario-meta">
+                                <div class="fw-semibold">${pair.left.label}</div>
+                                <div class="subtle small">Mode: ${pair.left.mode} | Samples: ${pair.left.samples}</div>
+                            </div>
+                            <div class="compare-run-meta">${runALabel}</div>
+                            ${renderRunMetric(pair.left.allocMin, pair.right.allocMin, formatWhole, 'left')}
+                            ${renderRunMetric(pair.left.allocMed, pair.right.allocMed, formatWhole, 'left')}
+                            ${renderRunMetric(pair.left.allocAvg, pair.right.allocAvg, formatWhole, 'left')}
+                            ${renderRunMetric(pair.left.allocMax, pair.right.allocMax, formatWhole, 'left')}
+                            ${renderRunMetric(pair.left.bytesPerOp, pair.right.bytesPerOp, formatWhole, 'left')}
+                            ${renderRunMetric(pair.left.timeMed, pair.right.timeMed, formatTime, 'left')}
+                        </div>
+                        <div class="compare-run-row">
+                            <div><span class="compare-run-chip">B</span></div>
+                            <div class="compare-scenario-meta">
+                                <div class="fw-semibold">${pair.right.label}</div>
+                                <div class="subtle small">Mode: ${pair.right.mode} | Samples: ${pair.right.samples}</div>
+                            </div>
+                            <div class="compare-run-meta">${runBLabel}</div>
+                            ${renderRunMetric(pair.right.allocMin, pair.left.allocMin, formatWhole, 'right')}
+                            ${renderRunMetric(pair.right.allocMed, pair.left.allocMed, formatWhole, 'right')}
+                            ${renderRunMetric(pair.right.allocAvg, pair.left.allocAvg, formatWhole, 'right')}
+                            ${renderRunMetric(pair.right.allocMax, pair.left.allocMax, formatWhole, 'right')}
+                            ${renderRunMetric(pair.right.bytesPerOp, pair.left.bytesPerOp, formatWhole, 'right')}
+                            ${renderRunMetric(pair.right.timeMed, pair.left.timeMed, formatTime, 'right')}
+                        </div>
+                        <div class="compare-divider"></div>
+                    </div>`).join('');
+
+                return `
+                    <article class="benchmark-card rounded-4 p-4">
+                        <div class="d-flex flex-column flex-xl-row justify-content-between gap-3 mb-3">
+                            <div>
+                                <h3 class="h5 mb-1">${benchmarkName}</h3>
+                                <p class="subtle mb-2">${description}</p>
+                                <div class="d-flex flex-wrap gap-2">
+                                    <span class="pill">Mode: ${mode}</span>
+                                    <span class="pill">Measurement: ${measurement}</span>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="compare-grid-head">
+                            <div>Run</div>
+                            <div>Scenario</div>
+                            <div>Run Meta</div>
+                            <div>Alloc min</div>
+                            <div>Alloc med</div>
+                            <div>Alloc avg</div>
+                            <div>Alloc max</div>
+                            <div>B/op med</div>
+                            <div>Time med</div>
+                        </div>
+                        <div class="compare-table">${rowsHtml}</div>
+                    </article>`;
+            }
+
+            function renderCompare() {
+                const leftRunId = compareLeftRun.value;
+                const rightRunId = compareRightRun.value;
+                const benchmarkFilter = compareBenchmark.value;
+
+                comparePanel.style.display = runOptions.length > 1 ? 'block' : 'none';
+                if (!leftRunId || !rightRunId) {
+                    compareResults.innerHTML = '';
+                    compareEmpty.textContent = 'Need at least two runs with shared benchmark scenarios to compare.';
+                    return;
+                }
+
+                if (leftRunId === rightRunId) {
+                    compareResults.innerHTML = '';
+                    compareEmpty.textContent = 'Pick two different runs to compare.';
+                    return;
+                }
+
+                const leftNames = new Set(Array.from(document.querySelectorAll(`.run-card[data-run-id="${CSS.escape(leftRunId)}"] .benchmark-card`)).map(card => card.dataset.benchmarkName));
+                const rightNames = new Set(Array.from(document.querySelectorAll(`.run-card[data-run-id="${CSS.escape(rightRunId)}"] .benchmark-card`)).map(card => card.dataset.benchmarkName));
+                let sharedBenchmarkNames = Array.from(leftNames).filter(name => rightNames.has(name)).sort((a, b) => a.localeCompare(b));
+
+                if (benchmarkFilter) {
+                    sharedBenchmarkNames = sharedBenchmarkNames.filter(name => name === benchmarkFilter);
+                }
+
+                const blocks = sharedBenchmarkNames
+                    .map(name => buildCompareBlock(leftRunId, rightRunId, name))
+                    .filter(Boolean);
+
+                compareResults.innerHTML = blocks.join('');
+                compareEmpty.textContent = blocks.length > 0
+                    ? ''
+                    : benchmarkFilter
+                        ? 'These runs do not share matching scenarios for the selected benchmark.'
+                        : 'These runs do not share matching benchmark scenarios.';
+            }
+
+            [searchInput, benchmarkSelect, modeSelect, commitSelect, latestCheckbox].forEach(control => {
+                control.addEventListener('input', applyFilters);
+                control.addEventListener('change', applyFilters);
+            });
+
+            [compareLeftRun, compareRightRun, compareBenchmark].forEach(control => {
+                control.addEventListener('input', renderCompare);
+                control.addEventListener('change', renderCompare);
+            });
+
+            resetButton.addEventListener('click', () => {
+                searchInput.value = '';
+                benchmarkSelect.value = '';
+                modeSelect.value = '';
+                commitSelect.value = '';
+                latestCheckbox.checked = false;
+                applyFilters();
+            });
+
+            applyFilters();
+            renderCompare();
+        })();
+    </script>
+</body>
+</html>
+""";
+    }
+
+    private static string BuildReportEntry(HarnessRunReport report)
+    {
+        var runId = report.StartedAtUtc.ToString("O", CultureInfo.InvariantCulture);
+        var timestampLabel = report.StartedAtUtc.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss zzz", CultureInfo.InvariantCulture);
+        var runSearch = $"{report.GitDescription} {report.DotNetVersion} {report.OsDescription}".ToLowerInvariant();
+
+        var builder = new StringBuilder();
+        builder.AppendLine($"""<section class="run-card rounded-4 p-4 mb-4" data-run-id="{Encode(runId)}" data-commit="{Encode(report.GitDescription)}" data-timestamp-label="{Encode(timestampLabel)}" data-search="{Encode(runSearch)}">""");
+        builder.AppendLine("""  <div class="d-flex flex-column flex-lg-row justify-content-between gap-3 mb-3">""");
+        builder.AppendLine("""    <div>""");
+        builder.AppendLine($"""      <h2 class="h4 mb-1">Run <span class="subtle">{Encode(timestampLabel)}</span></h2>""");
+        builder.AppendLine("""      <div class="d-flex flex-wrap gap-2 mt-2">""");
+        builder.AppendLine($"""        <span class="pill">Commit: {Encode(report.GitDescription)}</span>""");
+        builder.AppendLine($"""        <span class="pill">.NET: {Encode(report.DotNetVersion)}</span>""");
+        builder.AppendLine($"""        <span class="pill">OS: {Encode(report.OsDescription)}</span>""");
+        builder.AppendLine($"""        <span class="pill">Benchmarks: {report.Benchmarks.Count.ToString(CultureInfo.InvariantCulture)}</span>""");
+        builder.AppendLine("""      </div>""");
+        builder.AppendLine("""    </div>""");
+        builder.AppendLine("""  </div>""");
+
+        foreach (var benchmarkRun in report.Benchmarks)
+            builder.Append(BuildBenchmarkSection(benchmarkRun, report.GitDescription, timestampLabel));
+
+        builder.AppendLine("</section>");
+        return builder.ToString();
+    }
+
+    private static string BuildBenchmarkSection(BenchmarkRunResult run, string commit, string timestampLabel)
+    {
+        var builder = new StringBuilder();
+        var benchmark = run.Benchmark;
+        var mode = FormatMode(run.Options.Mode);
+        var searchText = string.Join(' ',
+            benchmark.Name,
+            benchmark.Description,
+            mode,
+            commit,
+            timestampLabel,
+            benchmark.MeasurementDescription).ToLowerInvariant();
+
+        builder.AppendLine($"""<article class="benchmark-card rounded-4 p-4 mb-4" data-benchmark-name="{Encode(benchmark.Name)}" data-mode="{Encode(mode)}" data-commit="{Encode(commit)}" data-description="{Encode(benchmark.Description)}" data-measurement="{Encode(benchmark.MeasurementDescription)}" data-search="{Encode(searchText)}">""");
+        builder.AppendLine("""  <div class="d-flex flex-column flex-xl-row justify-content-between gap-3 mb-3">""");
+        builder.AppendLine("""    <div>""");
+        builder.AppendLine($"""      <h3 class="h5 mb-1">{Encode(benchmark.Name)}</h3>""");
+        builder.AppendLine($"""      <p class="subtle mb-2">{Encode(benchmark.Description)}</p>""");
+        builder.AppendLine("""      <div class="d-flex flex-wrap gap-2">""");
+        builder.AppendLine($"""        <span class="pill">Mode: {Encode(mode)}</span>""");
+        builder.AppendLine($"""        <span class="pill">Samples: {run.Options.Samples.ToString(CultureInfo.InvariantCulture)}</span>""");
+        builder.AppendLine($"""        <span class="pill">Measurement: {Encode(benchmark.MeasurementDescription)}</span>""");
+        builder.AppendLine("""      </div>""");
+        builder.AppendLine("""    </div>""");
+        builder.AppendLine("""  </div>""");
+
+        builder.AppendLine("""  <div class="table-responsive mb-3">""");
+        builder.AppendLine("""    <table class="table table-sm align-middle mb-0">""");
+        builder.AppendLine("""      <thead><tr>""");
+        builder.AppendLine($"""        <th>Mode</th><th>{Encode(benchmark.ParameterNames[0])}</th><th>{Encode(benchmark.ParameterNames[1])}</th><th>{Encode(benchmark.ParameterNames[2])}</th><th>Samples</th><th>Alloc min</th><th>Alloc med</th><th>Alloc avg</th><th>Alloc max</th><th>B/op med</th><th>Time med (ms)</th>""");
+        builder.AppendLine("""      </tr></thead>""");
+        builder.AppendLine("""      <tbody>""");
+
+        foreach (var result in run.ScenarioResults)
+        {
+            var bytesPerOp = result.AllocationStats.Median / GetOperationCount(result.Scenario, benchmark);
+            var scenarioKey = $"{result.Scenario.P1}|{result.Scenario.P2}|{result.Scenario.P3}";
+            var scenarioLabel = $"{benchmark.ParameterNames[0]}={result.Scenario.P1}, {benchmark.ParameterNames[1]}={result.Scenario.P2}, {benchmark.ParameterNames[2]}={result.Scenario.P3}";
+            builder.AppendLine($"""        <tr data-scenario-key="{Encode(scenarioKey)}" data-scenario-label="{Encode(scenarioLabel)}" data-mode-label="{Encode(FormatScenarioMode(result.Mode))}" data-samples="{result.SampleResults.Count.ToString(CultureInfo.InvariantCulture)}" data-alloc-min="{result.AllocationStats.Min.ToString("0.###", CultureInfo.InvariantCulture)}" data-alloc-med="{result.AllocationStats.Median.ToString("0.###", CultureInfo.InvariantCulture)}" data-alloc-avg="{result.AllocationStats.Average.ToString("0.###", CultureInfo.InvariantCulture)}" data-alloc-max="{result.AllocationStats.Max.ToString("0.###", CultureInfo.InvariantCulture)}" data-bytes-per-op="{bytesPerOp.ToString("0.###", CultureInfo.InvariantCulture)}" data-time-med="{result.ElapsedStats.Median.ToString("0.###", CultureInfo.InvariantCulture)}">""");
+            builder.AppendLine($"""          <td>{Encode(FormatScenarioMode(result.Mode))}</td>""");
+            builder.AppendLine($"""          <td>{result.Scenario.P1.ToString(CultureInfo.InvariantCulture)}</td>""");
+            builder.AppendLine($"""          <td>{result.Scenario.P2.ToString(CultureInfo.InvariantCulture)}</td>""");
+            builder.AppendLine($"""          <td>{result.Scenario.P3.ToString(CultureInfo.InvariantCulture)}</td>""");
+            builder.AppendLine($"""          <td>{result.SampleResults.Count.ToString(CultureInfo.InvariantCulture)}</td>""");
+            builder.AppendLine($"""          <td>{FormatWholeNumber(result.AllocationStats.Min)}</td>""");
+            builder.AppendLine($"""          <td>{FormatWholeNumber(result.AllocationStats.Median)}</td>""");
+            builder.AppendLine($"""          <td>{FormatWholeNumber(result.AllocationStats.Average)}</td>""");
+            builder.AppendLine($"""          <td>{FormatWholeNumber(result.AllocationStats.Max)}</td>""");
+            builder.AppendLine($"""          <td>{FormatWholeNumber(bytesPerOp)}</td>""");
+            builder.AppendLine($"""          <td>{result.ElapsedStats.Median.ToString("0.###", CultureInfo.InvariantCulture)}</td>""");
+            builder.AppendLine("""        </tr>""");
+        }
+
+        builder.AppendLine("""      </tbody>""");
+        builder.AppendLine("""    </table>""");
+        builder.AppendLine("""  </div>""");
+
+        var comparisons = BuildComparisonRows(run.ScenarioResults);
+        if (comparisons.Count > 0)
+        {
+            builder.AppendLine("""  <div class="metric-card rounded-4 p-3">""");
+            builder.AppendLine("""    <div class="fw-semibold mb-2">Legacy-simulated vs checked-out</div>""");
+            builder.AppendLine("""    <div class="table-responsive">""");
+            builder.AppendLine("""      <table class="table table-sm align-middle mb-0">""");
+            builder.AppendLine("""        <thead><tr>""");
+            builder.AppendLine($"""          <th>{Encode(benchmark.ParameterNames[0])}</th><th>{Encode(benchmark.ParameterNames[1])}</th><th>{Encode(benchmark.ParameterNames[2])}</th><th>Alloc ratio (L/C)</th><th>Time ratio (L/C)</th>""");
+            builder.AppendLine("""        </tr></thead>""");
+            builder.AppendLine("""        <tbody>""");
+            foreach (var comparison in comparisons)
+            {
+                builder.AppendLine("""          <tr>""");
+                builder.AppendLine($"""            <td>{comparison.Scenario.P1.ToString(CultureInfo.InvariantCulture)}</td>""");
+                builder.AppendLine($"""            <td>{comparison.Scenario.P2.ToString(CultureInfo.InvariantCulture)}</td>""");
+                builder.AppendLine($"""            <td>{comparison.Scenario.P3.ToString(CultureInfo.InvariantCulture)}</td>""");
+                builder.AppendLine($"""            <td class="{GetRatioClass(comparison.AllocationRatio)}">{comparison.AllocationRatio.ToString("0.##", CultureInfo.InvariantCulture)}x</td>""");
+                builder.AppendLine($"""            <td class="{GetRatioClass(comparison.ElapsedRatio)}">{comparison.ElapsedRatio.ToString("0.##", CultureInfo.InvariantCulture)}x</td>""");
+                builder.AppendLine("""          </tr>""");
+            }
+            builder.AppendLine("""        </tbody>""");
+            builder.AppendLine("""      </table>""");
+            builder.AppendLine("""    </div>""");
+            builder.AppendLine("""  </div>""");
+        }
+
+        builder.AppendLine("""</article>""");
+        return builder.ToString();
+    }
+
+    private static List<ComparisonRow> BuildComparisonRows(IReadOnlyList<ScenarioResult> results)
+    {
+        return results
+            .GroupBy(x => x.Scenario)
+            .Select(group => new
+            {
+                Scenario = group.Key,
+                CheckedOut = group.FirstOrDefault(x => x.Mode == ScenarioMode.CheckedOut),
+                Legacy = group.FirstOrDefault(x => x.Mode == ScenarioMode.LegacySimulated)
+            })
+            .Where(x => x.CheckedOut is not null && x.Legacy is not null)
+            .Select(x => new ComparisonRow(
+                x.Scenario,
+                x.Legacy!.AllocationStats.Median / x.CheckedOut!.AllocationStats.Median,
+                x.Legacy.ElapsedStats.Median / x.CheckedOut.ElapsedStats.Median))
+            .ToList();
+    }
+
+    private static string GetRatioClass(double ratio)
+    {
+        return ratio >= 1.0d ? "ratio-warn" : "ratio-good";
+    }
+
+    private static string FormatMode(MeasurementMode mode)
+    {
+        return mode switch
+        {
+            MeasurementMode.CheckedOut => "checked-out",
+            MeasurementMode.Legacy => "legacy-simulated",
+            MeasurementMode.Both => "both",
+            _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null)
+        };
+    }
+
+    private static string FormatScenarioMode(ScenarioMode mode)
+    {
+        return mode switch
+        {
+            ScenarioMode.CheckedOut => "checked-out",
+            ScenarioMode.LegacySimulated => "legacy-sim",
+            _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null)
+        };
+    }
+
+    private static string FormatWholeNumber(double value)
+    {
+        return Math.Round(value).ToString("N0", CultureInfo.InvariantCulture);
+    }
+
+    private static double GetOperationCount(Scenario scenario, BenchmarkDefinition benchmark)
+    {
+        return benchmark.Name switch
+        {
+            "visibility" => scenario.P3,
+            "audio-effects" => scenario.P2,
+            "tcp-frame-read" => scenario.P3,
+            "tcp-write-payload" => scenario.P3,
+            "http-packed-packets" => scenario.P3,
+            "http-auth-path" => scenario.P3,
+            "wss-data-tunnel" => scenario.P3,
+            "mcapi-broadcast-fanout" => scenario.P3,
+            "event-handler-burst" => scenario.P3,
+            "entity-create-sync" => scenario.P3,
+            "audio-effect-process" => scenario.P3,
+            "jitter-buffer" => scenario.P3,
+            _ => 1
+        };
+    }
+
+    private static string Encode(string value)
+    {
+        return WebUtility.HtmlEncode(value);
+    }
+
+    private sealed record ComparisonRow(Scenario Scenario, double AllocationRatio, double ElapsedRatio);
+}
diff --git a/VoiceCraft.Tools/AllocHarness/Measurements.cs b/VoiceCraft.Tools/AllocHarness/Measurements.cs
new file mode 100644
index 00000000..a3ffd495
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/Measurements.cs
@@ -0,0 +1,753 @@
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Diagnostics;
+using System.Numerics;
+using System.Text;
+using LiteNetLib.Utils;
+using VoiceCraft.Core.Interfaces;
+using VoiceCraft.Core.World;
+using VoiceCraft.Network;
+using VoiceCraft.Network.Audio;
+using VoiceCraft.Network.Interfaces;
+using VoiceCraft.Network.NetPeers;
+using VoiceCraft.Network.Packets.McApiPackets;
+using VoiceCraft.Network.Packets.McApiPackets.Request;
+using VoiceCraft.Network.Systems;
+using VoiceCraft.Network.World;
+using VoiceCraft.Server.Systems;
+
+internal static class Measurements
+{
+    public static SampleResult MeasureVisibilitySample(Scenario scenario, ScenarioMode mode)
+    {
+        using var world = new VoiceCraftWorld();
+        using var effectSystem = new AudioEffectSystem();
+        var visibilitySystem = new VisibilitySystem(world, effectSystem);
+
+        for (var i = 0; i < scenario.P1; i++)
+            world.AddEntity(CreateNetworkEntity(i + 1));
+
+        for (var i = 0; i < scenario.P2; i++)
+            effectSystem.SetEffect((ushort)(1 << i), new FakeVisibleEffect(true));
+
+        Action action = mode switch
+        {
+            ScenarioMode.CheckedOut => visibilitySystem.Update,
+            ScenarioMode.LegacySimulated => () => _ = RunLegacyVisibilityPass(world, effectSystem),
+            _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null)
+        };
+
+        return MeasureAction(action, scenario.P3);
+    }
+
+    public static SampleResult MeasureAudioEffectsSample(Scenario scenario, ScenarioMode mode)
+    {
+        using var effectSystem = new AudioEffectSystem();
+        for (var i = 0; i < scenario.P1; i++)
+            effectSystem.SetEffect((ushort)(1 << i), new FakeVisibleEffect(true));
+
+        Action action = mode switch
+        {
+            ScenarioMode.CheckedOut => () => GC.KeepAlive(effectSystem.AudioEffectsSnapshot),
+            ScenarioMode.LegacySimulated => () => GC.KeepAlive(effectSystem.AudioEffects),
+            _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null)
+        };
+
+        return MeasureAction(action, scenario.P2);
+    }
+
+    public static SampleResult MeasureTcpFrameReadSample(Scenario scenario, ScenarioMode mode)
+    {
+        var packets = BuildPackets(scenario.P1, scenario.P2);
+        var payload = BuildTcpPayload(string.Empty, packets);
+        var frame = BuildTcpFrame(payload, ProtocolConstants.TcpRequestKind);
+        var headerBuffer = ArrayPool<byte>.Shared.Rent(ProtocolConstants.TcpFrameHeaderSize);
+
+        try
+        {
+            Action action = mode switch
+            {
+                ScenarioMode.CheckedOut => () => RunTcpFrameReadCheckedOut(frame, headerBuffer),
+                ScenarioMode.LegacySimulated => () => RunTcpFrameReadLegacy(frame),
+                _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null)
+            };
+
+            return MeasureAction(action, scenario.P3);
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(headerBuffer);
+        }
+    }
+
+    public static SampleResult MeasureTcpWritePayloadSample(Scenario scenario, ScenarioMode mode)
+    {
+        var packets = BuildPackets(scenario.P1, scenario.P2);
+
+        Action action = mode switch
+        {
+            ScenarioMode.CheckedOut => () => RunTcpWritePayloadCheckedOut(packets),
+            ScenarioMode.LegacySimulated => () => RunTcpWritePayloadLegacy(packets),
+            _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null)
+        };
+
+        return MeasureAction(action, scenario.P3);
+    }
+
+    public static SampleResult MeasureHttpPackedPacketsSample(Scenario scenario, ScenarioMode mode)
+    {
+        if (mode != ScenarioMode.CheckedOut)
+            throw new ArgumentOutOfRangeException(nameof(mode), mode, "HTTP packed packets has no legacy comparison path.");
+
+        var packets = BuildPackets(scenario.P1, scenario.P2);
+        var encodedRequest = BuildHttpPackedString(packets);
+        var reader = new NetDataReader();
+        var writer = new NetDataWriter();
+
+        return MeasureAction(() => RunHttpPackedPacketsCheckedOut(encodedRequest, reader, writer), scenario.P3);
+    }
+
+    public static SampleResult MeasureHttpAuthPathSample(Scenario scenario, ScenarioMode mode)
+    {
+        if (mode != ScenarioMode.CheckedOut)
+            throw new ArgumentOutOfRangeException(nameof(mode), mode, "HTTP auth path has no legacy comparison path.");
+
+        var requestBody = BuildHttpAuthRequestBody(scenario.P1, scenario.P2);
+        var authorizationHeader = "Bearer session-token";
+        var reader = new NetDataReader();
+        var packet = new McApiSetEntityPositionRequestPacket();
+        var peer = new FakeMcApiPeer("session-token");
+        var entity = new VoiceCraftEntity(100);
+
+        return MeasureAction(() => RunHttpAuthPathCheckedOut(authorizationHeader, requestBody, reader, packet, peer, entity), scenario.P3);
+    }
+
+    public static SampleResult MeasureWssDataTunnelSample(Scenario scenario, ScenarioMode mode)
+    {
+        if (mode != ScenarioMode.CheckedOut)
+            throw new ArgumentOutOfRangeException(nameof(mode), mode, "WSS data tunnel has no legacy comparison path.");
+
+        var packets = BuildPackets(scenario.P1, scenario.P2);
+        var encodedCommand = BuildHttpPackedString(packets);
+        var reader = new NetDataReader();
+        var writer = new NetDataWriter();
+
+        return MeasureAction(() => RunWssDataTunnelCheckedOut(encodedCommand, packets, reader, writer), scenario.P3);
+    }
+
+    public static SampleResult MeasureMcApiBroadcastFanoutSample(Scenario scenario, ScenarioMode mode)
+    {
+        if (mode != ScenarioMode.CheckedOut)
+            throw new ArgumentOutOfRangeException(nameof(mode), mode, "McApi broadcast fanout has no legacy comparison path.");
+
+        using var world = new VoiceCraftWorld();
+        using var effectSystem = new AudioEffectSystem();
+        var server = new FakeMcApiServer(world, effectSystem);
+        for (var i = 0; i < scenario.P1; i++)
+            server.AddPeer(new FakeMcApiPeer($"peer-{i}"));
+
+        return MeasureAction(() =>
+        {
+            server.ResetCounters();
+            server.Broadcast(new FakeMcApiPayloadPacket(scenario.P2));
+            GC.KeepAlive(server.TotalBytesWritten);
+        }, scenario.P3);
+    }
+
+    public static SampleResult MeasureEventHandlerBurstSample(Scenario scenario, ScenarioMode mode)
+    {
+        if (mode != ScenarioMode.CheckedOut)
+            throw new ArgumentOutOfRangeException(nameof(mode), mode, "Event handler burst has no legacy comparison path.");
+
+        using var world = new VoiceCraftWorld();
+        using var effectSystem = new AudioEffectSystem();
+        using var liteNetServer = new FakeLiteNetVoiceCraftServer(world);
+        using var mcApiServer = new FakeMcApiServer(world, effectSystem);
+        using var eventHandlerSystem = new EventHandlerSystem(liteNetServer, [mcApiServer], effectSystem, world);
+
+        var sourceEntity = new VoiceCraftEntity(1);
+        world.AddEntity(sourceEntity);
+
+        for (var i = 0; i < scenario.P2; i++)
+        {
+            var visible = CreateNetworkEntity(i + 1000);
+            world.AddEntity(visible);
+            sourceEntity.AddVisibleEntity(visible);
+        }
+
+        eventHandlerSystem.Update();
+
+        var positionSeed = 0f;
+        return MeasureAction(() =>
+        {
+            liteNetServer.ResetCounters();
+            mcApiServer.ResetCounters();
+
+            for (var i = 0; i < scenario.P1; i++)
+            {
+                positionSeed += 1f;
+                sourceEntity.Position = new Vector3(positionSeed, i, 0f);
+            }
+
+            eventHandlerSystem.Update();
+            GC.KeepAlive(liteNetServer.TotalBytesWritten + mcApiServer.TotalBytesWritten);
+        }, scenario.P3);
+    }
+
+    public static SampleResult MeasureEntityCreateSyncSample(Scenario scenario, ScenarioMode mode)
+    {
+        if (mode != ScenarioMode.CheckedOut)
+            throw new ArgumentOutOfRangeException(nameof(mode), mode, "Entity create sync has no legacy comparison path.");
+
+        using var world = new VoiceCraftWorld();
+        using var effectSystem = new AudioEffectSystem();
+        using var liteNetServer = new FakeLiteNetVoiceCraftServer(world);
+        using var mcApiServer = new FakeMcApiServer(world, effectSystem);
+        using var eventHandlerSystem = new EventHandlerSystem(liteNetServer, [mcApiServer], effectSystem, world);
+
+        for (var i = 0; i < scenario.P1; i++)
+            world.AddEntity(CreateEntityForSync(i));
+
+        for (var i = 0; i < scenario.P2; i++)
+            effectSystem.SetEffect((ushort)(1 << i), new FakeVisibleEffect(true));
+
+        eventHandlerSystem.Update();
+
+        var peer = new FakeMcApiPeer("entity-create-sync");
+        return MeasureAction(() =>
+        {
+            liteNetServer.ResetCounters();
+            mcApiServer.ResetCounters();
+            mcApiServer.RaisePeerConnected(peer, peer.SessionToken);
+            eventHandlerSystem.Update();
+            GC.KeepAlive(mcApiServer.TotalBytesWritten + liteNetServer.TotalBytesWritten);
+        }, scenario.P3);
+    }
+
+    public static SampleResult MeasureAudioEffectProcessSample(Scenario scenario, ScenarioMode mode)
+    {
+        if (mode != ScenarioMode.CheckedOut)
+            throw new ArgumentOutOfRangeException(nameof(mode), mode, "Audio effect process has no legacy comparison path.");
+
+        using var effectSystem = new AudioEffectSystem();
+        var source = new VoiceCraftEntity(1)
+        {
+            CaveFactor = 0.4f,
+            MuffleFactor = 0.1f
+        };
+        var targets = Enumerable.Range(0, scenario.P2)
+            .Select(i => new VoiceCraftEntity(i + 2)
+            {
+                CaveFactor = (i % 5) / 5f,
+                MuffleFactor = (i % 7) / 7f
+            })
+            .ToArray();
+
+        for (var i = 0; i < scenario.P1; i++)
+            effectSystem.SetEffect((ushort)(1 << i), new FakeProcessingEffect((i % 4) + 1));
+
+        var buffer = new float[960];
+
+        return MeasureAction(() =>
+        {
+            Array.Fill(buffer, 0.25f);
+            foreach (var target in targets)
+                foreach (var effect in effectSystem.AudioEffectsSnapshot)
+                    effect.Value.Process(source, target, effect.Key, buffer);
+
+            GC.KeepAlive(buffer[0]);
+        }, scenario.P3);
+    }
+
+    public static SampleResult MeasureJitterBufferSample(Scenario scenario, ScenarioMode mode)
+    {
+        if (mode != ScenarioMode.CheckedOut)
+            throw new ArgumentOutOfRangeException(nameof(mode), mode, "Jitter buffer has no legacy comparison path.");
+
+        var jitterBuffer = new JitterBuffer(TimeSpan.Zero);
+        var packets = BuildJitterPackets(scenario.P1, scenario.P2);
+
+        return MeasureAction(() => RunJitterBufferCycle(jitterBuffer, packets), scenario.P3);
+    }
+
+    private static SampleResult MeasureAction(Action action, int iterations)
+    {
+        action();
+
+        GC.Collect();
+        GC.WaitForPendingFinalizers();
+        GC.Collect();
+
+        var before = GC.GetTotalAllocatedBytes(true);
+        var stopwatch = Stopwatch.StartNew();
+        for (var i = 0; i < iterations; i++)
+            action();
+        stopwatch.Stop();
+        var after = GC.GetTotalAllocatedBytes(true);
+
+        return new SampleResult(after - before, stopwatch.Elapsed);
+    }
+
+    private static int RunLegacyVisibilityPass(VoiceCraftWorld world, AudioEffectSystem effectSystem)
+    {
+        var visibleCount = 0;
+        foreach (var entity in world.Entities)
+        {
+            entity.TrimDeadEntities();
+
+            var visibleNetworkEntities = world.Entities.OfType<VoiceCraftNetworkEntity>();
+            foreach (var possibleEntity in visibleNetworkEntities)
+            {
+                if (possibleEntity.Id == entity.Id) continue;
+                if ((entity.TalkBitmask & possibleEntity.ListenBitmask) == 0)
+                {
+                    entity.RemoveVisibleEntity(possibleEntity);
+                    continue;
+                }
+
+                var visible = true;
+                foreach (var effect in effectSystem.AudioEffects)
+                {
+                    if (effect.Value is not IVisible visibleEffect) continue;
+                    if (visibleEffect.Visibility(entity, possibleEntity, effect.Key)) continue;
+
+                    visible = false;
+                    break;
+                }
+
+                if (!visible)
+                {
+                    entity.RemoveVisibleEntity(possibleEntity);
+                    continue;
+                }
+
+                entity.AddVisibleEntity(possibleEntity);
+                visibleCount++;
+            }
+        }
+
+        return visibleCount;
+    }
+
+    private static byte[][] BuildPackets(int packetCount, int packetBytes)
+    {
+        var packets = new byte[packetCount][];
+        for (var packetIndex = 0; packetIndex < packets.Length; packetIndex++)
+        {
+            var packet = new byte[packetBytes];
+            for (var byteIndex = 0; byteIndex < packet.Length; byteIndex++)
+                packet[byteIndex] = (byte)((packetIndex + byteIndex) & 0xFF);
+            packets[packetIndex] = packet;
+        }
+
+        return packets;
+    }
+
+    private static JitterPacket[] BuildJitterPackets(int packetCount, int packetBytes)
+    {
+        var packets = new JitterPacket[packetCount];
+        for (var i = 0; i < packets.Length; i++)
+            packets[i] = new JitterPacket((ushort)i, BuildPacketPayload(i, packetBytes));
+        return packets;
+    }
+
+    private static byte[] BuildPacketPayload(int seed, int packetBytes)
+    {
+        var data = new byte[packetBytes];
+        for (var i = 0; i < data.Length; i++)
+            data[i] = (byte)((seed + i) & 0xFF);
+        return data;
+    }
+
+    private static byte[] BuildTcpPayload(string token, IReadOnlyList<byte[]> packets)
+    {
+        var tokenLength = string.IsNullOrEmpty(token) ? 0 : Encoding.UTF8.GetByteCount(token);
+        var payloadLength = 4 + tokenLength + 4;
+        foreach (var packet in packets)
+            payloadLength += 4 + packet.Length;
+
+        var payload = new byte[payloadLength];
+        var offset = 0;
+        WriteInt32(payload, ref offset, tokenLength);
+        if (tokenLength > 0)
+            offset += Encoding.UTF8.GetBytes(token, payload.AsSpan(offset, tokenLength));
+
+        WriteInt32(payload, ref offset, packets.Count);
+        foreach (var packet in packets)
+        {
+            WriteInt32(payload, ref offset, packet.Length);
+            packet.CopyTo(payload.AsSpan(offset));
+            offset += packet.Length;
+        }
+
+        return payload;
+    }
+
+    private static byte[] BuildTcpFrame(ReadOnlySpan<byte> payload, ushort kind)
+    {
+        var frame = new byte[ProtocolConstants.TcpFrameHeaderSize + payload.Length];
+        BinaryPrimitives.WriteInt32BigEndian(frame.AsSpan(0, 4), ProtocolConstants.TcpFrameMagic);
+        BinaryPrimitives.WriteUInt16BigEndian(frame.AsSpan(4, 2), ProtocolConstants.TcpFrameVersion);
+        BinaryPrimitives.WriteUInt16BigEndian(frame.AsSpan(6, 2), kind);
+        BinaryPrimitives.WriteInt32BigEndian(frame.AsSpan(8, 4), payload.Length);
+        payload.CopyTo(frame.AsSpan(ProtocolConstants.TcpFrameHeaderSize));
+        return frame;
+    }
+
+    private static void RunTcpFrameReadCheckedOut(ReadOnlySpan<byte> frame, byte[] headerBuffer)
+    {
+        frame[..ProtocolConstants.TcpFrameHeaderSize].CopyTo(headerBuffer);
+        if (!TryReadTcpFrameHeader(headerBuffer, ProtocolConstants.TcpRequestKind, out var payloadLength))
+            throw new InvalidOperationException("Invalid TCP frame header.");
+
+        var payloadBuffer = ArrayPool<byte>.Shared.Rent(payloadLength);
+        try
+        {
+            frame.Slice(ProtocolConstants.TcpFrameHeaderSize, payloadLength).CopyTo(payloadBuffer);
+            if (!TryReadTcpPayload(payloadBuffer.AsSpan(0, payloadLength), out var token, out var packets))
+                throw new InvalidOperationException("Invalid TCP payload.");
+
+            GC.KeepAlive(token);
+            GC.KeepAlive(packets);
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(payloadBuffer);
+        }
+    }
+
+    private static void RunTcpFrameReadLegacy(ReadOnlySpan<byte> frame)
+    {
+        var headerBuffer = new byte[ProtocolConstants.TcpFrameHeaderSize];
+        frame[..ProtocolConstants.TcpFrameHeaderSize].CopyTo(headerBuffer);
+        if (!TryReadTcpFrameHeader(headerBuffer, ProtocolConstants.TcpRequestKind, out var payloadLength))
+            throw new InvalidOperationException("Invalid TCP frame header.");
+
+        var payloadBuffer = new byte[payloadLength];
+        frame.Slice(ProtocolConstants.TcpFrameHeaderSize, payloadLength).CopyTo(payloadBuffer);
+        if (!TryReadTcpPayload(payloadBuffer, out var token, out var packets))
+            throw new InvalidOperationException("Invalid TCP payload.");
+
+        GC.KeepAlive(token);
+        GC.KeepAlive(packets);
+    }
+
+    private static void RunTcpWritePayloadCheckedOut(IReadOnlyList<byte[]> packets)
+    {
+        var payloadLength = CalculateTcpPayloadLength(tokenLength: 0, packets);
+        var frameLength = ProtocolConstants.TcpFrameHeaderSize + payloadLength;
+        var frameBuffer = ArrayPool<byte>.Shared.Rent(frameLength);
+
+        try
+        {
+            WriteTcpFrameHeader(frameBuffer, ProtocolConstants.TcpResponseKind, payloadLength);
+
+            var offset = ProtocolConstants.TcpFrameHeaderSize;
+            WriteInt32(frameBuffer, ref offset, 0);
+            WriteInt32(frameBuffer, ref offset, packets.Count);
+            foreach (var packet in packets)
+            {
+                WriteInt32(frameBuffer, ref offset, packet.Length);
+                packet.CopyTo(frameBuffer.AsSpan(offset));
+                offset += packet.Length;
+            }
+
+            GC.KeepAlive(frameBuffer[0]);
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(frameBuffer);
+        }
+    }
+
+    private static void RunTcpWritePayloadLegacy(IReadOnlyList<byte[]> packets)
+    {
+        var payloadLength = CalculateTcpPayloadLength(tokenLength: 0, packets);
+        var payload = new byte[payloadLength];
+        var payloadOffset = 0;
+        WriteInt32(payload, ref payloadOffset, 0);
+        WriteInt32(payload, ref payloadOffset, packets.Count);
+        foreach (var packet in packets)
+        {
+            WriteInt32(payload, ref payloadOffset, packet.Length);
+            packet.CopyTo(payload.AsSpan(payloadOffset));
+            payloadOffset += packet.Length;
+        }
+
+        var frameBuffer = new byte[ProtocolConstants.TcpFrameHeaderSize + payload.Length];
+        WriteTcpFrameHeader(frameBuffer, ProtocolConstants.TcpResponseKind, payload.Length);
+        payload.CopyTo(frameBuffer.AsSpan(ProtocolConstants.TcpFrameHeaderSize));
+        GC.KeepAlive(frameBuffer);
+    }
+
+    private static string BuildHttpPackedString(IReadOnlyList<byte[]> packets)
+    {
+        var writer = new NetDataWriter();
+        foreach (var packet in packets)
+        {
+            writer.Put((ushort)packet.Length);
+            writer.Put(packet);
+        }
+
+        return Z85.GetStringWithPadding(writer.AsReadOnlySpan());
+    }
+
+    private static void RunHttpPackedPacketsCheckedOut(string encodedRequest, NetDataReader reader, NetDataWriter writer)
+    {
+        var packets = new List<byte[]>();
+        if (!TryReadHttpPackedPackets(encodedRequest, packets, reader))
+            throw new InvalidOperationException("Invalid HTTP packed packets.");
+
+        writer.Reset();
+        foreach (var packet in packets)
+        {
+            writer.Put((ushort)packet.Length);
+            writer.Put(packet);
+        }
+
+        var encodedResponse = Z85.GetStringWithPadding(writer.AsReadOnlySpan());
+        var responseBuffer = Encoding.UTF8.GetBytes(encodedResponse);
+        GC.KeepAlive(responseBuffer);
+    }
+
+    private static string BuildHttpAuthRequestBody(int packetCount, int packetBytes)
+    {
+        var packets = new byte[packetCount][];
+        for (var i = 0; i < packetCount; i++)
+        {
+            var writer = new NetDataWriter();
+            writer.Put((byte)McApiPacketType.SetEntityPositionRequest);
+            var packet = new McApiSetEntityPositionRequestPacket()
+                .Set(i + 1, new Vector3(i, i + 1, i + 2));
+            writer.Put(packet);
+
+            if (packetBytes > writer.Length)
+                writer.Put(new byte[packetBytes - writer.Length]);
+
+            packets[i] = writer.CopyData();
+        }
+
+        return BuildHttpPackedString(packets);
+    }
+
+    private static void RunHttpAuthPathCheckedOut(
+        string authorizationHeader,
+        string encodedRequest,
+        NetDataReader reader,
+        McApiSetEntityPositionRequestPacket packet,
+        FakeMcApiPeer peer,
+        VoiceCraftEntity entity)
+    {
+        if (!TryGetBearerToken(authorizationHeader, out var token))
+            throw new InvalidOperationException("Missing bearer token.");
+
+        var contentLength = Encoding.UTF8.GetByteCount(encodedRequest);
+        if (contentLength is <= 0 or > 1_000_000)
+            throw new InvalidOperationException("Invalid request length.");
+
+        var packets = new List<byte[]>();
+        if (!TryReadHttpPackedPackets(encodedRequest, packets, reader))
+            throw new InvalidOperationException("Invalid packed request.");
+
+        foreach (var packetBytes in packets)
+        {
+            reader.Clear();
+            reader.SetSource(packetBytes);
+            var packetType = (McApiPacketType)reader.GetByte();
+            if (packetType != McApiPacketType.SetEntityPositionRequest)
+                continue;
+
+            packet.Deserialize(reader);
+            if (!AuthorizePacket(packet, peer, token))
+                continue;
+
+            entity.Position = packet.Value;
+        }
+    }
+
+    private static void RunWssDataTunnelCheckedOut(string encodedCommand, IReadOnlyList<byte[]> outboundPackets, NetDataReader reader, NetDataWriter writer)
+    {
+        var packets = new List<byte[]>();
+        if (!TryReadHttpPackedPackets(encodedCommand, packets, reader))
+            throw new InvalidOperationException("Invalid WSS command payload.");
+
+        writer.Reset();
+        foreach (var packet in outboundPackets)
+        {
+            writer.Put((ushort)packet.Length);
+            writer.Put(packet);
+        }
+
+        var encodedResponse = Z85.GetStringWithPadding(writer.AsReadOnlySpan());
+        GC.KeepAlive(packets);
+        GC.KeepAlive(encodedResponse);
+    }
+
+    private static void RunJitterBufferCycle(JitterBuffer jitterBuffer, IReadOnlyList<JitterPacket> packets)
+    {
+        jitterBuffer.Reset();
+        foreach (var packet in packets)
+            jitterBuffer.Add(packet);
+
+        while (jitterBuffer.Get(out var packet))
+            GC.KeepAlive(packet);
+    }
+
+    private static bool TryReadHttpPackedPackets(string encodedRequest, List<byte[]> packets, NetDataReader reader)
+    {
+        try
+        {
+            var packedPackets = Z85.GetBytesWithPadding(encodedRequest);
+            reader.Clear();
+            reader.SetSource(packedPackets);
+            while (!reader.EndOfData)
+            {
+                var packetSize = reader.GetUShort();
+                if (packetSize <= 0) continue;
+                if (reader.AvailableBytes < packetSize)
+                    return false;
+
+                var packet = new byte[packetSize];
+                reader.GetBytes(packet, packetSize);
+                packets.Add(packet);
+            }
+
+            return true;
+        }
+        catch (ArgumentException)
+        {
+            return false;
+        }
+    }
+
+    private static bool AuthorizePacket(IMcApiPacket packet, FakeMcApiPeer netPeer, string token)
+    {
+        return packet switch
+        {
+            McApiLoginRequestPacket => true,
+            McApiLogoutRequestPacket => true,
+            _ => netPeer.ConnectionState == McApiConnectionState.Connected && token == netPeer.SessionToken
+        };
+    }
+
+    private static bool TryGetBearerToken(string? authorizationHeader, out string token)
+    {
+        const string bearerPrefix = "Bearer ";
+
+        token = string.Empty;
+        if (string.IsNullOrWhiteSpace(authorizationHeader) ||
+            !authorizationHeader.StartsWith(bearerPrefix, StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        token = authorizationHeader[bearerPrefix.Length..].Trim();
+        return !string.IsNullOrWhiteSpace(token);
+    }
+
+    private static bool TryReadTcpFrameHeader(ReadOnlySpan<byte> header, ushort expectedKind, out int payloadLength)
+    {
+        payloadLength = 0;
+        if (header.Length < ProtocolConstants.TcpFrameHeaderSize)
+            return false;
+
+        var magic = BinaryPrimitives.ReadInt32BigEndian(header[..4]);
+        var version = BinaryPrimitives.ReadUInt16BigEndian(header.Slice(4, 2));
+        var kind = BinaryPrimitives.ReadUInt16BigEndian(header.Slice(6, 2));
+        payloadLength = BinaryPrimitives.ReadInt32BigEndian(header.Slice(8, 4));
+
+        return magic == ProtocolConstants.TcpFrameMagic &&
+               version == ProtocolConstants.TcpFrameVersion &&
+               kind == expectedKind &&
+               payloadLength is >= 0 and <= ProtocolConstants.MaxTcpFramePayloadLength;
+    }
+
+    private static bool TryReadTcpPayload(ReadOnlySpan<byte> payload, out string token, out List<byte[]> packets)
+    {
+        token = string.Empty;
+        packets = [];
+        if (payload.Length < 8)
+            return false;
+
+        var offset = 0;
+        if (!TryReadInt32(payload, ref offset, out var tokenLength) || tokenLength < 0 ||
+            payload.Length - offset < tokenLength)
+            return false;
+
+        token = tokenLength == 0 ? string.Empty : Encoding.UTF8.GetString(payload.Slice(offset, tokenLength));
+        offset += tokenLength;
+
+        if (!TryReadInt32(payload, ref offset, out var packetCount) || packetCount < 0)
+            return false;
+        if (packetCount > (payload.Length - offset) / 5)
+            return false;
+
+        packets = new List<byte[]>(packetCount);
+        for (var i = 0; i < packetCount; i++)
+        {
+            if (!TryReadInt32(payload, ref offset, out var packetLength) || packetLength <= 0 ||
+                payload.Length - offset < packetLength)
+                return false;
+
+            var packet = new byte[packetLength];
+            payload.Slice(offset, packetLength).CopyTo(packet);
+            packets.Add(packet);
+            offset += packetLength;
+        }
+
+        return offset == payload.Length;
+    }
+
+    private static bool TryReadInt32(ReadOnlySpan<byte> payload, ref int offset, out int value)
+    {
+        value = 0;
+        if (payload.Length - offset < 4)
+            return false;
+
+        value = BinaryPrimitives.ReadInt32BigEndian(payload.Slice(offset, 4));
+        offset += 4;
+        return true;
+    }
+
+    private static int CalculateTcpPayloadLength(int tokenLength, IReadOnlyList<byte[]> packets)
+    {
+        var payloadLength = 4 + tokenLength + 4;
+        foreach (var packet in packets)
+            payloadLength += 4 + packet.Length;
+        return payloadLength;
+    }
+
+    private static void WriteTcpFrameHeader(byte[] frameBuffer, ushort kind, int payloadLength)
+    {
+        BinaryPrimitives.WriteInt32BigEndian(frameBuffer.AsSpan(0, 4), ProtocolConstants.TcpFrameMagic);
+        BinaryPrimitives.WriteUInt16BigEndian(frameBuffer.AsSpan(4, 2), ProtocolConstants.TcpFrameVersion);
+        BinaryPrimitives.WriteUInt16BigEndian(frameBuffer.AsSpan(6, 2), kind);
+        BinaryPrimitives.WriteInt32BigEndian(frameBuffer.AsSpan(8, 4), payloadLength);
+    }
+
+    private static void WriteInt32(byte[] payload, ref int offset, int value)
+    {
+        BinaryPrimitives.WriteInt32BigEndian(payload.AsSpan(offset, 4), value);
+        offset += 4;
+    }
+
+    private static VoiceCraftNetworkEntity CreateNetworkEntity(int id)
+    {
+        return new VoiceCraftNetworkEntity(
+            new FakeNetPeer(Guid.NewGuid(), Guid.NewGuid(), "en-US", PositioningType.Client),
+            id);
+    }
+
+    private static VoiceCraftEntity CreateEntityForSync(int id)
+    {
+        return id % 3 == 0
+            ? CreateNetworkEntity(id + 1)
+            : new VoiceCraftEntity(id + 1)
+            {
+                Name = $"Entity {id + 1}",
+                WorldId = $"world-{id % 4}",
+                Position = new Vector3(id, id * 0.5f, id * 0.25f),
+                Rotation = new Vector2(id % 360, (id * 2) % 360),
+                CaveFactor = (id % 5) / 5f,
+                MuffleFactor = (id % 7) / 7f
+            };
+    }
+}
diff --git a/VoiceCraft.Tools/AllocHarness/Models.cs b/VoiceCraft.Tools/AllocHarness/Models.cs
new file mode 100644
index 00000000..850826c9
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/Models.cs
@@ -0,0 +1,365 @@
+using LiteNetLib.Utils;
+using VoiceCraft.Core.Interfaces;
+using VoiceCraft.Core.World;
+using VoiceCraft.Network;
+using VoiceCraft.Network.Interfaces;
+using VoiceCraft.Network.NetPeers;
+using VoiceCraft.Network.Packets.McApiPackets;
+using VoiceCraft.Network.Packets.VcPackets;
+using VoiceCraft.Network.Servers;
+using VoiceCraft.Network.World;
+
+internal sealed class FakeNetPeer(Guid userGuid, Guid serverUserGuid, string locale, PositioningType positioningType)
+    : VoiceCraftNetPeer(userGuid, serverUserGuid, locale, positioningType)
+{
+    public override VcConnectionState ConnectionState => VcConnectionState.Connected;
+}
+
+internal sealed class FakeVisibleEffect(bool result) : IAudioEffect, IVisible
+{
+    public EffectType EffectType => EffectType.Visibility;
+
+    public bool Visibility(VoiceCraftEntity from, VoiceCraftEntity to, ushort effectBitmask)
+    {
+        return result;
+    }
+
+    public void Process(VoiceCraftEntity from, VoiceCraftEntity to, ushort effectBitmask, Span<float> buffer)
+    {
+    }
+
+    public void Reset()
+    {
+    }
+
+    public void Serialize(NetDataWriter writer)
+    {
+    }
+
+    public void Deserialize(NetDataReader reader)
+    {
+    }
+
+    public void Dispose()
+    {
+    }
+}
+
+internal sealed class FakeProcessingEffect(int stride) : IAudioEffect
+{
+    public EffectType EffectType => EffectType.Echo;
+
+    public void Process(VoiceCraftEntity from, VoiceCraftEntity to, ushort effectBitmask, Span<float> buffer)
+    {
+        var scale = 0.02f * ((effectBitmask & 0xF) + 1);
+        for (var i = 0; i < buffer.Length; i += stride)
+            buffer[i] = (buffer[i] + from.CaveFactor + to.MuffleFactor) * scale;
+    }
+
+    public void Reset()
+    {
+    }
+
+    public void Serialize(NetDataWriter writer)
+    {
+        writer.Put(stride);
+    }
+
+    public void Deserialize(NetDataReader reader)
+    {
+        _ = reader.GetInt();
+    }
+
+    public void Dispose()
+    {
+    }
+}
+
+internal sealed class FakeMcApiPeer(string sessionToken, McApiConnectionState connectionState = McApiConnectionState.Connected)
+    : McApiNetPeer
+{
+    public override McApiConnectionState ConnectionState { get; } = connectionState;
+    public override string SessionToken { get; } = sessionToken;
+}
+
+internal sealed class FakeMcApiPayloadPacket(int payloadBytes) : IMcApiPacket
+{
+    private readonly byte[] _payload = Enumerable.Repeat((byte)0x5A, Math.Max(0, payloadBytes)).ToArray();
+
+    public McApiPacketType PacketType => McApiPacketType.OnEntityAudioReceived;
+
+    public void Serialize(NetDataWriter writer)
+    {
+        writer.Put((ushort)_payload.Length);
+        writer.Put(_payload);
+    }
+
+    public void Deserialize(NetDataReader reader)
+    {
+        var length = reader.GetUShort();
+        var buffer = new byte[length];
+        reader.GetBytes(buffer, length);
+    }
+}
+
+internal sealed class FakeVcPayloadPacket(int payloadBytes) : IVoiceCraftPacket
+{
+    private readonly byte[] _payload = Enumerable.Repeat((byte)0x47, Math.Max(0, payloadBytes)).ToArray();
+
+    public VcPacketType PacketType => VcPacketType.OnEntityAudioReceived;
+
+    public void Serialize(NetDataWriter writer)
+    {
+        writer.Put((ushort)_payload.Length);
+        writer.Put(_payload);
+    }
+
+    public void Deserialize(NetDataReader reader)
+    {
+        var length = reader.GetUShort();
+        var buffer = new byte[length];
+        reader.GetBytes(buffer, length);
+    }
+}
+
+internal sealed class FakeMcApiServer(VoiceCraftWorld world, VoiceCraft.Network.Systems.AudioEffectSystem audioEffectSystem)
+    : McApiServer(world, audioEffectSystem)
+{
+    private readonly NetDataWriter _writer = new();
+    private readonly List<FakeMcApiPeer> _peers = [];
+
+    public long TotalBytesWritten { get; private set; }
+    public int TotalPacketsWritten { get; private set; }
+
+    public override string LoginToken => string.Empty;
+    public override uint MaxClients => 10_000;
+    public override int ConnectedPeers => _peers.Count;
+    public override event Action<McApiNetPeer, string>? OnPeerConnected;
+    public override event Action<McApiNetPeer, string>? OnPeerDisconnected;
+
+    public void AddPeer(FakeMcApiPeer peer)
+    {
+        peer.Tag = this;
+        _peers.Add(peer);
+    }
+
+    public void RaisePeerConnected(FakeMcApiPeer peer, string token)
+    {
+        peer.Tag = this;
+        OnPeerConnected?.Invoke(peer, token);
+    }
+
+    public void ResetCounters()
+    {
+        TotalBytesWritten = 0;
+        TotalPacketsWritten = 0;
+    }
+
+    public override void Start()
+    {
+    }
+
+    public override void Update()
+    {
+    }
+
+    public override void Stop()
+    {
+    }
+
+    public override void SendPacket<T>(McApiNetPeer netPeer, T packet)
+    {
+        try
+        {
+            _writer.Reset();
+            _writer.Put((byte)packet.PacketType);
+            _writer.Put(packet);
+            TotalBytesWritten += _writer.Length;
+            TotalPacketsWritten++;
+        }
+        finally
+        {
+            PacketPool<T>.Return(packet);
+        }
+    }
+
+    public override void Broadcast<T>(T packet, params McApiNetPeer?[] excludes)
+    {
+        try
+        {
+            _writer.Reset();
+            _writer.Put((byte)packet.PacketType);
+            _writer.Put(packet);
+            foreach (var peer in _peers)
+            {
+                if (excludes.Contains(peer)) continue;
+                TotalBytesWritten += _writer.Length;
+                TotalPacketsWritten++;
+            }
+        }
+        finally
+        {
+            PacketPool<T>.Return(packet);
+        }
+    }
+
+    public override void Disconnect(McApiNetPeer netPeer, bool force = false)
+    {
+        OnPeerDisconnected?.Invoke(netPeer, netPeer.SessionToken);
+    }
+
+    protected override void AcceptRequest(VoiceCraft.Network.Packets.McApiPackets.Request.McApiLoginRequestPacket packet, object? data)
+    {
+    }
+
+    protected override void RejectRequest(VoiceCraft.Network.Packets.McApiPackets.Request.McApiLoginRequestPacket packet, string reason, object? data)
+    {
+    }
+}
+
+internal sealed class FakeLiteNetVoiceCraftServer(VoiceCraftWorld world) : LiteNetVoiceCraftServer(world)
+{
+    private readonly NetDataWriter _writer = new();
+
+    public long TotalBytesWritten { get; private set; }
+    public int TotalPacketsWritten { get; private set; }
+
+    public void ResetCounters()
+    {
+        TotalBytesWritten = 0;
+        TotalPacketsWritten = 0;
+    }
+
+    public override void Start()
+    {
+    }
+
+    public override void Update()
+    {
+    }
+
+    public override void Stop()
+    {
+    }
+
+    public override void SendUnconnectedPacket<T>(System.Net.IPEndPoint endPoint, T packet)
+    {
+        try
+        {
+            _writer.Reset();
+            _writer.Put((byte)packet.PacketType);
+            _writer.Put(packet);
+            TotalBytesWritten += _writer.Length;
+            TotalPacketsWritten++;
+        }
+        finally
+        {
+            PacketPool<T>.Return(packet);
+        }
+    }
+
+    public override void SendPacket<T>(VoiceCraftNetPeer vcNetPeer, T packet, VcDeliveryMethod deliveryMethod = VcDeliveryMethod.Reliable)
+    {
+        try
+        {
+            _writer.Reset();
+            _writer.Put((byte)packet.PacketType);
+            _writer.Put(packet);
+            TotalBytesWritten += _writer.Length;
+            TotalPacketsWritten++;
+        }
+        finally
+        {
+            PacketPool<T>.Return(packet);
+        }
+    }
+
+    public override void Broadcast<T>(T packet, VcDeliveryMethod deliveryMethod = VcDeliveryMethod.Reliable, params VoiceCraftNetPeer?[] excludes)
+    {
+        try
+        {
+            _writer.Reset();
+            _writer.Put((byte)packet.PacketType);
+            _writer.Put(packet);
+            TotalBytesWritten += _writer.Length;
+            TotalPacketsWritten++;
+        }
+        finally
+        {
+            PacketPool<T>.Return(packet);
+        }
+    }
+
+    public override void Disconnect(VoiceCraftNetPeer vcNetPeer, string reason, bool force = false)
+    {
+    }
+
+    public override void DisconnectAll(string? reason = null)
+    {
+    }
+}
+
+internal sealed record Options(
+    IReadOnlyList<Scenario> Scenarios,
+    int Samples,
+    MeasurementMode Mode,
+    string BenchmarkName,
+    bool ListBenchmarks,
+    bool RunAllBenchmarks);
+
+internal sealed record BenchmarkDefinition(
+    string Name,
+    string Description,
+    string[] ParameterNames,
+    IReadOnlyList<Scenario> DefaultScenarios,
+    string MeasurementDescription,
+    bool SupportsLegacyComparison,
+    Func<Scenario, ScenarioMode, SampleResult> CreateSampleResult);
+
+internal readonly record struct Scenario(int P1, int P2, int P3);
+
+internal sealed record ScenarioResult(
+    Scenario Scenario,
+    ScenarioMode Mode,
+    IReadOnlyList<SampleResult> SampleResults,
+    NumericStats AllocationStats,
+    NumericStats ElapsedStats);
+
+internal sealed record BenchmarkRunResult(
+    BenchmarkDefinition Benchmark,
+    Options Options,
+    IReadOnlyList<ScenarioResult> ScenarioResults);
+
+internal sealed record HarnessRunReport(
+    DateTimeOffset StartedAtUtc,
+    string GitDescription,
+    string DotNetVersion,
+    string OsDescription,
+    IReadOnlyList<BenchmarkRunResult> Benchmarks);
+
+internal readonly record struct SampleResult(long AllocatedBytes, TimeSpan Elapsed);
+
+internal readonly record struct NumericStats(double Min, double Median, double Average, double Max);
+
+internal enum MeasurementMode
+{
+    CheckedOut,
+    Legacy,
+    Both
+}
+
+internal enum ScenarioMode
+{
+    CheckedOut,
+    LegacySimulated
+}
+
+internal static class ProtocolConstants
+{
+    public const int TcpFrameHeaderSize = 12;
+    public const int MaxTcpFramePayloadLength = 1024 * 1024;
+    public const int TcpFrameMagic = 0x4D435450;
+    public const ushort TcpFrameVersion = 1;
+    public const ushort TcpRequestKind = 1;
+    public const ushort TcpResponseKind = 2;
+}
diff --git a/VoiceCraft.Tools/AllocHarness/OptionsParser.cs b/VoiceCraft.Tools/AllocHarness/OptionsParser.cs
new file mode 100644
index 00000000..7294f8de
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/OptionsParser.cs
@@ -0,0 +1,101 @@
+internal static class OptionsParser
+{
+    public static Options Parse(string[] args, IReadOnlyDictionary<string, BenchmarkDefinition> benchmarkDefinitions)
+    {
+        var samples = 7;
+        var mode = MeasurementMode.CheckedOut;
+        var benchmarkName = "visibility";
+        var listBenchmarks = false;
+        var runAllBenchmarks = false;
+        var positionalValues = new List<int>();
+
+        for (var i = 0; i < args.Length; i++)
+        {
+            switch (args[i])
+            {
+                case "--samples":
+                case "-s":
+                    samples = ParsePositiveInt(args, ref i, "samples");
+                    break;
+                case "--mode":
+                case "-m":
+                    mode = ParseMode(args, ref i);
+                    break;
+                case "--benchmark":
+                case "-b":
+                    i++;
+                    if (i >= args.Length)
+                        throw new ArgumentException(GetUsage());
+                    benchmarkName = args[i];
+                    break;
+                case "--list":
+                    listBenchmarks = true;
+                    break;
+                case "--all":
+                    runAllBenchmarks = true;
+                    break;
+                default:
+                    if (!int.TryParse(args[i], out var value))
+                        throw new ArgumentException(GetUsage());
+
+                    positionalValues.Add(value);
+                    break;
+            }
+        }
+
+        if (listBenchmarks)
+            return new Options([], samples, mode, benchmarkName, ListBenchmarks: true, RunAllBenchmarks: false);
+
+        if (runAllBenchmarks)
+            return new Options([], samples, mode, benchmarkName, ListBenchmarks: false, RunAllBenchmarks: true);
+
+        if (!benchmarkDefinitions.TryGetValue(benchmarkName, out var benchmark))
+            throw new ArgumentException($"Unknown benchmark '{benchmarkName}'. Use --list to see available benchmarks.");
+
+        if (samples <= 0)
+            throw new ArgumentOutOfRangeException(nameof(samples), "Samples must be greater than zero.");
+
+        if (positionalValues.Count == 0)
+            return new Options(benchmark.DefaultScenarios, samples, mode, benchmark.Name, ListBenchmarks: false, RunAllBenchmarks: false);
+
+        if (positionalValues.Count % 3 != 0)
+            throw new ArgumentException(GetUsage());
+
+        var scenarios = new List<Scenario>(positionalValues.Count / 3);
+        for (var i = 0; i < positionalValues.Count; i += 3)
+            scenarios.Add(new Scenario(positionalValues[i], positionalValues[i + 1], positionalValues[i + 2]));
+
+        return new Options(scenarios, samples, mode, benchmark.Name, ListBenchmarks: false, RunAllBenchmarks: false);
+    }
+
+    private static int ParsePositiveInt(string[] args, ref int index, string name)
+    {
+        index++;
+        if (index >= args.Length || !int.TryParse(args[index], out var value) || value <= 0)
+            throw new ArgumentException(GetUsage(), name);
+
+        return value;
+    }
+
+    private static MeasurementMode ParseMode(string[] args, ref int index)
+    {
+        index++;
+        if (index >= args.Length)
+            throw new ArgumentException(GetUsage(), "mode");
+
+        return args[index].ToLowerInvariant() switch
+        {
+            "current" => MeasurementMode.CheckedOut,
+            "checked-out" => MeasurementMode.CheckedOut,
+            "legacy" => MeasurementMode.Legacy,
+            "both" => MeasurementMode.Both,
+            _ => throw new ArgumentException(GetUsage(), "mode")
+        };
+    }
+
+    private static string GetUsage()
+    {
+        return "Usage: dotnet run --project .\\VoiceCraft.Tools\\AllocHarness\\AllocHarness.csproj -c Release -- " +
+               "[--list] [--all] [--benchmark NAME] [--samples N] [--mode checked-out|legacy|both] [p1 p2 p3]...";
+    }
+}
diff --git a/VoiceCraft.Tools/AllocHarness/Program.cs b/VoiceCraft.Tools/AllocHarness/Program.cs
new file mode 100644
index 00000000..1f3b10b7
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/Program.cs
@@ -0,0 +1,45 @@
+var benchmarkDefinitions = BenchmarkCatalog.Build();
+var options = OptionsParser.Parse(args, benchmarkDefinitions);
+
+if (options.ListBenchmarks)
+{
+    ConsoleOutput.PrintBenchmarkList(benchmarkDefinitions);
+    return;
+}
+
+if (options.RunAllBenchmarks)
+{
+    var orderedBenchmarks = benchmarkDefinitions.Values.OrderBy(x => x.Name, StringComparer.OrdinalIgnoreCase).ToArray();
+    var runResults = new List<BenchmarkRunResult>(orderedBenchmarks.Length);
+    for (var index = 0; index < orderedBenchmarks.Length; index++)
+    {
+        var selectedBenchmark = orderedBenchmarks[index];
+        var selectedOptions = options with
+        {
+            BenchmarkName = selectedBenchmark.Name,
+            Scenarios = selectedBenchmark.DefaultScenarios
+        };
+
+        runResults.Add(BenchmarkRunner.Run(selectedBenchmark, selectedOptions));
+        if (index < orderedBenchmarks.Length - 1)
+            Console.WriteLine();
+    }
+
+    var reportPath = HtmlReportWriter.Append(new HarnessRunReport(
+        DateTimeOffset.UtcNow,
+        RuntimeMetadata.GetGitDescription(),
+        RuntimeMetadata.GetDotNetVersion(),
+        RuntimeMetadata.GetOsDescription(),
+        runResults));
+    ConsoleOutput.PrintReportLocation(reportPath);
+    return;
+}
+
+var benchmarkRun = BenchmarkRunner.Run(benchmarkDefinitions[options.BenchmarkName], options);
+var singleReportPath = HtmlReportWriter.Append(new HarnessRunReport(
+    DateTimeOffset.UtcNow,
+    RuntimeMetadata.GetGitDescription(),
+    RuntimeMetadata.GetDotNetVersion(),
+    RuntimeMetadata.GetOsDescription(),
+    [benchmarkRun]));
+ConsoleOutput.PrintReportLocation(singleReportPath);
diff --git a/VoiceCraft.Tools/AllocHarness/Stats.cs b/VoiceCraft.Tools/AllocHarness/Stats.cs
new file mode 100644
index 00000000..2594d19c
--- /dev/null
+++ b/VoiceCraft.Tools/AllocHarness/Stats.cs
@@ -0,0 +1,30 @@
+internal static class Stats
+{
+    public static NumericStats BuildLongStats(long[] values)
+    {
+        Array.Sort(values);
+        var min = values[0];
+        var max = values[^1];
+        var average = values.Average();
+        var median = CalculateMedian(values.Select(x => (double)x).ToArray());
+        return new NumericStats(min, median, average, max);
+    }
+
+    public static NumericStats BuildDoubleStats(double[] values)
+    {
+        Array.Sort(values);
+        var min = values[0];
+        var max = values[^1];
+        var average = values.Average();
+        var median = CalculateMedian(values);
+        return new NumericStats(min, median, average, max);
+    }
+
+    private static double CalculateMedian(double[] values)
+    {
+        var middle = values.Length / 2;
+        return values.Length % 2 == 0
+            ? (values[middle - 1] + values[middle]) / 2d
+            : values[middle];
+    }
+}