'use strict';

const tarea = new Tarea({
  id: 6, titulo: 'Presupuesto de la carpintería', responsable: 'Iván',
  prioridad: 'alta', horasEstimadas: 5, fechaLimite: '2026-09-05'
});

// ✗ 1 · Salta la R6: de 'pendiente' a 'hecha' sin pasar por 'en-curso'
tarea.estado = 'hecha';

// ✗ 2 · Salta la R3: horas fuera del rango 1-40
tarea.horasEstimadas = 500;

// ✗ 3 · Estado inexistente: ni siquiera está en Tarea.ESTADOS
tarea.estado = 'archivada';

// ✗ 4 · Salta la R8: cadena vacía en lugar de null
tarea.responsable = '';

console.log(tarea.descripcion('2026-09-20'));
// ? [6] Presupuesto de la carpintería ·  · 500 h

'use strict';

class Tarea {
  constructor(datos) {
    this.id = datos.id;
    this.titulo = datos.titulo;
    this.estado = datos.estado ?? 'pendiente';
    this.horasEstimadas = datos.horasEstimadas;
    this.fechaLimite = datos.fechaLimite;
  }

  get abierta() {
    return this.estado !== 'hecha';
  }

  get diasRestantes() {
    const limite = new Date(this.fechaLimite);
    const hoy = new Date('2026-09-20');
    return Math.round((limite - hoy) / (1000 * 60 * 60 * 24));
  }
}

const carpinteria = new Tarea({ id: 6, titulo: 'Presupuesto de la carpintería', horasEstimadas: 5, fechaLimite: '2026-09-05' });

console.log(carpinteria.abierta);          // true    ← sin paréntesis
console.log(carpinteria.diasRestantes);    // -15     ← vencida hace 15 días

// ✗ Dato derivado guardado: hay que acordarse de actualizarlo SIEMPRE
this.abierta = datos.estado !== 'hecha';
tarea.estado = 'hecha';
console.log(tarea.abierta);        // true  ← mentira

const equipo = {
  miembros: ['Marta', 'Iván', 'Lucía'],
  get tamano() { return this.miembros.length; }
};
console.log(equipo.tamano);        // 3

class Tablero {
  constructor(nombre, tareas = []) {
    this.nombre = nombre;
    this.tareas = [...tareas];
  }

  get total()          { return this.tareas.length; }
  get abiertas()       { return this.tareas.filter((t) => t.abierta); }
  get horasTotales()   { return this.tareas.reduce((s, t) => s + t.horasEstimadas, 0); }
  get horasAbiertas()  { return this.abiertas.reduce((s, t) => s + t.horasEstimadas, 0); }
  get esfuerzo()       { return this.tareas.reduce((s, t) => s + t.esfuerzo(), 0); }
}

console.log(tablero.total);           // 6
console.log(tablero.horasTotales);    // 48
console.log(tablero.horasAbiertas);   // 45
console.log(tablero.esfuerzo);        // 124

'use strict';

class Tarea {
  constructor(datos) {
    this.id = datos.id;
    this._horas = 0;
    this.horasEstimadas = datos.horasEstimadas;   // ← pasa por el setter, se valida
  }

  get horasEstimadas() {
    return this._horas;
  }

  set horasEstimadas(valor) {
    if (typeof valor !== 'number' || Number.isNaN(valor)) {
      throw new ErrorDeValidacion('Las horas deben ser un número.', 'horasEstimadas', valor);
    }
    if (valor <= 0 || valor > 40) {                                              // R3
      throw new ErrorDeValidacion('Las horas deben estar entre 1 y 40.', 'horasEstimadas', valor);
    }
    this._horas = valor;
  }
}

const t = new Tarea({ id: 6, horasEstimadas: 5 });
console.log(t.horasEstimadas);      // 5

t.horasEstimadas = 8;               // ✓ válido
console.log(t.horasEstimadas);      // 8

try {
  t.horasEstimadas = 500;           // ✗ ahora SÍ salta
} catch (error) {
  console.error(error.message);     // 'Las horas deben estar entre 1 y 40.'
}
console.log(t.horasEstimadas);      // 8   ← el objeto quedó intacto

class SoloLectura {
  #valor = 42;
  get valor() { return this.#valor; }
}

const sl = new SoloLectura();
// sl.valor = 7;      // ✗ TypeError: Cannot set property valor… which has only a getter

class Tarea {
  get abierta()        { … }          // ✓ dato propio, barato, sin argumentos
  get diasRestantes()  { … }          // ✓ derivado de fechaLimite

  estaVencida(hoy)     { … }          // ✓ método: recibe un argumento
  cambiarEstado(nuevo) { … }          // ✓ método: es una ACCIÓN, y puede lanzar
  esfuerzo()           { … }          // ✓ método: podría ser getter; se mantiene por coherencia
}

// Si horasAbiertas fuera costoso, esto sería un desastre invisible
for (const tarea of tablero.tareas) {
  console.log(tarea.horasEstimadas / tablero.horasAbiertas);   // ← recalcula en cada vuelta
}

'use strict';

class Tarea {
  #estado = 'pendiente';          // campo privado, con valor inicial (R5)

  constructor(datos) {
    this.id = datos.id;
    this.titulo = datos.titulo;
    if (datos.estado !== undefined) this.#validarYAsignarEstado(datos.estado, true);
  }

  get estado() {
    return this.#estado;          // lectura pública, escritura imposible
  }

  cambiarEstado(nuevo) {
    this.#validarYAsignarEstado(nuevo, false);
    return this;
  }

  #validarYAsignarEstado(nuevo, esInicial) { /* apartado 6 */ }
}

const t = new Tarea({ id: 6, titulo: 'Presupuesto de la carpintería' });

console.log(t.estado);            // 'pendiente'   ← se lee por el getter
// t.#estado;                     // ✗ SyntaxError: Private field '#estado' must be declared in an enclosing class
// t.estado = 'hecha';            // ✗ TypeError: solo tiene getter

const tarea = new Tarea({ id: 6, titulo: 'Presupuesto de la carpintería' });

tarea.estado = 'hecha';                     // en modo estricto → TypeError
console.log(tarea.estado);                  // 'pendiente'  ← intacta

tarea.cambiarEstado('en-curso');            // ✓ único camino
console.log(tarea.estado);                  // 'en-curso'

'use strict';

class Tarea {
  // ── Configuración privada de la clase ───────────────────────────
  static #TRANSICIONES = {                       // R6
    pendiente: ['en-curso'],
    'en-curso': ['pendiente', 'hecha'],
    hecha: []
  };
  static #MARCAS = { pendiente: '○', 'en-curso': '▸', hecha: '✓' };
  static #PESOS = { alta: 3, media: 2, baja: 1 };
  static #ultimoId = 6;                          // R1: el backlog llega hasta el 6

  // ── Estado privado de la instancia ──────────────────────────────
  #estado = 'pendiente';                         // R5
  #horas;
  #etiquetas = [];

  constructor(datos) {
    this.id = datos.id ?? Tarea.siguienteId();
    this.titulo = Tarea.#validarTitulo(datos.titulo);
    this.responsable = datos.responsable || null;                 // R8
    this.prioridad = datos.prioridad ?? 'media';
    this.fechaLimite = datos.fechaLimite;
    this.revisor = datos.revisor ?? null;

    this.horasEstimadas = datos.horasEstimadas;                   // pasa por el setter (R3)
    this.etiquetas = datos.etiquetas ?? [];                       // pasa por el setter (R9)
    if (datos.estado !== undefined) this.#asignarEstadoInicial(datos.estado);
  }

  // ── Estáticos ───────────────────────────────────────────────────
  static siguienteId() {
    Tarea.#ultimoId += 1;
    return Tarea.#ultimoId;
  }

  static #validarTitulo(titulo) {                                 // método estático PRIVADO
    if (typeof titulo !== 'string' || titulo.trim() === '') {
      throw new ErrorDeValidacion('El título no puede estar vacío.', 'titulo', titulo);   // R2
    }
    return titulo.trim();
  }

  // ── Getters ─────────────────────────────────────────────────────
  get estado()         { return this.#estado; }
  get horasEstimadas() { return this.#horas; }
  get etiquetas()      { return [...this.#etiquetas]; }           // copia defensiva
  get abierta()        { return this.#estado !== 'hecha'; }
  get esfuerzo()       { return (Tarea.#PESOS[this.prioridad] ?? 0) * this.#horas; }
  get marca()          { return Tarea.#MARCAS[this.#estado]; }

  // ── Setters ─────────────────────────────────────────────────────
  set horasEstimadas(valor) {
    if (typeof valor !== 'number' || !(valor > 0 && valor <= 40)) {
      throw new ErrorDeValidacion('Las horas deben ser un número entre 1 y 40.', 'horasEstimadas', valor);
    }
    this.#horas = valor;
  }

  set etiquetas(lista) {
    if (!Array.isArray(lista)) {
      throw new ErrorDeValidacion('Las etiquetas deben ser un array.', 'etiquetas', lista);
    }
    this.#etiquetas = [...new Set(lista.map((e) => String(e).trim().toLowerCase()))].filter(Boolean);   // R9
  }

  // ── Métodos privados ────────────────────────────────────────────
  #asignarEstadoInicial(estado) {
    if (!Object.hasOwn(Tarea.#TRANSICIONES, estado)) {
      throw new ErrorDeValidacion(`Estado desconocido: "${estado}".`, 'estado', estado);
    }
    this.#estado = estado;
  }

  #puedeIrA(nuevo) {
    return (Tarea.#TRANSICIONES[this.#estado] ?? []).includes(nuevo);
  }

  // ── Interfaz pública ────────────────────────────────────────────
  cambiarEstado(nuevo) {
    if (!Object.hasOwn(Tarea.#TRANSICIONES, nuevo)) {
      throw new ErrorDeValidacion(`Estado desconocido: "${nuevo}".`, 'estado', nuevo);
    }
    if (!this.#puedeIrA(nuevo)) {
      throw new ErrorDeValidacion(
        `Transición no permitida: "${this.#estado}" → "${nuevo}".`, 'estado', nuevo);   // R6
    }
    this.#estado = nuevo;
    return this;
  }

  estaVencida(hoy) {
    return this.fechaLimite < hoy && this.abierta;                // R10
  }

  descripcion(hoy) {
    const aviso = hoy !== undefined && this.estaVencida(hoy) ? ' ⚠ VENCIDA' : '';
    return `${this.marca} [${this.id}] ${this.titulo} · ${this.responsable ?? 'sin asignar'} · ${this.#horas} h${aviso}`;
  }
}

const carpinteria = new Tarea({
  id: 6, titulo: '  Presupuesto de la carpintería  ', responsable: 'Iván',
  prioridad: 'alta', etiquetas: ['Carpintería', 'compras', 'CARPINTERÍA', '  '],
  horasEstimadas: 5, fechaLimite: '2026-09-05', revisor: 'Marta'
});

console.log(carpinteria.titulo);                    // 'Presupuesto de la carpintería'  ← trim, R2
console.log(carpinteria.etiquetas);                 // [ 'carpintería', 'compras' ]     ← R9
console.log(carpinteria.descripcion('2026-09-20')); // ○ [6] Presupuesto de la carpintería · Iván · 5 h ⚠ VENCIDA
console.log(carpinteria.esfuerzo);                  // 15

// Los cuatro ataques del apartado 1, ahora:
try { carpinteria.estado = 'hecha'; }          catch (e) { console.log('✓ bloqueado:', e.constructor.name); }
try { carpinteria.horasEstimadas = 500; }      catch (e) { console.log('✓ bloqueado:', e.message); }
try { carpinteria.cambiarEstado('archivada'); }catch (e) { console.log('✓ bloqueado:', e.message); }
try { carpinteria.cambiarEstado('hecha'); }    catch (e) { console.log('✓ bloqueado:', e.message); }

console.log(carpinteria.estado, carpinteria.horasEstimadas);   // 'pendiente' 5   ← intacto

'use strict';

class Tarea {
  #estado = 'pendiente';

  /** ¿Es este objeto una Tarea auténtica, creada por esta clase? */
  static esTarea(objeto) {
    return #estado in objeto;
  }
}

const real = new Tarea({ id: 1, titulo: 'Rediseñar la sala polivalente', horasEstimadas: 12, fechaLimite: '2026-09-30' });
const impostor = { id: 1, titulo: 'Rediseñar la sala polivalente', estado: 'pendiente' };

console.log(Tarea.esTarea(real));        // true
console.log(Tarea.esTarea(impostor));    // false
console.log(Tarea.esTarea(null));        // false  (in devuelve false, no lanza, para objetos)

const falsificado = Object.create(Tarea.prototype);
console.log(falsificado instanceof Tarea);     // true   ← ¡miente!
console.log(Tarea.esTarea(falsificado));       // false  ← la marca no se puede falsificar
// falsificado.descripcion();                  // ✗ TypeError: no tiene los campos privados

class TareaAntigua {
  constructor(estado) { this._estado = estado; }
  get estado() { return this._estado; }
}
const t = new TareaAntigua('pendiente');
t._estado = 'archivada';        // funciona perfectamente: nada lo impide

function crearTarea(datosIniciales) {
  let estado = 'pendiente';                     // ← inaccesible desde fuera, de verdad
  const transiciones = { pendiente: ['en-curso'], 'en-curso': ['pendiente', 'hecha'], hecha: [] };

  return {
    id: datosIniciales.id,
    titulo: datosIniciales.titulo,
    get estado() { return estado; },
    cambiarEstado(nuevo) {
      if (!transiciones[estado].includes(nuevo)) throw new ErrorDeValidacion('Transición no permitida.', 'estado', nuevo);
      estado = nuevo;
      return this;
    }
  };
}

const privados = new WeakMap();

class TareaWeak {
  constructor(datos) {
    privados.set(this, { estado: 'pendiente' });
    this.id = datos.id;
  }
  get estado() { return privados.get(this).estado; }
  cambiarEstado(nuevo) { privados.get(this).estado = nuevo; return this; }
}

carpinteria.id = 999;      // ✗ nada lo impide todavía

'use strict';

class Tarea {
  constructor(datos) {
    Object.defineProperty(this, 'id', {
      value: datos.id,
      writable: false,       // no se puede reasignar
      enumerable: true,      // sí aparece en Object.keys y JSON.stringify
      configurable: false    // no se puede borrar ni redefinir
    });
    this.titulo = datos.titulo;
  }
}

const t = new Tarea({ id: 6, titulo: 'Presupuesto de la carpintería' });

console.log(t.id);                      // 6
// t.id = 999;                          // ✗ TypeError: Cannot assign to read only property 'id'
// delete t.id;                         // ✗ TypeError: Cannot delete property 'id'
console.log(Object.keys(t));            // [ 'id', 'titulo' ]
console.log(JSON.stringify(t));         // {"id":6,"titulo":"Presupuesto de la carpintería"}

console.log(Object.getOwnPropertyDescriptor(t, 'id'));
// { value: 6, writable: false, enumerable: true, configurable: false }

console.log(Object.getOwnPropertyDescriptor(t, 'titulo'));
// { value: '…', writable: true, enumerable: true, configurable: true }

Object.defineProperty(Tarea.prototype, 'oculto', { value() { return 1; }, enumerable: false });

'use strict';

class Tablero {
  #tareas = [];
  #nombre;

  constructor(nombre, tareas = []) {
    this.#nombre = nombre;
    for (const tarea of tareas) this.agregar(tarea);      // toda entrada pasa por la puerta oficial
  }

  // ── Lecturas ────────────────────────────────────────────────────
  get nombre()        { return this.#nombre; }
  get total()         { return this.#tareas.length; }
  get tareas()        { return [...this.#tareas]; }              // copia: mutarla no afecta al tablero
  get abiertas()      { return this.#tareas.filter((t) => t.abierta); }
  get horasTotales()  { return this.#tareas.reduce((s, t) => s + t.horasEstimadas, 0); }
  get horasAbiertas() { return this.abiertas.reduce((s, t) => s + t.horasEstimadas, 0); }
  get esfuerzo()      { return this.#tareas.reduce((s, t) => s + t.esfuerzo, 0); }

  buscarPorId(id)     { return this.#tareas.find((t) => t.id === id) ?? null; }
  filtrar(predicado)  { return this.#tareas.filter(predicado); }

  vencidas(hoy)       { return this.abiertas.filter((t) => t.estaVencida(hoy)); }

  horasPorResponsable() {
    return this.abiertas.reduce((acc, t) => {
      const clave = t.responsable ?? 'sin asignar';
      acc[clave] = (acc[clave] ?? 0) + t.horasEstimadas;
      return acc;
    }, {});
  }

  resumen(hoy) {
    return {
      total: this.total, abiertas: this.abiertas.length,
      horasTotales: this.horasTotales, horasAbiertas: this.horasAbiertas,
      vencidas: this.vencidas(hoy).length, esfuerzo: this.esfuerzo
    };
  }

  // ── Escrituras (las únicas puertas) ─────────────────────────────
  agregar(tarea) {
    if (!(tarea instanceof Tarea)) throw new ErrorDeValidacion('Solo se admiten instancias de Tarea.', 'tarea', tarea);
    if (this.buscarPorId(tarea.id)) throw new ErrorDeValidacion(`Id duplicado: ${tarea.id}.`, 'id', tarea.id);   // R1
    this.#comprobarCarga(tarea);                                                                                 // R7
    this.#tareas.push(tarea);
    return this;
  }

  eliminar(id) {
    const i = this.#tareas.findIndex((t) => t.id === id);
    if (i === -1) throw new ErrorDeValidacion(`No existe la tarea ${id}.`, 'id', id);
    return this.#tareas.splice(i, 1)[0];
  }

  cambiarEstado(id, nuevo) {
    const tarea = this.buscarPorId(id);
    if (tarea === null) throw new ErrorDeValidacion(`No existe la tarea ${id}.`, 'id', id);
    tarea.cambiarEstado(nuevo);
    return this;
  }

  // ── Mecanismo interno ───────────────────────────────────────────
  #comprobarCarga(tarea) {
    if (!tarea.abierta || tarea.responsable === null) return;
    const actual = this.horasPorResponsable()[tarea.responsable] ?? 0;
    if (actual + tarea.horasEstimadas > 40) {
      throw new ErrorDeValidacion(
        `${tarea.responsable} llegaría a ${actual + tarea.horasEstimadas} h (máximo 40).`, 'horasEstimadas', tarea.horasEstimadas);
    }
  }
}

const tablero = new Tablero('Taller Nómada', datosBacklog.map((d) => new Tarea(d)));

console.log(tablero.resumen('2026-09-20'));
// { total: 6, abiertas: 5, horasTotales: 48, horasAbiertas: 45, vencidas: 1, esfuerzo: 124 }
console.log(tablero.horasPorResponsable());     // { 'Iván': 25, 'Marta': 6, 'Lucía': 14 }

// Los intentos de rodear la API:
tablero.tareas.push('esto no es una tarea');
console.log(tablero.total);                     // 6   ← se mutó una copia, el tablero no se enteró

try { tablero.agregar('esto tampoco'); }
catch (e) { console.log('✓ bloqueado:', e.message); }   // Solo se admiten instancias de Tarea.

const tarea = new Tarea({
  id: 6, titulo: 'Presupuesto de la carpintería', responsable: 'Iván',
  prioridad: 'alta', etiquetas: ['carpintería', 'compras'],
  horasEstimadas: 5, fechaLimite: '2026-09-05', revisor: 'Marta'
});

console.log(JSON.stringify(tarea));
// {"id":6,"titulo":"Presupuesto de la carpintería","responsable":"Iván","prioridad":"alta","fechaLimite":"2026-09-05","revisor":"Marta"}

class Tarea {
  // …todo lo anterior…

  /** Representación serializable: incluye lo privado como campos públicos. */
  toJSON() {
    return {
      id: this.id,
      titulo: this.titulo,
      responsable: this.responsable,
      prioridad: this.prioridad,
      estado: this.#estado,
      etiquetas: [...this.#etiquetas],
      horasEstimadas: this.#horas,
      fechaLimite: this.fechaLimite,
      revisor: this.revisor
    };
  }

  /** Camino inverso: reconstruye una instancia desde datos planos. */
  static desdeJSON(datos) {
    return new Tarea(typeof datos === 'string' ? JSON.parse(datos) : datos);
  }
}

console.log(JSON.stringify(tarea));
// {"id":6,…,"estado":"pendiente","etiquetas":["carpintería","compras"],"horasEstimadas":5,…}

class Tablero {
  // …todo lo anterior…

  toJSON() {
    return { version: 1, nombre: this.#nombre, tareas: this.#tareas };   // stringify llama al toJSON de cada tarea
  }

  static importar(texto) {
    let datos;
    try {
      datos = JSON.parse(texto);
    } catch (error) {
      throw new ErrorDeDatos('El backlog no es JSON válido.', error);
    }
    if (datos.version !== 1) throw new ErrorDeDatos(`Versión no soportada: ${datos.version}.`);
    return new Tablero(datos.nombre, datos.tareas.map((d) => Tarea.desdeJSON(d)));
  }
}

const texto = JSON.stringify(tablero);
const recuperado = Tablero.importar(texto);

console.log(recuperado.resumen('2026-09-20'));
// { total: 6, abiertas: 5, horasTotales: 48, horasAbiertas: 45, vencidas: 1, esfuerzo: 124 }
console.log(recuperado.buscarPorId(6) instanceof Tarea);   // true  ← instancias de verdad

class Presupuesto {
  constructor(limite) {
    this._limite = limite;
    this._lineas = [];
  }
  get total() { return this._lineas.reduce((s, l) => s + l.importe, 0); }
  get lineas() { return this._lineas; }
  anadir(concepto, importe) {
    if (this.total + importe > this._limite) throw new Error('Se supera el límite.');
    this._lineas.push({ concepto, importe });
  }
}

'use strict';

class Residente {
  static #CUPOS = { mensual: 40, diario: 8 };

  #plan;
  #horasReservadas = 0;

  constructor(nombre, plan) {
    Object.defineProperty(this, 'nombre', { value: nombre, writable: false, enumerable: true, configurable: false });
    this.plan = plan;                              // pasa por el setter: valida
  }

  get plan()             { return this.#plan; }
  get horasReservadas()  { return this.#horasReservadas; }
  get cupo()             { return Residente.#CUPOS[this.#plan]; }
  get horasDisponibles() { return this.cupo - this.#horasReservadas; }
  get alDia()            { return this.horasDisponibles > 0; }

  set plan(nuevo) {
    if (!Object.hasOwn(Residente.#CUPOS, nuevo)) {
      throw new ErrorDeValidacion(`Plan desconocido: "${nuevo}".`, 'plan', nuevo);
    }
    if (this.#horasReservadas > Residente.#CUPOS[nuevo]) {
      throw new ErrorDeValidacion(
        `No se puede pasar a "${nuevo}": ya hay ${this.#horasReservadas} h reservadas y el cupo es ${Residente.#CUPOS[nuevo]}.`,
        'plan', nuevo);
    }
    this.#plan = nuevo;
  }

  reservar(horas) {
    if (typeof horas !== 'number' || horas <= 0) {
      throw new ErrorDeValidacion('Las horas deben ser un número positivo.', 'horas', horas);
    }
    if (this.#horasReservadas + horas > this.cupo) {
      throw new ErrorDeValidacion(
        `${this.nombre} solo tiene ${this.horasDisponibles} h disponibles.`, 'horas', horas);
    }
    this.#horasReservadas += horas;
    return this;
  }
}

const lucia = new Residente('Lucía', 'mensual');
lucia.reservar(14).reservar(12);
console.log(lucia.horasReservadas, lucia.horasDisponibles, lucia.alDia);   // 26 14 true

try { lucia.plan = 'diario'; }
catch (e) { console.error(e.message); }   // No se puede pasar a "diario": ya hay 26 h reservadas y el cupo es 8.

try { lucia.nombre = 'Lucia'; }
catch (e) { console.error(e.constructor.name); }   // TypeError

try { lucia.reservar(20); }
catch (e) { console.error(e.message); }   // Lucía solo tiene 14 h disponibles.

const p = new Presupuesto(500);
p.anadir('Tinta serigráfica', 120);
p.lineas.push({ concepto: 'Torno nuevo', importe: 9000 });   // ✗ nadie comprueba nada
console.log(p.total);                                         // 9120, con límite 500

'use strict';

class Presupuesto {
  #limite;
  #lineas = [];

  constructor(limite) {
    if (typeof limite !== 'number' || limite <= 0) {
      throw new ErrorDeValidacion('El límite debe ser un número positivo.', 'limite', limite);
    }
    this.#limite = limite;
  }

  get limite()    { return this.#limite; }
  get total()     { return this.#lineas.reduce((s, l) => s + l.importe, 0); }
  get disponible(){ return this.#limite - this.total; }
  get lineas()    { return this.#lineas.map((l) => ({ ...l })); }   // copia de 2 niveles

  anadir(concepto, importe) {
    if (this.total + importe > this.#limite) {
      throw new ErrorDeValidacion(
        `Se supera el límite: quedan ${this.disponible} € y se piden ${importe} €.`, 'importe', importe);
    }
    this.#lineas.push({ concepto, importe });
    return this;
  }
}

const p = new Presupuesto(500);
p.anadir('Tinta serigráfica', 120).anadir('Papel de encuadernación', 80);
p.lineas.push({ concepto: 'Torno nuevo', importe: 9000 });   // muta una copia

console.log(p.total, p.disponible);      // 200 300   ← el presupuesto no se enteró
try { p.anadir('Torno nuevo', 9000); }
catch (e) { console.error(e.message); }  // Se supera el límite: quedan 300 € y se piden 9000 €.

'use strict';

class Tarea {
  // …campos privados y métodos del apartado 6…

  toJSON() {
    return {
      id: this.id, titulo: this.titulo, responsable: this.responsable,
      prioridad: this.prioridad, estado: this.#estado,
      etiquetas: [...this.#etiquetas], horasEstimadas: this.#horas,
      fechaLimite: this.fechaLimite, revisor: this.revisor
    };
  }

  static desdeJSON(datos) {
    return new Tarea(typeof datos === 'string' ? JSON.parse(datos) : datos);
  }

  clonar() {
    return Tarea.desdeJSON(this.toJSON());
  }
}

const original = new Tarea({
  id: 1, titulo: 'Rediseñar la sala polivalente', responsable: 'Iván',
  prioridad: 'alta', estado: 'en-curso', etiquetas: ['espacio', 'diseño'],
  horasEstimadas: 12, fechaLimite: '2026-09-30', revisor: 'Marta'
});

// (a) Sin toJSON se perderían tres campos. Simulándolo con el spread:
console.log(Object.keys({ ...original }));
// [ 'id', 'titulo', 'responsable', 'prioridad', 'fechaLimite', 'revisor' ]
// faltan: estado, etiquetas, horasEstimadas

// (b) Con toJSON, ida y vuelta completo
const texto = JSON.stringify(original);
const vuelta = Tarea.desdeJSON(texto);
console.log(vuelta.estado, vuelta.horasEstimadas, vuelta.etiquetas);
// 'en-curso' 12 [ 'espacio', 'diseño' ]
console.log(vuelta instanceof Tarea);          // true

// (c) El clon es independiente
const copia = original.clonar();
copia.cambiarEstado('hecha');
console.log(original.estado, copia.estado);    // 'en-curso' 'hecha'
copia.etiquetas = ['espacio'];
console.log(original.etiquetas);               // [ 'espacio', 'diseño' ]  ← intactas

// (d) structuredClone no puede con los privados
try { structuredClone(original); }
catch (e) { console.error(e.name); }           // 'DataCloneError'