perf(runtime): deduplicate concurrent client manifest loads (#528)

## Issue

`createManifestLoader()` caches the client manifest after fetching and
parsing it. Concurrent HTML renders on a fresh instance can all miss
that cache and load separate copies.

This duplicates work during overlapping cold loads. Warm requests
already reuse the cached manifest.

## Fix

Share one pending promise across concurrent manifest loads. Cache
successful results and clear the pending promise when it settles,
allowing missing manifests and failed loads to be retried.

## Verification

Added unit coverage for concurrent loads sharing one fetch and manifest
object, completed-cache reuse, and retries after a missing response or
rejected fetch.

- `vp test run packages/void/test/unit/routing-runtime.test.ts`: 40
tests passed on Node 24.21.0.

Benchmarked eight simultaneous cold SSR requests using real generated
manifests, with no artificial asset delay. Median burst completion times
across nine shuffled runs on Node 24.21.0:

| Generated pages | Before | After | Manifest reads/parses |
|---|---:|---:|---:|
| 1,000 | 28.52 ms | 21.27 ms | 8 → 1 |
| 10,000 | 120.55 ms | 49.43 ms | 8 → 1 |

Single-request controls performed one load on both revisions; warm
bursts performed zero additional loads. HTML output matched, and browser
hydration and navigation checks passed.

These results describe concurrent cold bursts. Production frequency and
full SSG build impact have not been measured.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: yangshun

packages/void/src/runtime/routing-assets.ts

@@ -54,6 +54,7 @@ export type ManifestLoader = (
 ) => Promise<ClientManifest | null>;
 export function createManifestLoader(): ManifestLoader {
   let cached: ClientManifest | null = null;
+  let pending: Promise<ClientManifest | null> | null = null;
   return async (request, env) => {
     if (cached) {
       return cached;
@@ -68,14 +69,21 @@ export function createManifestLoader(): ManifestLoader {
     if (!assets || typeof assets.fetch !== 'function') {
       return null;
     }
-    const response = await assets.fetch(
-      new Request(new URL('/.vite/manifest.json', request.url).toString()),
-    );
-    if (!response.ok) {
-      return null;
-    }
-    cached = (await response.json()) as ClientManifest;
-    return cached;
+    // Concurrent cold requests share one fetch and parse. A missing or failed
+    // manifest is not cached, so a later request retries.
+    pending ??= (async () => {
+      const response = await assets.fetch(
+        new Request(new URL('/.vite/manifest.json', request.url).toString()),
+      );
+      if (!response.ok) {
+        return null;
+      }
+      cached = (await response.json()) as ClientManifest;
+      return cached;
+    })().finally(() => {
+      pending = null;
+    });
+    return pending;
   };
 }
 export type ClientAssetOptions = {

packages/void/test/unit/routing-runtime.test.ts

@@ -805,6 +805,42 @@ describe('typed client asset tags', () => {
     expect(islandTags.preloads).not.toContain('/md.js');
     expect(binding).toHaveBeenCalledTimes(1);
   });
+
+  it('shares one manifest fetch between concurrent cold loads', async () => {
+    const binding = vi.fn(async () => Response.json({ page: { file: 'page.js' } }));
+    const loader = createManifestLoader();
+    const env = { ASSETS: { fetch: binding } };
+    const request = new Request('https://app.test/page');
+    const manifests = await Promise.all(Array.from({ length: 8 }, () => loader(request, env)));
+    expect(binding).toHaveBeenCalledTimes(1);
+    expect(new Set(manifests).size).toBe(1);
+    expect(manifests[0]).toEqual({ page: { file: 'page.js' } });
+    expect(await loader(request, env)).toBe(manifests[0]);
+    expect(binding).toHaveBeenCalledTimes(1);
+  });
+
+  it('retries the manifest after a missing response or a rejected fetch', async () => {
+    const manifest = { page: { file: 'page.js' } };
+    const binding = vi
+      .fn<() => Promise<Response>>()
+      .mockResolvedValueOnce(new Response('missing', { status: 404 }))
+      .mockRejectedValueOnce(new Error('assets unavailable'))
+      .mockImplementation(async () => Response.json(manifest));
+    const loader = createManifestLoader();
+    const env = { ASSETS: { fetch: binding } };
+    const request = new Request('https://app.test/page');
+    expect(await loader(request, env)).toBeNull();
+    expect(binding).toHaveBeenCalledTimes(1);
+    const rejected = [loader(request, env), loader(request, env)];
+    await expect(rejected[0]).rejects.toThrow('assets unavailable');
+    await expect(rejected[1]).rejects.toThrow('assets unavailable');
+    expect(binding).toHaveBeenCalledTimes(2);
+    expect(await loader(request, env)).toEqual(manifest);
+    expect(binding).toHaveBeenCalledTimes(3);
+    await loader(request, env);
+    expect(binding).toHaveBeenCalledTimes(3);
+  });
+
   it('loads development CSS with active roots and omits client tags when production has no manifest', async () => {
     const devCss = vi.fn(
       async (