{"version":3,"sources":["../../../src/server/app-render/stream-ops.node.ts"],"sourcesContent":["/**\n * Node.js stream operations for the rendering pipeline.\n * Loaded by stream-ops.ts when process.env.__NEXT_USE_NODE_STREAMS is true.\n *\n * AnyStream = AnyStreamType so the exported type surface matches stream-ops.web.ts,\n * allowing the switcher to assign either module without casts.\n * Rendering uses pipeable APIs; continue functions wrap the existing web\n * transforms via Readable.fromWeb() on their output.\n */\n\nimport type { PostponedState, PrerenderOptions } from 'react-dom/static'\nimport {\n  renderToPipeableStream,\n  resumeToPipeableStream,\n} from 'react-dom/server'\nimport { prerender } from 'react-dom/static'\nimport { PassThrough, Readable, Transform } from 'node:stream'\nimport { isUtf8 } from 'node:buffer'\n\nimport {\n  continueStaticPrerender as webContinueStaticPrerender,\n  continueDynamicPrerender as webContinueDynamicPrerender,\n  continueStaticFallbackPrerender as webContinueStaticFallbackPrerender,\n  continueDynamicHTMLResume as webContinueDynamicHTMLResume,\n  streamToBuffer as webStreamToBuffer,\n  streamToString as webStreamToString,\n  createDocumentClosingStream as webCreateDocumentClosingStream,\n  createRuntimePrefetchTransformStream,\n  CLOSE_TAG,\n} from '../stream-utils/node-web-streams-helper'\nimport { indexOfUint8Array } from '../stream-utils/uint8array-helpers'\nimport { ENCODED_TAGS } from '../stream-utils/encoded-tags'\nimport { createNodeBufferedTransformStream } from '../stream-utils/node-buffered-transform-stream'\nimport { MISSING_ROOT_TAGS_ERROR } from '../../shared/lib/errors/constants'\nimport {\n  htmlEscapeAttributeString,\n  htmlEscapeJsonString,\n} from '../../shared/lib/htmlescape'\nimport { createInlinedDataReadableStream } from './use-flight-response'\nimport {\n  ReplayableNodeStream,\n  type AnyStream as AnyStreamType,\n} from './app-render-prerender-utils'\nimport { DetachedPromise } from '../../lib/detached-promise'\nimport { getTracer } from '../lib/trace/tracer'\nimport { AppRenderSpan } from '../lib/trace/constants'\nimport {\n  atLeastOneTask,\n  waitAtLeastOneReactRenderTask,\n} from '../../lib/scheduler'\nimport type {\n  FlightPayload,\n  FlightClientModules,\n  FlightRenderOptions,\n} from './stream-ops.web'\n\n// ---------------------------------------------------------------------------\n// Re-export shared types from the web module\n// ---------------------------------------------------------------------------\n\nexport type {\n  ContinueStreamSharedOptions,\n  ContinueFizzStreamOptions,\n  ContinueStaticPrerenderOptions,\n  ContinueDynamicHTMLResumeOptions,\n  ServerPrerenderComponentMod,\n  FlightPayload,\n  FlightClientModules,\n  FlightRenderOptions,\n} from './stream-ops.web'\n\n// ---------------------------------------------------------------------------\n// AnyStream matches stream-ops.web.ts so both modules have the same type surface\n// ---------------------------------------------------------------------------\n\nexport type AnyStream = AnyStreamType\n\nexport type FlightComponentMod = {\n  renderToReadableStream: (\n    model: any,\n    webpackMap: any,\n    options?: any\n  ) => ReadableStream<Uint8Array>\n  renderToPipeableStream?: (\n    model: any,\n    webpackMap: any,\n    options?: any\n  ) => {\n    pipe<Writable extends NodeJS.WritableStream>(\n      destination: Writable\n    ): Writable\n    abort(reason?: unknown): void\n  }\n}\n\nexport type FizzStreamResult = {\n  stream: AnyStream\n  allReady: Promise<void>\n  abort?: (reason?: unknown) => void\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\ntype WebReadableStream = import('stream/web').ReadableStream\n\nfunction nodeReadableToWebReadableStream(\n  stream: Readable | ReadableStream<Uint8Array>\n): ReadableStream<Uint8Array> {\n  if (stream instanceof ReadableStream) {\n    return stream\n  }\n  // Readable.toWeb returns stream/web ReadableStream which is structurally\n  // identical to the global ReadableStream<Uint8Array>.\n  return Readable.toWeb(stream) as unknown as ReadableStream<Uint8Array>\n}\n\nfunction webToReadable(\n  stream: ReadableStream<Uint8Array> | Readable\n): Readable {\n  if (stream instanceof Readable) {\n    return stream\n  }\n  return Readable.fromWeb(stream as WebReadableStream)\n}\n\n// ---------------------------------------------------------------------------\n// Flight data injection – Node.js Transform that passes HTML chunks through\n// while pulling from a separate data stream and interleaving its chunks.\n// ---------------------------------------------------------------------------\n\nfunction createFlightDataInjectionTransform(\n  dataStream: Readable,\n  delayDataUntilFirstHtmlChunk: boolean\n): Transform {\n  let htmlStreamFinished = false\n  let pull: Promise<void> | null = null\n  let donePulling = false\n\n  function startOrContinuePulling(target: Transform) {\n    if (!pull) {\n      pull = startPulling(target)\n    }\n    return pull\n  }\n\n  async function startPulling(target: Transform) {\n    if (delayDataUntilFirstHtmlChunk) {\n      // Buffer the inlined data stream until we've left the current Task so\n      // it's inserted after flushing the shell.\n      await atLeastOneTask()\n    }\n\n    try {\n      const iterator = dataStream[Symbol.asyncIterator]()\n      while (true) {\n        const { done, value } = await iterator.next()\n        if (done) {\n          donePulling = true\n          return\n        }\n\n        // Prioritize HTML over RSC data: the SSR render produces HTML from\n        // the same RSC stream, so yield a task to let HTML flush first.\n        if (!delayDataUntilFirstHtmlChunk && !htmlStreamFinished) {\n          await atLeastOneTask()\n        }\n        target.push(value)\n      }\n    } catch (err) {\n      target.destroy(err as Error)\n    }\n  }\n\n  const nodeTransform = new Transform({\n    transform(chunk, _encoding, callback) {\n      this.push(chunk)\n      if (delayDataUntilFirstHtmlChunk) {\n        startOrContinuePulling(this)\n      }\n      callback()\n    },\n    flush(callback) {\n      htmlStreamFinished = true\n      if (donePulling) {\n        callback()\n        return\n      }\n      startOrContinuePulling(this).then(\n        () => callback(),\n        (err) => callback(err as Error)\n      )\n    },\n  })\n\n  if (!delayDataUntilFirstHtmlChunk) {\n    startOrContinuePulling(nodeTransform)\n  }\n\n  return nodeTransform\n}\n\n// ---------------------------------------------------------------------------\n// Head insertion – Node.js Transform that inserts server-generated HTML\n// (e.g. <script>, <style>) right before </head>, or prepends it if no\n// </head> tag is found (PPR resume case).\n// ---------------------------------------------------------------------------\n\nfunction createHeadInsertionTransform(\n  insert: () => Promise<string>\n): Transform {\n  let inserted = false\n  let hasBytes = false\n\n  return new Transform({\n    async transform(chunk, _encoding, callback) {\n      hasBytes = true\n\n      try {\n        const insertion = await insert()\n        if (inserted) {\n          if (insertion) {\n            this.push(Buffer.from(insertion))\n          }\n          this.push(chunk)\n        } else {\n          const index = indexOfUint8Array(chunk, ENCODED_TAGS.CLOSED.HEAD)\n          if (index !== -1) {\n            if (insertion) {\n              const encodedInsertion = Buffer.from(insertion)\n              const merged = Buffer.allocUnsafe(\n                chunk.length + encodedInsertion.length\n              )\n              merged.set(chunk.slice(0, index))\n              merged.set(encodedInsertion, index)\n              merged.set(chunk.slice(index), index + encodedInsertion.length)\n              this.push(merged)\n            } else {\n              this.push(chunk)\n            }\n            inserted = true\n          } else {\n            if (insertion) {\n              this.push(Buffer.from(insertion))\n            }\n            this.push(chunk)\n            inserted = true\n          }\n        }\n        callback()\n      } catch (err) {\n        callback(err as Error)\n      }\n    },\n    async flush(callback) {\n      try {\n        if (hasBytes) {\n          const insertion = await insert()\n          if (insertion) {\n            this.push(Buffer.from(insertion))\n          }\n        }\n        callback()\n      } catch (err) {\n        callback(err as Error)\n      }\n    },\n  })\n}\n\n// ---------------------------------------------------------------------------\n// Metadata transform – Node.js Transform that finds the «nxt-icon» meta mark\n// and replaces it with a script tag (or removes it if inside <head>).\n// ---------------------------------------------------------------------------\n\nfunction createMetadataTransform(\n  insert: () => Promise<string> | string\n): Transform {\n  let chunkIndex = -1\n  let isMarkRemoved = false\n\n  return new Transform({\n    async transform(chunk, _encoding, callback) {\n      let iconMarkIndex = -1\n      let closedHeadIndex = -1\n      chunkIndex++\n\n      if (isMarkRemoved) {\n        this.push(chunk)\n        callback()\n        return\n      }\n\n      try {\n        let iconMarkLength = 0\n        iconMarkIndex = indexOfUint8Array(chunk, ENCODED_TAGS.META.ICON_MARK)\n        if (iconMarkIndex === -1) {\n          this.push(chunk)\n          callback()\n          return\n        }\n\n        iconMarkLength = ENCODED_TAGS.META.ICON_MARK.length\n        if (chunk[iconMarkIndex + iconMarkLength] === 47) {\n          iconMarkLength += 2\n        } else {\n          iconMarkLength++\n        }\n\n        if (chunkIndex === 0) {\n          closedHeadIndex = indexOfUint8Array(chunk, ENCODED_TAGS.CLOSED.HEAD)\n          if (iconMarkIndex < closedHeadIndex) {\n            const replaced = Buffer.allocUnsafe(chunk.length - iconMarkLength)\n            replaced.set(chunk.subarray(0, iconMarkIndex))\n            replaced.set(\n              chunk.subarray(iconMarkIndex + iconMarkLength),\n              iconMarkIndex\n            )\n            chunk = replaced\n          } else {\n            const insertion = await insert()\n            const encodedInsertion = Buffer.from(insertion)\n            const insertionLength = encodedInsertion.length\n            const replaced = Buffer.allocUnsafe(\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        } else {\n          const insertion = await insert()\n          const encodedInsertion = Buffer.from(insertion)\n          const insertionLength = encodedInsertion.length\n          const replaced = Buffer.allocUnsafe(\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          isMarkRemoved = true\n        }\n        this.push(chunk)\n        callback()\n      } catch (err) {\n        callback(err as Error)\n      }\n    },\n  })\n}\n\n// ---------------------------------------------------------------------------\n// Deferred suffix – Node.js Transform that appends a suffix string after the\n// first HTML chunk, deferring via queueMicrotask so the chunk flushes first.\n// ---------------------------------------------------------------------------\n\nfunction createDeferredSuffixTransform(suffix: string): Transform {\n  let flushed = false\n  const encodedSuffix = Buffer.from(suffix)\n\n  return new Transform({\n    transform(chunk, _encoding, callback) {\n      this.push(chunk)\n\n      if (!flushed) {\n        flushed = true\n        queueMicrotask(() => {\n          this.push(encodedSuffix)\n        })\n      }\n      callback()\n    },\n    flush(callback) {\n      if (!flushed) {\n        this.push(encodedSuffix)\n      }\n      callback()\n    },\n  })\n}\n\n// ---------------------------------------------------------------------------\n// Move suffix – Node.js Transform that strips </body></html> from its\n// original position and re-appends it at the very end of the stream, so any\n// content injected after the suffix still appears before the closing tags.\n// ---------------------------------------------------------------------------\n\nfunction createMoveSuffixTransform(): Transform {\n  let foundSuffix = false\n\n  return new Transform({\n    transform(chunk, _encoding, callback) {\n      if (foundSuffix) {\n        this.push(chunk)\n        callback()\n        return\n      }\n\n      const index = indexOfUint8Array(chunk, ENCODED_TAGS.CLOSED.BODY_AND_HTML)\n      if (index > -1) {\n        foundSuffix = true\n\n        if (chunk.length === ENCODED_TAGS.CLOSED.BODY_AND_HTML.length) {\n          callback()\n          return\n        }\n\n        const before = chunk.slice(0, index)\n        this.push(before)\n\n        if (chunk.length > ENCODED_TAGS.CLOSED.BODY_AND_HTML.length + index) {\n          const after = chunk.slice(\n            index + ENCODED_TAGS.CLOSED.BODY_AND_HTML.length\n          )\n          this.push(after)\n        }\n      } else {\n        this.push(chunk)\n      }\n      callback()\n    },\n    flush(callback) {\n      this.push(ENCODED_TAGS.CLOSED.BODY_AND_HTML)\n      callback()\n    },\n  })\n}\n\n// ---------------------------------------------------------------------------\n// data-dpl-id insertion – Node.js Transform that inserts a `data-dpl-id`\n// attribute on the opening <html tag for deployment identification.\n// ---------------------------------------------------------------------------\n\nfunction createHtmlDataDplIdTransform(dplId: string): Transform {\n  let didTransform = false\n\n  return new Transform({\n    transform(chunk, _encoding, callback) {\n      if (didTransform) {\n        this.push(chunk)\n        callback()\n        return\n      }\n\n      const htmlTagIndex = indexOfUint8Array(chunk, ENCODED_TAGS.OPENING.HTML)\n      if (htmlTagIndex === -1) {\n        this.push(chunk)\n        callback()\n        return\n      }\n\n      const insertionPoint = htmlTagIndex + ENCODED_TAGS.OPENING.HTML.length\n      const encodedAttribute = Buffer.from(` data-dpl-id=\"${dplId}\"`)\n      const modified = Buffer.allocUnsafe(\n        chunk.length + encodedAttribute.length\n      )\n\n      modified.set(chunk.subarray(0, insertionPoint))\n      modified.set(encodedAttribute, insertionPoint)\n      modified.set(\n        chunk.subarray(insertionPoint),\n        insertionPoint + encodedAttribute.length\n      )\n\n      this.push(modified)\n      didTransform = true\n      callback()\n    },\n  })\n}\n\n// ---------------------------------------------------------------------------\n// Root layout validator – Node.js Transform that checks whether <html> and\n// <body> tags are present in the streamed output.  Dev-only; appends an\n// error template when tags are missing so the error overlay can display it.\n// ---------------------------------------------------------------------------\n\nfunction createRootLayoutValidatorTransform(): Transform {\n  let foundHtml = false\n  let foundBody = false\n\n  return new Transform({\n    transform(chunk, _encoding, callback) {\n      if (\n        !foundHtml &&\n        indexOfUint8Array(chunk, ENCODED_TAGS.OPENING.HTML) > -1\n      ) {\n        foundHtml = true\n      }\n      if (\n        !foundBody &&\n        indexOfUint8Array(chunk, ENCODED_TAGS.OPENING.BODY) > -1\n      ) {\n        foundBody = true\n      }\n      this.push(chunk)\n      callback()\n    },\n    flush(callback) {\n      const missingTags: ('html' | 'body')[] = []\n      if (!foundHtml) missingTags.push('html')\n      if (!foundBody) missingTags.push('body')\n\n      if (missingTags.length) {\n        this.push(\n          Buffer.from(\n            `<html id=\"__next_error__\">\n            <template\n              data-next-error-message=\"Missing ${missingTags\n                .map((c) => `<${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            ></template>\n          `\n          )\n        )\n      }\n      callback()\n    },\n  })\n}\n\n// ---------------------------------------------------------------------------\n// Rendering functions (output Node Readable natively via PassThrough)\n// ---------------------------------------------------------------------------\n\nexport { renderToWebFlightStream } from './stream-ops.web'\n\nexport function renderToNodeFlightStream(\n  ComponentMod: FlightComponentMod,\n  payload: FlightPayload,\n  clientModules: FlightClientModules,\n  opts: FlightRenderOptions\n): AnyStream {\n  if (!ComponentMod.renderToPipeableStream) {\n    throw new Error('renderToPipeableStream is not implemented')\n  }\n\n  // `renderToPipeableStream` has no `signal` option (unlike the Web\n  // `renderToReadableStream`), so pull `signal` out of the options and abort\n  // the returned pipeable ourselves when it fires. We drop the listener when\n  // the passthrough closes so a finished render's `pipeable` isn't retained by\n  // the request signal, which can outlive it.\n  const { signal, ...renderOptions } = opts ?? {}\n\n  const pt = new PassThrough()\n  const pipeable = ComponentMod.renderToPipeableStream!(\n    payload,\n    clientModules,\n    renderOptions\n  )\n  pipeable.pipe(pt)\n\n  if (signal) {\n    if (signal.aborted) {\n      pipeable.abort(signal.reason)\n    } else {\n      const onAbort = () => pipeable.abort(signal.reason)\n      signal.addEventListener('abort', onAbort, { once: true })\n      pt.on('close', () => signal.removeEventListener('abort', onAbort))\n    }\n  }\n\n  return pt\n}\n\nexport { renderToWebFizzStream } from './stream-ops.web'\n\nexport async function renderToNodeFizzStream(\n  element: React.ReactElement,\n  streamOptions: any,\n  options?: { waitForAllReady?: boolean }\n): Promise<FizzStreamResult> {\n  const pt = new PassThrough()\n  const shellReady = new DetachedPromise<void>()\n  const allReady = new DetachedPromise<void>()\n  const deferPipe = options?.waitForAllReady === true\n\n  const pipeable = getTracer().trace(AppRenderSpan.renderToReadableStream, () =>\n    renderToPipeableStream(element, {\n      ...streamOptions,\n      onHeaders: streamOptions?.onHeaders,\n      onShellReady() {\n        streamOptions?.onShellReady?.()\n        shellReady.resolve()\n      },\n      onShellError(error: unknown) {\n        streamOptions?.onShellError?.(error)\n        shellReady.reject(error)\n      },\n      onAllReady() {\n        streamOptions?.onAllReady?.()\n        if (deferPipe) {\n          pipeable.pipe(pt)\n        }\n        allReady.resolve()\n      },\n      onError: streamOptions?.onError,\n    })\n  )\n\n  await getTracer().trace(\n    AppRenderSpan.waitShellReady,\n    () => shellReady.promise\n  )\n\n  if (!deferPipe) {\n    await waitAtLeastOneReactRenderTask()\n    pipeable.pipe(pt)\n  }\n\n  return {\n    stream: pt,\n    allReady: allReady.promise,\n    abort: (reason?: unknown) => pipeable.abort(reason),\n  }\n}\n\nexport async function resumeToFizzStream(\n  element: React.ReactElement,\n  postponedState: PostponedState,\n  streamOptions: any,\n  runInContext?: <T>(fn: () => T) => T\n): Promise<FizzStreamResult> {\n  const run: <T>(fn: () => T) => T = runInContext ?? ((fn) => fn())\n\n  const pt = new PassThrough()\n  const shellReady = new DetachedPromise<void>()\n  const allReady = new DetachedPromise<void>()\n\n  const pipeable = await run(() =>\n    resumeToPipeableStream(element, postponedState, {\n      ...streamOptions,\n      onShellReady() {\n        streamOptions?.onShellReady?.()\n        shellReady.resolve()\n      },\n      onShellError(error: unknown) {\n        streamOptions?.onShellError?.(error)\n        shellReady.reject(error)\n      },\n      onAllReady() {\n        streamOptions?.onAllReady?.()\n        allReady.resolve()\n      },\n    })\n  )\n\n  pipeable.pipe(pt)\n  await shellReady.promise\n\n  return {\n    stream: pt,\n    allReady: allReady.promise,\n    abort: (reason?: unknown) => pipeable.abort(reason),\n  }\n}\n\nexport async function resumeAndAbort(\n  element: React.ReactElement,\n  postponed: PostponedState | null,\n  opts: any\n): Promise<AnyStream> {\n  const pt = new PassThrough()\n  const pipeable = await resumeToPipeableStream(\n    element,\n    postponed as PostponedState,\n    opts\n  )\n  pipeable.pipe(pt)\n  pipeable.abort(opts?.signal?.reason)\n  return pt\n}\n\n// ---------------------------------------------------------------------------\n// Continue function wrappers\n// Bridge Node Readable → web, apply existing web transforms, Readable.fromWeb()\n// ---------------------------------------------------------------------------\n\nexport async function continueFizzStream(\n  renderStream: AnyStream,\n  {\n    suffix,\n    inlinedDataStream,\n    isStaticGeneration,\n    allReady,\n    deploymentId,\n    getServerInsertedHTML,\n    getServerInsertedMetadata,\n    validateRootLayout,\n  }: import('./stream-ops.web').ContinueFizzStreamOptions\n): Promise<Readable> {\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 (allReady) {\n      await allReady\n    }\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  // Pipe the render stream through Node.js Transforms:\n  // 1. Buffer – coalesces chunks written in the same microtask into one Uint8Array\n  // 2. Flight data injection – interleaves RSC data chunks with the HTML stream\n  // 3. Head insertion – inserts server-generated HTML before </head>\n  const buffered = createNodeBufferedTransformStream()\n  webToReadable(renderStream).pipe(buffered)\n\n  let source: Readable = buffered\n\n  if (deploymentId) {\n    const dplId = createHtmlDataDplIdTransform(deploymentId)\n    source.pipe(dplId)\n    source = dplId\n  }\n\n  // Metadata (icon mark replacement)\n  const metadata = createMetadataTransform(getServerInsertedMetadata)\n  source.pipe(metadata)\n  source = metadata\n\n  // Insert suffix content\n  if (suffixUnclosed != null && suffixUnclosed.length > 0) {\n    const deferredSuffix = createDeferredSuffixTransform(suffixUnclosed)\n    source.pipe(deferredSuffix)\n    source = deferredSuffix\n  }\n\n  // Flight data injection – interleaves RSC data chunks with the HTML stream\n  if (inlinedDataStream) {\n    const flightInjection = createFlightDataInjectionTransform(\n      webToReadable(inlinedDataStream),\n      true\n    )\n    source.pipe(flightInjection)\n    source = flightInjection\n  }\n\n  if (validateRootLayout) {\n    const rootLayoutValidator = createRootLayoutValidatorTransform()\n    source.pipe(rootLayoutValidator)\n    source = rootLayoutValidator\n  }\n\n  // Close tags should always be deferred to the end\n  const moveSuffix = createMoveSuffixTransform()\n  source.pipe(moveSuffix)\n  source = moveSuffix\n\n  // Head insertion – inserts server-generated HTML before </head>\n  const headInsertion = createHeadInsertionTransform(getServerInsertedHTML)\n  source.pipe(headInsertion)\n  source = headInsertion\n\n  return source\n}\n\nexport async function continueStaticPrerender(\n  prerenderStream: AnyStream,\n  opts: import('./stream-ops.web').ContinueStaticPrerenderOptions\n): Promise<AnyStream> {\n  const webResult = await webContinueStaticPrerender(\n    nodeReadableToWebReadableStream(prerenderStream),\n    {\n      ...opts,\n      inlinedDataStream: nodeReadableToWebReadableStream(\n        opts.inlinedDataStream\n      ),\n    }\n  )\n  return webToReadable(webResult)\n}\n\nexport async function continueDynamicPrerender(\n  prerenderStream: AnyStream,\n  opts: {\n    getServerInsertedHTML: () => Promise<string>\n    getServerInsertedMetadata: () => Promise<string>\n    deploymentId: string | undefined\n  }\n): Promise<AnyStream> {\n  const webResult = await webContinueDynamicPrerender(\n    nodeReadableToWebReadableStream(prerenderStream),\n    opts\n  )\n  return webToReadable(webResult)\n}\n\nexport async function continueStaticFallbackPrerender(\n  prerenderStream: AnyStream,\n  opts: import('./stream-ops.web').ContinueStaticPrerenderOptions\n): Promise<AnyStream> {\n  const webResult = await webContinueStaticFallbackPrerender(\n    nodeReadableToWebReadableStream(prerenderStream),\n    {\n      ...opts,\n      inlinedDataStream: nodeReadableToWebReadableStream(\n        opts.inlinedDataStream\n      ),\n    }\n  )\n  return webToReadable(webResult)\n}\n\nexport async function continueDynamicHTMLResumeNode(\n  renderStream: AnyStream,\n  {\n    delayDataUntilFirstHtmlChunk,\n    inlinedDataStream,\n    getServerInsertedHTML,\n    getServerInsertedMetadata,\n    deploymentId,\n  }: import('./stream-ops.web').ContinueDynamicHTMLResumeOptions\n): Promise<AnyStream> {\n  await waitAtLeastOneReactRenderTask()\n\n  const buffered = createNodeBufferedTransformStream()\n  webToReadable(renderStream).pipe(buffered)\n\n  let source: Readable = buffered\n\n  if (deploymentId) {\n    const dplId = createHtmlDataDplIdTransform(deploymentId)\n    source.pipe(dplId)\n    source = dplId\n  }\n\n  const headInsertion = createHeadInsertionTransform(getServerInsertedHTML)\n  source.pipe(headInsertion)\n  source = headInsertion\n\n  const metadata = createMetadataTransform(getServerInsertedMetadata)\n  source.pipe(metadata)\n  source = metadata\n\n  const flightInjection = createFlightDataInjectionTransform(\n    webToReadable(inlinedDataStream),\n    delayDataUntilFirstHtmlChunk\n  )\n  source.pipe(flightInjection)\n  source = flightInjection\n\n  const moveSuffix = createMoveSuffixTransform()\n  source.pipe(moveSuffix)\n  source = moveSuffix\n\n  return source\n}\n\nexport async function continueDynamicHTMLResumeWeb(\n  renderStream: AnyStream,\n  opts: import('./stream-ops.web').ContinueDynamicHTMLResumeOptions\n): Promise<AnyStream> {\n  const webResult = await webContinueDynamicHTMLResume(\n    nodeReadableToWebReadableStream(renderStream),\n    {\n      ...opts,\n      inlinedDataStream: nodeReadableToWebReadableStream(\n        opts.inlinedDataStream\n      ),\n    }\n  )\n  return webToReadable(webResult)\n}\n\n// ---------------------------------------------------------------------------\n// Utility functions (Node-native)\n// ---------------------------------------------------------------------------\n\nexport function chainStreams(...streams: AnyStream[]): AnyStream {\n  if (streams.length === 0) {\n    const pt = new PassThrough()\n    pt.end()\n    return pt\n  }\n\n  if (streams.length === 1) {\n    return streams[0]\n  }\n\n  const out = new PassThrough()\n  let i = 0\n\n  function pipeNext() {\n    if (i >= streams.length) {\n      out.end()\n      return\n    }\n    const current = webToReadable(streams[i++])\n    current.pipe(out, { end: false })\n    current.on('end', pipeNext)\n    current.on('error', (err) => out.destroy(err))\n  }\n\n  pipeNext()\n  return out\n}\n\nexport async function streamToBuffer(stream: AnyStream): Promise<Buffer> {\n  return webStreamToBuffer(nodeReadableToWebReadableStream(stream))\n}\n\nexport async function streamToString(stream: AnyStream): Promise<string> {\n  return webStreamToString(nodeReadableToWebReadableStream(stream))\n}\n\nexport function createWebInlinedDataStream(\n  source: AnyStream,\n  nonce: string | undefined,\n  formState: unknown | null\n): AnyStream {\n  const webSource = nodeReadableToWebReadableStream(source)\n  const webResult = createInlinedDataReadableStream(webSource, nonce, formState)\n  return webToReadable(webResult)\n}\n\nexport function createNodeInlinedDataStream(\n  source: AnyStream,\n  nonce: string | undefined,\n  formState: unknown | null\n): AnyStream {\n  const startScriptTag = nonce\n    ? `<script nonce=\"${htmlEscapeAttributeString(nonce)}\">`\n    : '<script>'\n\n  const dataStream = webToReadable(source)\n  const pt = new PassThrough()\n\n  // Write initial bootstrap instructions\n  let scriptContents = `(self.__next_f=self.__next_f||[]).push(${htmlEscapeJsonString(\n    JSON.stringify([INLINE_FLIGHT_PAYLOAD_BOOTSTRAP])\n  )})`\n  if (formState != null) {\n    scriptContents += `;self.__next_f.push(${htmlEscapeJsonString(\n      JSON.stringify([INLINE_FLIGHT_PAYLOAD_FORM_STATE, formState])\n    )})`\n  }\n  pt.push(Buffer.from(`${startScriptTag}${scriptContents}</script>`))\n\n  // Pull from the flight data stream and wrap each chunk in a <script> tag\n  pullFlightData(dataStream, pt, startScriptTag)\n\n  return pt\n}\n\nconst INLINE_FLIGHT_PAYLOAD_BOOTSTRAP = 0\nconst INLINE_FLIGHT_PAYLOAD_DATA = 1\nconst INLINE_FLIGHT_PAYLOAD_FORM_STATE = 2\nconst INLINE_FLIGHT_PAYLOAD_BINARY = 3\n\nasync function pullFlightData(\n  dataStream: Readable,\n  output: PassThrough,\n  startScriptTag: string\n): Promise<void> {\n  function waitForReadableOrEnd(): Promise<void> {\n    if (dataStream.readableLength > 0 || dataStream.readableEnded) {\n      return Promise.resolve()\n    }\n    return new Promise<void>((resolve, reject) => {\n      function cleanup() {\n        dataStream.removeListener('readable', onDone)\n        dataStream.removeListener('end', onDone)\n        dataStream.removeListener('error', onError)\n      }\n      function onDone() {\n        cleanup()\n        resolve()\n      }\n      function onError(err: Error) {\n        cleanup()\n        reject(err)\n      }\n      dataStream.on('readable', onDone)\n      dataStream.on('end', onDone)\n      dataStream.on('error', onError)\n    })\n  }\n\n  try {\n    while (true) {\n      const chunk: Buffer | null = dataStream.read()\n      if (chunk !== null) {\n        let htmlInlinedData: string\n        if (isUtf8(chunk)) {\n          const decodedString = chunk.toString('utf-8')\n          htmlInlinedData = htmlEscapeJsonString(\n            JSON.stringify([INLINE_FLIGHT_PAYLOAD_DATA, decodedString])\n          )\n        } else {\n          const base64 = Buffer.from(\n            chunk.buffer,\n            chunk.byteOffset,\n            chunk.byteLength\n          ).toString('base64')\n          htmlInlinedData = htmlEscapeJsonString(\n            JSON.stringify([INLINE_FLIGHT_PAYLOAD_BINARY, base64])\n          )\n        }\n        output.push(\n          Buffer.from(\n            `${startScriptTag}self.__next_f.push(${htmlInlinedData})</script>`\n          )\n        )\n        continue\n      }\n\n      if (dataStream.readableEnded) {\n        output.end()\n        return\n      }\n\n      await waitForReadableOrEnd()\n    }\n  } catch (err) {\n    output.destroy(err as Error)\n  }\n}\n\nexport function createPendingStream(): AnyStream {\n  return new PassThrough()\n}\n\nexport function createDocumentClosingStream(): AnyStream {\n  const webStream = webCreateDocumentClosingStream()\n  return webToReadable(webStream)\n}\n\nexport function createOnHeadersCallback(\n  appendHeader: (key: string, value: string) => void\n): NonNullable<PrerenderOptions['onHeaders']> {\n  return (headers: Headers) => {\n    headers.forEach((value, key) => {\n      appendHeader(key, value)\n    })\n  }\n}\n\nexport function pipeRuntimePrefetchTransform(\n  stream: AnyStream,\n  sentinel: number,\n  isPartial: boolean,\n  staleTime: number\n): AnyStream {\n  const webStream = nodeReadableToWebReadableStream(stream)\n  const transformed = webStream.pipeThrough(\n    createRuntimePrefetchTransformStream(sentinel, isPartial, staleTime)\n  )\n  return webToReadable(transformed)\n}\n\n// ---------------------------------------------------------------------------\n// Re-exports (no stream involvement, identical to web)\n// ---------------------------------------------------------------------------\n\nexport async function processPrelude(unprocessedPrelude: AnyStream) {\n  const [prelude, peek] =\n    nodeReadableToWebReadableStream(unprocessedPrelude).tee()\n\n  const reader = peek.getReader()\n  const firstResult = await reader.read()\n  reader.cancel()\n\n  return {\n    prelude: webToReadable(prelude) as AnyStream,\n    preludeIsEmpty: firstResult.done === true,\n  }\n}\n\nexport function getServerPrerender(ComponentMod: {\n  prerender: (...args: any[]) => Promise<any>\n}): (...args: any[]) => any {\n  return ComponentMod.prerender\n}\n\nexport const getClientPrerender: typeof import('react-dom/static').prerender =\n  prerender\n\n// Node counterpart of the web `teeStream`. Like the web version it assumes the\n// stream type matching its build — here a Node `Readable` — and fans out\n// through `ReplayableNodeStream`. Need three or more consumers from one source?\n// Use `ReplayableNodeStream` directly (N `createReplayStream()` calls) to avoid\n// nesting tees.\nexport function teeStream(stream: AnyStream): [AnyStream, AnyStream] {\n  const replayable = new ReplayableNodeStream(stream as Readable)\n  return [replayable.createReplayStream(), replayable.createReplayStream()]\n}\n"],"names":["chainStreams","continueDynamicHTMLResumeNode","continueDynamicHTMLResumeWeb","continueDynamicPrerender","continueFizzStream","continueStaticFallbackPrerender","continueStaticPrerender","createDocumentClosingStream","createNodeInlinedDataStream","createOnHeadersCallback","createPendingStream","createWebInlinedDataStream","getClientPrerender","getServerPrerender","pipeRuntimePrefetchTransform","processPrelude","renderToNodeFizzStream","renderToNodeFlightStream","renderToWebFizzStream","renderToWebFlightStream","resumeAndAbort","resumeToFizzStream","streamToBuffer","streamToString","teeStream","nodeReadableToWebReadableStream","stream","ReadableStream","Readable","toWeb","webToReadable","fromWeb","createFlightDataInjectionTransform","dataStream","delayDataUntilFirstHtmlChunk","htmlStreamFinished","pull","donePulling","startOrContinuePulling","target","startPulling","atLeastOneTask","iterator","Symbol","asyncIterator","done","value","next","push","err","destroy","nodeTransform","Transform","transform","chunk","_encoding","callback","flush","then","createHeadInsertionTransform","insert","inserted","hasBytes","insertion","Buffer","from","index","indexOfUint8Array","ENCODED_TAGS","CLOSED","HEAD","encodedInsertion","merged","allocUnsafe","length","set","slice","createMetadataTransform","chunkIndex","isMarkRemoved","iconMarkIndex","closedHeadIndex","iconMarkLength","META","ICON_MARK","replaced","subarray","insertionLength","createDeferredSuffixTransform","suffix","flushed","encodedSuffix","queueMicrotask","createMoveSuffixTransform","foundSuffix","BODY_AND_HTML","before","after","createHtmlDataDplIdTransform","dplId","didTransform","htmlTagIndex","OPENING","HTML","insertionPoint","encodedAttribute","modified","createRootLayoutValidatorTransform","foundHtml","foundBody","BODY","missingTags","map","c","join","MISSING_ROOT_TAGS_ERROR","ComponentMod","payload","clientModules","opts","renderToPipeableStream","Error","signal","renderOptions","pt","PassThrough","pipeable","pipe","aborted","abort","reason","onAbort","addEventListener","once","on","removeEventListener","element","streamOptions","options","shellReady","DetachedPromise","allReady","deferPipe","waitForAllReady","getTracer","trace","AppRenderSpan","renderToReadableStream","onHeaders","onShellReady","resolve","onShellError","error","reject","onAllReady","onError","waitShellReady","promise","waitAtLeastOneReactRenderTask","postponedState","runInContext","run","fn","resumeToPipeableStream","postponed","renderStream","inlinedDataStream","isStaticGeneration","deploymentId","getServerInsertedHTML","getServerInsertedMetadata","validateRootLayout","suffixUnclosed","split","CLOSE_TAG","buffered","createNodeBufferedTransformStream","source","metadata","deferredSuffix","flightInjection","rootLayoutValidator","moveSuffix","headInsertion","prerenderStream","webResult","webContinueStaticPrerender","webContinueDynamicPrerender","webContinueStaticFallbackPrerender","webContinueDynamicHTMLResume","streams","end","out","i","pipeNext","current","webStreamToBuffer","webStreamToString","nonce","formState","webSource","createInlinedDataReadableStream","startScriptTag","htmlEscapeAttributeString","scriptContents","htmlEscapeJsonString","JSON","stringify","INLINE_FLIGHT_PAYLOAD_BOOTSTRAP","INLINE_FLIGHT_PAYLOAD_FORM_STATE","pullFlightData","INLINE_FLIGHT_PAYLOAD_DATA","INLINE_FLIGHT_PAYLOAD_BINARY","output","waitForReadableOrEnd","readableLength","readableEnded","Promise","cleanup","removeListener","onDone","read","htmlInlinedData","isUtf8","decodedString","toString","base64","buffer","byteOffset","byteLength","webStream","webCreateDocumentClosingStream","appendHeader","headers","forEach","key","sentinel","isPartial","staleTime","transformed","pipeThrough","createRuntimePrefetchTransformStream","unprocessedPrelude","prelude","peek","tee","reader","getReader","firstResult","cancel","preludeIsEmpty","prerender","replayable","ReplayableNodeStream","createReplayStream"],"mappings":"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","ignoreList":[0]}