// packages/next/src/server/next-server.ts (constructor)
const { createWorker, createIpcServer } =
  require('./lib/server-ipc') as typeof import('./lib/server-ipc')
this.renderWorkersPromises = new Promise<void>(async (resolveWorkers) => {
  try {
    this.renderWorkers = {}
    const { ipcPort } = await createIpcServer(this)
    if (this.hasAppDir) {
      this.renderWorkers.app = createWorker(
        this.port || 0,
        ipcPort,
        options.isNodeDebugging,
        'app'
      )
    }
    this.renderWorkers.pages = createWorker(
      this.port || 0,
      ipcPort,
      options.isNodeDebugging,
      'pages'
    )
    this.renderWorkers.middleware =
      this.renderWorkers.pages || this.renderWorkers.app

    resolveWorkers()
    // 생략

export const createWorker = async (
  ipcPort: number,
  ipcValidationKey: string,
  isNodeDebugging: boolean | 'brk' | undefined,
  type: 'pages' | 'app',
  useServerActions?: boolean
) => {
  const { initialEnv } = require('@next/env') as typeof import('@next/env')
  const { Worker } = require('next/dist/compiled/jest-worker')

// server/ssr.js
createServer(async (req, res) => {
  try {
    const url = new URL(req.url, `http://${req.headers.host}`);
    if (url.pathname === "/client.js") {
      // ...
    }
    // Get the serialized JSX response from the RSC server
    const response = await fetch("http://127.0.0.1:8081" + url.pathname);
    if (!response.ok) {
      res.statusCode = response.status;
      res.end();
      return;
    }
    const clientJSXString = await response.text();
    if (url.searchParams.has("jsx")) {
      // If the user is navigating between pages, send that serialized JSX as is
      res.setHeader("Content-Type", "application/json");
      res.end(clientJSXString);
    } else {
      // If this is an initial page load, revive the tree and turn it into HTML
      const clientJSX = JSON.parse(clientJSXString, parseJSX);
      let html = renderToString(clientJSX);
      html += `<script>window.__INITIAL_CLIENT_JSX_STRING__ = `;
      html += JSON.stringify(clientJSXString).replace(/</g, "\\u003c");
      html += `</script>`;
      // ...
      res.setHeader("Content-Type", "text/html");
      res.end(html);
    }
  } catch (err) {
    // ...
  }
}).listen(8080);

// we can't use process.send as jest-worker relies on
// it already and can cause unexpected message errors
// so we create an IPC server for communicating
export const createWorker = async (

process.send({ foo: "bar" });

child.on("message", (msg) => {
  console.log("Received message:", msg);
});

// packages/next/src/server/next-server.ts (generateRoutes)
// 생략...
  if (this.renderWorkersPromises) {
    await this.renderWorkersPromises
    this.renderWorkersPromises = undefined
  }
  const renderWorker = this.renderWorkers?.[renderKind]

  if (renderWorker) {
    const initUrl = getRequestMeta(req, '__NEXT_INIT_URL')!
    const { port, hostname } = await renderWorker.initialize(
      this.renderWorkerOpts!
    )
    const renderUrl = new URL(initUrl)
    renderUrl.hostname = hostname
    renderUrl.port = port + ''

    let invokePathname = pathname
    const normalizedInvokePathname =
      this.localeNormalizer?.normalize(pathname)

    // 생략...
    const invokeRes = await invokeRequest(
      renderUrl.toString(),
      {
        headers: invokeHeaders,
        method: req.method,
      },
      getRequestMeta(req, '__NEXT_CLONABLE_BODY')?.cloneBodyStream()
    )
    // 생략...
    res.statusCode = invokeRes.statusCode
    res.statusMessage = invokeRes.statusMessage

    for await (const chunk of invokeRes) {
      this.streamResponseChunk(res as NodeNextResponse, chunk)
    }
    ;(res as NodeNextResponse).originalResponse.end()
    return {
      finished: true,
    }
  }
}

// packages/next/src/server/lib/server-ipc/invoke-request.ts
import { IncomingMessage } from "http";
import { filterReqHeaders } from "./utils";

export const invokeRequest = async (
  targetUrl: string,
  requestInit: {
    headers: IncomingMessage["headers"];
    method: IncomingMessage["method"];
  },
  readableBody?: import("stream").Readable
) => {
  const invokeHeaders = filterReqHeaders({
    ...requestInit.headers,
  }) as IncomingMessage["headers"];

  const invokeRes = await new Promise<IncomingMessage>(
    (resolveInvoke, rejectInvoke) => {
      const http = require("http") as typeof import("http");

      try {
        const invokeReq = http.request(
          targetUrl,
          {
            headers: invokeHeaders,
            method: requestInit.method,
          },
          (res) => {
            resolveInvoke(res);
          }
        );
        invokeReq.on("error", (err) => {
          rejectInvoke(err);
        });

        if (requestInit.method !== "GET" && requestInit.method !== "HEAD") {
          if (readableBody) {
            readableBody.pipe(invokeReq);
            readableBody.on("close", () => {
              invokeReq.end();
            });
          }
        } else {
          invokeReq.end();
        }
      } catch (err) {
        rejectInvoke(err);
      }
    }
  );

  return invokeRes;
};

class NextNodeServer extends BaseServer {
  protected streamResponseChunk(res: NodeNextResponse, chunk: any) {
    res.originalResponse.write(chunk);
    // 생략...
  }
}