Challenge 2: Move Blocking Work Off the Event Loop — Possible Solution
====================================================================

BEFORE (blocks the event loop — every other request waits):

app.post("/reports/generate", (req, res) => {
  const result = generateHeavyReport(req.body.dataset); // synchronous, CPU-heavy
  res.json({ status: "success", data: result });
});

function generateHeavyReport(dataset: number[]): number {
  let total = 0;
  for (let i = 0; i < dataset.length; i++) {
    for (let j = 0; j < dataset.length; j++) {
      total += dataset[i] * dataset[j]; // deliberately expensive O(n^2) work
    }
  }
  return total;
}

AFTER (offloaded to a worker_thread):

// report-worker.ts — runs in a separate thread
import { parentPort, workerData } from "worker_threads";

function generateHeavyReport(dataset: number[]): number {
  let total = 0;
  for (let i = 0; i < dataset.length; i++) {
    for (let j = 0; j < dataset.length; j++) {
      total += dataset[i] * dataset[j];
    }
  }
  return total;
}

const result = generateHeavyReport(workerData.dataset as number[]);
parentPort?.postMessage(result);

// server.ts — main thread, event loop stays free
import { Worker } from "worker_threads";
import path from "path";

function runReportInWorker(dataset: number[]): Promise<number> {
  return new Promise((resolve, reject) => {
    const worker = new Worker(path.join(__dirname, "report-worker.js"), {
      workerData: { dataset },
    });
    worker.once("message", (result: number) => resolve(result));
    worker.once("error", reject);
    worker.once("exit", (code) => {
      if (code !== 0) reject(new Error(`Worker stopped with exit code ${code}`));
    });
  });
}

app.post("/reports/generate", async (req, res) => {
  const result = await runReportInWorker(req.body.dataset);
  res.json({ status: "success", data: result });
});

WHY THIS WORKS
--------------
- The original version runs generateHeavyReport() directly on Node's single
  JavaScript thread — while it runs, the event loop cannot process any
  other request, timer, or I/O callback, no matter how many are queued.
- Moving the same function into a worker_thread runs it on a genuinely
  separate OS thread; the main thread's event loop stays free to keep
  handling other requests while the worker computes.
- runReportInWorker() wraps the worker's message-passing in a Promise, so
  the route handler can simply `await` it — the request-handling code
  reads the same as the synchronous version, but no longer blocks anyone else.