// What is the output order?
setTimeout(() => console.log('1. setTimeout'), 0);

setImmediate(() => console.log('2. setImmediate'));

process.nextTick(() => console.log('3. nextTick'));

Promise.resolve().then(() => console.log('4. Promise.then'));

console.log('5. synchronous');

/*
  Output:
  5. synchronous          ← sync code runs first (call stack)
  3. nextTick             ← nextTick queue (before promises)
  4. Promise.then         ← promise microtask queue
  1. setTimeout           ← timers phase (may swap with setImmediate
  2. setImmediate           depending on when loop starts)
*/

// OUTSIDE an I/O callback — order of setTimeout vs setImmediate is UNDEFINED
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
// Could print either order — depends on OS timer resolution

// INSIDE an I/O callback — setImmediate ALWAYS wins
fs.readFile(__filename, () => {
  setTimeout(() => console.log('timeout'), 0);
  setImmediate(() => console.log('immediate')); // always first
});

// ❌ BLOCKS the event loop — no request served during this
function badRoute(req, res) {
  const data = fs.readFileSync('/huge-file.json');
  const parsed = JSON.parse(data);  // still on main thread
  res.send(parsed);
}

// ✅ Non-blocking — event loop is free while file is being read
async function goodRoute(req, res) {
  const data = await fs.promises.readFile('/huge-file.json');
  const parsed = JSON.parse(data); // JSON.parse still blocks! See below
  res.send(parsed);
}

// ✅ Offload CPU work to a worker thread
const { Worker } = require('worker_threads');
function parseInWorker(rawJson) {
  return new Promise((resolve, reject) => {
    const worker = new Worker(`
      const { workerData, parentPort } = require('worker_threads');
      parentPort.postMessage(JSON.parse(workerData));
    `, { eval: true, workerData: rawJson });
    worker.on('message', resolve);
    worker.on('error', reject);
  });
}

const { monitorEventLoopDelay } = require('perf_hooks');
const h = monitorEventLoopDelay({ resolution: 20 });
h.enable();

setInterval(() => {
  console.log(`Event loop lag: ${h.mean / 1e6}ms mean`);
}, 5000);

  ┌─────────────────────────────────────┐
  │   Your JavaScript Code (V8)         │  ← Single thread
  ├─────────────────────────────────────┤
  │   Node.js Core APIs (C++ bindings)  │
  ├─────────────────────────────────────┤
  │              libuv                   │
  │  ┌─────────────┐  ┌───────────────┐ │
  │  │ Event Loop  │  │  Thread Pool  │ │  ← 4 threads default
  │  │  (1 thread) │  │  (UV_THREADPOOL│ │     (max 128)
  │  └─────────────┘  │  _SIZE)       │ │
  │                   └───────────────┘ │
  ├─────────────────────────────────────┤
  │         Operating System            │
  │  (epoll/kqueue/IOCP - async I/O)    │
  └─────────────────────────────────────┘

1. fs.readFile('data.txt', callback)
   → Registers callback, hands work to libuv thread pool

2. Event loop continues processing other events (non-blocking)

3. A libuv thread performs the blocking OS read() call

4. Thread completes → posts result to event loop's poll queue

5. Poll phase picks it up → calls your callback on the main thread

const crypto = require('crypto');

// These 4 hashes run CONCURRENTLY on 4 libuv threads
// despite JavaScript initiating them "one after another"
for (let i = 0; i < 4; i++) {
  crypto.pbkdf2('password', 'salt', 100000, 64, 'sha512', (err, key) => {
    console.log(`Hash ${i} done`);
  });
}
// All 4 finish at roughly the same time — parallel on thread pool

// 5th one has to wait for a free thread (default pool = 4)
crypto.pbkdf2('password', 'salt', 100000, 64, 'sha512', (err, key) => {
  console.log('Hash 4 done — waited for a free thread');
});

// Simulating CPU work — blocks event loop for ~2 seconds
function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

app.get('/slow', (req, res) => {
  const result = fibonacci(44); // ← blocks ALL requests for ~2s
  res.send({ result });
});

// Fix: offload to worker thread
app.get('/fast', async (req, res) => {
  const result = await runInWorker(44); // non-blocking
  res.send({ result });
});

// ❌ Hard to read, error-prone, hard to maintain
fs.readFile('user.json', (err, userData) => {
  if (err) return handleError(err);
  db.getUser(userData.id, (err, user) => {
    if (err) return handleError(err);
    db.getOrders(user.id, (err, orders) => {
      if (err) return handleError(err);
      emailService.send(user.email, orders, (err) => {
        if (err) return handleError(err);
        console.log('Done!');  // deeply nested — "pyramid of doom"
      });
    });
  });
});

// ✅ Same logic — flat, readable, error handled in one place
async function processUser() {
  try {
    const userData = JSON.parse(await fs.promises.readFile('user.json'));
    const user   = await db.getUser(userData.id);
    const orders = await db.getOrders(user.id);
    await emailService.send(user.email, orders);
    console.log('Done!');
  } catch (err) {
    handleError(err); // one catch handles all failures
  }
}

// math.js
function add(a, b) { return a + b; }
module.exports = { add };

// app.js
const { add } = require('./math');
// Can also do this dynamically:
if (condition) {
  const utils = require('./utils'); // dynamic require — valid in CJS
}

// math.mjs
export function add(a, b) { return a + b; }

// app.mjs
import { add } from './math.mjs';  // must include extension

// Dynamic import — works in ESM (returns a Promise)
const { add } = await import('./math.mjs');

// __dirname equivalent in ESM
import { fileURLToPath } from 'url';
import { dirname } from 'path';
const __dirname = dirname(fileURLToPath(import.meta.url));

// counter.js
let count = 0;
module.exports = {
  increment: () => ++count,
  get: () => count
};

// app.js
const a = require('./counter');
const b = require('./counter'); // same cached object

a.increment();
console.log(b.get()); // → 1 (a and b are the SAME object)

// Force a fresh load (rare — testing, hot reload)
delete require.cache[require.resolve('./counter')];
const c = require('./counter'); // fresh copy, count = 0

// a.js
console.log('a.js loading');
const b = require('./b');          // triggers b.js to load
console.log('b.done =>', b.done);  // → true
module.exports = { done: true };

// b.js
console.log('b.js loading');
const a = require('./a');          // a is mid-load → gets {} (empty!)
console.log('a.done =>', a.done);  // → undefined (partial export)
module.exports = { done: true };

// See exactly where a module was loaded from:
console.log(require.resolve('express'));
// → /project/node_modules/express/index.js

// Inspect the full module cache:
console.log(Object.keys(require.cache));

// package.json "main" field controls which file is the entry
// package.json "exports" field (Node 12+) controls subpath exports
// package.json "type": "module" makes .js files use ESM

const p = new Promise((resolve, reject) => {
  // executor runs SYNCHRONOUSLY
  setTimeout(() => resolve(42), 1000);
});

p
  .then(val => {
    console.log('Got:', val);  // Got: 42
    return val * 2;           // value passed to next .then
  })
  .then(val => console.log('Doubled:', val))  // Doubled: 84
  .catch(err => console.error('Error:', err))  // catches any error above
  .finally(() => console.log('Done'));          // always runs, passes value through

console.log('1 — sync');

Promise.resolve('hello')
  .then(v => console.log('3 —', v)); // microtask — runs AFTER sync code

console.log('2 — sync');

// Output: 1 — sync, 2 — sync, 3 — hello
// Even though the Promise is already resolved, .then fires asynchronously

// ❌ Missing return — next .then gets undefined
fetch('/api/user')
  .then(res => {
    res.json();  // ← no return!
  })
  .then(user => console.log(user)); // → undefined

// ✅ Correct — return the promise so it chains
fetch('/api/user')
  .then(res => res.json())      // returns the json() Promise
  .then(user => console.log(user)); // gets the actual user object

// ❌ Nested .then — defeats the purpose of chaining
fetch('/api/user')
  .then(res => res.json()
    .then(user => fetch(`/api/orders/${user.id}`)
      .then(r => r.json())));

// ✅ Flat chain — return the inner promise to the outer chain
fetch('/api/user')
  .then(res    => res.json())
  .then(user   => fetch(`/api/orders/${user.id}`))
  .then(res    => res.json())
  .then(orders => console.log(orders))
  .catch(err   => console.error(err)); // one handler for all

// These two are functionally equivalent:

async function fetchUser(id) {
  const res  = await fetch(`/api/users/${id}`);
  const user = await res.json();
  return user;
}

function fetchUser(id) {
  return fetch(`/api/users/${id}`)
    .then(res => res.json());
}

// async always returns a Promise — even plain values get wrapped:
async function getValue() { return 42; }
getValue().then(console.log); // logs 42 — it IS a Promise

// await works on any thenable — even plain values:
const a = await 42;           // valid — wraps in Promise.resolve(42)
const b = await Promise.resolve('hello');

async function demo() {
  console.log('A');
  await Promise.resolve(); // suspends here — schedules resume as microtask
  console.log('C');         // runs AFTER the current sync code finishes
}

demo();
console.log('B');

// Output: A → B → C
// "B" runs before "C" because await yields to the event loop

// ❌ user is a Promise object, not a user!
async function bad() {
  const user = getUser(1);   // forgot await
  console.log(user.name);     // → undefined (no crash!)
}

// ✅
async function good() {
  const user = await getUser(1);
  console.log(user.name);  // works
}

// ❌ forEach ignores returned Promises — items process uncontrolled
async function processAll(items) {
  items.forEach(async (item) => {
    await processItem(item);
  });
  console.log('Done?'); // prints BEFORE items finish!
}

// ✅ Option A: for...of (sequential)
async function processSequential(items) {
  for (const item of items) {
    await processItem(item);  // truly waits for each
  }
  console.log('Done');
}

// ✅ Option B: Promise.all (parallel)
async function processParallel(items) {
  await Promise.all(items.map(item => processItem(item)));
  console.log('Done');
}

// ❌ Total time: 300ms (100 + 200) — these are independent!
async function slow() {
  const user   = await getUser(1);    // waits 100ms
  const orders = await getOrders(1);  // then waits 200ms
}

// ✅ Total time: ~200ms (run together)
async function fast() {
  const [user, orders] = await Promise.all([
    getUser(1),    // both start at the same time
    getOrders(1)
  ]);
}

// ✅ try/catch — standard for async functions
async function fetchData(url) {
  try {
    const res = await fetch(url);
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return await res.json();
  } catch (err) {
    console.error('Fetch failed:', err.message);
    throw err; // re-throw so caller can decide
  }
}

// ✅ Global safety net — last resort, NOT a substitute for local handling
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1); // explicit crash is safer than corrupt state
});

// ✅ Express: async route errors are NOT caught by default
const asyncHandler = fn => (req, res, next) =>
  Promise.resolve(fn(req, res, next)).catch(next); // forwards to error middleware

app.get('/user/:id', asyncHandler(async (req, res) => {
  const user = await getUser(req.params.id);
  res.json(user);
}));

// ❌ The catch block never runs
async function tricky() {
  try {
    setTimeout(async () => {
      await mightFail(); // error thrown here...
    }, 1000);
    // ...but the try block has already exited by then!
  } catch (err) {
    console.log('never runs');
  }
}

// ✅ Move the try/catch inside the callback
setTimeout(async () => {
  try { await mightFail(); }
  catch (err) { handleError(err); }
}, 1000);

// ❌ If task2 rejects, you lose task1 and task3 results entirely
try {
  const [a, b, c] = await Promise.all([task1(), task2(), task3()]);
} catch (err) {
  // only know SOMETHING failed, not which one
}

// ✅ allSettled when you need every result regardless of failures
const results = await Promise.allSettled([task1(), task2(), task3()]);
results.forEach((r, i) => {
  if (r.status === 'fulfilled') console.log(`task${i+1}:`, r.value);
  else                           console.error(`task${i+1} failed:`, r.reason);
});

// ❌ This outer try/catch does NOT catch errors thrown inside .then()
try {
  somePromise().then(result => {
    throw new Error('oops'); // becomes a rejected Promise
  });
} catch (e) {
  console.log('never runs');
}

// ✅ Errors in .then() are caught by the next .catch() in the chain
somePromise()
  .then(result => { throw new Error('oops'); })
  .catch(e => console.log('caught:', e.message)); // works

const p1 = new Promise(r => setTimeout(() => r('A'), 100));
const p2 = new Promise(r => setTimeout(() => r('B'), 200));
const p3 = new Promise((_, r) => setTimeout(() => r(new Error('C failed')), 150));

// .all — all or nothing
await Promise.all([p1, p2]);         // → ['A', 'B'] after 200ms
await Promise.all([p1, p2, p3]);   // throws at 150ms, A still pending

// .allSettled — always waits, gives status for each
await Promise.allSettled([p1, p2, p3]);
// → [{status:'fulfilled', value:'A'},
//    {status:'fulfilled', value:'B'},
//    {status:'rejected',  reason: Error}]

// .race — first to settle wins (resolve OR reject)
await Promise.race([p1, p2, p3]);  // → 'A' at 100ms

// .any — first to RESOLVE (skips rejections)
await Promise.any([p3, p1, p2]);  // → 'A' at 100ms (p3 rejection ignored)
await Promise.any([p3]);           // throws AggregateError (all rejected)

function withTimeout(promise, ms) {
  const timer = new Promise((_, reject) =>
    setTimeout(() => reject(new Error(`Timed out after ${ms}ms`)), ms)
  );
  return Promise.race([promise, timer]);
}

const data = await withTimeout(fetchData(), 5000);

// ❌ Fires ALL 1000 requests simultaneously
const results = await Promise.all(urls.map(url => fetch(url)));

// ✅ Process max 5 at a time using a worker-pool pattern
async function pLimit(taskFns, concurrency) {
  const results = new Array(taskFns.length);
  let cursor = 0;

  async function worker() {
    while (cursor < taskFns.length) {
      const i = cursor++;
      results[i] = await taskFns[i](); // each worker picks next available task
    }
  }

  // Start `concurrency` workers — they race to consume tasks
  await Promise.all(Array.from({ length: concurrency }, worker));
  return results;
}

const tasks = urls.map(url => () => fetch(url).then(r => r.json()));
const results = await pLimit(tasks, 5); // max 5 in-flight at any time

// Or use the battle-tested p-limit package (same idea, more robust):
import pLimit from 'p-limit';
const limit = pLimit(5);
const out = await Promise.all(
  urls.map(url => limit(() => fetch(url).then(r => r.json())))
);

// Async generator — produces pages lazily, on demand
async function* paginate(url) {
  let page = 1;
  while (true) {
    const data = await fetch(`${url}?page=${page}`).then(r => r.json());
    if (!data.length) break;
    yield data;     // pause until consumer asks for next
    page++;
  }
}

// Consumer controls the pace — next page only fetched when loop body finishes
for await (const page of paginate('/api/users')) {
  await processPage(page);  // slow processing doesn't flood the API
}

// Node.js Readable streams are async iterables (Node 10+):
const stream = createReadStream('large-file.txt', { encoding: 'utf8' });
for await (const chunk of stream) {
  process(chunk); // backpressure handled automatically
}

// Promise — single value, resolves once
const data = await fetchUser(1); // done, can't receive more

// EventEmitter — producer pushes multiple values (push model)
const stream = getDataStream();
stream.on('data', chunk => process(chunk)); // producer controls pace
stream.on('end',  () => console.log('done'));
stream.on('error', err => handleError(err));

// Async Generator — consumer pulls values (pull model)
async function* getDataStream() {
  yield await fetch('/chunk/1').then(r => r.json());
  yield await fetch('/chunk/2').then(r => r.json());
}
for await (const chunk of getDataStream()) {
  await process(chunk); // next fetch only starts when I'm ready
}

// Node Readable stream can be consumed BOTH ways:
const rs = fs.createReadStream('file.txt');
rs.on('data', chunk => ...);    // push style
for await (const chunk of rs) ... // pull style (same stream)

  Character:   H     e     l     l     o
  Decimal:     72    101   108   108   111
  Hex:         0x48  0x65  0x6c  0x6c  0x6f
  Binary:      01001000 01100101 01101100 01101100 01101111

  Buffer:     <Buffer 48 65 6c 6c 6f>  ← Node.js shows hex by default

const buf = Buffer.from('Hello');
console.log(buf);           // <Buffer 48 65 6c 6c 6f>  (hex values)
console.log(buf[0]);        // 72  — decimal value of 'H'
console.log(buf.length);    // 5   — bytes, not characters

// ⚠ bytes ≠ characters for non-ASCII text
const euro = Buffer.from('€');
console.log(euro.length);   // 3  — '€' needs 3 bytes in UTF-8
console.log('€'.length);   // 1  — JS string measures in UTF-16 code units

// Buffer IS a Uint8Array (subclass check)
console.log(buf instanceof Uint8Array);      // true
console.log(Buffer.isBuffer(buf));           // true
console.log(Buffer.isBuffer(new Uint8Array(5))); // false

// Buffer.from — create from existing data
Buffer.from('hello', 'utf8')         // from string with encoding
Buffer.from([0x48, 0x65, 0x6c])     // from array of byte values
Buffer.from(anotherBuf)              // copy of another buffer

// Buffer.alloc — safe zeroed memory
const safe = Buffer.alloc(10);
console.log(safe); // <Buffer 00 00 00 00 00 00 00 00 00 00> — all zeros

// Buffer.allocUnsafe — fast but raw memory (may contain old bytes!)
const unsafe = Buffer.allocUnsafe(10);
// May print: <Buffer a3 00 f2 11 ...> — leftover garbage from other processes
unsafe.fill(0); // you MUST zero it yourself before using

const buf = Buffer.from('hello');

buf.toString('utf8')    // → 'hello'        (human-readable text)
buf.toString('hex')     // → '68656c6c6f'    (good for debugging)
buf.toString('base64')  // → 'aGVsbG8='      (good for HTTP/JSON)

// Round-trip: base64 → Buffer → utf8
const encoded = buf.toString('base64');           // 'aGVsbG8='
const decoded = Buffer.from(encoded, 'base64').toString(); // 'hello'

// Utility operations
const combined = Buffer.concat([buf1, buf2, buf3]); // join multiple buffers
const isEqual  = buf1.equals(buf2);               // constant-time compare (safe for crypto)

const fs   = require('fs');
const zlib = require('zlib');

// Readable — produces data from disk chunk by chunk
const readable = fs.createReadStream('input.txt', {
  highWaterMark: 64 * 1024  // 64 KB internal buffer (default)
});

// Transform — compresses each chunk as it flows through
const gzip = zlib.createGzip();

// Writable — writes compressed chunks to a file
const writable = fs.createWriteStream('output.txt.gz');

// pipe() connects them: readable feeds gzip which feeds writable
readable.pipe(gzip).pipe(writable);

// Listening to events from each stream
readable.on('data',   chunk => console.log('read chunk:', chunk.length));
readable.on('end',   () => console.log('reading done'));
writable.on('finish', () => console.log('file fully written'));
readable.on('error',  err => console.error('read error:', err));

                    ┌──────────────────────────────────┐
                    │  Created — starts in PAUSED mode │
                    └──────────────┬───────────────────┘
                                   │
          ┌────────────────────────▼──────────────────────────┐
          │                   PAUSED MODE                      │
          │  Data sits in internal buffer waiting to be pulled │
          │  You call stream.read() to get a chunk             │
          └──────┬──────────────────────────────┬─────────────┘
                 │                              │
    ┌────────────▼──────────┐     ┌─────────────▼────────────┐
    │ stream.on('data', …)  │     │       stream.pipe()       │
    │ stream.resume()       │     │  (also switches to flow)  │
    └────────────┬──────────┘     └─────────────┬────────────┘
                 │                              │
          ┌──────▼──────────────────────────────▼─────────────┐
          │                  FLOWING MODE                       │
          │  Stream pushes data to you as fast as it arrives   │
          │  'data' event fires for every chunk                │
          └────────────────────────┬───────────────────────────┘
                                   │
                         stream.pause() / stream.unpipe()
                                   │
                             back to PAUSED

const stream = fs.createReadStream('file.txt');
// Stream starts paused — nothing flowing yet

stream.on('readable', () => {
  // This fires whenever data becomes available in the internal buffer
  let chunk;
  while ((chunk = stream.read(1024)) !== null) {
    // read(1024) pulls exactly 1024 bytes at a time
    // returns null when the internal buffer is empty
    processChunk(chunk);
  }
});

stream.on('end', () => console.log('All data consumed'));

const stream = fs.createReadStream('file.txt');

// Attaching 'data' immediately switches to FLOWING mode
stream.on('data', chunk => {
  console.log('Got chunk of', chunk.length, 'bytes');

  // If processing this chunk is slow, pause the stream:
  stream.pause();                       // stop the flow
  doSlowWork(chunk).then(() => {
    stream.resume();                     // resume when ready
  });
});

stream.on('end',  () => console.log('stream finished'));
stream.on('error', err => console.error('error:', err));

// In practice: pipe() does the pause/resume automatically
stream.pipe(writable); // you almost never manage modes manually

  Producer (network, disk)   →   [internal buffer]   →   Consumer (disk, DB)
  reads: 500 MB/s                  fills up!               writes: 10 MB/s

  Without backpressure: buffer grows until OOM crash
  With backpressure:    producer pauses when buffer is full, resumes on drain

// pipe() is roughly equivalent to this:
readable.on('data', (chunk) => {
  const ok = writable.write(chunk);
  // write() returns false when the internal buffer is full (highWaterMark reached)
  if (!ok) {
    readable.pause();               // stop asking for more data
    writable.once('drain', () => {
      readable.resume();             // writable has space again — keep going
    });
  }
});
readable.on('end', () => writable.end());

// pipe() does all of this for you in one line:
readable.pipe(writable);

// Default highWaterMark = 16 KB for byte streams
const stream = fs.createReadStream('file.txt', {
  highWaterMark: 64 * 1024  // 64 KB chunks — larger = fewer I/O ops, more memory
});

// For object streams (highWaterMark = 16 objects by default)
const objectStream = new Readable({
  objectMode: true,
  highWaterMark: 100  // buffer up to 100 objects
});

FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory

 1: 0xb7c9e0 node::Abort() [node]
 ...
Aborted (core dumped)

# Your entire server is dead. Every active request is dropped.
# Users get connection refused. Logs stop. Alerts fire.

const src  = fs.createReadStream('/dev/urandom'); // fast source
const dest = fs.createWriteStream('output.bin');    // slow sink

// ❌ Ignores backpressure — writable buffer grows without bound
src.on('data', (chunk) => {
  dest.write(chunk); // return value ignored — buffer fills up!
});
// Result: dest's internal buffer balloons → GC pressure → eventual OOM

src.on('data', (chunk) => {
  const canContinue = dest.write(chunk); // false = buffer full
  if (!canContinue) {
    src.pause();                             // stop producing
    dest.once('drain', () => src.resume()); // resume when drained
  }
});
src.on('end', () => dest.end());

// ✅ pipe() — handles backpressure, but errors don't propagate
src.pipe(dest);

// ✅ pipeline() — handles backpressure AND errors AND cleanup
const { pipeline } = require('stream/promises');

await pipeline(
  fs.createReadStream('huge.txt'),
  zlib.createGzip(),
  fs.createWriteStream('huge.txt.gz')
);
// If any stream errors: all streams destroyed, file descriptors closed

const { Transform } = require('stream');

class UpperCaseTransform extends Transform {
  _transform(chunk, encoding, callback) {
    // chunk is a Buffer (or string if decodeStrings: false)
    const upper = chunk.toString().toUpperCase();
    this.push(upper);  // push to readable side
    callback();        // signal chunk is fully processed (ready for next)
    // shorthand: callback(null, upper) — push + signal in one call
  }

  _flush(callback) {
    // Input ended — push anything remaining (e.g. buffered partial lines)
    this.push('\n--- END OF DOCUMENT ---\n');
    callback();
  }
}

// Usage
fs.createReadStream('input.txt')
  .pipe(new UpperCaseTransform())
  .pipe(fs.createWriteStream('output.txt'));

class CSVLineParser extends Transform {
  constructor() {
    super({ objectMode: true }); // output objects, not Buffers
    this._buffer = '';
    this._headers = null;
  }

  _transform(chunk, _, cb) {
    this._buffer += chunk.toString();
    const lines = this._buffer.split('\n');
    this._buffer = lines.pop();     // keep incomplete last line

    for (const line of lines) {
      if (!this._headers) { this._headers = line.split(','); continue; }
      const vals = line.split(',');
      const row  = Object.fromEntries(this._headers.map((h, i) => [h, vals[i]]));
      this.push(row);  // push parsed object downstream
    }
    cb();
  }

  _flush(cb) {
    if (this._buffer.trim()) this.push(/* parse last line */);
    cb();
  }
}

  Duplex:
  [write side] ──────────────────────── you write data in
  [read  side] ──────────────────────── data comes out (independently produced)
  ↑ Two unconnected pipes sharing one object

  Transform:
  [write side] → [_transform()] → [read side]
  ↑ Data written in flows through your logic and emerges out the other end

const { Duplex, Transform } = require('stream');

// Duplex — read and write sides are completely independent
class EchoDuplex extends Duplex {
  _read(size) {
    // Produce data for the readable side (independently)
    this.push('data from readable side');
    this.push(null);  // end the readable side
  }
  _write(chunk, enc, cb) {
    // Handle incoming writes (independently of _read)
    console.log('received:', chunk.toString());
    cb();
  }
}

// Transform — writable input IS the readable output (transformed)
class ReverseTransform extends Transform {
  _transform(chunk, enc, cb) {
    // What comes in, goes out reversed
    const reversed = chunk.toString().split('').reverse().join('');
    cb(null, reversed); // push reversed chunk to readable side
  }
}

const fs       = require('fs');
const readline = require('readline');

// ❌ Loads entire 2 GB log file into memory
const content = fs.readFileSync('huge.log', 'utf8');
const errors  = content.split('\n').filter(l => l.includes('ERROR'));

// ✅ Streams line by line — constant ~64 KB memory
const rl = readline.createInterface({
  input: fs.createReadStream('huge.log'),
  crlfDelay: Infinity
});

const errors = [];
for await (const line of rl) {
  if (line.includes('ERROR')) errors.push(line);
}

// ✅ Stream file download directly to disk without buffering in memory
const { pipeline } = require('stream/promises');
const https = require('https');

https.get('https://example.com/huge-file.zip', async (response) => {
  await pipeline(response, fs.createWriteStream('huge-file.zip'));
  // HTTP response IS a Readable stream — no temp buffer needed
});

const r = fs.createReadStream('in.txt');
const z = zlib.createGzip();
const w = fs.createWriteStream('out.gz');

r.pipe(z).pipe(w);

// ❌ If r errors (file not found):
//   - Error event emitted on r
//   - z and w are NOT destroyed
//   - w's file descriptor stays open → resource leak!
//   - Unhandled 'error' event crashes the process

// To do it properly with pipe() you need this boilerplate:
[r, z, w].forEach(s => s.on('error', err => {
  [r, z, w].forEach(s => s.destroy());
  console.error(err);
}));

const { pipeline } = require('stream/promises');
const fs   = require('fs');
const zlib = require('zlib');

async function compress(input, output) {
  try {
    await pipeline(
      fs.createReadStream(input),
      zlib.createGzip(),
      fs.createWriteStream(output)
    );
    console.log('Compressed successfully');
  } catch (err) {
    console.error('Compression failed:', err.message);
    // All three streams are already destroyed — no cleanup needed
  }
}

// pipeline also accepts async generators as stages:
await pipeline(
  fs.createReadStream('data.csv'),
  async function* (source) {
    for await (const chunk of source) {
      yield chunk.toString().toUpperCase();  // transform inline
    }
  },
  fs.createWriteStream('data-upper.csv')
);

// ❌ This FREEZES the event loop for ~2 seconds on a modern CPU
//    Every other request waits. Health checks time out. Metrics drop.
app.get('/hash', (req, res) => {
  const result = expensiveHash(req.body.data); // runs for 2s on main thread
  res.json({ result });
});

// ❌ Making it async does NOT fix the problem
//    "await" only helps if there's I/O to yield on
app.get('/hash', async (req, res) => {
  const result = await expensiveHash(req.body.data); // still 2s on main thread!
  res.json({ result });
});

const { Worker } = require('worker_threads');

app.get('/hash', (req, res) => {
  const worker = new Worker('./hash-worker.js', {
    workerData: { data: req.body.data }
  });

  worker.once('message', result => res.json({ result }));
  worker.once('error',   err    => res.status(500).json({ error: err.message }));
  // Main thread event loop is FREE while the worker runs
});

const { Worker, isMainThread, workerData } = require('worker_threads');

// isMainThread is true when this code runs on the main thread
if (isMainThread) {
  const worker = new Worker(__filename, {    // run THIS file as worker too
    workerData: { n: 42 }                  // data passed to the worker
  });

  worker.on('message', (result) => {
    console.log('Fibonacci result:', result);  // 267914296
  });

  worker.on('error', (err) => {
    console.error('Worker error:', err);
  });

  worker.on('exit', (code) => {
    if (code !== 0) console.error('Worker stopped with exit code', code);
  });

  console.log('Main thread continues — not blocked!');

} else {
  // This branch runs inside the worker thread
  const { parentPort, workerData } = require('worker_threads');

  function fib(n) {
    return n <= 1 ? n : fib(n - 1) + fib(n - 2); // expensive!
  }

  const result = fib(workerData.n);    // workerData = { n: 42 }
  parentPort.postMessage(result);       // send result to main thread
}

// Main thread sends progress requests, worker reports back
const worker = new Worker('./worker.js');

worker.on('message', ({ type, data }) => {
  if (type === 'progress') console.log('Progress:', data + '%');
  if (type === 'result')   console.log('Done:', data);
});

worker.postMessage({ cmd: 'start', payload: 'large dataset' });

// worker.js
parentPort.on('message', ({ cmd, payload }) => {
  if (cmd === 'start') {
    for (let i = 0; i <= 100; i += 10) {
      doChunk(payload, i);
      parentPort.postMessage({ type: 'progress', data: i });
    }
    parentPort.postMessage({ type: 'result', data: 'processed' });
  }
});

// ✅ Structured Clone handles all of these:
worker.postMessage('hello');                        // string
worker.postMessage({ a: 1, b: [2, 3] });             // plain objects/arrays
worker.postMessage(Buffer.from('data'));              // Buffer (copied)
worker.postMessage(new Map([['key', 'val']]));       // Map, Set, Date, RegExp
worker.postMessage(new Error('oops'));               // Error objects

// ❌ Structured Clone CANNOT handle these:
worker.postMessage(() => {});          // Functions — throws DataCloneError
worker.postMessage(Promise.resolve()); // Promises — throws DataCloneError
worker.postMessage(myClassInstance);   // Custom class methods are lost

// ❌ Copy — 100 MB Buffer is duplicated (slow, doubles memory usage)
const buf = Buffer.allocUnsafe(100 * 1024 * 1024);
worker.postMessage({ buf }); // copies all 100 MB

// ✅ Transfer — zero-copy, instantaneous, buf is now empty here
const ab = new ArrayBuffer(100 * 1024 * 1024);
worker.postMessage({ ab }, [ab]); // second arg = transferList
console.log(ab.byteLength); // 0 — ownership transferred, can't use here

// Transferable types: ArrayBuffer, MessagePort, ImageBitmap, OffscreenCanvas

// Main thread creates the shared buffer
const sharedBuffer = new SharedArrayBuffer(4); // 4 bytes = one Int32
const view = new Int32Array(sharedBuffer);

const worker = new Worker('./worker.js', {
  workerData: { sharedBuffer }  // buffer is SHARED, not copied
});

view[0] = 0;  // initial value

worker.on('message', () => {
  console.log('Value written by worker:', view[0]); // sees worker's write!
});

// worker.js
const { workerData, parentPort } = require('worker_threads');
const view = new Int32Array(workerData.sharedBuffer);
view[0] = 42;          // written directly to shared memory
parentPort.postMessage('done'); // notify main thread

  Thread A: reads value = 0
  Thread B: reads value = 0        ← both read before either writes
  Thread A: adds 1 → result = 1
  Thread B: adds 1 → result = 1
  Thread A: writes 1
  Thread B: writes 1               ← overwrites Thread A's write!
  Final value: 1   (expected: 2)   ← one increment was lost!

const sab  = new SharedArrayBuffer(4);
const view = new Int32Array(sab);

// ❌ Not safe — two threads can race
view[0]++;

// ✅ Safe — atomic add: read+add+write as one uninterruptible step
Atomics.add(view, 0, 1);       // add 1 to index 0
Atomics.sub(view, 0, 1);       // subtract 1
Atomics.store(view, 0, 99);    // write 99
Atomics.load(view, 0);         // read safely
Atomics.compareExchange(view, 0, 99, 100); // if 99, swap to 100

// Atomics.wait — blocks the thread until value changes (like a mutex)
Atomics.wait(view, 0, 0);       // sleep until view[0] != 0
Atomics.notify(view, 0, 1);    // wake one waiting thread

const { Worker } = require('worker_threads');
const os          = require('os');

class WorkerPool {
  constructor(workerFile, size = os.cpus().length) {
    this.queue   = [];             // pending tasks
    this.workers = [];             // all worker instances
    this.free    = [];             // idle workers

    for (let i = 0; i < size; i++) {
      const worker = new Worker(workerFile);
      this.workers.push(worker);
      this.free.push(worker);
    }
  }

  run(data) {
    return new Promise((resolve, reject) => {
      const task = { data, resolve, reject };
      if (this.free.length) {
        this._dispatch(this.free.pop(), task);
      } else {
        this.queue.push(task); // all busy — wait in queue
      }
    });
  }

  _dispatch(worker, { data, resolve, reject }) {
    worker.once('message', (result) => {
      resolve(result);
      if (this.queue.length) {
        this._dispatch(worker, this.queue.shift()); // next task
      } else {
        this.free.push(worker); // return to idle pool
      }
    });
    worker.once('error', reject);
    worker.postMessage(data);
  }
}

// Usage
const pool = new WorkerPool('./hash-worker.js'); // one worker per core
const result = await pool.run({ input: 'data to hash' });

const worker = new Worker('./worker.js', { workerData: { n: 10 } });

worker.on('message', (result) => {
  console.log('Result:', result);
});

worker.on('error', (err) => {
  // Worker threw an unhandled exception
  console.error('Worker error:', err.message);
  // Spawn a replacement worker if needed
});

worker.on('exit', (code) => {
  if (code !== 0) {
    console.error('Worker exited with code', code);
    // code 0 = clean exit, non-zero = crash or process.exit(N)
  }
});

// Inside the worker — propagate errors explicitly:
parentPort.on('message', async (data) => {
  try {
    const result = await doWork(data);
    parentPort.postMessage({ ok: true, result });
  } catch (err) {
    // Don't throw — postMessage the error so main thread can handle it
    parentPort.postMessage({ ok: false, error: err.message });
  }
});

// Terminate a worker that is taking too long (timeout pattern)
const timeout = setTimeout(() => {
  worker.terminate(); // forcefully ends the worker thread
  reject(new Error('Worker timed out'));
}, 5000);

worker.once('message', (result) => {
  clearTimeout(timeout);
  resolve(result);
});

# Increase before starting Node — must be set before any I/O operations
UV_THREADPOOL_SIZE=16 node server.js

// Or in code (must be set VERY early, before any I/O):
process.env.UV_THREADPOOL_SIZE = '16';

// Useful when: many concurrent crypto operations, many simultaneous
// fs calls, or many DNS lookups — these all compete for the 4 libuv threads.
// Unlike Worker Threads, increasing this does NOT help pure JS computation.

  1. Is this work CPU-bound (not waiting on I/O)?    → if no: async/await is enough
  2. Does it take > a few milliseconds?              → if no: overhead > benefit
  3. Does it happen frequently enough to warrant a pool?
  4. Is the data small enough that serialization cost is acceptable?
     (or can I use SharedArrayBuffer / Transferable?)
  5. Can I structure the task as a standalone script?
     (workers can't share closures, class instances, or open DB connections)

  ── REQUEST (browser → server) ──────────────────────────────────
  GET /users/42 HTTP/1.1\r\n
  Host: api.example.com\r\n
  Accept: application/json\r\n
  Connection: keep-alive\r\n
  \r\n                          ← blank line = end of headers
  (no body for GET)

  ── RESPONSE (server → browser) ─────────────────────────────────
  HTTP/1.1 200 OK\r\n
  Content-Type: application/json\r\n
  Content-Length: 27\r\n
  \r\n
  {"id":42,"name":"Alice"}     ← body

const http = require('http');

const server = http.createServer((req, res) => {
  // req = IncomingMessage (Readable stream)
  // res = ServerResponse  (Writable stream)

  console.log(req.method, req.url);   // "GET /users/42"
  console.log(req.headers['accept']);  // "application/json"
  console.log(req.httpVersion);       // "1.1"

  // Route matching (what Express does under the hood)
  if (req.method === 'GET' && req.url === '/health') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'ok' }));
    return;
  }

  // Default 404
  res.writeHead(404, { 'Content-Type': 'text/plain' });
  res.end('Not Found');
});

server.listen(3000, () => console.log('Server on :3000'));

// server.listen() calls the OS bind() + listen() syscalls
// Node then polls for new connections via libuv

const http = require('http');
const { URL } = require('url');

http.createServer(async (req, res) => {

  // ── 1. Parse URL and query parameters ───────────────────────────
  const url    = new URL(req.url, 'http://localhost');
  const path   = url.pathname;          // "/users/42"
  const page   = url.searchParams.get('page'); // "?page=2" → "2"

  // ── 2. Route parameter extraction (manual regex) ─────────────────
  const match  = path.match(/^\/users\/(\d+)$/);
  const userId = match?.[1]; // "42" (string — remember to parseInt)

  // ── 3. Read headers ──────────────────────────────────────────────
  const contentType = req.headers['content-type']; // always lowercase
  const auth        = req.headers['authorization'];

  // ── 4. Parse the request BODY (streaming) ────────────────────────
  const parseBody = (req) => new Promise((resolve, reject) => {
    const chunks = [];
    req.on('data', (chunk) => chunks.push(chunk));
    req.on('end',  () => resolve(Buffer.concat(chunks).toString()));
    req.on('error', reject);
  });

  if (req.method === 'POST') {
    const rawBody = await parseBody(req);

    if (contentType?..includes('application/json')) {
      const body = JSON.parse(rawBody);  // now you have your object
    } else if (contentType?..includes('application/x-www-form-urlencoded')) {
      const params = new URLSearchParams(rawBody); // form fields
    }
  }

  res.end('ok');
}).listen(3000);

const parseBody = (req, maxBytes = 1 * 1024 * 1024) => new Promise((resolve, reject) => {
  const chunks = [];
  let total = 0;

  req.on('data', (chunk) => {
    total += chunk.length;
    if (total > maxBytes) {
      req.destroy();  // abort the connection immediately
      reject(new Error('Request body too large'));
      return;
    }
    chunks.push(chunk);
  });
  req.on('end',  () => resolve(Buffer.concat(chunks).toString()));
  req.on('error', reject);
});

const https = require('https');

const req = https.request({
  hostname: 'api.github.com',
  path:     '/users/torvalds',
  method:   'GET',
  headers:  { 'User-Agent': 'Node.js' }
}, (res) => {
  // res is a Readable stream of the response body
  console.log('Status:', res.statusCode);

  const chunks = [];
  res.on('data', chunk => chunks.push(chunk));
  res.on('end', () => {
    const body = JSON.parse(Buffer.concat(chunks).toString());
    console.log(body.name); // "Linus Torvalds"
  });
});

req.on('error', err => console.error(err));
req.end(); // must call end() to signal no body (even for GET)

// Native fetch — available globally in Node 18+
const getUser = async (id) => {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 5000); // 5s timeout

  try {
    const res = await fetch(`https://api.example.com/users/${id}`, {
      signal: controller.signal,
      headers: { 'Authorization': `Bearer ${process.env.TOKEN}` }
    });

    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return await res.json();
  } finally {
    clearTimeout(timeout);
  }
};

  Without keep-alive (HTTP/1.0 default):
  Request 1: SYN → SYN-ACK → ACK → GET /a → 200 → FIN (connection closed)
  Request 2: SYN → SYN-ACK → ACK → GET /b → 200 → FIN (new connection!)
  Request 3: SYN → SYN-ACK → ACK → GET /c → 200 → FIN (new connection!)

  With keep-alive (HTTP/1.1 default):
  SYN → SYN-ACK → ACK
  → GET /a → 200
  → GET /b → 200   ← reusing same socket, no new handshake
  → GET /c → 200
  → FIN (one close for all three)

const https  = require('https');

const agent = new https.Agent({
  keepAlive:    true,   // reuse sockets (default: false in Node <19)
  maxSockets:   50,    // max concurrent connections per host:port
  maxFreeSockets: 10, // max idle sockets to keep in pool
  timeout:      60000 // socket timeout in ms
});

// Pass agent to each request:
fetch('https://api.example.com/data', { agent });

// Or set globally for all https requests:
https.globalAgent.keepAlive = true;

// ⚠ agent: false means NO pooling — new socket per request
//   Use this only for one-off requests or when testing
fetch('https://api.example.com/one-off', { agent: false });

const https = require('https');
const fs    = require('fs');

const options = {
  key:  fs.readFileSync('server.key'),   // private key (keep secret!)
  cert: fs.readFileSync('server.cert'),  // public certificate (share freely)

  // Modern TLS hardening:
  minVersion: 'TLSv1.2',   // reject TLS 1.0 / 1.1 (deprecated, insecure)
  ciphers: 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256' // TLS 1.3 only
};

https.createServer(options, (req, res) => {
  res.end('Secure!');
}).listen(443);

// In production: use nginx/Caddy as TLS terminator in front of Node.
// Node handles HTTP on port 3000; nginx handles TLS on port 443 and proxies.

// Server requires a client certificate (used for service-to-service auth)
https.createServer({
  key:                fs.readFileSync('server.key'),
  cert:               fs.readFileSync('server.cert'),
  ca:                 fs.readFileSync('ca.cert'),   // trusted CA for clients
  requestCert:        true,                          // ask for client cert
  rejectUnauthorized: true                           // reject if cert invalid
}, (req, res) => {
  const cert = req.socket.getPeerCertificate();
  console.log('Client CN:', cert.subject.CN);
  res.end('Hello trusted client');
}).listen(443);

  HTTP/1.1 (one connection, serial):
  ──[GET /api/users]──[response]──[GET /api/posts]──[response]──

  HTTP/2 (one connection, multiplexed streams):
  Stream 1: ──[GET /api/users]─────────[response]──
  Stream 2:    ──[GET /api/posts]──[response]──
  Stream 3:       ──[GET /static/app.js]─────[response]──
  All running in parallel on the same TCP connection

const http2 = require('http2');
const fs    = require('fs');

// HTTP/2 requires TLS in browsers (h2c = cleartext only for testing)
const server = http2.createSecureServer({
  key:  fs.readFileSync('server.key'),
  cert: fs.readFileSync('server.cert')
});

server.on('stream', (stream, headers) => {
  // Each request is a "stream" with an ID (1, 3, 5, 7...)
  const path = headers[':path'];    // pseudo-header (HTTP/2 specific)
  const method = headers[':method'];

  if (path === '/') {
    // Server push — send CSS before browser requests it
    stream.pushStream({ ':path': '/style.css' }, (err, push) => {
      if (!err) {
        push.respond({ ':status': 200, 'content-type': 'text/css' });
        push.end('body { color: red }');
      }
    });
  }

  stream.respond({ ':status': 200, 'content-type': 'text/html' });
  stream.end('<html>Hello HTTP/2!</html>');
});

server.listen(443);

  ── CLIENT REQUEST ──────────────────────────────────────────────
  GET /chat HTTP/1.1
  Host: server.example.com
  Upgrade: websocket
  Connection: Upgrade
  Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
  Sec-WebSocket-Version: 13

  ── SERVER RESPONSE (101 = switching protocols) ─────────────────
  HTTP/1.1 101 Switching Protocols
  Upgrade: websocket
  Connection: Upgrade
  Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

  ── NOW SPEAKING WEBSOCKET FRAMES (not HTTP anymore) ────────────
  [frame] [frame] [frame] ... (bidirectional, any time)

const { WebSocketServer } = require('ws');
const http  = require('http');

const httpServer = http.createServer((req, res) => {
  res.end('HTTP server running'); // handle regular HTTP requests
});

// Attach WebSocket server to the same HTTP server
const wss = new WebSocketServer({ server: httpServer });

wss.on('connection', (ws, req) => {
  const ip = req.socket.remoteAddress;
  console.log('New connection from', ip);

  ws.on('message', (data, isBinary) => {
    const msg = isBinary ? data : data.toString();
    console.log('Received:', msg);

    // Broadcast to all connected clients
    wss.clients.forEach(client => {
      if (client.readyState === client.OPEN) {
        client.send(msg);
      }
    });
  });

  ws.on('close', (code, reason) => {
    console.log('Disconnected:', code, reason.toString());
  });

  ws.on('error', err => console.error('WS error:', err));

  ws.send('Welcome!'); // server sends first
});

httpServer.listen(3000);

function heartbeat() { this.isAlive = true; }

wss.on('connection', (ws) => {
  ws.isAlive = true;
  ws.on('pong', heartbeat); // client responds to our ping
});

// Every 30 seconds, ping all clients. Kill ones that didn't pong.
setInterval(() => {
  wss.clients.forEach(ws => {
    if (ws.isAlive === false) { ws.terminate(); return; }
    ws.isAlive = false;
    ws.ping(); // ws library sends WS ping frame
  });
}, 30_000);

const net = require('net');

// ── TCP Server ───────────────────────────────────────────────────
const server = net.createServer((socket) => {
  // socket is a Duplex stream — you can read and write bytes
  console.log('Client connected:', socket.remoteAddress);

  socket.on('data', (data) => {
    console.log('Received:', data.toString()); // raw bytes
    socket.write('Echo: ' + data);            // write back
  });

  socket.on('end',   () => console.log('Client disconnected'));
  socket.on('error', (err) => console.error('Socket error:', err));
});

server.listen(8080, () => console.log('TCP server on :8080'));

// ── TCP Client ───────────────────────────────────────────────────
const client = net.connect({ port: 8080 }, () => {
  client.write('Hello server!');
});
client.on('data', data => console.log(data.toString())); // "Echo: Hello server!"

// Server: listen on a file path instead of a port
net.createServer(handler).listen('/tmp/myapp.sock');

// Client: connect via file path
net.connect('/tmp/myapp.sock');

// Used by: nginx ↔ Node.js, PM2 process manager, Redis on localhost
// ~30% faster than loopback TCP (127.0.0.1) for local IPC

const server = http.createServer(app).listen(3000);

async function shutdown(signal) {
  console.log(`${signal} received — graceful shutdown`);

  await new Promise(resolve => server.close(resolve)); // stop new connections
  await db.close();           // close DB pool
  await redisClient.quit(); // close Redis connection

  console.log('Shutdown complete');
  process.exit(0);
}

process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT',  () => shutdown('SIGINT'));  // Ctrl+C

// Safety net — force exit if graceful shutdown hangs
setTimeout(() => { console.error('Forced exit'); process.exit(1); }, 30_000).unref();

const server = http.createServer(handler);

// 1. Keep-alive timeout — how long to hold an idle persistent connection
server.keepAliveTimeout = 65_000; // must be > load balancer's idle timeout

// 2. Headers timeout — how long to wait for request headers to arrive
server.headersTimeout = 60_000;

// 3. Request timeout — total time allowed for the full request cycle
server.requestTimeout = 300_000; // Node 14+

// 4. Socket timeout — per-socket idle timeout (no data for N ms)
server.setTimeout(120_000, (socket) => {
  socket.destroy(); // socket went idle — destroy it
});

# Install once
npm install -g clinic

# Run your server under clinic's harness
clinic doctor -- node server.js

# In another terminal, generate load
npx autocannon -c 100 -d 30 http://localhost:3000

# When done, Ctrl+C — clinic opens HTML report automatically
# It shows: event loop delay, CPU usage, memory over time

# For detailed flame graphs:
clinic flame -- node server.js

# For async/await timing issues:
clinic bubbleprof -- node server.js

  ┌─────────────────────────────────────────────────────────┐
  │  JSON.parse           [████████████████]   ← WIDE = SLOW │
  │  parseBody            [████████████████████]             │
  │  routeHandler         [██████████████████████████]       │
  │  http.Server.emit     [████████████████████████████████] │
  └─────────────────────────────────────────────────────────┘

  X-axis  → NOT time order — it is sorted alphabetically
            (so adjacent bars are NOT related in time)
  Y-axis  → call stack depth (bottom = root, top = leaf)
  Width   → proportion of CPU time spent in that function
            (wider = more samples = more CPU consumed)

  🔴 Hot path: wide bars near the TOP of the stack
     These are the actual bottlenecks — the functions doing real work.
  🟡 Wide bars in the MIDDLE: a function that calls slow children
     (fix the children, not the parent)
  🟣 "Plateau" bars: a function running flat across the graph
     = blocking the event loop — nothing else ran during that time

  JSON.stringify / JSON.parse  → large objects, run in worker or use faster-json
  RegExp                       → catastrophic backtracking — rewrite regex or use re2
  crypto.pbkdf2Sync            → blocking crypto — use async version or worker
  fs.readFileSync              → blocking I/O — replace with createReadStream
  Array.sort on large arrays   → move to worker or optimise comparator
  Deep object cloning          → avoid lodash.cloneDeep on hot paths

// ✅ GOOD — both objects have same property order → share hidden class C2
//    V8 can use fast fixed-offset property access (like C struct)
const a = { x: 1, y: 2 }; // hidden class: C0 → C1 (add x) → C2 (add y)
const b = { x: 3, y: 4 }; // same shape → shares C2 → fast!

// ❌ BAD — different property order → different hidden classes → slower
const c = { x: 1, y: 2 }; // hidden class C2
const d = { y: 4, x: 3 }; // different class C4 — two separate layouts!

// ❌ BAD — adding properties after creation creates new hidden classes
const e = {};
e.x = 1; // C0 → C1
e.y = 2; // C1 → C2 (transition OK if always in this order)

// ❌ WORST — deleting properties destroys hidden class sharing
delete e.x; // forces dictionary mode — all property access becomes slow

// 1. Type change mid-function
function add(a, b) { return a + b; }
add(1, 2);       // V8 optimises assuming a,b are always Numbers
add('hi', 'yo'); // ❌ type changed → DEOPT → back to interpreter

// 2. try/catch around hot code (historically; mostly fixed in modern V8)
function hotPath() {
  try { /* hot work */ } catch(e) {}  // can prevent optimisation
}

// 3. arguments object (old pattern — use rest params instead)
function old() { return arguments[0]; }   // ❌ arguments prevents opt
function modern(...args) { return args[0]; } // ✅ rest params are fine

// 4. for...in on objects with prototype properties (use Object.keys instead)
// 5. eval() — prevents all optimisation of the enclosing function
// 6. with statement — same issue

# Print every deopt to stdout with reason and source location
node --trace-deopt server.js

# Example output:
# [deoptimize] reason: wrong type at [doWork] /app/server.js:42
# [deoptimize] reason: lost precision at [parseAmount] /app/parser.js:17

# See all V8 optimisation decisions:
node --trace-opt --trace-deopt server.js 2>&1 | grep -E "(optimiz|deoptim)"

# Or use the --allow-natives-syntax flag + %OptimizationStatus() in tests
node --allow-natives-syntax -e "
  function add(a,b){ return a+b; }
  add(1,2); add(1,2);
  %OptimizeFunctionOnNextCall(add);
  add(1,2);
  console.log(%GetOptimizationStatus(add)); // 2 = optimized
"

  ┌─────────────────────────────────────────────────────────────┐
  │                    V8 HEAP                                   │
  │                                                             │
  │  ┌──────────────┐  ┌──────────────┐  ┌───────────────────┐ │
  │  │  Young Gen   │  │   Old Gen    │  │   Large Objects   │ │
  │  │  (Nursery)   │  │  (Tenured)   │  │   Space           │ │
  │  │              │  │              │  │                   │ │
  │  │ New objects  │  │ Survived 2+  │  │ Objects > 512 KB  │ │
  │  │ live here    │  │ minor GCs    │  │ live here         │ │
  │  │ ~1–8 MB      │  │ ~1.4 GB max  │  │ allocated once    │ │
  │  │ GC: fast     │  │ GC: slow     │  │ GC: full heap     │ │
  │  └──────────────┘  └──────────────┘  └───────────────────┘ │
  │                                                             │
  │  OUTSIDE HEAP (not managed by V8 GC):                       │
  │  Buffer data, ArrayBuffer data — allocated via C++ malloc   │
  └─────────────────────────────────────────────────────────────┘

// 1. Using the perf_hooks PerformanceObserver
const { PerformanceObserver } = require('perf_hooks');

const obs = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    console.log('GC type:', entry.detail.kind,
               'duration:', entry.duration.toFixed(2), 'ms');
  }
});
obs.observe({ type: 'gc' });

// 2. Heap statistics via process.memoryUsage()
const mem = process.memoryUsage();
console.log({
  heapUsed:  (mem.heapUsed  / 1024 / 1024).toFixed(1) + ' MB',  // JS objects
  heapTotal: (mem.heapTotal / 1024 / 1024).toFixed(1) + ' MB',  // V8 heap capacity
  external:  (mem.external  / 1024 / 1024).toFixed(1) + ' MB',  // Buffer / C++ memory
  rss:       (mem.rss       / 1024 / 1024).toFixed(1) + ' MB'   // total process RSS
});

// 3. Expose GC logs at runtime
node --expose-gc server.js  // enables global.gc() to trigger GC manually
node --trace-gc  server.js  // prints every GC event with type + duration

// 1. Unbounded caches / collections (most common leak)
const cache = {}; // grows forever — never evicts
app.get('/user/:id', (req, res) => {
  cache[req.params.id] = fetchUser(req.params.id); // every userId ever hit → leak
});
// Fix: use a Map with a max size (LRU cache) or WeakMap for object keys

// 2. Event emitter listener accumulation
function addHandler() {
  emitter.on('data', (d) => process(d)); // adds a new listener on every call!
}
// Fix: use .once() or remove listener in cleanup; check emitter.listenerCount()

// 3. Closure retaining large objects
function buildHandler(largeData) {  // 50 MB object
  return (req, res) => {
    const id = largeData.id;  // closure keeps largeData alive in memory
    res.send(id);
  };
}
// Fix: only close over what you need — const id = largeData.id; (then largeData can GC)

// 4. Circular references with external resources
class Connection {
  constructor() {
    this.socket = createSocket();
    this.socket.conn = this; // circular — neither can GC
  }
}

// Simple measurement using setTimeout baseline
function measureLag() {
  const start = Date.now();
  setTimeout(() => {
    const lag = Date.now() - start; // should be ~0, anything > 50ms is a problem
    if (lag > 50) console.warn('Event loop lag:', lag, 'ms');
    measureLag(); // schedule next measurement
  }, 0);
}
measureLag();

// Production-grade: use Node.js built-in monitorEventLoopDelay (Node 11+)
const { monitorEventLoopDelay } = require('perf_hooks');
const h = monitorEventLoopDelay({ resolution: 20 }); // sample every 20ms
h.enable();

setInterval(() => {
  console.log({
    mean:  (h.mean / 1e6).toFixed(2),    // nanoseconds → ms
    p99:   (h.percentile(99) / 1e6).toFixed(2),
    max:   (h.max / 1e6).toFixed(2)
  });
  h.reset();
}, 5000);

const cluster = require('cluster');
const http    = require('http');
const os      = require('os');
const numCPUs = os.cpus().length;

if (cluster.isPrimary) {
  console.log(`Primary ${process.pid} forking ${numCPUs} workers`);

  for (let i = 0; i < numCPUs; i++) cluster.fork();

  cluster.on('exit', (worker, code) => {
    console.warn(`Worker ${worker.process.pid} died (code ${code}) — respawning`);
    cluster.fork(); // auto-restart crashed workers
  });

} else {
  // Each worker runs its own HTTP server on the same port
  http.createServer((req, res) => {
    res.end(`Worker ${process.pid} handled this`);
  }).listen(3000, () => {
    console.log(`Worker ${process.pid} listening`);
  });
}

// Node's built-in LRU via a bounded Map (Map preserves insertion order)
class LRUCache {
  constructor(maxSize = 500) {
    this.cache   = new Map();
    this.maxSize = maxSize;
  }
  get(key) {
    if (!this.cache.has(key)) return undefined;
    const val = this.cache.get(key);
    this.cache.delete(key); this.cache.set(key, val); // move to end (MRU)
    return val;
  }
  set(key, val) {
    if (this.cache.has(key)) this.cache.delete(key);
    else if (this.cache.size >= this.maxSize)
      this.cache.delete(this.cache.keys().next().value); // evict LRU (first entry)
    this.cache.set(key, val);
  }
}

// 1. Cache-Control: max-age — browser caches for N seconds, no server hit
res.setHeader('Cache-Control', 'public, max-age=3600'); // 1 hour

// 2. ETag — fingerprint of the response; conditional GET saves bandwidth
const etag = crypto(body);
res.setHeader('ETag', etag);
if (req.headers['if-none-match'] === etag) {
  res.writeHead(304); res.end(); return; // Not Modified — no body sent!
}

// 3. Stale-While-Revalidate — serve stale immediately, refresh in background
res.setHeader('Cache-Control', 'public, max-age=60, stale-while-revalidate=300');
// Browser serves cached version instantly; background request updates cache

// 4. Cache-Control: private — per-user data, only browser caches (not CDN)
res.setHeader('Cache-Control', 'private, max-age=0, must-revalidate');

# Install
npm install -g autocannon

# Basic benchmark: 100 connections, 30 seconds
autocannon -c 100 -d 30 http://localhost:3000/api/users

# Output shows:
# Stat    | 2.5% | 50%  | 97.5% | 99%  | Avg     | Stdev | Max
# Latency | 4 ms | 7 ms | 18 ms | 45ms | 8.2 ms  | 3.1   | 234ms
# Req/Sec | 9200 |10500 | 11400 | ...  | 10213.5 | ...

# POST with JSON body
autocannon -c 50 -d 20 \
  -m POST \
  -H 'Content-Type: application/json' \
  -b '{"name":"test"}' \
  http://localhost:3000/api/users

# Programmatic use in Node
const autocannon = require('autocannon');
const result = await autocannon.run({ url: 'http://localhost:3000', connections: 100 });
console.log(autocannon.printResult(result));