let & const: TDZ, Block Scope & Redeclaration Rules

const prevents REBINDING of the variable — you cannot reassign the variable to point to something else. But const does NOT prevent MUTATION of the value it points to.

const + primitive: completely immutable (primitives cannot be mutated anyway — strings, numbers, booleans are value types).

const + object/array: the binding is fixed (the variable always points to the same object), but the object's contents can change — properties can be added, removed, or modified.

// const prevents rebinding
const x = 10;
// x = 20; // TypeError: Assignment to constant variable

// But const with objects — mutation is allowed!
const user = { name: 'Sai', age: 26 };
user.name = 'Rahul';  // ✅ mutation works
user.city = 'Hyd';   // ✅ adding property works
// user = { name: 'New' }; // TypeError — rebinding not allowed!
console.log(user); // { name: 'Rahul', age: 26, city: 'Hyd' }

// const with array — same pattern
const scores = [95, 87, 72];
scores.push(100);    // ✅ mutation allowed
scores[0] = 50;      // ✅ mutation allowed
// scores = [1,2,3]; // TypeError — rebinding not allowed

// Object.freeze() — prevents mutation (shallow only!)
const config = Object.freeze({ theme: 'dark', lang: 'en' });
config.theme = 'light'; // silently fails in sloppy mode
config.newProp = 'x';   // silently fails
console.log(config);    // still { theme: 'dark', lang: 'en' }

// But freeze is SHALLOW — nested objects not frozen!
const nested = Object.freeze({ settings: { dark: true } });
nested.settings.dark = false; // ✅ mutation works — nested not frozen!
console.log(nested.settings.dark); // false — changed!

// Deep freeze pattern:
function deepFreeze(obj) {
  Object.getOwnPropertyNames(obj).forEach(name => {
    const value = obj[name];
    if (typeof value === 'object' && value !== null) {
      deepFreeze(value); // recurse
    }
  });
  return Object.freeze(obj);
}