Inside JavaScript Execution Contexts: How V8 Manages Scope and This

┌─────────────────────────────────────────────────────────────────────────────┐
│                      EXECUTION CONTEXT STRUCTURE                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌───────────────────────────────────────────────────────────────────────┐ │
│  │                        EXECUTION CONTEXT                              │ │
│  │  ┌─────────────────────────────────────────────────────────────────┐ │ │
│  │  │                    Lexical Environment                          │ │ │
│  │  │  ┌───────────────────────────────────────────────────────────┐ │ │ │
│  │  │  │              Environment Record                           │ │ │ │
│  │  │  │  • let/const bindings                                     │ │ │ │
│  │  │  │  • function declarations                                  │ │ │ │
│  │  │  │  • class declarations                                     │ │ │ │
│  │  │  │  • import bindings                                        │ │ │ │
│  │  │  └───────────────────────────────────────────────────────────┘ │ │ │
│  │  │  ┌───────────────────────────────────────────────────────────┐ │ │ │
│  │  │  │        Outer Environment Reference                        │ │ │ │
│  │  │  │  Points to parent lexical environment                     │ │ │ │
│  │  │  │  (forms scope chain)                                      │ │ │ │
│  │  │  └───────────────────────────────────────────────────────────┘ │ │ │
│  │  └─────────────────────────────────────────────────────────────────┘ │ │
│  │                                                                       │ │
│  │  ┌─────────────────────────────────────────────────────────────────┐ │ │
│  │  │                   Variable Environment                          │ │ │
│  │  │  ┌───────────────────────────────────────────────────────────┐ │ │ │
│  │  │  │              Environment Record                           │ │ │ │
│  │  │  │  • var bindings                                           │ │ │ │
│  │  │  │  • function declarations (hoisted)                        │ │ │ │
│  │  │  └───────────────────────────────────────────────────────────┘ │ │ │
│  │  │  ┌───────────────────────────────────────────────────────────┐ │ │ │
│  │  │  │        Outer Environment Reference                        │ │ │ │
│  │  │  └───────────────────────────────────────────────────────────┘ │ │ │
│  │  └─────────────────────────────────────────────────────────────────┘ │ │
│  │                                                                       │ │
│  │  ┌─────────────────────────────────────────────────────────────────┐ │ │
│  │  │                      This Binding                               │ │ │
│  │  │  • undefined (strict mode, no receiver)                         │ │ │
│  │  │  • global object (sloppy mode)                                  │ │ │
│  │  │  • object (method call)                                         │ │ │
│  │  │  • new.target (constructor)                                     │ │ │
│  │  └─────────────────────────────────────────────────────────────────┘ │ │
│  └───────────────────────────────────────────────────────────────────────┘ │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

// Execution Context Types
enum ExecutionContextType {
  GLOBAL = 'global',
  FUNCTION = 'function',
  EVAL = 'eval',
  MODULE = 'module',
}

interface ExecutionContext {
  type: ExecutionContextType;
  lexicalEnvironment: LexicalEnvironment;
  variableEnvironment: VariableEnvironment;
  thisBinding: ThisBinding;

  // V8-specific fields
  code: BytecodeArray;
  scriptOrModule: Script | Module;
  realm: Realm;

  // For generators/async
  generator?: GeneratorObject;
}

interface LexicalEnvironment {
  environmentRecord: EnvironmentRecord;
  outerEnvironment: LexicalEnvironment | null;
}

interface VariableEnvironment {
  environmentRecord: EnvironmentRecord;
  outerEnvironment: VariableEnvironment | null;
}

// Environment Record Types
type EnvironmentRecord =
  | DeclarativeEnvironmentRecord  // Most common: functions, blocks
  | ObjectEnvironmentRecord       // with statements, global
  | GlobalEnvironmentRecord       // Global scope
  | FunctionEnvironmentRecord     // Functions (extends declarative)
  | ModuleEnvironmentRecord;      // ES modules

interface DeclarativeEnvironmentRecord {
  type: 'declarative';
  bindings: Map<string, Binding>;
}

interface Binding {
  value: any;
  mutable: boolean;  // false for const
  initialized: boolean;  // TDZ tracking
  deletable: boolean;  // true for eval declarations
}

interface ObjectEnvironmentRecord {
  type: 'object';
  bindingObject: object;
  withEnvironment: boolean;  // true for 'with' statements
}

interface GlobalEnvironmentRecord {
  type: 'global';
  objectRecord: ObjectEnvironmentRecord;  // var, function declarations
  declarativeRecord: DeclarativeEnvironmentRecord;  // let, const, class
  globalThis: object;
  varNames: Set<string>;
}

interface FunctionEnvironmentRecord extends DeclarativeEnvironmentRecord {
  thisValue: any;
  thisBindingStatus: 'lexical' | 'initialized' | 'uninitialized';
  functionObject: Function;
  newTarget?: Function;  // For constructor calls
}

class ExecutionContextManager {
  private stack: ExecutionContext[] = [];
  private globalContext: ExecutionContext;

  constructor(globalObject: object) {
    this.globalContext = this.createGlobalContext(globalObject);
    this.stack.push(this.globalContext);
  }

  // Create global execution context
  createGlobalContext(globalObject: object): ExecutionContext {
    const globalEnvRecord: GlobalEnvironmentRecord = {
      type: 'global',
      objectRecord: {
        type: 'object',
        bindingObject: globalObject,
        withEnvironment: false,
      },
      declarativeRecord: {
        type: 'declarative',
        bindings: new Map(),
      },
      globalThis: globalObject,
      varNames: new Set(),
    };

    const globalEnv: LexicalEnvironment = {
      environmentRecord: globalEnvRecord,
      outerEnvironment: null,
    };

    return {
      type: ExecutionContextType.GLOBAL,
      lexicalEnvironment: globalEnv,
      variableEnvironment: globalEnv,
      thisBinding: globalObject,
      code: null!,
      scriptOrModule: null!,
      realm: this.createRealm(globalObject),
    };
  }

  // Create function execution context
  createFunctionContext(
    func: FunctionObject,
    thisValue: any,
    args: any[],
    newTarget?: Function
  ): ExecutionContext {
    // 1. Determine this binding
    const thisBinding = this.resolveThisBinding(func, thisValue, newTarget);

    // 2. Create function environment record
    const funcEnvRecord: FunctionEnvironmentRecord = {
      type: 'declarative',
      bindings: new Map(),
      thisValue: thisBinding,
      thisBindingStatus: func.isArrowFunction ? 'lexical' : 'initialized',
      functionObject: func,
      newTarget,
    };

    // 3. Set up variable environment (for var declarations)
    const varEnv: VariableEnvironment = {
      environmentRecord: funcEnvRecord,
      outerEnvironment: func.scope,  // Closure!
    };

    // 4. Set up lexical environment (for let/const)
    const lexEnv: LexicalEnvironment = {
      environmentRecord: funcEnvRecord,
      outerEnvironment: func.scope,
    };

    // 5. Bind parameters
    this.bindParameters(funcEnvRecord, func.formalParameters, args);

    // 6. Create arguments object (if needed)
    if (!func.isArrowFunction && !func.isStrict) {
      this.createArgumentsObject(funcEnvRecord, args, func);
    }

    return {
      type: ExecutionContextType.FUNCTION,
      lexicalEnvironment: lexEnv,
      variableEnvironment: varEnv,
      thisBinding,
      code: func.code,
      scriptOrModule: func.scriptOrModule,
      realm: func.realm,
    };
  }

  // Create block context (for let/const in blocks)
  createBlockContext(currentContext: ExecutionContext): LexicalEnvironment {
    return {
      environmentRecord: {
        type: 'declarative',
        bindings: new Map(),
      },
      outerEnvironment: currentContext.lexicalEnvironment,
    };
  }

  private resolveThisBinding(
    func: FunctionObject,
    thisArg: any,
    newTarget?: Function
  ): any {
    // Arrow functions don't have their own this
    if (func.isArrowFunction) {
      return undefined;  // Will use lexical this
    }

    // Constructor call
    if (newTarget) {
      return Object.create(func.prototype || Object.prototype);
    }

    // Strict mode: use thisArg as-is
    if (func.isStrict) {
      return thisArg;
    }

    // Sloppy mode: coerce to object, default to global
    if (thisArg === null || thisArg === undefined) {
      return this.globalContext.thisBinding;
    }

    return Object(thisArg);
  }

  private bindParameters(
    envRecord: FunctionEnvironmentRecord,
    params: Parameter[],
    args: any[]
  ): void {
    for (let i = 0; i < params.length; i++) {
      const param = params[i];

      if (param.type === 'Identifier') {
        // Simple parameter
        envRecord.bindings.set(param.name, {
          value: args[i],
          mutable: true,
          initialized: true,
          deletable: false,
        });
      } else if (param.type === 'RestElement') {
        // Rest parameter: ...args
        envRecord.bindings.set(param.argument.name, {
          value: args.slice(i),
          mutable: true,
          initialized: true,
          deletable: false,
        });
        break;
      } else if (param.type === 'AssignmentPattern') {
        // Default parameter: x = 10
        const value = args[i] === undefined
          ? this.evaluateDefaultValue(param.right)
          : args[i];
        envRecord.bindings.set(param.left.name, {
          value,
          mutable: true,
          initialized: true,
          deletable: false,
        });
      } else if (param.type === 'ObjectPattern' || param.type === 'ArrayPattern') {
        // Destructuring parameter
        this.bindDestructuringPattern(envRecord, param, args[i]);
      }
    }
  }

  private createArgumentsObject(
    envRecord: FunctionEnvironmentRecord,
    args: any[],
    func: FunctionObject
  ): void {
    // Arguments object is exotic - has special behavior
    const argumentsObject = {
      length: args.length,
      callee: func,
      [Symbol.iterator]: function* () {
        for (let i = 0; i < args.length; i++) {
          yield args[i];
        }
      },
    };

    // Map indices to values
    for (let i = 0; i < args.length; i++) {
      Object.defineProperty(argumentsObject, i, {
        value: args[i],
        writable: true,
        enumerable: true,
        configurable: true,
      });
    }

    envRecord.bindings.set('arguments', {
      value: argumentsObject,
      mutable: true,
      initialized: true,
      deletable: false,
    });
  }

  // Push context onto stack
  pushContext(context: ExecutionContext): void {
    this.stack.push(context);
  }

  // Pop context from stack
  popContext(): ExecutionContext {
    return this.stack.pop()!;
  }

  // Get current context
  currentContext(): ExecutionContext {
    return this.stack[this.stack.length - 1];
  }
}

class VariableResolver {
  // Resolve a variable name through the scope chain
  resolveBinding(
    name: string,
    environment: LexicalEnvironment,
    strict: boolean
  ): ResolvedBinding {
    let current: LexicalEnvironment | null = environment;

    while (current !== null) {
      const record = current.environmentRecord;

      if (this.hasBinding(record, name)) {
        return {
          found: true,
          environmentRecord: record,
          name,
          strict,
        };
      }

      current = current.outerEnvironment;
    }

    // Not found in any environment
    return {
      found: false,
      environmentRecord: null,
      name,
      strict,
    };
  }

  private hasBinding(record: EnvironmentRecord, name: string): boolean {
    if (record.type === 'declarative') {
      return record.bindings.has(name);
    }

    if (record.type === 'object') {
      return name in record.bindingObject;
    }

    if (record.type === 'global') {
      return (
        record.declarativeRecord.bindings.has(name) ||
        name in record.objectRecord.bindingObject
      );
    }

    return false;
  }

  // Get variable value
  getBindingValue(
    resolved: ResolvedBinding
  ): any {
    if (!resolved.found) {
      if (resolved.strict) {
        throw new ReferenceError(`${resolved.name} is not defined`);
      }
      return undefined;
    }

    const record = resolved.environmentRecord!;

    if (record.type === 'declarative' || record.type === 'global') {
      const binding = this.getBinding(record, resolved.name);

      // Check Temporal Dead Zone
      if (!binding.initialized) {
        throw new ReferenceError(
          `Cannot access '${resolved.name}' before initialization`
        );
      }

      return binding.value;
    }

    if (record.type === 'object') {
      return record.bindingObject[resolved.name];
    }
  }

  // Set variable value
  setBindingValue(
    resolved: ResolvedBinding,
    value: any
  ): void {
    if (!resolved.found) {
      if (resolved.strict) {
        throw new ReferenceError(`${resolved.name} is not defined`);
      }
      // Sloppy mode: create global variable (bad!)
      (globalThis as any)[resolved.name] = value;
      return;
    }

    const record = resolved.environmentRecord!;

    if (record.type === 'declarative') {
      const binding = record.bindings.get(resolved.name)!;

      if (!binding.mutable) {
        throw new TypeError(`Assignment to constant variable '${resolved.name}'`);
      }

      if (!binding.initialized) {
        throw new ReferenceError(
          `Cannot access '${resolved.name}' before initialization`
        );
      }

      binding.value = value;
    } else if (record.type === 'object') {
      record.bindingObject[resolved.name] = value;
    }
  }

  // Create new binding (for declarations)
  createBinding(
    record: EnvironmentRecord,
    name: string,
    kind: 'var' | 'let' | 'const' | 'function' | 'class',
    value?: any
  ): void {
    if (record.type === 'declarative') {
      if (kind === 'let' || kind === 'const' || kind === 'class') {
        // Check for duplicate lexical declaration
        if (record.bindings.has(name)) {
          throw new SyntaxError(`Identifier '${name}' has already been declared`);
        }

        record.bindings.set(name, {
          value: value,
          mutable: kind !== 'const',
          initialized: kind === 'function',  // Functions are initialized immediately
          deletable: false,
        });
      } else {
        // var or function
        if (!record.bindings.has(name)) {
          record.bindings.set(name, {
            value: kind === 'var' ? undefined : value,
            mutable: true,
            initialized: true,
            deletable: false,
          });
        } else if (kind === 'function') {
          // Function declarations overwrite
          record.bindings.get(name)!.value = value;
        }
      }
    }
  }

  // Initialize binding (for let/const after declaration)
  initializeBinding(
    record: EnvironmentRecord,
    name: string,
    value: any
  ): void {
    if (record.type === 'declarative') {
      const binding = record.bindings.get(name);
      if (binding) {
        binding.value = value;
        binding.initialized = true;
      }
    }
  }

  private getBinding(
    record: EnvironmentRecord,
    name: string
  ): Binding {
    if (record.type === 'declarative') {
      return record.bindings.get(name)!;
    }

    if (record.type === 'global') {
      const lexBinding = record.declarativeRecord.bindings.get(name);
      if (lexBinding) return lexBinding;

      return {
        value: record.objectRecord.bindingObject[name],
        mutable: true,
        initialized: true,
        deletable: true,
      };
    }

    throw new Error('Unsupported record type');
  }
}

interface ResolvedBinding {
  found: boolean;
  environmentRecord: EnvironmentRecord | null;
  name: string;
  strict: boolean;
}

┌─────────────────────────────────────────────────────────────────────────────┐
│                         SCOPE CHAIN EXAMPLE                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  const globalVar = 'global';                                                │
│                                                                             │
│  function outer(outerParam) {                                               │
│    const outerVar = 'outer';                                                │
│                                                                             │
│    function inner(innerParam) {                                             │
│      const innerVar = 'inner';                                              │
│      console.log(innerVar, outerVar, globalVar);                            │
│    }                                                                        │
│                                                                             │
│    inner('innerArg');                                                       │
│  }                                                                          │
│                                                                             │
│  outer('outerArg');                                                         │
│                                                                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  SCOPE CHAIN WHEN inner() EXECUTES:                                         │
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ INNER FUNCTION ENVIRONMENT                                          │   │
│  │   innerParam: 'innerArg'                                            │   │
│  │   innerVar: 'inner'                                                 │   │
│  │   outer: ────────────────────────────────────────────────┐          │   │
│  └──────────────────────────────────────────────────────────┼──────────┘   │
│                                                              │              │
│                                                              ▼              │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ OUTER FUNCTION ENVIRONMENT                                          │   │
│  │   outerParam: 'outerArg'                                            │   │
│  │   outerVar: 'outer'                                                 │   │
│  │   inner: [function]                                                 │   │
│  │   outer: ────────────────────────────────────────────────┐          │   │
│  └──────────────────────────────────────────────────────────┼──────────┘   │
│                                                              │              │
│                                                              ▼              │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ GLOBAL ENVIRONMENT                                                  │   │
│  │   globalVar: 'global'                                               │   │
│  │   outer: [function]                                                 │   │
│  │   console: [object]                                                 │   │
│  │   outer: null                                                       │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

class ClosureManager {
  // When a function is created, capture its [[Scope]]
  createFunction(
    code: BytecodeArray,
    currentContext: ExecutionContext
  ): FunctionObject {
    return {
      code,
      // Capture the lexical environment - this creates the closure
      scope: currentContext.lexicalEnvironment,
      isStrict: code.isStrict,
      isArrowFunction: code.isArrowFunction,
      formalParameters: code.parameters,
      name: code.functionName,
      prototype: code.isArrowFunction ? undefined : Object.create(Object.prototype),
      realm: currentContext.realm,
      scriptOrModule: currentContext.scriptOrModule,
    };
  }
}

interface FunctionObject {
  code: BytecodeArray;
  scope: LexicalEnvironment;  // [[Scope]] - the closure
  isStrict: boolean;
  isArrowFunction: boolean;
  formalParameters: Parameter[];
  name: string;
  prototype?: object;
  realm: Realm;
  scriptOrModule: Script | Module;
}

// Example: Closure in action
function createClosureExample() {
  // When makeCounter is called:
  // 1. Create function context with count variable
  // 2. When inner function is created, it captures the lexical environment
  // 3. Even after makeCounter returns, the environment stays alive

  function makeCounter() {
    let count = 0;  // In function's environment record

    return function increment() {
      // This function's [[Scope]] points to makeCounter's environment
      // So it can access 'count' even after makeCounter returns
      return ++count;
    };
  }

  const counter = makeCounter();
  console.log(counter()); // 1 - accesses count through closure
  console.log(counter()); // 2 - same count variable
  console.log(counter()); // 3 - still the same
}

// V8's optimized context representation
class V8Context {
  // V8 doesn't create full environments for every scope
  // Instead, it uses "Context" objects only when needed

  // Scenario 1: No closure needed
  // Variables stay on stack (register allocation)
  // No heap allocation, maximum performance

  // Scenario 2: Closure needed
  // Variables are "context allocated" - moved to heap
  // Context object holds captured variables

  // V8 performs "scope analysis" to determine which variables
  // need context allocation

  analyzeScope(ast: FunctionAST): ScopeAnalysis {
    const localVariables = new Set<string>();
    const capturedVariables = new Set<string>();
    const freeVariables = new Set<string>(); // From outer scopes

    // Walk AST to find variable references
    this.walkAST(ast, (node) => {
      if (node.type === 'VariableDeclaration') {
        for (const decl of node.declarations) {
          localVariables.add(decl.id.name);
        }
      }

      if (node.type === 'Identifier' && this.isVariableReference(node)) {
        if (!localVariables.has(node.name)) {
          freeVariables.add(node.name);
        }
      }

      if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
        // Inner function might capture our variables
        const innerAnalysis = this.analyzeScope(node);
        for (const free of innerAnalysis.freeVariables) {
          if (localVariables.has(free)) {
            capturedVariables.add(free);
          }
        }
      }
    });

    return {
      localVariables,
      capturedVariables,
      freeVariables,
      needsContext: capturedVariables.size > 0,
    };
  }
}

interface ScopeAnalysis {
  localVariables: Set<string>;
  capturedVariables: Set<string>;
  freeVariables: Set<string>;
  needsContext: boolean;
}

// V8 Context object (simplified)
interface V8ContextObject {
  // Pointer to parent context
  previous: V8ContextObject | null;

  // Extension object (for with/eval)
  extension: object | null;

  // Native context reference (realm)
  nativeContext: NativeContext;

  // Captured variables (context-allocated)
  // Stored at known offsets for fast access
  slots: any[];
}

// Bytecode for context access
class ContextAccessBytecode {
  // LdaContextSlot [context_depth] [slot_index]
  // Load from context at given depth with given slot

  // StaContextSlot [context_depth] [slot_index]
  // Store to context at given depth with given slot

  generateContextAccess(
    variable: string,
    analysis: ScopeAnalysis,
    depth: number
  ): BytecodeInstruction[] {
    if (analysis.capturedVariables.has(variable)) {
      // Context-allocated variable
      const slotIndex = Array.from(analysis.capturedVariables).indexOf(variable);
      return [
        { opcode: Bytecode.LdaContextSlot, operands: [depth, slotIndex] },
      ];
    } else {
      // Stack-allocated variable (register)
      const register = this.getRegisterForVariable(variable);
      return [
        { opcode: Bytecode.Ldar, operands: [register] },
      ];
    }
  }
}

class ThisResolver {
  // This binding rules (ES6+):
  // 1. Arrow functions: lexical this (no own binding)
  // 2. new: newly created object
  // 3. call/apply/bind: first argument
  // 4. Method call: receiver object
  // 5. Direct call (strict): undefined
  // 6. Direct call (sloppy): global object

  resolveThis(
    callType: CallType,
    callee: FunctionObject,
    receiver: any,
    isStrict: boolean
  ): any {
    // Arrow functions inherit this from enclosing scope
    if (callee.isArrowFunction) {
      return this.getLexicalThis(callee);
    }

    switch (callType) {
      case CallType.NEW:
        // Create new object with callee's prototype
        return Object.create(callee.prototype || Object.prototype);

      case CallType.METHOD:
        // Use the receiver (the object before the dot)
        return this.coerceThis(receiver, isStrict || callee.isStrict);

      case CallType.CALL_APPLY:
        // Explicit this from call/apply
        return this.coerceThis(receiver, isStrict || callee.isStrict);

      case CallType.DIRECT:
        // Direct function call
        if (isStrict || callee.isStrict) {
          return undefined;
        }
        return globalThis;

      default:
        return undefined;
    }
  }

  private coerceThis(thisArg: any, strict: boolean): any {
    if (strict) {
      return thisArg;
    }

    // Sloppy mode: coerce primitives to objects
    if (thisArg === null || thisArg === undefined) {
      return globalThis;
    }

    if (typeof thisArg !== 'object') {
      return Object(thisArg);
    }

    return thisArg;
  }

  private getLexicalThis(arrowFunc: FunctionObject): any {
    // Walk up the scope chain to find enclosing function's this
    let scope = arrowFunc.scope;

    while (scope) {
      const record = scope.environmentRecord;

      if (record.type === 'declarative' && 'thisValue' in record) {
        const funcRecord = record as FunctionEnvironmentRecord;
        if (funcRecord.thisBindingStatus !== 'lexical') {
          return funcRecord.thisValue;
        }
      }

      scope = scope.outerEnvironment;
    }

    // Global this
    return globalThis;
  }
}

enum CallType {
  NEW,        // new Func()
  METHOD,     // obj.func()
  CALL_APPLY, // func.call(this) or func.apply(this)
  DIRECT,     // func()
}

class TDZChecker {
  // TDZ: Region between entering scope and initialization
  // Accessing let/const before initialization throws ReferenceError

  // V8 implementation:
  // 1. At declaration, create binding with initialized=false
  // 2. When accessed, check initialized flag
  // 3. At initialization point, set initialized=true

  checkTDZ(binding: Binding, name: string): void {
    if (!binding.initialized) {
      throw new ReferenceError(
        `Cannot access '${name}' before initialization`
      );
    }
  }
}

// TDZ Example
function tdzExample() {
  // TDZ for 'x' starts here (block entry)
  console.log(typeof x);  // ReferenceError! TDZ
  let x = 10;             // TDZ ends here

  // TDZ for 'y' in same block
  {
    console.log(y);  // ReferenceError! TDZ
    const y = 20;    // TDZ ends
  }

  // Function hoisting vs TDZ
  foo();  // Works! Function declarations are hoisted AND initialized
  bar();  // ReferenceError! const is not initialized

  function foo() { console.log('foo'); }
  const bar = () => { console.log('bar'); };
}

// Bytecode for TDZ checking
class TDZBytecode {
  generateLetDeclaration(name: string, initializer?: Expression): BytecodeInstruction[] {
    const instructions: BytecodeInstruction[] = [];

    // 1. Create binding in current context (uninitialized)
    instructions.push({
      opcode: Bytecode.CreateBlockContextSlot,
      operands: [this.getSlotIndex(name)],
    });

    // 2. If initializer exists, evaluate and initialize
    if (initializer) {
      instructions.push(...this.generateExpression(initializer));
      instructions.push({
        opcode: Bytecode.InitializeContextSlot,
        operands: [this.getSlotIndex(name)],
      });
    }

    return instructions;
  }

  generateVariableAccess(name: string, scopeInfo: ScopeInfo): BytecodeInstruction[] {
    const instructions: BytecodeInstruction[] = [];

    if (scopeInfo.isLetOrConst(name)) {
      // Check TDZ before access
      instructions.push({
        opcode: Bytecode.ThrowIfHole,
        operands: [this.getNameIndex(name)],
      });
    }

    instructions.push({
      opcode: Bytecode.LdaContextSlot,
      operands: [scopeInfo.depth(name), this.getSlotIndex(name)],
    });

    return instructions;
  }
}

class HoistingAnalyzer {
  // Hoisting: Moving declarations to top of scope
  // But var and function are hoisted differently!

  analyzeHoisting(statements: Statement[]): HoistingResult {
    const varDeclarations: string[] = [];
    const functionDeclarations: Map<string, FunctionDeclaration> = new Map();
    const lexicalDeclarations: string[] = [];

    for (const stmt of statements) {
      this.collectDeclarations(stmt, varDeclarations, functionDeclarations, lexicalDeclarations);
    }

    return {
      varDeclarations,
      functionDeclarations,
      lexicalDeclarations,
    };
  }

  private collectDeclarations(
    stmt: Statement,
    varDecls: string[],
    funcDecls: Map<string, FunctionDeclaration>,
    lexDecls: string[]
  ): void {
    switch (stmt.type) {
      case 'VariableDeclaration':
        if (stmt.kind === 'var') {
          for (const decl of stmt.declarations) {
            varDecls.push(decl.id.name);
          }
        } else {
          for (const decl of stmt.declarations) {
            lexDecls.push(decl.id.name);
          }
        }
        break;

      case 'FunctionDeclaration':
        // Function declarations are hoisted AND initialized
        funcDecls.set(stmt.id.name, stmt);
        break;

      case 'BlockStatement':
        // Only var hoists out of blocks
        for (const innerStmt of stmt.body) {
          if (innerStmt.type === 'VariableDeclaration' && innerStmt.kind === 'var') {
            this.collectDeclarations(innerStmt, varDecls, funcDecls, lexDecls);
          }
        }
        break;
    }
  }

  // What the engine "sees" after hoisting
  transformForHoisting(code: string): string {
    // Original:
    // console.log(x); // undefined (not ReferenceError)
    // console.log(y); // ReferenceError (TDZ)
    // foo(); // Works
    // bar(); // ReferenceError
    //
    // var x = 1;
    // let y = 2;
    // function foo() {}
    // const bar = () => {};

    // Transformed (conceptually):
    // var x;  // Declaration hoisted
    // function foo() {}  // Declaration AND value hoisted
    // // let y stays in TDZ until initialization
    // // const bar stays in TDZ until initialization
    //
    // console.log(x); // undefined
    // console.log(y); // ReferenceError
    // foo(); // Works
    // bar(); // ReferenceError
    //
    // x = 1;  // Assignment stays in place
    // let y = 2;  // TDZ ends here
    // const bar = () => {};  // TDZ ends here

    return code; // Simplified
  }
}

interface HoistingResult {
  varDeclarations: string[];
  functionDeclarations: Map<string, FunctionDeclaration>;
  lexicalDeclarations: string[];
}

// ES Modules have special execution context behavior
class ModuleContextManager {
  private moduleRegistry: Map<string, ModuleRecord> = new Map();

  // Module execution follows specific order:
  // 1. Parse all modules
  // 2. Instantiate (link imports/exports)
  // 3. Evaluate (execute module code)

  async executeModule(specifier: string): Promise<any> {
    // 1. Load and parse
    const moduleRecord = await this.loadModule(specifier);

    // 2. Instantiate module
    this.instantiateModule(moduleRecord);

    // 3. Evaluate module
    return this.evaluateModule(moduleRecord);
  }

  private instantiateModule(module: ModuleRecord): void {
    // Create module environment record
    const envRecord: ModuleEnvironmentRecord = {
      type: 'module',
      bindings: new Map(),
      importBindings: new Map(),
    };

    // Process imports
    for (const importEntry of module.imports) {
      // Import bindings are immutable indirect references
      envRecord.importBindings.set(importEntry.localName, {
        module: this.resolveModule(importEntry.moduleSpecifier),
        exportName: importEntry.importName,
      });
    }

    // Process local exports
    for (const exportEntry of module.localExports) {
      envRecord.bindings.set(exportEntry.localName, {
        value: undefined,
        mutable: exportEntry.kind !== 'const',
        initialized: false,
        deletable: false,
      });
    }

    module.environment = {
      environmentRecord: envRecord,
      outerEnvironment: null,  // Module scope doesn't have outer
    };
  }

  private evaluateModule(module: ModuleRecord): any {
    // Modules are evaluated only once
    if (module.status === 'evaluated') {
      return module.evaluationResult;
    }

    // Evaluate dependencies first (DFS)
    for (const dep of module.dependencies) {
      this.evaluateModule(dep);
    }

    // Create module execution context
    const context: ExecutionContext = {
      type: ExecutionContextType.MODULE,
      lexicalEnvironment: module.environment!,
      variableEnvironment: module.environment!,
      thisBinding: undefined,  // Modules always have undefined this
      code: module.code,
      scriptOrModule: module,
      realm: module.realm,
    };

    // Execute module code
    module.status = 'evaluating';

    try {
      this.executeContext(context);
      module.status = 'evaluated';
    } catch (error) {
      module.status = 'errored';
      module.evaluationError = error;
      throw error;
    }

    return module.namespace;
  }
}

interface ModuleRecord {
  specifier: string;
  imports: ImportEntry[];
  localExports: ExportEntry[];
  dependencies: ModuleRecord[];
  environment?: LexicalEnvironment;
  status: 'unlinked' | 'linking' | 'linked' | 'evaluating' | 'evaluated' | 'errored';
  evaluationResult?: any;
  evaluationError?: Error;
  code: BytecodeArray;
  namespace: object;
  realm: Realm;
}

interface ModuleEnvironmentRecord {
  type: 'module';
  bindings: Map<string, Binding>;
  importBindings: Map<string, IndirectBinding>;
}

interface IndirectBinding {
  module: ModuleRecord;
  exportName: string;
}

// Event handler factory with hidden closure leak
function createHandler(element, data) {
  const heavyData = processData(data);  // 10MB object

  element.addEventListener('click', function onClick() {
    // Only uses element.id, but entire closure is retained
    console.log('Clicked:', element.id);
  });

  // heavyData is captured in closure even though unused!
  // Because onClick's scope chain includes this function's environment
}

// Called for every element
document.querySelectorAll('.item').forEach((el, i) => {
  createHandler(el, items[i]);
});

// Result: 1000 elements × 10MB = 10GB retained

function createHandler(element, data) {
  const heavyData = processData(data);

  // Process what we need
  const elementId = element.id;
  const summary = summarize(heavyData);

  // Heavy data can now be collected
  element.addEventListener('click', function onClick() {
    console.log('Clicked:', elementId);
  });
}

// Or use an IIFE to create separate scope
function createHandler(element, data) {
  const heavyData = processData(data);
  const summary = summarize(heavyData);

  ((id) => {
    element.addEventListener('click', () => {
      console.log('Clicked:', id);
    });
  })(element.id);
}

// config.js
import { getEnv } from './env.js';

// Circular dependency issue
export const config = {
  apiUrl: getEnv('API_URL'),
  timeout: getEnv('TIMEOUT'),
};

// env.js
import { config } from './config.js';  // Circular!

const envCache = new Map();

export function getEnv(key) {
  if (!envCache.has(key)) {
    // This tries to access config, but it's not initialized yet!
    const defaultValue = config.defaults?.[key];  // ReferenceError!
    envCache.set(key, process.env[key] ?? defaultValue);
  }
  return envCache.get(key);
}

// Break circular dependency with lazy evaluation
// env.js
let configRef = null;

export function getEnv(key) {
  if (!configRef) {
    // Lazy load to avoid TDZ
    configRef = require('./config.js').config;
  }
  if (!envCache.has(key)) {
    const defaultValue = configRef.defaults?.[key];
    envCache.set(key, process.env[key] ?? defaultValue);
  }
  return envCache.get(key);
}

// Or restructure to eliminate circular dependency
// defaults.js (new file)
export const defaults = { ... };

// config.js
import { defaults } from './defaults.js';
export const config = { ...defaults, ... };

// env.js
import { defaults } from './defaults.js';  // No circular dep

// Deeply nested async calls
async function processItems(items) {
  const results = [];
  for (const item of items) {
    results.push(await processItem(item));
  }
  return results;
}

async function processItem(item) {
  const validated = await validate(item);
  const transformed = await transform(validated);
  const enriched = await enrich(transformed);
  return enriched;
}

async function validate(item) {
  return await checkSchema(item);  // Unnecessary await
}

async function transform(item) {
  return await applyRules(item);  // Unnecessary await
}

// Each await:
// 1. Saves current execution context
// 2. Creates Promise
// 3. Schedules microtask
// 4. Restores execution context on resume
// 5. Resumes generator (async functions are generators internally)

// Batch processing
async function processItems(items) {
  // Process in parallel batches
  const batchSize = 100;
  const results = [];

  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    const batchResults = await Promise.all(
      batch.map(item => processItem(item))
    );
    results.push(...batchResults);
  }

  return results;
}

// Eliminate unnecessary async/await
function validate(item) {
  return checkSchema(item);  // Return promise directly
}

function transform(item) {
  return applyRules(item);  // Return promise directly
}

// Reduce nesting
async function processItem(item) {
  // Chain promises instead of sequential awaits
  return validate(item)
    .then(transform)
    .then(enrich);
}