diff --git a/Directory.Packages.props b/Directory.Packages.props
index 2bb1a528..e9993841 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -4,8 +4,8 @@
     <PackageVersion Include="Ashcroft" Version="0.5.1" />
     <PackageVersion Include="Beck" Version="0.6.0" />
     <PackageVersion Include="CooklangSharp" Version="0.0.0-alpha.0.9" />
-    <PackageVersion Include="DeweySearch" Version="0.1.2" />
-    <PackageVersion Include="DeweySearch.Web" Version="0.1.2" />
+    <PackageVersion Include="DeweySearch" Version="0.2.0" />
+    <PackageVersion Include="DeweySearch.Web" Version="0.2.0" />
     <PackageVersion Include="DiffPlex" Version="1.9.0" />
     <!-- Linux/CI native binaries for Ashcroft's SkiaSharp + HarfBuzz render path; versions track
          Ashcroft 0.5.1's SkiaSharp 4.150.0 / HarfBuzzSharp 14.2.1 dependencies
diff --git a/docs/Pennington.Docs/Content/explanation/discovery/search.md b/docs/Pennington.Docs/Content/explanation/discovery/search.md
index 0a86e98e..346d43cc 100644
--- a/docs/Pennington.Docs/Content/explanation/discovery/search.md
+++ b/docs/Pennington.Docs/Content/explanation/discovery/search.md
@@ -27,7 +27,7 @@ nodes:
 edges:
   - { from: render, to: extractor, label: render fold }
   - { from: extractor, to: builder, label: sections }
-  - { from: builder, to: shards, label: "index.json · t-* · f-*" }
+  - { from: builder, to: shards, label: "index.json · d-* · t-* · f-*" }
   - { from: shards, to: client, label: fetched on demand }
 ```
 
@@ -45,11 +45,14 @@ A site of any size produces an index too large to ship as one file and download
 
 Each locale gets a tree under `/search/{locale}/`:
 
-- `index.json` — the entrypoint: the document table (one row per record: URL, title, length, priority, facet ids), the facet label vocabularies, ranking statistics, and the stemmed synonym map.
+- `index.json` — the entrypoint, carrying only what ranking needs before any result is displayed: the ranking statistics, each record's priority and quantized length, the facet label vocabularies, the breadcrumb label dictionary, the stemmed synonym map, and the list of term-shard keys.
+- `d-*.json` — document-table shards: the URL, title, and breadcrumb ids for a run of records. URLs and titles are front-coded against the previous row, which collapses the long shared prefixes a sorted route list produces.
 - `t-*.json` — term shards. Terms are bucketed by the first few characters of their stemmed form, so a query fetches only the shards for the terms it contains.
 - `f-*.json` — per-page fragments holding the indexed body text, fetched only when a page surfaces in results.
 
-The client downloads `index.json` once, then pulls term shards and fragments on demand. Typing a query fetches a handful of small files rather than one large one; opening a result fetches that page's fragment and nothing else. The shard granularity is tunable, but the default keeps shards small enough that no single fetch dominates.
+The split is deliberate: ranking a query needs statistics for every record, but titles and URLs are needed only for the handful of records actually shown. Holding the document table back shrinks the first-keystroke download to the part that ranking actually uses — this site's 2,695 records ship a 43 KB entrypoint while the 183 KB document table stays cold until a query produces hits. The entrypoint still carries a few bytes per record, so it grows with the corpus; it just grows far more slowly than a catalogue of every URL and title would.
+
+The client downloads `index.json` once, then pulls term shards, the document shards covering its hits, and fragments on demand. Typing a query fetches a handful of small files rather than one large one; opening a result fetches that page's fragment and nothing else. The shard granularity is tunable, but the default keeps shards small enough that no single fetch dominates.
 
 ## The build is a fold over the render
 
diff --git a/src/Pennington/Infrastructure/HttpDispatcher.cs b/src/Pennington/Infrastructure/HttpDispatcher.cs
index cc28a1f8..5a5e29a8 100644
--- a/src/Pennington/Infrastructure/HttpDispatcher.cs
+++ b/src/Pennington/Infrastructure/HttpDispatcher.cs
@@ -9,12 +9,27 @@ namespace Pennington.Infrastructure;
 /// <see cref="IServer"/> and returns an in-memory client when it's a
 /// <see cref="TestServer"/>, or a socket-bound client pointing at Kestrel's
 /// listening address otherwise.
+/// <para>
+/// The handler chain is built once and shared by every client this dispatcher hands out
+/// — clients are cheap wrappers created with <c>disposeHandler: false</c>, so a caller's
+/// <c>using</c> releases the wrapper without tearing down the connection pool. This
+/// matters on the Kestrel path: <see cref="Pipeline.SiteProjection"/> issues one fetch per
+/// page, and a per-fetch handler cannot pool, so every fetch opened a fresh loopback socket
+/// that then sat in TIME_WAIT. A corpus larger than the ~16k Windows ephemeral port range
+/// exhausted it partway through and the remaining fetches failed with
+/// <c>SocketError.AddressAlreadyInUse</c> — silently dropping those pages from the search
+/// index and llms.txt, since <c>RenderOneAsync</c> treats a failed fetch as a per-page error.
+/// </para>
 /// </summary>
-public sealed class HttpDispatcher : IInProcessHttpDispatcher
+public sealed class HttpDispatcher : IInProcessHttpDispatcher, IDisposable
 {
     private readonly IServer _server;
     private readonly BuildHtmlCache _cache;
 
+    private readonly Lock _handlerLock = new();
+    private HttpMessageHandler? _handler;
+    private bool _disposed;
+
     /// <summary>Initializes the dispatcher with the host's registered <see cref="IServer"/> and the shared render cache.</summary>
     public HttpDispatcher(IServer server, BuildHtmlCache cache)
     {
@@ -25,13 +40,71 @@ public HttpDispatcher(IServer server, BuildHtmlCache cache)
     /// <inheritdoc/>
     public HttpClient CreateClient()
     {
-        if (_server is TestServer testServer)
+        var (handler, baseAddress) = GetOrCreateHandler();
+
+        // disposeHandler: false — the chain outlives every client so connections stay pooled.
+        return new HttpClient(handler, disposeHandler: false) { BaseAddress = baseAddress };
+    }
+
+    /// <summary>Disposes the shared handler chain and its pooled connections.</summary>
+    public void Dispose()
+    {
+        lock (_handlerLock)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+            _handler?.Dispose();
+            _handler = null;
+        }
+    }
+
+    private (HttpMessageHandler Handler, Uri BaseAddress) GetOrCreateHandler()
+    {
+        lock (_handlerLock)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+
+            // The base address is recomputed per call: it is cheap, and on the Kestrel path
+            // it is only known once the server has bound. Only the handler is cached.
+            var baseAddress = ResolveBaseAddress();
+            _handler ??= BuildHandler();
+            return (_handler, baseAddress);
+        }
+    }
+
+    private Uri ResolveBaseAddress()
+    {
+        if (_server is TestServer)
         {
             // TestServer.CreateClient() returns BaseAddress = http://localhost/.
             // Path-relative URLs ("/foo/bar") resolve against that and are dispatched
-            // to the same RequestDelegate Kestrel would have invoked. Wrap its handler
-            // with the cache so repeat self-fetches replay one render.
-            HttpMessageHandler innerHandler;
+            // to the same RequestDelegate Kestrel would have invoked.
+            return new Uri("http://localhost/");
+        }
+
+        var addresses = _server.Features.Get<IServerAddressesFeature>()?.Addresses;
+        if (addresses is null || addresses.Count == 0)
+        {
+            throw new SelfFetchUnavailableException(
+                "HttpDispatcher requires either a started TestServer or a listening Kestrel host. " +
+                "IServerAddressesFeature has no addresses — is the app started yet?");
+        }
+
+        // Prefer http:// to avoid dev-cert trust issues when self-fetching from Kestrel.
+        var baseAddress = addresses.FirstOrDefault(a => a.StartsWith("http://", StringComparison.OrdinalIgnoreCase))
+            ?? addresses.First();
+        return new Uri(baseAddress);
+    }
+
+    private HttpMessageHandler BuildHandler()
+    {
+        HttpMessageHandler innerHandler;
+        if (_server is TestServer testServer)
+        {
             try
             {
                 innerHandler = testServer.CreateHandler();
@@ -42,37 +115,26 @@ public HttpClient CreateClient()
                 // self-fetch issued before that — e.g. a startup hosted service racing the
                 // server start — is an infrastructure failure, not a per-page content error.
                 // Surface it as such so callers retry once the host is up instead of baking
-                // an empty corpus.
+                // an empty corpus. Nothing is cached, so the retry rebuilds.
                 throw new SelfFetchUnavailableException(
                     "The in-process TestServer has not started yet; a self-fetch was issued before " +
                     "the host's server was ready.",
                     ex);
             }
-
-            var testHandler = new CachingHttpHandler(_cache) { InnerHandler = innerHandler };
-            return new HttpClient(testHandler) { BaseAddress = new Uri("http://localhost/") };
         }
-
-        var addresses = _server.Features.Get<IServerAddressesFeature>()?.Addresses;
-        if (addresses is null || addresses.Count == 0)
+        else
         {
-            throw new SelfFetchUnavailableException(
-                "HttpDispatcher requires either a started TestServer or a listening Kestrel host. " +
-                "IServerAddressesFeature has no addresses — is the app started yet?");
+            // Bounded pool: the projection renders pages with Parallel.ForEachAsync at the
+            // default degree of parallelism, so a handful of pooled connections serves the
+            // whole corpus. Left unbounded, a burst opens far more sockets than it reuses.
+            innerHandler = new SocketsHttpHandler
+            {
+                AllowAutoRedirect = false,
+                MaxConnectionsPerServer = Environment.ProcessorCount * 2,
+            };
         }
 
-        // Prefer http:// to avoid dev-cert trust issues when self-fetching from Kestrel.
-        var baseAddress = addresses.FirstOrDefault(a => a.StartsWith("http://", StringComparison.OrdinalIgnoreCase))
-            ?? addresses.First();
-
-        var handler = new CachingHttpHandler(_cache)
-        {
-            InnerHandler = new HttpClientHandler { AllowAutoRedirect = false },
-        };
-        var client = new HttpClient(handler)
-        {
-            BaseAddress = new Uri(baseAddress),
-        };
-        return client;
+        // Wrap with the cache so repeat self-fetches replay one render.
+        return new CachingHttpHandler(_cache) { InnerHandler = innerHandler };
     }
 }
\ No newline at end of file
diff --git a/tests/Pennington.IntegrationTests/DocsSite/LlmsTxtAndSearchEndpointTests.cs b/tests/Pennington.IntegrationTests/DocsSite/LlmsTxtAndSearchEndpointTests.cs
index 974e6b0f..5177fa76 100644
--- a/tests/Pennington.IntegrationTests/DocsSite/LlmsTxtAndSearchEndpointTests.cs
+++ b/tests/Pennington.IntegrationTests/DocsSite/LlmsTxtAndSearchEndpointTests.cs
@@ -33,8 +33,8 @@ public async Task LlmsTxt_ReturnsIndexWithEntries()
         response.EnsureSuccessStatusCode();
 
         var content = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken);
-        content.ShouldContain("# ");                // site title heading
-        content.ShouldContain(".md)");              // at least one co-located per-page markdown link
+        content.ShouldContain("# "); // site title heading
+        content.ShouldContain(".md)"); // at least one co-located per-page markdown link
         // The docs site configures an absolute CanonicalBaseUrl, so per-page markdown links are
         // emitted as absolute URLs. The assertion below rejects the bare-relative form (no origin,
         // no scheme) which would be unusable for LLMs that fetch /llms.txt and try to resolve
@@ -73,27 +73,27 @@ public async Task SearchIndex_EntrypointHasDocumentTable()
         using var doc = JsonDocument.Parse(json);
 
         doc.RootElement.ValueKind.ShouldBe(JsonValueKind.Object);
-        var docs = doc.RootElement.GetProperty("docs");
-        docs.ValueKind.ShouldBe(JsonValueKind.Array);
-        docs.GetArrayLength().ShouldBeGreaterThan(0);
 
-        // BM25 stats and at least one shard must be present for the client to query.
+        // BM25 stats and at least one term shard must be present for the client to query.
         doc.RootElement.GetProperty("n").GetInt32().ShouldBeGreaterThan(0);
         doc.RootElement.GetProperty("shards").GetArrayLength().ShouldBeGreaterThan(0);
 
+        // The document table itself is cold (d-{n}.json shards) as of DeweySearch 0.2.0.
+        var docs = await SearchIndexReader.LoadAsync(_client, cancellationToken: TestContext.Current.CancellationToken);
+        docs.Count.ShouldBeGreaterThan(0);
+        docs.Count.ShouldBe(doc.RootElement.GetProperty("n").GetInt32());
+
         // Every document-table row should have the required fields populated.
-        foreach (var element in docs.EnumerateArray())
+        foreach (var entry in docs)
         {
-            element.GetProperty("t").GetString().ShouldNotBeNullOrEmpty();
-            element.GetProperty("u").GetString().ShouldNotBeNullOrEmpty();
+            entry.Title.ShouldNotBeNullOrEmpty();
+            entry.Url.ShouldNotBeNullOrEmpty();
             // Records are heading-level: every row carries a (possibly empty) breadcrumb trail.
-            element.TryGetProperty("c", out var crumbs).ShouldBeTrue();
-            crumbs.ValueKind.ShouldBe(JsonValueKind.Array);
+            entry.Crumbs.ShouldNotBeNull();
         }
 
         // At least one row deep-links to a heading anchor, proving heading-level indexing.
-        docs.EnumerateArray()
-            .Any(d => (d.GetProperty("u").GetString() ?? "").Contains('#'))
+        docs.Any(d => d.Url.Contains('#'))
             .ShouldBeTrue("expected at least one heading-level record with a #anchor URL");
     }
 
@@ -104,23 +104,19 @@ public async Task SearchIndex_ApiReferencePages_CarryLowPrefixPriority()
         // SearchIndexOptions.PrefixPriorities, so every generated API page row carries p=3 while
         // same-area prose under /reference/ keeps its (higher) area priority. This proves the
         // prefix-priority override flows all the way into the emitted index.
-        var json = await _client.GetStringAsync("/search/en/index.json", TestContext.Current.CancellationToken);
-        using var doc = JsonDocument.Parse(json);
-        var docs = doc.RootElement.GetProperty("docs");
+        var docs = await SearchIndexReader.LoadAsync(_client, cancellationToken: TestContext.Current.CancellationToken);
 
         var apiPriorities = new List<int>();
         var proseReferencePriorities = new List<int>();
-        foreach (var entry in docs.EnumerateArray())
+        foreach (var entry in docs)
         {
-            var u = entry.GetProperty("u").GetString() ?? "";
-            var p = entry.GetProperty("p").GetInt32();
-            if (u.StartsWith("/reference/api/", StringComparison.Ordinal))
+            if (entry.Url.StartsWith("/reference/api/", StringComparison.Ordinal))
             {
-                apiPriorities.Add(p);
+                apiPriorities.Add(entry.Priority);
             }
-            else if (u.StartsWith("/reference/", StringComparison.Ordinal))
+            else if (entry.Url.StartsWith("/reference/", StringComparison.Ordinal))
             {
-                proseReferencePriorities.Add(p);
+                proseReferencePriorities.Add(entry.Priority);
             }
         }
 
@@ -139,12 +135,10 @@ public async Task SearchFragments_HaveNonEmptyBodyText()
         // Bodies live in per-page fragments (f-{docId}.json), fetched lazily by the
         // client. Verifies the selector resolved and StripHtml produced meaningful
         // text after the full pipeline ran (Razor pages included).
-        var json = await _client.GetStringAsync("/search/en/index.json", TestContext.Current.CancellationToken);
-        using var doc = JsonDocument.Parse(json);
-        var count = doc.RootElement.GetProperty("docs").GetArrayLength();
+        var docs = await SearchIndexReader.LoadAsync(_client, cancellationToken: TestContext.Current.CancellationToken);
 
         var nonEmpty = 0;
-        for (var i = 0; i < count; i++)
+        for (var i = 0; i < docs.Count; i++)
         {
             var frag = await _client.GetStringAsync($"/search/en/f-{i}.json", TestContext.Current.CancellationToken);
             using var fd = JsonDocument.Parse(frag);
@@ -163,25 +157,20 @@ public async Task SearchFragments_ExcludeCodeBlockText_ByDefault()
         // Pick any indexed doc whose rendered page has a <pre> block, then verify
         // a distinctive token from inside that <pre> does not appear in the fragment
         // body for the same doc. The document-table order is the fragment id.
-        var json = await _client.GetStringAsync("/search/en/index.json", TestContext.Current.CancellationToken);
-        using var doc = JsonDocument.Parse(json);
-        var docs = doc.RootElement.GetProperty("docs");
+        var docs = await SearchIndexReader.LoadAsync(_client, cancellationToken: TestContext.Current.CancellationToken);
 
         // Records are heading-level, so a page maps to several fragments (its sections). Group
         // doc ids by page URL (strip the #anchor) so we can check every section of a page.
         var sectionIdsByPage = new Dictionary<string, List<int>>(StringComparer.Ordinal);
-        var id = -1;
-        foreach (var entry in docs.EnumerateArray())
+        foreach (var entry in docs)
         {
-            id++;
-            var u = entry.GetProperty("u").GetString();
-            if (string.IsNullOrEmpty(u))
+            if (string.IsNullOrEmpty(entry.Url))
             {
                 continue;
             }
 
-            var pageUrl = u.Split('#', 2)[0];
-            (sectionIdsByPage.TryGetValue(pageUrl, out var ids) ? ids : sectionIdsByPage[pageUrl] = []).Add(id);
+            var pageUrl = entry.Url.Split('#', 2)[0];
+            (sectionIdsByPage.TryGetValue(pageUrl, out var ids) ? ids : sectionIdsByPage[pageUrl] = []).Add(entry.Id);
         }
 
         var context = BrowsingContext.New(Configuration.Default);
@@ -204,7 +193,8 @@ public async Task SearchFragments_ExcludeCodeBlockText_ByDefault()
             var pageTextWithoutPre = page.Body?.TextContent ?? "";
 
             var candidate = preText
-                .Split([' ', '\n', '\r', '\t', '(', ')', '{', '}', '[', ']', ';', ','], StringSplitOptions.RemoveEmptyEntries)
+                .Split([' ', '\n', '\r', '\t', '(', ')', '{', '}', '[', ']', ';', ','],
+                    StringSplitOptions.RemoveEmptyEntries)
                 .FirstOrDefault(t => t.Length >= 6 && !pageTextWithoutPre.Contains(t, StringComparison.Ordinal));
             if (candidate is null)
             {
@@ -214,7 +204,8 @@ public async Task SearchFragments_ExcludeCodeBlockText_ByDefault()
             // Collect the body of every section fragment belonging to this page.
             foreach (var sectionId in ids)
             {
-                var frag = await _client.GetStringAsync($"/search/en/f-{sectionId}.json", TestContext.Current.CancellationToken);
+                var frag = await _client.GetStringAsync($"/search/en/f-{sectionId}.json",
+                    TestContext.Current.CancellationToken);
                 using var fd = JsonDocument.Parse(frag);
                 pageSectionBodies.Add(fd.RootElement.GetProperty("body").GetString() ?? "");
             }
@@ -223,9 +214,10 @@ public async Task SearchFragments_ExcludeCodeBlockText_ByDefault()
             break;
         }
 
-        codeOnlyToken.ShouldNotBeNull("expected at least one docs page with a <pre> block containing a code-only token");
+        codeOnlyToken.ShouldNotBeNull(
+            "expected at least one docs page with a <pre> block containing a code-only token");
         pageSectionBodies.ShouldNotBeEmpty();
-        pageSectionBodies.ShouldAllBe(body => !body.Contains(codeOnlyToken!, StringComparison.Ordinal));
+        pageSectionBodies.ShouldAllBe(body => !body.Contains(codeOnlyToken, StringComparison.Ordinal));
     }
 
     [Fact]
@@ -309,7 +301,7 @@ public async Task ReferenceSubtree_LlmsTxt_ContainsReferenceEntries()
             f.OutputPath.Value.Equals("reference/llms.txt", StringComparison.OrdinalIgnoreCase));
 
         refFile.ShouldNotBeNull("expected /reference/llms.txt subtree file");
-        var text = Encoding.UTF8.GetString(refFile!.Content);
+        var text = Encoding.UTF8.GetString(refFile.Content);
         text.ShouldContain("# Reference");
         // Should contain at least one entry linked to its co-located page markdown.
         System.Text.RegularExpressions.Regex.IsMatch(text, @"/reference/[^\s)]*\.md")
@@ -393,9 +385,9 @@ public async Task ContentPage_AdvertisesCoLocatedMarkdownAlternate()
 
         var link = page.QuerySelector("link[rel='alternate'][type='text/markdown']");
         link.ShouldNotBeNull("content pages should advertise their co-located markdown copy");
-        var href = link!.GetAttribute("href");
+        var href = link.GetAttribute("href");
         href.ShouldNotBeNull();
-        href!.ShouldEndWith("/how-to/feeds/llms-txt.md");
+        href.ShouldEndWith("/how-to/feeds/llms-txt.md");
 
         var markdown = await _client.GetAsync(href, TestContext.Current.CancellationToken);
         markdown.EnsureSuccessStatusCode();
@@ -419,7 +411,7 @@ public async Task DocsPage_BodyCarriesRobotsOnlyCueToLlmsTxt()
 
         var cue = page.QuerySelector("body > p.robots-only");
         cue.ShouldNotBeNull("expected a .robots-only cue paragraph at the top of <body>");
-        cue!.TextContent.ShouldContain("/llms.txt");
+        cue.TextContent.ShouldContain("/llms.txt");
         cue.QuerySelector("a[href='/llms.txt']").ShouldNotBeNull(
             "the cue should link to /llms.txt so an extractor sees the path verbatim");
     }
diff --git a/tests/Pennington.IntegrationTests/DocsSite/SearchIndexReader.cs b/tests/Pennington.IntegrationTests/DocsSite/SearchIndexReader.cs
new file mode 100644
index 00000000..7ff5ebea
--- /dev/null
+++ b/tests/Pennington.IntegrationTests/DocsSite/SearchIndexReader.cs
@@ -0,0 +1,87 @@
+namespace Pennington.IntegrationTests.DocsSite;
+
+using System.Text.Json;
+using DeweySearch;
+
+/// <summary>
+/// One decoded row of the search document table: what the client resolves a hit to.
+/// </summary>
+internal sealed record IndexedDoc(int Id, string Url, string Title, IReadOnlyList<string> Crumbs, int Priority);
+
+/// <summary>
+/// Reads the emitted search artifacts back into document rows for assertions.
+/// <para>
+/// DeweySearch 0.2.0 splits the index hot/cold: <c>index.json</c> is the hot entrypoint
+/// (BM25 stats, per-doc priorities, the crumb-label dictionary, shard keys) and the document
+/// table lives in cold <c>d-{n}.json</c> shards the client fetches on demand. Urls and titles
+/// inside a shard are front-coded against the previous row — the leading character carries the
+/// shared-prefix length as <c>c - '0'</c>.
+/// </para>
+/// <para>
+/// This is the only place in the test suite that knows that wire format. Tests assert on
+/// <see cref="IndexedDoc"/> so a future DeweySearch layout change lands here rather than across
+/// every search assertion. The manifest and shards deserialize into DeweySearch's own
+/// <see cref="IndexManifest"/> / <see cref="DocShard"/> types, so the field-name contract stays
+/// the package's to define.
+/// </para>
+/// </summary>
+internal static class SearchIndexReader
+{
+    public static async Task<IReadOnlyList<IndexedDoc>> LoadAsync(
+        HttpClient client, string locale = "en", CancellationToken cancellationToken = default)
+    {
+        var manifestJson = await client.GetStringAsync($"/search/{locale}/index.json", cancellationToken);
+        var manifest = JsonSerializer.Deserialize<IndexManifest>(manifestJson)
+            ?? throw new InvalidOperationException($"search/{locale}/index.json did not deserialize");
+
+        var docs = new List<IndexedDoc>(manifest.DocCount);
+        var shardCount = (manifest.DocCount + manifest.DocShardSize - 1) / manifest.DocShardSize;
+
+        for (var s = 0; s < shardCount; s++)
+        {
+            var shardJson = await client.GetStringAsync($"/search/{locale}/d-{s}.json", cancellationToken);
+            var shard = JsonSerializer.Deserialize<DocShard>(shardJson)
+                ?? throw new InvalidOperationException($"search/{locale}/d-{s}.json did not deserialize");
+
+            var urls = FrontDecode(shard.Urls);
+            var titles = FrontDecode(shard.Titles);
+
+            for (var i = 0; i < urls.Count; i++)
+            {
+                var id = shard.Offset + i;
+                if (id >= manifest.DocCount)
+                {
+                    break;
+                }
+
+                var crumbs = shard.Crumbs is { } c && i < c.Length && c[i] is { } row
+                    ? row.Select(ix => manifest.CrumbLabels[ix]).ToArray()
+                    : [];
+
+                var priority = manifest.Priorities is { } pri && id < pri.Length
+                    ? pri[id]
+                    : manifest.DefaultPriority;
+
+                docs.Add(new IndexedDoc(id, urls[i], titles[i], crumbs, priority));
+            }
+        }
+
+        return docs;
+    }
+
+    private static IReadOnlyList<string> FrontDecode(IReadOnlyList<string> encoded)
+    {
+        var result = new List<string>(encoded.Count);
+        var previous = "";
+        foreach (var entry in encoded)
+        {
+            // Leading char is the shared-prefix length against the previous entry.
+            var shared = entry[0] - '0';
+            var value = string.Concat(previous.AsSpan(0, shared), entry.AsSpan(1));
+            result.Add(value);
+            previous = value;
+        }
+
+        return result;
+    }
+}
diff --git a/tests/Pennington.Tests/Infrastructure/HttpDispatcherTests.cs b/tests/Pennington.Tests/Infrastructure/HttpDispatcherTests.cs
index 19aae1b6..83098e2b 100644
--- a/tests/Pennington.Tests/Infrastructure/HttpDispatcherTests.cs
+++ b/tests/Pennington.Tests/Infrastructure/HttpDispatcherTests.cs
@@ -1,13 +1,65 @@
+using System.Collections.Concurrent;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting.Server;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
+using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Pennington.Infrastructure;
 
 namespace Pennington.Tests.Infrastructure;
 
 public class HttpDispatcherTests
 {
+    [Fact]
+    public async Task CreateClient_KestrelPath_PoolsConnectionsAcrossClients()
+    {
+        // Regression: the dispatcher used to build a fresh HttpClientHandler per CreateClient(),
+        // and both callers wrap the result in `using`. Every self-fetch therefore opened a new
+        // loopback socket that then sat in TIME_WAIT — on a 22k-page corpus that exhausted the
+        // ~16k Windows ephemeral port range partway through, and the remaining fetches failed
+        // with SocketError.AddressAlreadyInUse. Those pages were silently dropped from the search
+        // index, since SiteProjection treats a failed fetch as a per-page error. Sharing one
+        // handler chain keeps the connections pooled, so a whole corpus costs a handful of ports.
+        var clientPorts = new ConcurrentBag<int>();
+
+        var builder = WebApplication.CreateSlimBuilder();
+        builder.Logging.ClearProviders();
+        builder.WebHost.UseUrls("http://127.0.0.1:0");
+        await using var app = builder.Build();
+
+        app.Map("/{**slug}", (HttpContext ctx) =>
+        {
+            clientPorts.Add(ctx.Connection.RemotePort);
+            return Results.Text("<html><body>ok</body></html>", "text/html");
+        });
+
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        var dispatcher = new HttpDispatcher(
+            app.Services.GetRequiredService<IServer>(),
+            new BuildHtmlCache([]));
+
+        // Distinct paths on purpose: CachingHttpHandler replays a cached response per path, so
+        // repeating one URL would never reach the socket and the test would pass vacuously.
+        const int requests = 200;
+        for (var i = 0; i < requests; i++)
+        {
+            using var client = dispatcher.CreateClient();
+            var response = await client.GetAsync($"/page-{i}", TestContext.Current.CancellationToken);
+            response.EnsureSuccessStatusCode();
+        }
+
+        clientPorts.Count.ShouldBe(requests);
+
+        // Before the fix this was `requests` (one socket per fetch, none reused).
+        clientPorts.Distinct().Count().ShouldBeLessThanOrEqualTo(Environment.ProcessorCount * 2);
+
+        await app.StopAsync(TestContext.Current.CancellationToken);
+    }
+
     [Fact]
     public void CreateClient_UnstartedTestServer_ThrowsSelfFetchUnavailable()
     {