// An object is LIVE if it is reachable from a root (global, stack, closure):
let obj = { name: 'Alice', data: new Array(1000) }
// obj is reachable → NOT collected

obj = null
// The original object is now unreachable → eligible for collection

// Circular references do NOT prevent collection — V8 traces reachability from roots,
// not reference counts:
function createCycle() {
  const a: any = {}
  const b: any = {}
  a.b = b
  b.a = a
  // a and b reference each other, but neither is reachable from outside this function.
  // When the function returns, both are collected.
}

New Space (young generation): two equal semi-spaces ("from" and "to")

Before Scavenge:
  from-space: [obj-A (dead)] [obj-B (live)] [obj-C (dead)] [obj-D (live, survived once)]
  to-space:   [empty]

Scavenge runs:
  1. Trace from roots → find live objects in from-space: B and D
  2. Copy B → to-space (first survival)
  3. Copy D → OLD SPACE (second survival = promoted)
  4. Swap from/to spaces — entire from-space is now free (no per-object free needed)

After Scavenge:
  from-space: [empty — the new "to-space" for next GC]
  to-space:   [obj-B]
  old-space:  [obj-D (promoted)]

Duration: microseconds to low milliseconds

Old Space GC — three phases:

1. MARK: Trace all live objects from roots, set a "mark bit" on each.
         V8 does this INCREMENTALLY — the main thread does a small slice,
         then yields to JavaScript, then resumes — avoiding one long pause.

2. SWEEP: Scan Old Space for unmarked (dead) objects. Free their memory.
          Add freed slots to free-lists for future allocations.
          Also done concurrently on helper threads.

3. COMPACT (optional): Move live objects together to reduce fragmentation.
          This STOPS THE WORLD — can cause 10–100ms+ pauses on large heaps.
          V8 compacts only the most fragmented pages to limit pause time.

node --trace-gc server.js

// Or observe GC events programmatically with perf_hooks:
import { PerformanceObserver, constants } from 'node:perf_hooks'

const obs = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    const detail = entry.detail as any
    console.log(`GC [${detail.kind === constants.NODE_PERFORMANCE_GC_MINOR ? 'minor' : 'major'}]`,
      `duration: ${entry.duration.toFixed(2)}ms`)
  }
})
obs.observe({ entryTypes: ['gc'] })

// WeakRef: hold a reference that doesn't prevent GC
const cache = new Map<string, WeakRef<ExpensiveObject>>()

function get(key: string): ExpensiveObject | undefined {
  return cache.get(key)?.deref()   // deref() returns undefined if GC'd
}

function set(key: string, obj: ExpensiveObject) {
  cache.set(key, new WeakRef(obj))
}

// FinalizationRegistry: run a callback when an object is GC'd
const registry = new FinalizationRegistry((key: string) => {
  cache.delete(key)   // clean up the Map entry when the value is GC'd
  console.log(`Cache entry ${key} was GC'd`)
})

function setWithCleanup(key: string, obj: ExpensiveObject) {
  cache.set(key, new WeakRef(obj))
  registry.register(obj, key)
}