// js/app.js — al final, quan l'essencial ja funciona
if ('serviceWorker' in navigator) {                    // ← millora progressiva
  window.addEventListener('load', async () => {        // no competeixis amb la càrrega inicial
    try {
      const registre = await navigator.serviceWorker.register('/sw.js', { scope: '/' });
      console.log('[nomada] Service worker registrat. Àmbit:', registre.scope);
    } catch (error) {
      console.error('[nomada] Fallada en registrar el service worker:', error);
    }
  });
}

nomada-tasques/
  index.html
  manifest.json        ← nou
  sw.js                ← nou, A L'ARREL (àmbit '/')
  offline.html         ← nou, pàgina de reserva
  css/estils.css
  js/app.js
  js/…

self.addEventListener('install', (esdeveniment) => {
  esdeveniment.waitUntil(                            // ← sense això, el worker pot morir a mitges
    caches.open('nomada-v1').then((cache) => cache.addAll(RECURSOS))
  );
});

// Des de la pàgina, cap al worker
navigator.serviceWorker.controller?.postMessage({ tipus: 'netejar-cache-api' });

// Des de la pàgina, escoltant el worker
navigator.serviceWorker.addEventListener('message', (esdeveniment) => {
  if (esdeveniment.data.tipus === 'sincronitzat') {
    vista.avisar(`${esdeveniment.data.quants} canvis enviats al servidor.`);
  }
});

// Dins de sw.js
self.addEventListener('message', (esdeveniment) => {
  if (esdeveniment.data?.tipus === 'saltar-espera') self.skipWaiting();
});

/** Avisa TOTES les pestanyes controlades. */
async function avisarClients(missatge) {
  const clients = await self.clients.matchAll({ includeUncontrolled: true });
  for (const client of clients) client.postMessage(missatge);
}

// Obrir (o crear) una memòria cau amb nom
const cache = await caches.open('nomada-shell-v1');

// Desar: descarrega i emmagatzema
await cache.add('/css/estils.css');
await cache.addAll(['/index.html', '/js/app.js', '/css/estils.css']);

// Desar una resposta que ja tens
await cache.put('/api/tasques', resposta.clone());     // ← clone(), el cos es llegeix una vegada (07-02)

// Cercar
const desada = await cache.match('/css/estils.css');
const enQualsevol = await caches.match('/css/estils.css');   // cerca a TOTES les memòries cau

// Gestionar
await cache.delete('/js/vell.js');
const noms = await caches.keys();                      // ['nomada-shell-v1', 'nomada-dades-v1']
await caches.delete('nomada-shell-v0');

// sw.js
const VERSIO = 'v3';                                    // ← puja-la a cada desplegament
const CACHE_SHELL = `nomada-shell-${VERSIO}`;

const RECURSOS_SHELL = [
  '/',                          // important: l'arrel, a més de l'index.html
  '/index.html',
  '/offline.html',
  '/manifest.json',
  '/css/estils.css',
  '/js/app.js',
  '/js/model/tasca.js',
  '/js/model/tauler.js',
  '/js/model/errors.js',
  '/js/dades/backlog.js',
  '/js/dades/repositori-local.js',
  '/js/dades/api-tasques.js',
  '/js/dades/http.js',
  '/js/dades/temps-real.js',
  '/js/util/dates.js',
  '/js/util/format.js',
  '/js/util/temps.js',
  '/js/vista/dom.js',
  '/js/vista/targeta.js',
  '/js/vista/pintar.js',
  '/js/vista/tauler-vista.js',
  '/js/vista/esdeveniments.js',
  '/js/vista/controlador.js',
  '/js/vista/formulari.js',
  '/icones/icona-192.png',
  '/icones/icona-512.png'
];

self.addEventListener('install', (esdeveniment) => {
  console.log(`[sw] Instal·lant ${VERSIO}`);
  esdeveniment.waitUntil(
    caches.open(CACHE_SHELL)
      .then((cache) => cache.addAll(RECURSOS_SHELL))
      .then(() => console.log('[sw] App shell precarregat'))
  );
});

self.addEventListener('activate', (esdeveniment) => {
  console.log(`[sw] Activant ${VERSIO}`);
  esdeveniment.waitUntil((async () => {
    const noms = await caches.keys();

    await Promise.all(
      noms
        .filter((nom) => nom.startsWith('nomada-') && !nom.endsWith(VERSIO))
        .map((nom) => {
          console.log('[sw] Esborrant memòria cau antiga:', nom);
          return caches.delete(nom);
        })
    );

    await self.clients.claim();      // pren el control de les pestanyes ja obertes
  })());
});

/** Cache first: per al que no canvia dins d'una mateixa versió. */
async function cacheFirst(peticio) {
  const desada = await caches.match(peticio);
  if (desada) return desada;

  const resposta = await fetch(peticio);
  if (resposta.ok) {
    const cache = await caches.open(CACHE_SHELL);
    cache.put(peticio, resposta.clone());         // clone: l'original es retorna
  }
  return resposta;
}

/** Network first: per a dades, amb la memòria cau com a xarxa de seguretat. */
async function networkFirst(peticio, nomCache = CACHE_DADES) {
  try {
    const resposta = await fetch(peticio);
    if (resposta.ok) {
      const cache = await caches.open(nomCache);
      cache.put(peticio, resposta.clone());
    }
    return resposta;
  } catch {
    const desada = await caches.match(peticio);
    if (desada) {
      // Marquem la resposta perquè la interfície pugui avisar que és antiga
      const capcaleres = new Headers(desada.headers);
      capcaleres.set('X-Des-De-Cache', 'true');
      return new Response(desada.body, { status: 200, headers: capcaleres });
    }
    throw new Error('Sense xarxa i sense còpia a la memòria cau');
  }
}

/** Stale-while-revalidate: el millor dels dos mons per a dades poc crítiques. */
async function staleWhileRevalidate(peticio, nomCache = CACHE_DADES) {
  const cache = await caches.open(nomCache);
  const desada = await cache.match(peticio);

  const actualitzant = fetch(peticio)
    .then((resposta) => {
      if (resposta.ok) cache.put(peticio, resposta.clone());
      return resposta;
    })
    .catch(() => null);                            // sense xarxa: no passa res, ja hem retornat la cau

  return desada ?? await actualitzant;             // ← retorna JA el que hi ha desat, si n'hi ha
}

self.addEventListener('fetch', (esdeveniment) => {
  const peticio = esdeveniment.request;
  const url = new URL(peticio.url);

  // 1 · Només GET: no interceptis mai escriptures
  if (peticio.method !== 'GET') return;                     // sense respondWith: va a la xarxa normal

  // 2 · Només el nostre origen (i el que decidim permetre)
  if (url.origin !== self.location.origin && !esApiPermesa(url)) return;

  // 3 · Navegacions (l'usuari obre o recarrega la pàgina)
  if (peticio.mode === 'navigate') {
    esdeveniment.respondWith(gestionarNavegacio(peticio));
    return;
  }

  // 4 · Crides a l'API: network first
  if (url.pathname.startsWith('/api/') || esApiPermesa(url)) {
    esdeveniment.respondWith(networkFirst(peticio));
    return;
  }

  // 5 · Tota la resta (CSS, JS, imatges): cache first
  esdeveniment.respondWith(cacheFirst(peticio));
});

async function gestionarNavegacio(peticio) {
  try {
    return await fetch(peticio);                     // network first: sempre l'HTML més fresc
  } catch {
    const desada = await caches.match('/index.html');
    return desada ?? await caches.match('/offline.html');
  }
}

<!-- offline.html — autònom: no pot dependre de res que no estigui a la memòria cau -->
<main class="offline">
  <h1>Sense connexió</h1>
  <p>Nómada Tasques no pot contactar amb el servidor ara mateix.</p>
  <p>Els teus canvis s'estan desant al dispositiu i s'enviaran així que torni la connexió.</p>
  <button type="button" onclick="location.reload()">Reintentar</button>
</main>

// js/app.js
function actualitzarConnectivitat() {
  const enLinia = navigator.onLine;
  $('#estat-xarxa').textContent = enLinia ? '' : 'Sense connexió — treballant en local';
  $('#estat-xarxa').hidden = enLinia;
  document.body.classList.toggle('sense-connexio', !enLinia);
}

window.addEventListener('online',  () => { actualitzarConnectivitat(); sincronitzarPendents(); });
window.addEventListener('offline', actualitzarConnectivitat);
actualitzarConnectivitat();

// js/dades/cua-pendents.js (a la PÀGINA, no al worker)
const BD = 'nomada-pendents';
const MAGATZEM = 'canvis';

function obrir() {
  return new Promise((resoldre, rebutjar) => {
    const sollicitud = indexedDB.open(BD, 1);
    sollicitud.onupgradeneeded = () => {
      sollicitud.result.createObjectStore(MAGATZEM, { keyPath: 'id', autoIncrement: true });
    };
    sollicitud.onsuccess = () => resoldre(sollicitud.result);
    sollicitud.onerror = () => rebutjar(sollicitud.error);
  });
}

export async function encuar(canvi) {
  const bd = await obrir();
  const tx = bd.transaction(MAGATZEM, 'readwrite');
  tx.objectStore(MAGATZEM).add({ ...canvi, ts: Date.now() });
  return new Promise((r) => { tx.oncomplete = r; });
}

export async function llegirTots() {
  const bd = await obrir();
  return new Promise((resoldre) => {
    const sollicitud = bd.transaction(MAGATZEM).objectStore(MAGATZEM).getAll();
    sollicitud.onsuccess = () => resoldre(sollicitud.result);
  });
}

export async function eliminar(id) {
  const bd = await obrir();
  bd.transaction(MAGATZEM, 'readwrite').objectStore(MAGATZEM).delete(id);
}

// js/app.js — envia el que s'ha acumulat quan torna la xarxa
export async function sincronitzarPendents() {
  const pendents = await llegirTots();
  if (pendents.length === 0) return;

  vista.avisar(`Enviant ${pendents.length} canvis pendents…`);

  for (const canvi of pendents) {
    try {
      await api.actualitzarTasca(canvi.id, canvi.dades);   // amb reintents de 07-03
      await eliminar(canvi.clauCua);
    } catch (error) {
      if (!error.reintentable) await eliminar(canvi.clauCua);   // no insisteixis amb un 400
      break;                                                    // la resta, al pròxim intent
    }
  }
  vista.avisar('Sincronització completada.');
}

// Des de la pàgina
const registre = await navigator.serviceWorker.ready;
if ('sync' in registre) await registre.sync.register('enviar-canvis');

// Dins de sw.js
self.addEventListener('sync', (esdeveniment) => {
  if (esdeveniment.tag === 'enviar-canvis') esdeveniment.waitUntil(enviarCanvisPendents());
});

{
  "name": "Nómada Tasques — Taller Nómada",
  "short_name": "Nómada",
  "description": "Gestió de tasques del taller i el coworking",
  "start_url": "/?origen=pwa",
  "scope": "/",
  "display": "standalone",
  "orientation": "any",
  "background_color": "#faf7f2",
  "theme_color": "#2b6b5b",
  "lang": "ca",
  "dir": "ltr",
  "icons": [
    { "src": "/icones/icona-192.png", "sizes": "192x192", "type": "image/png" },
    { "src": "/icones/icona-512.png", "sizes": "512x512", "type": "image/png" },
    { "src": "/icones/icona-mascara.png", "sizes": "512x512", "type": "image/png", "purpose": "maskable" }
  ],
  "shortcuts": [
    { "name": "Nova tasca", "url": "/?accio=nova", "description": "Crear una tasca" }
  ]
}

<!-- index.html, dins de <head> -->
<link rel="manifest" href="/manifest.json">
<meta name="theme-color" content="#2b6b5b">
<link rel="apple-touch-icon" href="/icones/icona-192.png">

let promesaInstalacio = null;

window.addEventListener('beforeinstallprompt', (esdeveniment) => {
  esdeveniment.preventDefault();                 // ← evita l'avís automàtic del navegador
  promesaInstalacio = esdeveniment;
  $('#instalar').hidden = false;                 // mostra EL TEU botó, en EL TEU moment
});

$('#instalar').addEventListener('click', async () => {
  if (promesaInstalacio === null) return;

  promesaInstalacio.prompt();
  const { outcome } = await promesaInstalacio.userChoice;
  console.log('[nomada] Instal·lació:', outcome);      // 'accepted' | 'dismissed'

  promesaInstalacio = null;                      // l'esdeveniment és d'un sol ús
  $('#instalar').hidden = true;
});

window.addEventListener('appinstalled', () => {
  $('#instalar').hidden = true;
  console.log('[nomada] Instal·lada');
});

// sw.js
self.addEventListener('install', (esdeveniment) => {
  esdeveniment.waitUntil(caches.open(CACHE_SHELL).then((c) => c.addAll(RECURSOS_SHELL)));
  // ← NO cridem skipWaiting() aquí: esperem que l'usuari accepti
});

self.addEventListener('message', (esdeveniment) => {
  if (esdeveniment.data?.tipus === 'saltar-espera') self.skipWaiting();
});

// js/app.js
const registre = await navigator.serviceWorker.register('/sw.js');

// 1 · Detectar que hi ha un worker nou esperant
registre.addEventListener('updatefound', () => {
  const nou = registre.installing;

  nou.addEventListener('statechange', () => {
    // 'installed' + hi ha un controlador = és una ACTUALITZACIÓ, no la primera instal·lació
    if (nou.state === 'installed' && navigator.serviceWorker.controller) {
      mostrarAvisActualitzacio(nou);
    }
  });
});

function mostrarAvisActualitzacio(treballadorNou) {
  $('#avis-versio').hidden = false;
  $('#avis-versio-actualitzar').addEventListener('click', () => {
    treballadorNou.postMessage({ tipus: 'saltar-espera' });    // 2 · l'usuari accepta
  }, { once: true });
}

// 3 · Quan el nou pren el control, recarregar UNA vegada
let recarregant = false;
navigator.serviceWorker.addEventListener('controllerchange', () => {
  if (recarregant) return;                                      // ← guarda contra bucles
  recarregant = true;
  window.location.reload();
});

// Comprovar si hi ha actualitzacions en tornar a la pestanya
document.addEventListener('visibilitychange', () => {
  if (document.visibilityState === 'visible') registre.update();
});

const ENTORN_LOCAL = ['localhost', '127.0.0.1'].includes(location.hostname);
if ('serviceWorker' in navigator && (!ENTORN_LOCAL || location.search.includes('sw=1'))) {
  navigator.serviceWorker.register('/sw.js');
}

// 1 · La pàgina demana permís i se subscriu (amb la clau pública VAPID del servidor)
const registre = await navigator.serviceWorker.ready;
const subscripcio = await registre.pushManager.subscribe({
  userVisibleOnly: true,
  applicationServerKey: CLAU_PUBLICA_VAPID
});
await api.desarSubscripcio(subscripcio);          // el servidor la necessita per enviar-te coses

// 2 · A sw.js: arriba el push
self.addEventListener('push', (esdeveniment) => {
  const dades = esdeveniment.data?.json() ?? {};
  esdeveniment.waitUntil(self.registration.showNotification('Nómada Tasques', {
    body: dades.missatge ?? 'Hi ha novetats al tauler',
    icon: '/icones/icona-192.png',
    data: { url: dades.url ?? '/' }
  }));
});

// 3 · L'usuari prem la notificació
self.addEventListener('notificationclick', (esdeveniment) => {
  esdeveniment.notification.close();
  esdeveniment.waitUntil(self.clients.openWindow(esdeveniment.notification.data.url));
});

// sw.js — a l'ARREL del lloc, perquè l'àmbit sigui '/'
const VERSIO = 'v3';
const CACHE_SHELL = `nomada-shell-${VERSIO}`;
const CACHE_DADES = `nomada-dades-${VERSIO}`;
const API = 'http://localhost:3000';                     // en producció, la URL real de l'API

const RECURSOS_SHELL = [
  '/', '/index.html', '/offline.html', '/manifest.json',
  '/css/estils.css',
  '/js/app.js',
  '/js/model/tasca.js', '/js/model/tauler.js', '/js/model/errors.js',
  '/js/dades/backlog.js', '/js/dades/repositori-local.js',
  '/js/dades/api-tasques.js', '/js/dades/http.js', '/js/dades/temps-real.js',
  '/js/util/dates.js', '/js/util/format.js', '/js/util/temps.js',
  '/js/vista/dom.js', '/js/vista/targeta.js', '/js/vista/pintar.js',
  '/js/vista/tauler-vista.js', '/js/vista/esdeveniments.js',
  '/js/vista/controlador.js', '/js/vista/formulari.js',
  '/icones/icona-192.png', '/icones/icona-512.png'
];

// ══════════════════ INSTAL·LACIÓ ══════════════════
self.addEventListener('install', (esdeveniment) => {
  console.log(`[sw] install ${VERSIO}`);
  esdeveniment.waitUntil(
    caches.open(CACHE_SHELL).then((cache) => cache.addAll(RECURSOS_SHELL))
  );
  // Sense skipWaiting(): l'actualització la decideix l'usuari (apartat 14)
});

// ══════════════════ ACTIVACIÓ ══════════════════
self.addEventListener('activate', (esdeveniment) => {
  console.log(`[sw] activate ${VERSIO}`);
  esdeveniment.waitUntil((async () => {
    const noms = await caches.keys();
    await Promise.all(
      noms
        .filter((n) => n.startsWith('nomada-') && !n.endsWith(VERSIO))
        .map((n) => caches.delete(n))
    );
    await self.clients.claim();
  })());
});

// ══════════════════ MISSATGES DES DE LA PÀGINA ══════════════════
self.addEventListener('message', (esdeveniment) => {
  if (esdeveniment.data?.tipus === 'saltar-espera') self.skipWaiting();
});

// ══════════════════ ESTRATÈGIES ══════════════════
async function cacheFirst(peticio) {
  const desada = await caches.match(peticio);
  if (desada) return desada;
  try {
    const resposta = await fetch(peticio);
    if (resposta.ok) (await caches.open(CACHE_SHELL)).put(peticio, resposta.clone());
    return resposta;
  } catch (error) {
    if (peticio.destination === 'image') return caches.match('/icones/icona-192.png');
    throw error;
  }
}

async function networkFirst(peticio) {
  try {
    const resposta = await fetch(peticio);
    if (resposta.ok) (await caches.open(CACHE_DADES)).put(peticio, resposta.clone());
    return resposta;
  } catch {
    const desada = await caches.match(peticio);
    if (desada) {
      const capcaleres = new Headers(desada.headers);
      capcaleres.set('X-Des-De-Cache', 'true');            // la interfície avisarà que és antic
      return new Response(desada.body, { status: 200, headers: capcaleres });
    }
    // Resposta JSON de reserva: millor que un error de xarxa opac
    return new Response(
      JSON.stringify({ error: 'sense-connexio', missatge: 'Sense connexió i sense còpia local.' }),
      { status: 503, headers: { 'Content-Type': 'application/json' } }
    );
  }
}

async function gestionarNavegacio(peticio) {
  try {
    return await fetch(peticio);
  } catch {
    return (await caches.match('/index.html')) ?? (await caches.match('/offline.html'));
  }
}

// ══════════════════ INTERCEPCIÓ ══════════════════
self.addEventListener('fetch', (esdeveniment) => {
  const peticio = esdeveniment.request;
  const url = new URL(peticio.url);

  if (peticio.method !== 'GET') return;                  // mai POST/PATCH/DELETE
  if (url.protocol.startsWith('ws')) return;             // el WebSocket de 07-04 va a part

  if (peticio.mode === 'navigate') {
    esdeveniment.respondWith(gestionarNavegacio(peticio));
    return;
  }
  if (url.origin === API) {
    esdeveniment.respondWith(networkFirst(peticio));
    return;
  }
  if (url.origin === self.location.origin) {
    esdeveniment.respondWith(cacheFirst(peticio));
  }
  // Qualsevol altre origen: sense respondWith, va a la xarxa tal qual
});

const CAPCALERA_DATA = 'X-Cachejat-En';

async function desarAmbMarca(nomCache, peticio, resposta) {
  const capcaleres = new Headers(resposta.headers);
  capcaleres.set(CAPCALERA_DATA, String(Date.now()));

  // Cal reconstruir la Response: les seves capçaleres són immutables
  const ambMarca = new Response(await resposta.clone().blob(), {
    status: resposta.status,
    statusText: resposta.statusText,
    headers: capcaleres
  });

  const cache = await caches.open(nomCache);
  await cache.put(peticio, ambMarca);
}

function estaCaducada(resposta, maxEdatMs) {
  const marca = Number(resposta.headers.get(CAPCALERA_DATA));
  if (!Number.isFinite(marca)) return true;          // sense marca: la tractem com a caducada
  return Date.now() - marca > maxEdatMs;
}

async function cacheAmbCaducitat(peticio, maxEdatMs = 3600000) {
  try {
    const resposta = await fetch(peticio);
    if (resposta.ok) await desarAmbMarca(CACHE_DADES, peticio, resposta);
    return resposta;
  } catch (error) {
    const cache = await caches.open(CACHE_DADES);
    const desada = await cache.match(peticio);

    if (!desada) throw error;
    if (estaCaducada(desada, maxEdatMs)) {
      await cache.delete(peticio);
      throw new Error('Còpia a la memòria cau massa antiga');
    }
    return desada;
  }
}

async function netejarCaducats(nomCache, maxEdatMs) {
  const cache = await caches.open(nomCache);
  const peticions = await cache.keys();

  await Promise.all(peticions.map(async (peticio) => {
    const resposta = await cache.match(peticio);
    if (resposta && estaCaducada(resposta, maxEdatMs)) await cache.delete(peticio);
  }));
}

const CLAU_REBUIG = 'nomada:actualitzacio-rebutjada';

export function vigilarActualitzacions(registre, { enHaverVersio }) {
  let recarregant = false;

  function avaluar(treballador) {
    if (treballador.state !== 'installed') return;
    if (!navigator.serviceWorker.controller) return;        // primera instal·lació, no actualització
    if (sessionStorage.getItem(CLAU_REBUIG) === 'si') return;

    enHaverVersio(() => treballador.postMessage({ tipus: 'saltar-espera' }));
  }

  // Un worker que ja estava esperant quan hem carregat
  if (registre.waiting && navigator.serviceWorker.controller) avaluar(registre.waiting);

  registre.addEventListener('updatefound', () => {
    const nou = registre.installing;
    nou?.addEventListener('statechange', () => avaluar(nou));
  });

  navigator.serviceWorker.addEventListener('controllerchange', () => {
    if (recarregant) return;                                // ← guarda contra el bucle infinit
    recarregant = true;
    window.location.reload();
  });

  document.addEventListener('visibilitychange', () => {
    if (document.visibilityState === 'visible') registre.update().catch(() => {});
  });
  setInterval(() => registre.update().catch(() => {}), 3600000);
}

<div id="avis-versio" role="status" aria-live="polite" hidden>
  <p>Hi ha una versió nova de Nómada Tasques.</p>
  <button type="button" id="versio-actualitzar">Actualitzar ara</button>
  <button type="button" id="versio-despres">Més tard</button>
</div>

vigilarActualitzacions(registre, {
  enHaverVersio(aplicar) {
    const avis = document.querySelector('#avis-versio');
    avis.hidden = false;
    document.querySelector('#versio-actualitzar')
      .addEventListener('click', aplicar, { once: true });
    document.querySelector('#versio-despres').addEventListener('click', () => {
      sessionStorage.setItem(CLAU_REBUIG, 'si');            // no insistir en aquesta sessió
      avis.hidden = true;
    }, { once: true });
  }
});

// auditar-shell.js — executar amb: node auditar-shell.js
import { readdirSync, readFileSync, statSync } from 'node:fs';
import { join, relative } from 'node:path';

const ARREL = process.cwd();

/** Recorre un directori recursivament retornant les rutes dels .js */
function llistarJs(directori) {
  const sortida = [];
  for (const entrada of readdirSync(directori)) {
    const ruta = join(directori, entrada);
    if (statSync(ruta).isDirectory()) sortida.push(...llistarJs(ruta));
    else if (entrada.endsWith('.js')) sortida.push('/' + relative(ARREL, ruta).replaceAll('\\', '/'));
  }
  return sortida;
}

const enDisc = new Set(llistarJs(join(ARREL, 'js')));

// Extreu les cadenes entre cometes de la llista RECURSOS_SHELL
const sw = readFileSync(join(ARREL, 'sw.js'), 'utf8');
const bloc = sw.match(/const RECURSOS_SHELL\s*=\s*\[([\s\S]*?)\]/)?.[1] ?? '';
const declarats = new Set([...bloc.matchAll(/'([^']+)'/g)].map((m) => m[1]));

const falten = [...enDisc].filter((r) => !declarats.has(r));
const sobren = [...declarats].filter((r) => r.startsWith('/js/') && !enDisc.has(r));

if (falten.length) console.error('❌ Falten a RECURSOS_SHELL:\n  ' + falten.join('\n  '));
if (sobren.length) console.error('❌ Declarats però inexistents:\n  ' + sobren.join('\n  '));

if (falten.length === 0 && sobren.length === 0) {
  console.log(`✅ La precàrrega està al dia (${enDisc.size} mòduls).`);
  process.exit(0);
}
process.exit(1);