[Flight] Deduplicate chunk entries in client reference metadata

Each client reference in the RSC stream includes an array of chunk
entries (URLs or chunk ID/filename pairs) that the client needs to load.
When many client components share the same chunks, these strings were
repeated across every import row, significantly bloating the payload.

This change deduplicates individual chunk entries across client
references by outlining each unique entry as its own model row and
replacing it with a `$` reference in the import metadata. The client's
existing `parseModel` reviver resolves these references transparently,
so no client-side changes are needed.

Only string entries longer than 5 characters are outlined. Short strings
like webpack chunk IDs are kept inline since the `$` reference would be
close to the same size. If SRI (Subresource Integrity) support is added
in the future, the dedup strategy for chunk entries will need to be
revisited.

The debug and production streams use separate dedup maps
(`writtenDebugClientReferenceChunkEntries` and
`writtenClientReferenceChunkEntries`) because chunk model rows must
appear in the same stream as the import row that references them.

Author: unstubbable

packages/react-server/src/ReactFlightServer.js

@@ -580,6 +580,7 @@ export type Request = {
   completedErrorChunks: Array<Chunk>,
   writtenSymbols: Map<symbol, number>,
   writtenClientReferences: Map<ClientReferenceKey, number>,
+  writtenClientReferenceChunkEntries: Map<string, number>,
   writtenServerReferences: Map<ServerReference<any>, number>,
   writtenObjects: WeakMap<Reference, string>,
   temporaryReferences: void | TemporaryReferenceSet,
@@ -604,6 +605,7 @@ export type Request = {
     columnNumber: number,
   ) => boolean,
   didWarnForKey: null | WeakSet<ReactComponentInfo>,
+  writtenDebugClientReferenceChunkEntries: Map<string, number>,
   writtenDebugObjects: WeakMap<Reference, string>,
   deferredDebugObjects: null | DeferredDebugStore,
 };
@@ -699,6 +701,7 @@ function RequestInstance(
   this.completedErrorChunks = ([]: Array<Chunk>);
   this.writtenSymbols = new Map();
   this.writtenClientReferences = new Map();
+  this.writtenClientReferenceChunkEntries = new Map();
   this.writtenServerReferences = new Map();
   this.writtenObjects = new WeakMap();
   this.temporaryReferences = temporaryReferences;
@@ -724,6 +727,7 @@ function RequestInstance(
         ? defaultFilterStackFrame
         : filterStackFrame;
     this.didWarnForKey = null;
+    this.writtenDebugClientReferenceChunkEntries = new Map();
     this.writtenDebugObjects = new WeakMap();
     this.deferredDebugObjects = keepDebugAlive
       ? {
@@ -4326,6 +4330,64 @@ function emitImportChunk(
   clientReferenceMetadata: ClientReferenceMetadata,
   debug: boolean,
 ): void {
+  if (clientReferenceMetadata.length >= 3) {
+    // Dedupe individual chunk entries across client references.
+    // $FlowFixMe[invalid-tuple-index] guarded by length check above
+    const chunks = clientReferenceMetadata[2];
+    if (chunks.length > 0) {
+      const writtenChunkEntries =
+        __DEV__ && debug
+          ? request.writtenDebugClientReferenceChunkEntries
+          : request.writtenClientReferenceChunkEntries;
+      const newChunks = [];
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        // Only outline and dedupe string entries longer than 5 characters.
+        // Short strings (e.g. webpack chunk IDs) are kept inline since the
+        // reference would be close to the same length.
+        if (typeof chunk === 'string' && chunk.length > 5) {
+          let chunkId = writtenChunkEntries.get(chunk);
+          if (chunkId === undefined) {
+            chunkId = request.nextChunkId++;
+            // $FlowFixMe[incompatible-type] stringify can return null
+            const chunkJson: string = stringify(chunk);
+            const chunkRow = chunkId.toString(16) + ':' + chunkJson + '\n';
+            if (__DEV__ && debug) {
+              request.pendingDebugChunks++;
+              request.completedDebugChunks.push(stringToChunk(chunkRow));
+            } else {
+              request.pendingChunks++;
+              request.completedImportChunks.push(stringToChunk(chunkRow));
+            }
+            writtenChunkEntries.set(chunk, chunkId);
+          }
+          newChunks.push(serializeByValueID(chunkId));
+        } else {
+          // Other entries are emitted as-is. No bundler currently uses
+          // non-string chunk entries, but the opaque type allows for the
+          // possibility of other types in the future (e.g. tuples with SRI
+          // hashes). The dedupe strategy should be revisited then.
+          newChunks.push(chunk);
+        }
+      }
+      if (clientReferenceMetadata.length === 3) {
+        clientReferenceMetadata = [
+          clientReferenceMetadata[0],
+          clientReferenceMetadata[1],
+          newChunks,
+        ];
+      } else {
+        clientReferenceMetadata = [
+          clientReferenceMetadata[0],
+          clientReferenceMetadata[1],
+          newChunks,
+          // $FlowFixMe[invalid-tuple-index] guarded by length check above
+          clientReferenceMetadata[3],
+        ];
+      }
+    }
+  }
+
   // $FlowFixMe[incompatible-type] stringify can return null
   const json: string = stringify(clientReferenceMetadata);
   const row = serializeRowHeader('I', id) + json + '\n';