undefined

```bash

In TypeScript, mark hot sections explicitly for DevTools profiling:

```typescript
// Wrap suspected hot paths to isolate them in profiles
function processItems(items: Item[]): Result[] {
  console.time('processItems');
  const result = items.map(transform);
  console.timeEnd('processItems');
  return result;
}

import { writeHeapSnapshot } from 'v8';
import { setInterval } from 'timers';

// Snapshot 1: baseline
writeHeapSnapshot(); // writes Heap-<pid>-<seq>.heapsnapshot

// Simulate load / time passing
await runWorkload();

// Snapshot 2: after suspected leak
writeHeapSnapshot();
// Load both files in Chrome DevTools > Memory > Compare snapshots

class Cache {
  private store = new Map<string, WeakRef<object>>();
  private registry = new FinalizationRegistry((key: string) => {
    this.store.delete(key); // auto-cleanup when value is GC'd
  });

  set(key: string, value: object): void {
    this.store.set(key, new WeakRef(value));
    this.registry.register(value, key);
  }

  get(key: string): object | undefined {
    return this.store.get(key)?.deref();
  }
}

import Benchmark from 'benchmark';

const suite = new Benchmark.Suite();

suite
  .add('Array.from', () => {
    Array.from({ length: 1000 }, (_, i) => i * 2);
  })
  .add('for loop', () => {
    const arr: number[] = new Array(1000);
    for (let i = 0; i < 1000; i++) arr[i] = i * 2;
  })
  .on('cycle', (event: Benchmark.Event) => {
    console.log(String(event.target));
  })
  .on('complete', function (this: Benchmark.Suite) {
    console.log('Fastest: ' + this.filter('fastest').map('name'));
  })
  .run({ async: true });

import { performance, PerformanceObserver } from 'perf_hooks';

// Detect event loop lag
let lastCheck = Date.now();
setInterval(() => {
  const lag = Date.now() - lastCheck - 100; // expected 100ms
  if (lag > 50) console.warn(`Event loop lag: ${lag}ms`);
  lastCheck = Date.now();
}, 100).unref();

import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';

// main-thread side
function runCPUTask(data: unknown): Promise<unknown> {
  return new Promise((resolve, reject) => {
    const worker = new Worker(__filename, { workerData: data });
    worker.on('message', resolve);
    worker.on('error', reject);
  });
}

// worker side
if (!isMainThread) {
  const result = heavyComputation(workerData);
  parentPort?.postMessage(result);
}

undefined

Apply tree shaking with named imports:

```typescript
// Bad - imports entire lodash (~70KB)
import _ from 'lodash';
const result = _.debounce(fn, 300);

// Good - imports only debounce (~2KB)
import debounce from 'lodash/debounce';
const result = debounce(fn, 300);

// React lazy loading - splits route into separate chunk
import { lazy, Suspense } from 'react';

const Dashboard = lazy(() => import('./pages/Dashboard'));

function App() {
  return (
    <Suspense fallback={<Spinner />}>
      <Dashboard />
    </Suspense>
  );
}

import { onCLS, onINP, onLCP, onFCP, onTTFB } from 'web-vitals';

function sendToAnalytics(metric: { name: string; value: number; rating: string }) {
  navigator.sendBeacon('/analytics', JSON.stringify(metric));
}

onCLS(sendToAnalytics);   // Cumulative Layout Shift - target < 0.1
onINP(sendToAnalytics);   // Interaction to Next Paint - target < 200ms
onLCP(sendToAnalytics);   // Largest Contentful Paint - target < 2.5s
onFCP(sendToAnalytics);
onTTFB(sendToAnalytics);

import { performance } from 'perf_hooks';

function withTiming<T>(name: string, fn: () => Promise<T>): Promise<T> {
  const start = performance.now();
  return fn().finally(() => {
    const duration = performance.now() - start;
    metrics.histogram(name, duration); // send to Datadog/Prometheus
  });
}

// Usage
const user = await withTiming('db.getUser', () => db.users.findById(id));

import DataLoader from 'dataloader';

// Without DataLoader: 1 query per user = N+1
// With DataLoader: batches into 1 query per tick
const userLoader = new DataLoader(async (ids: readonly string[]) => {
  const users = await db.users.findMany({ where: { id: { in: [...ids] } } });
  const map = new Map(users.map((u) => [u.id, u]));
  return ids.map((id) => map.get(id) ?? null);
});

// Each call is automatically batched
const user = await userLoader.load(userId);

import { Pool } from 'pg';

const pool = new Pool({
  max: 20,           // max connections - tune to (2 * CPU cores + 1) as starting point
  idleTimeoutMillis: 30_000,
  connectionTimeoutMillis: 2_000,
});

// Always release connections - use try/finally
const client = await pool.connect();
try {
  const result = await client.query('SELECT ...', [params]);
  return result.rows;
} finally {
  client.release(); // critical - never omit
}