{"version":3,"sources":["../../../../src/server/stream-utils/node-web-streams-helper.ts"],"sourcesContent":["import type { ReactDOMServerReadableStream } from 'react-dom/server'\nimport { getTracer } from '../lib/trace/tracer'\nimport { AppRenderSpan } from '../lib/trace/constants'\nimport { DetachedPromise } from '../../lib/detached-promise'\nimport {\n scheduleImmediate,\n atLeastOneTask,\n waitAtLeastOneReactRenderTask,\n} from '../../lib/scheduler'\nimport { ENCODED_TAGS } from './encoded-tags'\nimport {\n indexOfUint8Array,\n isEquivalentUint8Arrays,\n removeFromUint8Array,\n} from './uint8array-helpers'\nimport { MISSING_ROOT_TAGS_ERROR } from '../../shared/lib/errors/constants'\nimport {\n RSC_HEADER,\n NEXT_ROUTER_PREFETCH_HEADER,\n NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,\n NEXT_RSC_UNION_QUERY,\n NEXT_INSTANT_PREFETCH_HEADER,\n} from '../../client/components/app-router-headers'\nimport { computeCacheBustingSearchParam } from '../../shared/lib/router/utils/cache-busting-search-param'\n\nfunction voidCatch() {\n // this catcher is designed to be used with pipeTo where we expect the underlying\n // pipe implementation to forward errors but we don't want the pipeTo promise to reject\n // and be unhandled\n}\n\n// We can share the same encoder instance everywhere\n// Notably we cannot do the same for TextDecoder because it is stateful\n// when handling streaming data\nconst encoder = new TextEncoder()\n\nexport function chainStreams(\n ...streams: ReadableStream[]\n): ReadableStream {\n // If we have no streams, return an empty stream. This behavior is\n // intentional as we're now providing the `RenderResult.EMPTY` value.\n if (streams.length === 0) {\n return new ReadableStream({\n start(controller) {\n controller.close()\n },\n })\n }\n\n // If we only have 1 stream we fast path it by returning just this stream\n if (streams.length === 1) {\n return streams[0]\n }\n\n const { readable, writable } = new TransformStream()\n\n // We always initiate pipeTo immediately. We know we have at least 2 streams\n // so we need to avoid closing the writable when this one finishes.\n let promise = streams[0].pipeTo(writable, { preventClose: true })\n\n let i = 1\n for (; i < streams.length - 1; i++) {\n const nextStream = streams[i]\n promise = promise.then(() =>\n nextStream.pipeTo(writable, { preventClose: true })\n )\n }\n\n // We can omit the length check because we halted before the last stream and there\n // is at least two streams so the lastStream here will always be defined\n const lastStream = streams[i]\n promise = promise.then(() => lastStream.pipeTo(writable))\n\n // Catch any errors from the streams and ignore them, they will be handled\n // by whatever is consuming the readable stream.\n promise.catch(voidCatch)\n\n return readable\n}\n\nexport function streamFromString(str: string): ReadableStream {\n return new ReadableStream({\n start(controller) {\n controller.enqueue(encoder.encode(str))\n controller.close()\n },\n })\n}\n\nexport function streamFromBuffer(chunk: Buffer): ReadableStream {\n return new ReadableStream({\n start(controller) {\n controller.enqueue(chunk)\n controller.close()\n },\n })\n}\n\nasync function streamToChunks(\n stream: ReadableStream\n): Promise> {\n const reader = stream.getReader()\n const chunks: Array = []\n\n while (true) {\n const { done, value } = await reader.read()\n if (done) {\n break\n }\n\n chunks.push(value)\n }\n\n return chunks\n}\n\nfunction concatUint8Arrays(chunks: Array): Uint8Array {\n const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)\n const result = new Uint8Array(totalLength)\n let offset = 0\n for (const chunk of chunks) {\n result.set(chunk, offset)\n offset += chunk.length\n }\n return result\n}\n\nexport async function streamToUint8Array(\n stream: ReadableStream\n): Promise {\n return concatUint8Arrays(await streamToChunks(stream))\n}\n\nexport async function streamToBuffer(\n stream: ReadableStream\n): Promise {\n return Buffer.concat(await streamToChunks(stream))\n}\n\nexport async function streamToString(\n stream: ReadableStream,\n signal?: AbortSignal\n): Promise {\n const decoder = new TextDecoder('utf-8', { fatal: true })\n let string = ''\n\n for await (const chunk of stream) {\n if (signal?.aborted) {\n return string\n }\n\n string += decoder.decode(chunk, { stream: true })\n }\n\n string += decoder.decode()\n\n return string\n}\n\nexport type BufferedTransformOptions = {\n /**\n * Flush synchronously once the buffer reaches this many bytes.\n */\n readonly maxBufferByteLength?: number\n}\n\nexport function createBufferedTransformStream(\n options: BufferedTransformOptions = {}\n): TransformStream {\n const { maxBufferByteLength = Infinity } = options\n\n let bufferedChunks: Array = []\n let bufferByteLength: number = 0\n let pending: DetachedPromise | undefined\n\n const flush = (controller: TransformStreamDefaultController) => {\n try {\n if (bufferedChunks.length === 0) {\n return\n }\n\n const chunk = new Uint8Array(bufferByteLength)\n let copiedBytes = 0\n\n for (let i = 0; i < bufferedChunks.length; i++) {\n const bufferedChunk = bufferedChunks[i]\n chunk.set(bufferedChunk, copiedBytes)\n copiedBytes += bufferedChunk.byteLength\n }\n // We just wrote all the buffered chunks so we need to reset the bufferedChunks array\n // and our bufferByteLength to prepare for the next round of buffered chunks\n bufferedChunks.length = 0\n bufferByteLength = 0\n controller.enqueue(chunk)\n } catch {\n // If an error occurs while enqueuing, it can't be due to this\n // transformer. It's most likely caused by the controller having been\n // errored (for example, if the stream was cancelled).\n }\n }\n\n const scheduleFlush = (controller: TransformStreamDefaultController) => {\n if (pending) {\n return\n }\n\n const detached = new DetachedPromise()\n pending = detached\n\n scheduleImmediate(() => {\n try {\n flush(controller)\n } finally {\n pending = undefined\n detached.resolve()\n }\n })\n }\n\n return new TransformStream({\n transform(chunk, controller) {\n // Combine the previous buffer with the new chunk.\n bufferedChunks.push(chunk)\n bufferByteLength += chunk.byteLength\n\n if (bufferByteLength >= maxBufferByteLength) {\n flush(controller)\n } else {\n scheduleFlush(controller)\n }\n },\n flush() {\n return pending?.promise\n },\n })\n}\n\n// TODO this is currently unused but once we add proper output:export support, it needs to be\n// revisited. See https://github.com/vercel/next.js/pull/89478 for more details\n//\n// function createPrefetchCommentStream(\n// isBuildTimePrerendering: boolean,\n// buildId: string\n// ): TransformStream {\n// // Insert an extra comment at the beginning of the HTML document. This must\n// // come after the DOCTYPE, which is inserted by React.\n// //\n// // The first chunk sent by React will contain the doctype. After that, we can\n// // pass through the rest of the chunks as-is.\n// let didTransformFirstChunk = false\n// return new TransformStream({\n// transform(chunk, controller) {\n// if (isBuildTimePrerendering && !didTransformFirstChunk) {\n// didTransformFirstChunk = true\n// const decoder = new TextDecoder('utf-8', { fatal: true })\n// const chunkStr = decoder.decode(chunk, {\n// stream: true,\n// })\n// const updatedChunkStr = insertBuildIdComment(chunkStr, buildId)\n// controller.enqueue(encoder.encode(updatedChunkStr))\n// return\n// }\n// controller.enqueue(chunk)\n// },\n// })\n// }\n\nexport function renderToInitialFizzStream({\n ReactDOMServer,\n element,\n streamOptions,\n}: {\n ReactDOMServer: {\n renderToReadableStream: typeof import('react-dom/server').renderToReadableStream\n }\n element: React.ReactElement\n streamOptions?: Parameters[1]\n}): Promise {\n return getTracer().trace(AppRenderSpan.renderToReadableStream, async () =>\n ReactDOMServer.renderToReadableStream(element, streamOptions)\n )\n}\n\nfunction createMetadataTransformStream(\n insert: () => Promise | string\n): TransformStream {\n let chunkIndex = -1\n let isMarkRemoved = false\n\n return new TransformStream({\n async transform(chunk, controller) {\n let iconMarkIndex = -1\n let closedHeadIndex = -1\n chunkIndex++\n\n if (isMarkRemoved) {\n controller.enqueue(chunk)\n return\n }\n let iconMarkLength = 0\n // Only search for the closed head tag once\n if (iconMarkIndex === -1) {\n iconMarkIndex = indexOfUint8Array(chunk, ENCODED_TAGS.META.ICON_MARK)\n if (iconMarkIndex === -1) {\n controller.enqueue(chunk)\n return\n } else {\n // When we found the `` or `>`, checking the next char to ensure we cover both cases.\n iconMarkLength = ENCODED_TAGS.META.ICON_MARK.length\n // Check if next char is /, this is for xml mode.\n if (chunk[iconMarkIndex + iconMarkLength] === 47) {\n iconMarkLength += 2\n } else {\n // The last char is `>`\n iconMarkLength++\n }\n }\n }\n\n // Check if icon mark is inside tag in the first chunk.\n if (chunkIndex === 0) {\n closedHeadIndex = indexOfUint8Array(chunk, ENCODED_TAGS.CLOSED.HEAD)\n if (iconMarkIndex !== -1) {\n // The mark icon is located in the 1st chunk before the head tag.\n // We do not need to insert the script tag in this case because it's in the head.\n // Just remove the icon mark from the chunk.\n if (iconMarkIndex < closedHeadIndex) {\n const replaced = new Uint8Array(chunk.length - iconMarkLength)\n\n // Remove the icon mark from the chunk.\n replaced.set(chunk.subarray(0, iconMarkIndex))\n replaced.set(\n chunk.subarray(iconMarkIndex + iconMarkLength),\n iconMarkIndex\n )\n chunk = replaced\n } else {\n // The icon mark is after the head tag, replace and insert the script tag at that position.\n const insertion = await insert()\n const encodedInsertion = encoder.encode(insertion)\n const insertionLength = encodedInsertion.length\n const replaced = new Uint8Array(\n chunk.length - iconMarkLength + insertionLength\n )\n replaced.set(chunk.subarray(0, iconMarkIndex))\n replaced.set(encodedInsertion, iconMarkIndex)\n replaced.set(\n chunk.subarray(iconMarkIndex + iconMarkLength),\n iconMarkIndex + insertionLength\n )\n chunk = replaced\n }\n isMarkRemoved = true\n }\n // If there's no icon mark located, it will be handled later when if present in the following chunks.\n } else {\n // When it's appeared in the following chunks, we'll need to\n // remove the mark and then insert the script tag at that position.\n const insertion = await insert()\n const encodedInsertion = encoder.encode(insertion)\n const insertionLength = encodedInsertion.length\n // Replace the icon mark with the hoist script or empty string.\n const replaced = new Uint8Array(\n chunk.length - iconMarkLength + insertionLength\n )\n // Set the first part of the chunk, before the icon mark.\n replaced.set(chunk.subarray(0, iconMarkIndex))\n // Set the insertion after the icon mark.\n replaced.set(encodedInsertion, iconMarkIndex)\n\n // Set the rest of the chunk after the icon mark.\n replaced.set(\n chunk.subarray(iconMarkIndex + iconMarkLength),\n iconMarkIndex + insertionLength\n )\n chunk = replaced\n isMarkRemoved = true\n }\n controller.enqueue(chunk)\n },\n })\n}\n\nfunction createHeadInsertionTransformStream(\n insert: () => Promise\n): TransformStream {\n let inserted = false\n\n // We need to track if this transform saw any bytes because if it didn't\n // we won't want to insert any server HTML at all\n let hasBytes = false\n\n return new TransformStream({\n async transform(chunk, controller) {\n hasBytes = true\n\n const insertion = await insert()\n if (inserted) {\n if (insertion) {\n const encodedInsertion = encoder.encode(insertion)\n controller.enqueue(encodedInsertion)\n }\n controller.enqueue(chunk)\n } else {\n // TODO (@Ethan-Arrowood): Replace the generic `indexOfUint8Array` method with something finely tuned for the subset of things actually being checked for.\n const index = indexOfUint8Array(chunk, ENCODED_TAGS.CLOSED.HEAD)\n // In fully static rendering or non PPR rendering cases:\n // `/head>` will always be found in the chunk in first chunk rendering.\n if (index !== -1) {\n if (insertion) {\n const encodedInsertion = encoder.encode(insertion)\n // Get the total count of the bytes in the chunk and the insertion\n // e.g.\n // chunk = \n // insertion = \n // output = [ ] \n const insertedHeadContent = new Uint8Array(\n chunk.length + encodedInsertion.length\n )\n // Append the first part of the chunk, before the head tag\n insertedHeadContent.set(chunk.slice(0, index))\n // Append the server inserted content\n insertedHeadContent.set(encodedInsertion, index)\n // Append the rest of the chunk\n insertedHeadContent.set(\n chunk.slice(index),\n index + encodedInsertion.length\n )\n controller.enqueue(insertedHeadContent)\n } else {\n controller.enqueue(chunk)\n }\n inserted = true\n } else {\n // This will happens in PPR rendering during next start, when the page is partially rendered.\n // When the page resumes, the head tag will be found in the middle of the chunk.\n // Where we just need to append the insertion and chunk to the current stream.\n // e.g.\n // PPR-static: ... [ resume content ] \n // PPR-resume: [ insertion ] [ rest content ]\n if (insertion) {\n controller.enqueue(encoder.encode(insertion))\n }\n controller.enqueue(chunk)\n inserted = true\n }\n }\n },\n async flush(controller) {\n // Check before closing if there's anything remaining to insert.\n if (hasBytes) {\n const insertion = await insert()\n if (insertion) {\n controller.enqueue(encoder.encode(insertion))\n }\n }\n },\n })\n}\n\nasync function createClientResumeScriptInsertionTransformStream(): Promise<\n TransformStream\n> {\n const segmentPath = '/_full'\n const cacheBustingHeader = await computeCacheBustingSearchParam(\n '1', // headers[NEXT_ROUTER_PREFETCH_HEADER]\n '/_full', // headers[NEXT_ROUTER_SEGMENT_PREFETCH_HEADER]\n undefined, // headers[NEXT_ROUTER_STATE_TREE_HEADER]\n undefined // headers[NEXT_URL]\n )\n const searchStr = `${NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`\n const NEXT_CLIENT_RESUME_SCRIPT = ``\n\n let didAlreadyInsert = false\n return new TransformStream({\n transform(chunk, controller) {\n if (didAlreadyInsert) {\n // Already inserted the script into the head. Pass through.\n controller.enqueue(chunk)\n return\n }\n // TODO (@Ethan-Arrowood): Replace the generic `indexOfUint8Array` method with something finely tuned for the subset of things actually being checked for.\n const headClosingTagIndex = indexOfUint8Array(\n chunk,\n ENCODED_TAGS.CLOSED.HEAD\n )\n\n if (headClosingTagIndex === -1) {\n // In fully static rendering or non PPR rendering cases:\n // `/head>` will always be found in the chunk in first chunk rendering.\n controller.enqueue(chunk)\n return\n }\n\n const encodedInsertion = encoder.encode(NEXT_CLIENT_RESUME_SCRIPT)\n // Get the total count of the bytes in the chunk and the insertion\n // e.g.\n // chunk = \n // insertion = \n // output = [ ] \n const insertedHeadContent = new Uint8Array(\n chunk.length + encodedInsertion.length\n )\n // Append the first part of the chunk, before the head tag\n insertedHeadContent.set(chunk.slice(0, headClosingTagIndex))\n // Append the server inserted content\n insertedHeadContent.set(encodedInsertion, headClosingTagIndex)\n // Append the rest of the chunk\n insertedHeadContent.set(\n chunk.slice(headClosingTagIndex),\n headClosingTagIndex + encodedInsertion.length\n )\n\n controller.enqueue(insertedHeadContent)\n didAlreadyInsert = true\n },\n })\n}\n\n/**\n * Creates a transform stream that injects an inline script as the first\n * element inside . Used during instant navigation testing to set\n * self.__next_instant_test before any async bootstrap scripts execute.\n */\nexport async function createInstantTestScriptInsertionTransformStream(\n requestId: string | null\n): Promise> {\n // Kick off a fetch for the static RSC payload. This is the hydration\n // source for the locked static shell — same as the __NEXT_CLIENT_RESUME\n // fetch used for fallback routes, but with NEXT_INSTANT_PREFETCH_HEADER\n // so the server returns static-only data.\n //\n // The fetch promise is stored as self.__next_instant_test, which doubles\n // as the feature flag (truthy = instant test mode). The client processes\n // this as a fallback prerender payload for hydration.\n const segmentPath = '/_full'\n const cacheBustingHeader = await computeCacheBustingSearchParam(\n '1',\n segmentPath,\n undefined,\n undefined\n )\n const searchStr = `${NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`\n // In dev mode, inject self.__next_r (request ID) so that HMR WebSocket\n // and debug channel initialization don't crash. The static shell\n // bypasses renderToFizzStream which normally injects this via\n // bootstrapScriptContent.\n const requestIdScript =\n requestId !== null ? `self.__next_r=${JSON.stringify(requestId)};` : ''\n const INSTANT_TEST_SCRIPT = ``\n\n let didAlreadyInsert = false\n return new TransformStream({\n transform(chunk, controller) {\n if (didAlreadyInsert) {\n // Already inserted the script into the head. Pass through.\n controller.enqueue(chunk)\n return\n }\n\n // Find the opening )\n const headOpenIndex = indexOfUint8Array(chunk, ENCODED_TAGS.OPENING.HEAD)\n\n if (headOpenIndex === -1) {\n controller.enqueue(chunk)\n return\n }\n\n // Find the closing > of the tag\n const headCloseAngle = chunk.indexOf(\n 62, // '>'\n headOpenIndex + ENCODED_TAGS.OPENING.HEAD.length\n )\n if (headCloseAngle === -1) {\n controller.enqueue(chunk)\n return\n }\n\n const encodedInsertion = encoder.encode(INSTANT_TEST_SCRIPT)\n const insertionPoint = headCloseAngle + 1\n // e.g.\n // chunk = ...\n // insertion = \n // output = [ ] ...\n const insertedHeadContent = new Uint8Array(\n chunk.length + encodedInsertion.length\n )\n insertedHeadContent.set(chunk.slice(0, insertionPoint))\n insertedHeadContent.set(encodedInsertion, insertionPoint)\n insertedHeadContent.set(\n chunk.slice(insertionPoint),\n insertionPoint + encodedInsertion.length\n )\n\n controller.enqueue(insertedHeadContent)\n didAlreadyInsert = true\n },\n flush(controller) {\n // Append closing tags so the browser can parse the full document.\n controller.enqueue(ENCODED_TAGS.CLOSED.BODY_AND_HTML)\n },\n })\n}\n\n// Suffix after main body content - scripts before ,\n// but wait for the major chunks to be enqueued.\nfunction createDeferredSuffixStream(\n suffix: string\n): TransformStream {\n let flushed = false\n let pending: DetachedPromise | undefined\n\n const flush = (controller: TransformStreamDefaultController) => {\n const detached = new DetachedPromise()\n pending = detached\n\n scheduleImmediate(() => {\n try {\n controller.enqueue(encoder.encode(suffix))\n } catch {\n // If an error occurs while enqueuing it can't be due to this\n // transformers fault. It's likely due to the controller being\n // errored due to the stream being cancelled.\n } finally {\n pending = undefined\n detached.resolve()\n }\n })\n }\n\n return new TransformStream({\n transform(chunk, controller) {\n controller.enqueue(chunk)\n\n // If we've already flushed, we're done.\n if (flushed) return\n\n // Schedule the flush to happen.\n flushed = true\n flush(controller)\n },\n flush(controller) {\n if (pending) return pending.promise\n if (flushed) return\n\n // Flush now.\n controller.enqueue(encoder.encode(suffix))\n },\n })\n}\n\nfunction createFlightDataInjectionTransformStream(\n stream: ReadableStream,\n delayDataUntilFirstHtmlChunk: boolean\n): TransformStream {\n let htmlStreamFinished = false\n\n let pull: Promise | null = null\n let donePulling = false\n\n function startOrContinuePulling(\n controller: TransformStreamDefaultController\n ) {\n if (!pull) {\n pull = startPulling(controller)\n }\n return pull\n }\n\n async function startPulling(controller: TransformStreamDefaultController) {\n const reader = stream.getReader()\n\n if (delayDataUntilFirstHtmlChunk) {\n // NOTE: streaming flush\n // We are buffering here for the inlined data stream because the\n // \"shell\" stream might be chunkenized again by the underlying stream\n // implementation, e.g. with a specific high-water mark. To ensure it's\n // the safe timing to pipe the data stream, this extra tick is\n // necessary.\n\n // We don't start reading until we've left the current Task to ensure\n // that it's inserted after flushing the shell. Note that this implementation\n // might get stale if impl details of Fizz change in the future.\n await atLeastOneTask()\n }\n\n try {\n while (true) {\n const { done, value } = await reader.read()\n if (done) {\n donePulling = true\n return\n }\n\n // We want to prioritize HTML over RSC data.\n // The SSR render is based on the same RSC stream, so when we get a new RSC chunk,\n // we're likely to produce an HTML chunk as well, so give it a chance to flush first.\n if (!delayDataUntilFirstHtmlChunk && !htmlStreamFinished) {\n await atLeastOneTask()\n }\n controller.enqueue(value)\n }\n } catch (err) {\n controller.error(err)\n }\n }\n\n return new TransformStream({\n start(controller) {\n if (!delayDataUntilFirstHtmlChunk) {\n startOrContinuePulling(controller)\n }\n },\n transform(chunk, controller) {\n controller.enqueue(chunk)\n\n // Start the streaming if it hasn't already been started yet.\n if (delayDataUntilFirstHtmlChunk) {\n startOrContinuePulling(controller)\n }\n },\n flush(controller) {\n htmlStreamFinished = true\n if (donePulling) {\n return\n }\n return startOrContinuePulling(controller)\n },\n })\n}\n\nconst CLOSE_TAG = ''\n\n/**\n * This transform stream moves the suffix to the end of the stream, so results\n * like `` will be transformed to\n * ``.\n */\nfunction createMoveSuffixStream(): TransformStream {\n let foundSuffix = false\n\n return new TransformStream({\n transform(chunk, controller) {\n if (foundSuffix) {\n return controller.enqueue(chunk)\n }\n\n const index = indexOfUint8Array(chunk, ENCODED_TAGS.CLOSED.BODY_AND_HTML)\n if (index > -1) {\n foundSuffix = true\n\n // If the whole chunk is the suffix, then don't write anything, it will\n // be written in the flush.\n if (chunk.length === ENCODED_TAGS.CLOSED.BODY_AND_HTML.length) {\n return\n }\n\n // Write out the part before the suffix.\n const before = chunk.slice(0, index)\n controller.enqueue(before)\n\n // In the case where the suffix is in the middle of the chunk, we need\n // to split the chunk into two parts.\n if (chunk.length > ENCODED_TAGS.CLOSED.BODY_AND_HTML.length + index) {\n // Write out the part after the suffix.\n const after = chunk.slice(\n index + ENCODED_TAGS.CLOSED.BODY_AND_HTML.length\n )\n controller.enqueue(after)\n }\n } else {\n controller.enqueue(chunk)\n }\n },\n flush(controller) {\n // Even if we didn't find the suffix, the HTML is not valid if we don't\n // add it, so insert it at the end.\n controller.enqueue(ENCODED_TAGS.CLOSED.BODY_AND_HTML)\n },\n })\n}\n\nfunction createStripDocumentClosingTagsTransform(): TransformStream<\n Uint8Array,\n Uint8Array\n> {\n return new TransformStream({\n transform(chunk, controller) {\n // We rely on the assumption that chunks will never break across a code unit.\n // This is reasonable because we currently concat all of React's output from a single\n // flush into one chunk before streaming it forward which means the chunk will represent\n // a single coherent utf-8 string. This is not safe to use if we change our streaming to no\n // longer do this large buffered chunk\n if (\n isEquivalentUint8Arrays(chunk, ENCODED_TAGS.CLOSED.BODY_AND_HTML) ||\n isEquivalentUint8Arrays(chunk, ENCODED_TAGS.CLOSED.BODY) ||\n isEquivalentUint8Arrays(chunk, ENCODED_TAGS.CLOSED.HTML)\n ) {\n // the entire chunk is the closing tags; return without enqueueing anything.\n return\n }\n\n // We assume these tags will go at together at the end of the document and that\n // they won't appear anywhere else in the document. This is not really a safe assumption\n // but until we revamp our streaming infra this is a performant way to string the tags\n chunk = removeFromUint8Array(chunk, ENCODED_TAGS.CLOSED.BODY)\n chunk = removeFromUint8Array(chunk, ENCODED_TAGS.CLOSED.HTML)\n\n controller.enqueue(chunk)\n },\n })\n}\n\nfunction createHtmlDataDplIdTransformStream(\n dplId: string\n): TransformStream {\n let didTransform = false\n\n return new TransformStream({\n transform(chunk, controller) {\n if (didTransform) {\n controller.enqueue(chunk)\n return\n }\n\n const htmlTagIndex = indexOfUint8Array(chunk, ENCODED_TAGS.OPENING.HTML)\n if (htmlTagIndex === -1) {\n controller.enqueue(chunk)\n return\n }\n\n // Insert the data-dpl-id attribute right after \" {\n let foundHtml = false\n let foundBody = false\n return new TransformStream({\n async transform(chunk, controller) {\n // Peek into the streamed chunk to see if the tags are present.\n if (\n !foundHtml &&\n indexOfUint8Array(chunk, ENCODED_TAGS.OPENING.HTML) > -1\n ) {\n foundHtml = true\n }\n\n if (\n !foundBody &&\n indexOfUint8Array(chunk, ENCODED_TAGS.OPENING.BODY) > -1\n ) {\n foundBody = true\n }\n\n controller.enqueue(chunk)\n },\n flush(controller) {\n const missingTags: ('html' | 'body')[] = []\n if (!foundHtml) missingTags.push('html')\n if (!foundBody) missingTags.push('body')\n\n if (!missingTags.length) return\n\n controller.enqueue(\n encoder.encode(\n `\n `<${c}>`)\n .join(\n missingTags.length > 1 ? ' and ' : ''\n )} tags in the root layout.\\nRead more at https://nextjs.org/docs/messages/missing-root-layout-tags\"\n data-next-error-digest=\"${MISSING_ROOT_TAGS_ERROR}\"\n data-next-error-stack=\"\"\n >\n `\n )\n )\n },\n })\n}\n\nfunction chainTransformers(\n readable: ReadableStream,\n transformers: ReadonlyArray | null>\n): ReadableStream {\n let stream = readable\n for (const transformer of transformers) {\n if (!transformer) continue\n\n stream = stream.pipeThrough(transformer)\n }\n return stream\n}\n\nexport type ContinueStreamOptions = {\n inlinedDataStream: ReadableStream | undefined\n isStaticGeneration: boolean\n deploymentId: string | undefined\n getServerInsertedHTML: () => Promise\n getServerInsertedMetadata: () => Promise\n validateRootLayout?: boolean\n /**\n * Suffix to inject after the buffered data, but before the close tags.\n */\n suffix?: string | undefined\n}\n\nexport async function continueFizzStream(\n renderStream: ReactDOMServerReadableStream,\n {\n suffix,\n inlinedDataStream,\n isStaticGeneration,\n deploymentId,\n getServerInsertedHTML,\n getServerInsertedMetadata,\n validateRootLayout,\n }: ContinueStreamOptions\n): Promise> {\n // Suffix itself might contain close tags at the end, so we need to split it.\n const suffixUnclosed = suffix ? suffix.split(CLOSE_TAG, 1)[0] : null\n\n if (isStaticGeneration) {\n // If we're generating static HTML we need to wait for it to resolve before continuing.\n await renderStream.allReady\n } else {\n // Otherwise, we want to make sure Fizz is done with all microtasky work\n // before we start pulling the stream and cause a flush.\n await waitAtLeastOneReactRenderTask()\n }\n\n return chainTransformers(renderStream, [\n // Buffer everything to avoid flushing too frequently\n createBufferedTransformStream(),\n\n // Insert data-dpl-id attribute on the html tag\n deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,\n\n // Transform metadata\n createMetadataTransformStream(getServerInsertedMetadata),\n\n // Insert suffix content\n suffixUnclosed != null && suffixUnclosed.length > 0\n ? createDeferredSuffixStream(suffixUnclosed)\n : null,\n\n // Insert the inlined data (Flight data, form state, etc.) stream into the HTML\n inlinedDataStream\n ? createFlightDataInjectionTransformStream(inlinedDataStream, true)\n : null,\n\n // Validate the root layout for missing html or body tags\n validateRootLayout ? createRootLayoutValidatorStream() : null,\n\n // Close tags should always be deferred to the end\n createMoveSuffixStream(),\n\n // Special head insertions\n // TODO-APP: Insert server side html to end of head in app layout rendering, to avoid\n // hydration errors. Remove this once it's ready to be handled by react itself.\n createHeadInsertionTransformStream(getServerInsertedHTML),\n ])\n}\n\ntype ContinueDynamicPrerenderOptions = {\n getServerInsertedHTML: () => Promise\n getServerInsertedMetadata: () => Promise\n deploymentId: string | undefined\n}\n\nexport async function continueDynamicPrerender(\n prerenderStream: ReadableStream,\n {\n getServerInsertedHTML,\n getServerInsertedMetadata,\n deploymentId,\n }: ContinueDynamicPrerenderOptions\n) {\n return chainTransformers(prerenderStream, [\n // Buffer everything to avoid flushing too frequently\n createBufferedTransformStream(),\n createStripDocumentClosingTagsTransform(),\n // Insert data-dpl-id attribute on the html tag\n deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,\n // Insert generated tags to head\n createHeadInsertionTransformStream(getServerInsertedHTML),\n // Transform metadata\n createMetadataTransformStream(getServerInsertedMetadata),\n ])\n}\n\ntype ContinueStaticPrerenderOptions = {\n inlinedDataStream: ReadableStream\n getServerInsertedHTML: () => Promise\n getServerInsertedMetadata: () => Promise\n deploymentId: string | undefined\n}\n\nexport async function continueStaticPrerender(\n prerenderStream: ReadableStream,\n {\n inlinedDataStream,\n getServerInsertedHTML,\n getServerInsertedMetadata,\n deploymentId,\n }: ContinueStaticPrerenderOptions\n) {\n return chainTransformers(prerenderStream, [\n // Buffer everything to avoid flushing too frequently\n createBufferedTransformStream(),\n // Add build id comment to start of the HTML document (in export mode)\n // Insert data-dpl-id attribute on the html tag\n deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,\n // Insert generated tags to head\n createHeadInsertionTransformStream(getServerInsertedHTML),\n // Transform metadata\n createMetadataTransformStream(getServerInsertedMetadata),\n // Insert the inlined data (Flight data, form state, etc.) stream into the HTML\n createFlightDataInjectionTransformStream(inlinedDataStream, true),\n // Close tags should always be deferred to the end\n createMoveSuffixStream(),\n ])\n}\n\nexport async function continueStaticFallbackPrerender(\n prerenderStream: ReadableStream,\n {\n inlinedDataStream,\n getServerInsertedHTML,\n getServerInsertedMetadata,\n deploymentId,\n }: ContinueStaticPrerenderOptions\n) {\n // Same as `continueStaticPrerender`, but also inserts an additional script\n // to instruct the client to start fetching the hydration data as early\n // as possible.\n return chainTransformers(prerenderStream, [\n // Buffer everything to avoid flushing too frequently\n createBufferedTransformStream(),\n // Insert data-dpl-id attribute on the html tag\n deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,\n // Insert generated tags to head\n createHeadInsertionTransformStream(getServerInsertedHTML),\n // Insert the client resume script into the head\n await createClientResumeScriptInsertionTransformStream(),\n // Transform metadata\n createMetadataTransformStream(getServerInsertedMetadata),\n // Insert the inlined data (Flight data, form state, etc.) stream into the HTML\n createFlightDataInjectionTransformStream(inlinedDataStream, true),\n // Close tags should always be deferred to the end\n createMoveSuffixStream(),\n ])\n}\n\ntype ContinueResumeOptions = {\n inlinedDataStream: ReadableStream\n getServerInsertedHTML: () => Promise\n getServerInsertedMetadata: () => Promise\n delayDataUntilFirstHtmlChunk: boolean\n deploymentId: string | undefined\n}\n\nexport async function continueDynamicHTMLResume(\n renderStream: ReadableStream,\n {\n delayDataUntilFirstHtmlChunk,\n inlinedDataStream,\n getServerInsertedHTML,\n getServerInsertedMetadata,\n deploymentId,\n }: ContinueResumeOptions\n) {\n return chainTransformers(renderStream, [\n // Buffer everything to avoid flushing too frequently\n createBufferedTransformStream(),\n // Insert data-dpl-id attribute on the html tag\n deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,\n // Insert generated tags to head\n createHeadInsertionTransformStream(getServerInsertedHTML),\n // Transform metadata\n createMetadataTransformStream(getServerInsertedMetadata),\n // Insert the inlined data (Flight data, form state, etc.) stream into the HTML\n createFlightDataInjectionTransformStream(\n inlinedDataStream,\n delayDataUntilFirstHtmlChunk\n ),\n // Close tags should always be deferred to the end\n createMoveSuffixStream(),\n ])\n}\n\nexport function createDocumentClosingStream(): ReadableStream {\n return streamFromString(CLOSE_TAG)\n}\n\n// ---------------------------------------------------------------------------\n// Runtime prefetch transform (Web streams)\n// ---------------------------------------------------------------------------\n\n/**\n * Web TransformStream that replaces the runtime prefetch sentinel in an RSC\n * payload stream: `[]` -> `[,]`.\n *\n * This is the web equivalent of createRuntimePrefetchNodeTransform\n * in node-stream-helpers.ts.\n */\nexport function createRuntimePrefetchTransformStream(\n sentinel: number,\n isPartial: boolean,\n staleTime: number\n): TransformStream {\n const enc = new TextEncoder()\n\n // Search for: []\n // Replace with: [,]\n const search = enc.encode(`[${sentinel}]`)\n const first = search[0]\n const replace = enc.encode(`[${isPartial},${staleTime}]`)\n const searchLen = search.length\n\n let currentChunk: Uint8Array | null = null\n let found = false\n\n function processChunk(\n controller: TransformStreamDefaultController,\n nextChunk: null | Uint8Array\n ) {\n if (found) {\n if (nextChunk) {\n controller.enqueue(nextChunk)\n }\n return\n }\n\n if (currentChunk) {\n // We can't search past the index that can contain a full match\n let exclusiveUpperBound = currentChunk.length - (searchLen - 1)\n if (nextChunk) {\n // If we have any overflow bytes we can search up to the chunk's final byte\n exclusiveUpperBound += Math.min(nextChunk.length, searchLen - 1)\n }\n if (exclusiveUpperBound < 1) {\n // we can't match the current chunk.\n controller.enqueue(currentChunk)\n currentChunk = nextChunk // advance so we don't process this chunk again\n return\n }\n\n let currentIndex = currentChunk.indexOf(first)\n\n // check the current candidate match if it is within the bounds of our search space for the currentChunk\n candidateLoop: while (\n -1 < currentIndex &&\n currentIndex < exclusiveUpperBound\n ) {\n // We already know index 0 matches because we used indexOf to find the candidateIndex so we start at index 1\n let matchIndex = 1\n while (matchIndex < searchLen) {\n const candidateIndex = currentIndex + matchIndex\n const candidateValue =\n candidateIndex < currentChunk.length\n ? currentChunk[candidateIndex]\n : // if we ever hit this condition it is because there is a nextChunk we can read from\n nextChunk![candidateIndex - currentChunk.length]\n if (candidateValue !== search[matchIndex]) {\n // No match, reset and continue the search from the next position\n currentIndex = currentChunk.indexOf(first, currentIndex + 1)\n continue candidateLoop\n }\n matchIndex++\n }\n // We found a complete match. currentIndex is our starting point to replace the value.\n found = true\n // enqueue everything up to the match\n controller.enqueue(currentChunk.subarray(0, currentIndex))\n // enqueue the replacement value\n controller.enqueue(replace)\n // If there are bytes in the currentChunk after the match enqueue them\n if (currentIndex + searchLen < currentChunk.length) {\n controller.enqueue(currentChunk.slice(currentIndex + searchLen))\n }\n // If we have a next chunk we enqueue it now\n if (nextChunk) {\n // if replacement spills over to the next chunk we first exclude the replaced bytes\n const overflowBytes = currentIndex + searchLen - currentChunk.length\n const truncatedChunk =\n overflowBytes > 0 ? nextChunk!.subarray(overflowBytes) : nextChunk\n controller.enqueue(truncatedChunk)\n }\n // We are now in found mode and don't need to track currentChunk anymore\n currentChunk = null\n return\n }\n // No match found in this chunk, emit it and wait for the next one\n controller.enqueue(currentChunk)\n }\n\n // Advance to the next chunk\n currentChunk = nextChunk\n }\n\n return new TransformStream({\n transform(chunk, controller) {\n processChunk(controller, chunk)\n },\n flush(controller) {\n processChunk(controller, null)\n },\n })\n}\n"],"names":["getTracer","AppRenderSpan","DetachedPromise","scheduleImmediate","atLeastOneTask","waitAtLeastOneReactRenderTask","ENCODED_TAGS","indexOfUint8Array","isEquivalentUint8Arrays","removeFromUint8Array","MISSING_ROOT_TAGS_ERROR","RSC_HEADER","NEXT_ROUTER_PREFETCH_HEADER","NEXT_ROUTER_SEGMENT_PREFETCH_HEADER","NEXT_RSC_UNION_QUERY","NEXT_INSTANT_PREFETCH_HEADER","computeCacheBustingSearchParam","voidCatch","encoder","TextEncoder","chainStreams","streams","length","ReadableStream","start","controller","close","readable","writable","TransformStream","promise","pipeTo","preventClose","i","nextStream","then","lastStream","catch","streamFromString","str","enqueue","encode","streamFromBuffer","chunk","streamToChunks","stream","reader","getReader","chunks","done","value","read","push","concatUint8Arrays","totalLength","reduce","sum","result","Uint8Array","offset","set","streamToUint8Array","streamToBuffer","Buffer","concat","streamToString","signal","decoder","TextDecoder","fatal","string","aborted","decode","createBufferedTransformStream","options","maxBufferByteLength","Infinity","bufferedChunks","bufferByteLength","pending","flush","copiedBytes","bufferedChunk","byteLength","scheduleFlush","detached","undefined","resolve","transform","renderToInitialFizzStream","ReactDOMServer","element","streamOptions","trace","renderToReadableStream","createMetadataTransformStream","insert","chunkIndex","isMarkRemoved","iconMarkIndex","closedHeadIndex","iconMarkLength","META","ICON_MARK","CLOSED","HEAD","replaced","subarray","insertion","encodedInsertion","insertionLength","createHeadInsertionTransformStream","inserted","hasBytes","index","insertedHeadContent","slice","createClientResumeScriptInsertionTransformStream","segmentPath","cacheBustingHeader","searchStr","NEXT_CLIENT_RESUME_SCRIPT","didAlreadyInsert","headClosingTagIndex","createInstantTestScriptInsertionTransformStream","requestId","requestIdScript","JSON","stringify","INSTANT_TEST_SCRIPT","headOpenIndex","OPENING","headCloseAngle","indexOf","insertionPoint","BODY_AND_HTML","createDeferredSuffixStream","suffix","flushed","createFlightDataInjectionTransformStream","delayDataUntilFirstHtmlChunk","htmlStreamFinished","pull","donePulling","startOrContinuePulling","startPulling","err","error","CLOSE_TAG","createMoveSuffixStream","foundSuffix","before","after","createStripDocumentClosingTagsTransform","BODY","HTML","createHtmlDataDplIdTransformStream","dplId","didTransform","htmlTagIndex","attribute","encodedAttribute","modifiedChunk","createRootLayoutValidatorStream","foundHtml","foundBody","missingTags","map","c","join","chainTransformers","transformers","transformer","pipeThrough","continueFizzStream","renderStream","inlinedDataStream","isStaticGeneration","deploymentId","getServerInsertedHTML","getServerInsertedMetadata","validateRootLayout","suffixUnclosed","split","allReady","continueDynamicPrerender","prerenderStream","continueStaticPrerender","continueStaticFallbackPrerender","continueDynamicHTMLResume","createDocumentClosingStream","createRuntimePrefetchTransformStream","sentinel","isPartial","staleTime","enc","search","first","replace","searchLen","currentChunk","found","processChunk","nextChunk","exclusiveUpperBound","Math","min","currentIndex","candidateLoop","matchIndex","candidateIndex","candidateValue","overflowBytes","truncatedChunk"],"mappings":"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","ignoreList":[0]}