const myModule = (() => {
  // Private scope -- not accessible outside
  const privateFoo = 'secret';
  const privateBar = () => privateFoo;

  // Public API -- only these are exposed
  return {
    getSecret: privateBar
  };
})();

myModule.getSecret();   // 'secret'
myModule.privateFoo;    // undefined -- truly private

(function(exports, require, module, __filename, __dirname) {
  // Your module code lives here
});

function loadModule(filename, module, require) {
  const wrappedSrc = `(function(module, exports, require, __filename, __dirname) {
    ${fs.readFileSync(filename, 'utf8')}
  })(module, module.exports, require, filename, dirname)`;
  eval(wrappedSrc);
}

require('myModule')
     |
     v
+-------------+     +--------------+
| 1. Resolve  |---->| Full path    |
|    path     |     | of the file  |
+-------------+     +--------------+
     |
     v
+-------------+     +------------------+
| 2. Check    |-YES>| Return cached    |
|    cache    |     | module.exports   |
+-------------+     +------------------+
     | NO
     v
+-------------+
| 3. Create   |  new Module({ id, exports: {}, loaded: false })
|    module   |
+-------------+
     |
     v
+-------------+
| 4. Cache it |  require.cache[resolvedPath] = module
|  (BEFORE    |  <-- Critical for circular deps!
|   loading!) |
+-------------+
     |
     v
+-------------+
| 5. Load &   |  Read file, wrap in function, execute
|    evaluate |
+-------------+
     |
     v
+-------------+
| 6. Return   |  return module.exports
|    exports  |
+-------------+

// exports is just a shorthand reference
exports === module.exports  // true (initially)

// Adding properties works fine
exports.hello = 'world';         // modifies module.exports
module.exports.hello = 'world';  // same thing

// Reassigning exports BREAKS the reference
exports = { hello: 'world' };    // exports now points to NEW object
                                 // module.exports is still {}

// Reassigning module.exports WORKS
module.exports = { hello: 'world' }; // this is what require() returns

require('X') from module at path Y:

1. If X is a core module (fs, path, http...)
   -> return core module

2. If X starts with './' or '/' or '../'
   -> resolve as file: X, X.js, X.json, X.node
   -> resolve as directory: X/index.js, X/index.json, X/index.node
   -> or check X/package.json -> "main" field

3. Otherwise (bare package name like 'lodash')
   -> look in ./node_modules/X
   -> look in ../node_modules/X
   -> look in ../../node_modules/X
   -> ... walk up to filesystem root

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

// a.js
const counter = require('./counter');
counter.increment();
counter.increment();

// b.js
const counter = require('./counter');
console.log(counter.getCount()); // 2 -- same instance as a.js!

// a.js
exports.loaded = false;
const b = require('./b');    // B starts loading here
exports.loaded = true;       // This runs AFTER b.js finishes
console.log('b.loaded:', b.loaded); // true

// b.js
const a = require('./a');    // Gets a's PARTIAL exports: { loaded: false }
exports.loaded = true;
console.log('a.loaded:', a.loaded); // false (!)

// Named exports
export const PI = 3.14159;
export function circleArea(r) { return PI * r ** 2; }

// Default export
export default class Logger { /* ... */ }

// Importing
import Logger, { PI, circleArea } from './math.js';
import { PI as pi } from './math.js';           // Rename
import * as math from './math.js';               // Namespace

// Conditional loading
if (needsFeature) {
  const { feature } = await import('./feature.js');
}

// Computed specifier
const lang = getUserLang();
const strings = await import(`./i18n/${lang}.js`);

Phase 1: PARSING
  Parse all source files, build dependency graph
  (static analysis -- no code runs)
       |
       v
Phase 2: INSTANTIATION
  Create live bindings for all exports/imports
  (memory allocated, connections made, no values yet)
       |
       v
Phase 3: EVALUATION
  Execute code in dependency order (deepest dependency first)
  (values flow through the live bindings)

// counter.mjs
export let count = 0;
export function increment() { count++; }

// main.mjs
import { count, increment } from './counter.mjs';
console.log(count);    // 0
increment();
console.log(count);    // 1 -- LIVE! reflects the change

count = 5;             // TypeError: read-only binding

// ESM importing CommonJS -- works
import cjsModule from './legacy.cjs';       // default = module.exports
import { named } from './legacy.cjs';       // may work (static analysis)

// CommonJS importing ESM -- must use import()
const esmModule = await import('./modern.mjs');