@glassnote/client 2.4.11 → 2.4.13

package/linuxCursor.js

@@ -0,0 +1,187 @@
+// Donde esta el mouse, preguntado directo al servidor X.
+//
+// Hace falta porque screen.getCursorScreenPoint() de Electron miente justo en el unico caso
+// que le importa a un overlay: mientras la ventana ignora el mouse (input shape de 1x1 px en
+// X11) Chromium no recibe un solo evento de puntero, y esa funcion devuelve para siempre la
+// ultima posicion que alcanzo a ver. Medido:
+//
+//   ventana ignorando   -> sigue al mouse   (cae al XQueryPointer del servidor)
+//   ventana clickeable  -> sigue al mouse   (le llegan eventos reales)
+//   vuelve a ignorar    -> CONGELADA en el ultimo punto que vio, para siempre
+//
+// O sea: funciona hasta la primera interaccion y despues miente. Ese es exactamente el
+// "andaba y dejo de andar" del passthrough en Linux.
+//
+// Asi que se le pregunta al servidor: XQueryPointer, opcode 38. Es protocolo binario a mano,
+// pero es protocolo congelado hace decadas y no arrastra ninguna dependencia nativa —que en
+// este cliente, que se instala con npx y sin compilador, no es un lujo sino un requisito—.
+// Si algo falla (Wayland, display por TCP, sin cookie) se devuelve null y quien llama se las
+// arregla con lo que tenga.
+'use strict';
+
+const net = require('net');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const OPCODE_QUERY_POINTER = 38;
+
+let socket = null;
+let ventanaRaiz = null;
+let ultimaPosicion = null;
+let consultaEnVuelo = false;
+let inutilizable = false;
+
+// El .Xauthority es una lista de bloques con largo de 2 bytes big-endian: familia, direccion,
+// numero de display, nombre del metodo y la cookie. Solo interesa la MIT-MAGIC-COOKIE-1 de
+// este display (o la que no fija display, que vale para todos).
+function leerCookie(numeroDisplay) {
+	const archivo = process.env.XAUTHORITY || path.join(os.homedir(), '.Xauthority');
+	let buf;
+	try {
+		buf = fs.readFileSync(archivo);
+	} catch (error) {
+		return null;
+	}
+
+	let i = 0;
+	const bloque = () => {
+		if (i + 2 > buf.length) return null;
+		const largo = buf.readUInt16BE(i);
+		i += 2;
+		if (i + largo > buf.length) return null;
+		const datos = buf.subarray(i, i + largo);
+		i += largo;
+		return datos;
+	};
+
+	while (i + 2 <= buf.length) {
+		i += 2; // familia
+		const direccion = bloque();
+		const numero = bloque();
+		const nombre = bloque();
+		const cookie = bloque();
+		if (!direccion || !numero || !nombre || !cookie) break;
+		if (nombre.toString() !== 'MIT-MAGIC-COOKIE-1') continue;
+		const suDisplay = numero.toString();
+		if (suDisplay === '' || suDisplay === String(numeroDisplay)) return { nombre, cookie };
+	}
+	return null;
+}
+
+const relleno = (largo) => (4 - (largo % 4)) % 4;
+
+function numeroDeDisplay() {
+	const display = process.env.DISPLAY || '';
+	// Solo sockets unix locales: ":0", ":0.0". Un display por TCP ("host:0") no se atiende.
+	const coincide = /^:(\d+)/.exec(display);
+	return coincide ? parseInt(coincide[1], 10) : null;
+}
+
+function conectar() {
+	const numero = numeroDeDisplay();
+	if (numero === null) {
+		inutilizable = true;
+		return;
+	}
+
+	const auth = leerCookie(numero) || { nombre: Buffer.alloc(0), cookie: Buffer.alloc(0) };
+	let cliente;
+	try {
+		cliente = net.connect(`/tmp/.X11-unix/X${numero}`);
+	} catch (error) {
+		inutilizable = true;
+		return;
+	}
+
+	cliente.on('error', () => {
+		inutilizable = true;
+		socket = null;
+		ventanaRaiz = null;
+	});
+	cliente.on('close', () => {
+		socket = null;
+		ventanaRaiz = null;
+		consultaEnVuelo = false;
+	});
+
+	cliente.once('connect', () => {
+		const largoNombre = auth.nombre.length;
+		const largoCookie = auth.cookie.length;
+		const inicio = Buffer.alloc(
+			12 + largoNombre + relleno(largoNombre) + largoCookie + relleno(largoCookie)
+		);
+		inicio.write('l', 0, 'ascii'); // little endian
+		inicio.writeUInt16LE(11, 2); // protocolo 11.0
+		inicio.writeUInt16LE(0, 4);
+		inicio.writeUInt16LE(largoNombre, 6);
+		inicio.writeUInt16LE(largoCookie, 8);
+		auth.nombre.copy(inicio, 12);
+		auth.cookie.copy(inicio, 12 + largoNombre + relleno(largoNombre));
+		cliente.write(inicio);
+
+		cliente.once('data', (respuesta) => {
+			if (respuesta[0] !== 1) {
+				// 0 = rechazado (cookie mala), 2 = pide mas autenticacion.
+				inutilizable = true;
+				cliente.destroy();
+				return;
+			}
+			// La ventana raiz esta despues del vendor y de los formatos de pixel, todos de
+			// largo variable: hay que saltearlos para llegar a la primera pantalla.
+			const largoVendor = respuesta.readUInt16LE(24);
+			const cantidadFormatos = respuesta[29];
+			const inicioPantallas = 40 + largoVendor + relleno(largoVendor) + 8 * cantidadFormatos;
+			if (inicioPantallas + 4 > respuesta.length) {
+				inutilizable = true;
+				cliente.destroy();
+				return;
+			}
+			ventanaRaiz = respuesta.readUInt32LE(inicioPantallas);
+			socket = cliente;
+
+			cliente.on('data', (paquete) => {
+				// Respuesta de QueryPointer: 32 bytes, root_x y root_y en 20 y 22.
+				if (paquete.length >= 32 && paquete[0] === 1) {
+					ultimaPosicion = { x: paquete.readInt16LE(20), y: paquete.readInt16LE(22) };
+				}
+				consultaEnVuelo = false;
+			});
+		});
+	});
+}
+
+// Pide la posicion al servidor y devuelve la ULTIMA que contesto: la respuesta llega por el
+// socket, no en el acto. Consultando a 30 Hz eso son 30 ms de atraso, que para decidir si el
+// cursor esta sobre un boton no se nota. Nunca hay mas de una consulta en vuelo: si el
+// servidor se atrasa, no se le encima una cola de pedidos que ya no le sirven a nadie.
+function posicion() {
+	if (inutilizable) return null;
+	if (!socket) {
+		conectar();
+		return ultimaPosicion;
+	}
+	if (!consultaEnVuelo) {
+		const pedido = Buffer.alloc(8);
+		pedido[0] = OPCODE_QUERY_POINTER;
+		pedido.writeUInt16LE(2, 2); // largo en palabras de 4 bytes
+		pedido.writeUInt32LE(ventanaRaiz, 4);
+		consultaEnVuelo = true;
+		try {
+			socket.write(pedido);
+		} catch (error) {
+			consultaEnVuelo = false;
+		}
+	}
+	return ultimaPosicion;
+}
+
+function detener() {
+	if (socket) socket.destroy();
+	socket = null;
+	ventanaRaiz = null;
+	ultimaPosicion = null;
+	consultaEnVuelo = false;
+}
+
+module.exports = { posicion, detener };

package/main.js

@@ -13,14 +13,28 @@ const userData = require('./userData');
 const { ipcMain } = require('electron');
 const path = require('path');
 const fs = require('fs');
+const { execFile } = require('child_process');
 const AutoStart = require('./autoStart');
 const AutoUpdate = require('./autoupdate');
 const NpmUpdate = require('./npmUpdate');
 const VersionReport = require('./versionReport');
 const npmMode = require('./npmMode');
 const AutoUpdateRenderer = require('./autoupdate_renderer');
-const { baselineRendererDir, rendererVersionFrom: getRendererVersionFromPath } = require('./rendererPaths');
+const { resolverRenderer } = require('./rendererPaths');
+const cursorX11 = require('./linuxCursor');
 const { createTailUtility } = require('./logUtilities');
+const { crashReporter } = require('electron');
+
+// Sin esto un crash nativo —del proceso principal o de un hijo— no deja absolutamente
+// nada: ni log, ni volcado, y desde afuera se ve igual que un cierre voluntario. No se
+// sube a ningun lado. Los minidumps NO caen junto a los logs: van a la carpeta que
+// Electron llama crashDumps, que se arma con el nombre del paquete y queda en otro arbol
+// (<AppData>/@glassnote/client/Crashpad). Por eso el arranque la escribe en el log.
+try {
+	crashReporter.start({ uploadToServer: false });
+} catch (error) {
+	console.error('No se pudo iniciar el crashReporter:', error.message);
+}
 
 const logRenderer = packageJson.logRenderer !== undefined ? packageJson.logRenderer : true;
 
@@ -33,7 +47,12 @@ let mainWindow;
 let localServer = null;
 let tray = null;
 let lockCheckerInterval = null;
-let lockCheckerTimeout = null;
+let sondeoCursor = null;
+let ultimoPuntoEnviado = { x: null, y: null };
+let ultimoEnvioMs = 0;
+let cursorFueraDeLaVentana = false;
+let passthroughPedidoPorRenderer = true;
+let ignorandoMouse = true;
 let isCleaningUp = false;
 
 
@@ -53,15 +72,22 @@ function cleanupOldLogs() {
 		const now = Date.now();
 		const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1000;
 
+		const borrados = [];
 		files.forEach((file) => {
 			if (file.endsWith('.log')) {
 				const filePath = path.join(logsDir, file);
 				const stats = fs.statSync(filePath);
 				if (stats.mtimeMs < thirtyDaysAgo) {
 					fs.unlinkSync(filePath);
+					borrados.push(file);
 				}
 			}
 		});
+		if (borrados.length) {
+			console.warn(
+				`[logs] borrados ${borrados.length} de mas de 30 dias: ${borrados.join(', ')}`
+			);
+		}
 	} catch (error) {
 		console.error('Error cleaning up old logs:', error);
 	}
@@ -92,7 +118,67 @@ console.log = function (...args) {
 	// Call original console.log
 	originalConsoleLog.apply(console, args);
 };
+// console.warn no estaba interceptado y se perdian los 10 avisos del proceso principal,
+// justo los que dicen que algo raro paso pero todavia no es un error: entre ellos el
+// marcador de arranque de aca abajo y el "el archivo actual no es legible" de userData,
+// que es exactamente lo que hace falta para entender un cierre silencioso.
+const originalConsoleWarn = console.warn;
+console.warn = function (...args) {
+	const timestamp = new Date().toISOString();
+	const message = args
+		.map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg)))
+		.join(' ');
+
+	const logMessage = `[${timestamp}] WARN: ${message}\n`;
+
+	try {
+		fs.appendFileSync(logFilePath, logMessage, 'utf8');
+	} catch (error) {
+		originalConsoleWarn.apply(console, ['Error writing to log file:', error]);
+	}
+
+	originalConsoleWarn.apply(console, args);
+};
+
+// Marca de cierre limpio. Es lo unico que distingue "la app se cerro sola" de "a la app
+// la mataron", porque un crash o un apagado no llegan a borrarla. Se escribe en su propio
+// archivo y no en .glassnote, que es el del lock: tocar ese al salir seria pedirle a otra
+// instancia que se cierre.
+const marcaCierrePath = path.join(userData.getUserDataDir(), 'cierre-limpio');
+
+function huboCierreLimpio() {
+	try {
+		if (!fs.existsSync(marcaCierrePath)) return null;
+		const contenido = fs.readFileSync(marcaCierrePath, 'utf8').trim();
+		fs.unlinkSync(marcaCierrePath);
+		return contenido || 'sin motivo';
+	} catch (error) {
+		return null;
+	}
+}
+
+function marcarCierreLimpio(motivo) {
+	try {
+		fs.mkdirSync(userData.getUserDataDir(), { recursive: true });
+		fs.writeFileSync(marcaCierrePath, String(motivo), 'utf8');
+	} catch (error) {
+		console.error('No se pudo dejar la marca de cierre limpio:', error.message);
+	}
+}
+
+const cierreAnterior = huboCierreLimpio();
+
 console.warn('====== APPLICATION START ======');
+console.warn(
+	`arranque: v${packageJson.version} ${process.platform} ${process.arch} ` +
+	`electron ${process.versions.electron} node ${process.versions.node} pid ${process.pid}`
+);
+console.warn(`volcados de crash en: ${app.getPath('crashDumps')}`);
+console.warn(
+	cierreAnterior
+		? `el cierre anterior fue limpio (${cierreAnterior})`
+		: `ATENCION: el arranque anterior NO cerro limpio; se murio o lo mataron`
+);
 let initialLock = Date.now().toString();
 
 // Override console.error as well
@@ -117,7 +203,13 @@ console.error = function (...args) {
 };
 
 // Clean up old logs on startup
+// Corria una sola vez, al arrancar, y este cliente esta pensado para quedarse prendido
+// semanas: mientras siguiera vivo los logs de mas de 30 dias no se borraban nunca. Con el
+// log mas hablador eso se nota antes, asi que ademas se repasa una vez por dia. unref()
+// para que este reloj no sea motivo de que el proceso siga en pie.
+const LIMPIEZA_LOGS_MS = 24 * 60 * 60 * 1000;
 cleanupOldLogs();
+setInterval(cleanupOldLogs, LIMPIEZA_LOGS_MS).unref();
 
 // Create tail utility in logs directory for debugging
 createTailUtility(logsDir);
@@ -173,6 +265,8 @@ app.whenReady().then(() => {
 	const versionReport = new VersionReport();
 	versionReport.start();
 
+	avisarSiFaltaCompositor();
+
 	// Create system tray with platform-appropriate icon
 	let iconPath;
 	if (process.platform === 'win32') {
@@ -183,32 +277,34 @@ app.whenReady().then(() => {
 	} else {
 		iconPath = path.join(__dirname, 'images/icon.png');
 	}
-	tray = new Tray(iconPath);
-	const contextMenu = Menu.buildFromTemplate([
-		{
-			label: `glassnote v${packageJson.version}`,
-			enabled: false,
-		},
-		{ type: 'separator' },
-		{
-			label: 'Config Menu',
-			click: () => {
-				// Enviar mensaje al renderer para mostrar el ConfigMenu con vista Review
-				if (mainWindow && !mainWindow.isDestroyed()) {
-					mainWindow.webContents.send('show-config-menu', 'review');
-				}
+	// En Linux el icono de bandeja viaja por D-Bus (StatusNotifierItem) y Electron solo manda
+	// el mapa de bits. Los paneles cuyo watcher es ayatana-indicator-application (XFCE con el
+	// plugin Indicator, Unity, MATE) exigen ademas IconName y descartan el item completo si
+	// falta: el icono no aparece en ningun lado y no hay error. Chromium si escribe el icono a
+	// un archivo y manda IconName, pero solo cuando cree estar en GNOME o Pantheon
+	// (ShouldWriteIconToFile, status_icon_linux_dbus.cc). Eso se lee una unica vez, dentro del
+	// constructor de Tray, asi que se miente para esa linea y se restaura enseguida: al resto
+	// de Chromium (dialogos, decoraciones) le sigue constando el escritorio real.
+	const realDesktop = process.env.XDG_CURRENT_DESKTOP;
+	if (process.platform === 'linux') {
+		process.env.XDG_CURRENT_DESKTOP = 'GNOME';
+	}
+	try {
+		tray = new Tray(iconPath);
+	} finally {
+		if (process.platform === 'linux') {
+			if (realDesktop === undefined) {
+				delete process.env.XDG_CURRENT_DESKTOP;
+			} else {
+				process.env.XDG_CURRENT_DESKTOP = realDesktop;
 			}
 		}
-	]);
-	tray.setToolTip(`GlassNote v${packageJson.version}`);
-	tray.setContextMenu(contextMenu);
+	}
+	actualizarMenuTray();
 	
 	// Agregar funcionalidad de click izquierdo para mostrar el Config Menu
 	tray.on('click', () => {
-		// Enviar mensaje al renderer para mostrar el ConfigMenu con vista Review
-		if (mainWindow && !mainWindow.isDestroyed()) {
-			mainWindow.webContents.send('show-config-menu', 'review');
-		}
+		abrirConfigMenu('review');
 	});
 
 	// Platform-specific window configuration
@@ -246,6 +342,39 @@ app.whenReady().then(() => {
 		// es el borde negro que se ve alrededor de los mensajes. Una capa de overlay no
 		// necesita sombra.
 		windowOptions.hasShadow = false;
+	} else if (process.platform === 'linux') {
+		// En Linux fullscreen es justo lo que NO hay que pedir. Un gestor de ventanas
+		// tipico —xfwm4, y no es el unico— trata "pantalla completa" como una app que se
+		// adueña del monitor: mientras tiene el foco la deja arriba de todo, y en cuanto se
+		// lo lleva otra ventana la BAJA, para que se pueda salir de ella. Medido en XFCE:
+		//
+		//   fullscreen: true  -> _NET_WM_STATE_FULLSCREEN, sin ABOVE; al enfocar otra
+		//                        ventana el overlay cae de la posicion 14/14 a la 9/14
+		//   del tamaño de la pantalla -> _NET_WM_STATE_ABOVE, se queda en 14/14
+		//
+		// O sea que el alwaysOnTop solo se respeta si la ventana NO es fullscreen: pedir las
+		// dos cosas a la vez es pedir que se ignore la que importa.
+		//
+		// Va al AREA UTIL y no a la pantalla entera porque una ventana normal no puede
+		// meterse debajo de los paneles: si se le pide la pantalla completa, el gestor la
+		// empuja igual —queda en (0,25) y con 25 px afuera— y encima el tamaño le baja un
+		// pixel solo. Pidiendo el area util la geometria sale exacta y estable, que es lo que
+		// necesita el renderer para colocar los glasses.
+		const areaUtil = screen.getPrimaryDisplay().workArea;
+		windowOptions.x = areaUtil.x;
+		windowOptions.y = areaUtil.y;
+		windowOptions.width = areaUtil.width;
+		windowOptions.height = areaUtil.height;
+		windowOptions.fullscreen = false;
+		// `skipTaskbar` no existe en Linux —Electron solo lo implementa para Windows y macOS—
+		// asi que el overlay salia como una ventana normal y el panel le ponia su boton, que
+		// para una capa transparente no tiene ningun sentido. Se arregla por el tipo de
+		// ventana: TOOLBAR sale con SKIP_TASKBAR y SKIP_PAGER puestos por el gestor.
+		//
+		// De los tipos que Linux acepta es el unico que sirve: `splash` tambien se esconde
+		// pero NO se puede enfocar, y sin foco el ConfigMenu se queda sin teclado;
+		// `notification` se enfoca pero igual aparece en la barra.
+		windowOptions.type = 'toolbar';
 	} else {
 		// Windows and other platforms
 		windowOptions.width = 400;
@@ -358,22 +487,90 @@ app.whenReady().then(() => {
 	// Cargar el HTML del renderer (priorizar userData, fallback a app)
 	loadRendererHtml(mainWindow, uuid);
 
-	// Mouse events control
+	// Mouse events control (en Linux el forward lo emula iniciarSondeoCursor)
 	mainWindow.setIgnoreMouseEvents(true, { forward: true });
+	iniciarSondeoCursor();
 	ipcMain.on('set-ignore-events-true', () => {
-		mainWindow.setIgnoreMouseEvents(true, { forward: true });
+		pedirPassthrough(true);
 	});
 	ipcMain.on('set-ignore-events-false', () => {
-		mainWindow.setIgnoreMouseEvents(false, { forward: true });
+		pedirPassthrough(false);
 	});
 
 	// Window visibility control
+	//
+	// showInactive y no show: un glass es una notificacion, no tiene por que sacarle el
+	// teclado a lo que el usuario este haciendo. show() enfoca la ventana, y como el
+	// overlay ocupa toda la pantalla eso equivale a interrumpir. El unico que necesita
+	// foco es el ConfigMenu, y ese lo pide aparte.
 	ipcMain.on('show-window', () => {
 		if (mainWindow && !mainWindow.isDestroyed()) {
-			mainWindow.show();
+			mainWindow.showInactive();
 		}
 	});
 
+	// En X11 la ventana pierde la input shape al volver a mostrarse, y con ella el
+	// passthrough: el overlay se queda comiendo los clics de TODA la pantalla aunque las dos
+	// mitades del programa crean que esta dejando pasar el mouse. Medido con la ventana X que
+	// hay bajo el puntero, que es quien manda de verdad:
+	//
+	//   sin nada en pantalla -> la ventana de abajo    (pasa el clic)
+	//   despues de show()    -> el overlay             (se lo come)
+	//
+	// Por eso el glass del splash se portaba bien —la ventana ya estaba mapeada desde el
+	// arranque— y cualquier mensaje posterior bloqueaba: cada uno llega con su show(). Se
+	// reaplica en el evento, no en el handler del IPC, para cubrir tambien los show() que
+	// salen de otro lado.
+	// Y la GEOMETRIA se pierde igual que la input shape. El gestor recoloca la ventana por
+	// su cuenta DESPUES de mapearla y la deja corrida 25 px hacia el monitor de al lado, asi
+	// que el primer glass salia bien y los siguientes no. Medido con xwininfo, que es quien
+	// dice la verdad: getBounds() de Electron devuelve lo que se pidio, no lo que quedo.
+	//
+	//   pedido x=0 -> electron dice x=0, X11 dice x=25
+	//
+	// Pedirla una sola vez al mostrar es una carrera que se pierde la mitad de las veces
+	// (medido: 25, 0, 25 en tres glasses seguidos). Por eso se reacciona tambien al evento
+	// `move`, que es el gestor avisando que la movio, y se la vuelve a poner. El contador
+	// corta el ida y vuelta por si alguna vez el gestor se planta.
+	//
+	// Se le pide de la barra de arriba hasta el borde de abajo: asi la ventana entra justa
+	// en la pantalla, no se sale por la derecha, tapa el panel inferior y le deja al arte
+	// una proporcion mucho mas cerca de 16:9 que el area util.
+	let correccionesDeGeometria = 0;
+
+	function fijarGeometria() {
+		if (!mainWindow || mainWindow.isDestroyed()) return;
+		const pantalla = screen.getPrimaryDisplay();
+		mainWindow.setBounds({
+			x: 0,
+			y: pantalla.workArea.y,
+			width: pantalla.bounds.width,
+			height: pantalla.bounds.height - pantalla.workArea.y
+		});
+	}
+
+	mainWindow.on('move', () => {
+		if (process.platform !== 'linux') return;
+		if (correccionesDeGeometria >= 8) return;
+		correccionesDeGeometria++;
+		fijarGeometria();
+	});
+
+	mainWindow.on('show', () => {
+		if (process.platform === 'linux') {
+			correccionesDeGeometria = 0;
+			fijarGeometria();
+		}
+		reafirmarAlwaysOnTop();
+		aplicarPassthrough({ forzar: true });
+	});
+
+	// El canal ya estaba habilitado en el preload para renderer -> main, pero del lado de
+	// main no lo escuchaba nadie: el menu solo se podia abrir desde la bandeja.
+	ipcMain.on('show-config-menu', (event, vista) => {
+		abrirConfigMenu(vista);
+	});
+
 	ipcMain.on('hide-window', () => {
 		if (mainWindow && !mainWindow.isDestroyed()) {
 			mainWindow.hide();
@@ -404,6 +601,9 @@ app.whenReady().then(() => {
 		const registrationWindow = new BrowserWindow({
 			width: 1200,
 			height: 800,
+			// Sin esto Electron no pone _NET_WM_ICON y la unica ventana que sale en la barra de
+			// tareas de Linux aparece con el icono generico del gestor de ventanas.
+			icon: path.join(__dirname, 'images/icon.png'),
 			minWidth: 800,
 			minHeight: 600,
 			show: false,
@@ -434,7 +634,7 @@ app.whenReady().then(() => {
 	});
 
 	mainWindow.on('ready-to-show', () => {
-		mainWindow.show();
+		mainWindow.showInactive();
 
 		// Use LocalServer singleton
 		if (!localServer) {
@@ -449,12 +649,30 @@ app.whenReady().then(() => {
 	lockChecker();
 });
 
+// Un crash del renderer o de un hijo (GPU, utility) no pasa por ningun handler de los de
+// arriba: no es una excepcion de JavaScript ni una senal, asi que el log se quedaba mudo.
+// `reason` es lo que hay que leer: 'crashed', 'oom', 'killed', 'abnormal-exit',
+// 'launch-failed', 'integrity-failure' o 'clean-exit'.
+app.on('render-process-gone', (event, webContents, details) => {
+	console.error(
+		`====== MURIO EL RENDERER: ${details.reason} (exitCode ${details.exitCode}) ======`
+	);
+});
+
+app.on('child-process-gone', (event, details) => {
+	console.error(
+		`====== MURIO UN PROCESO HIJO: ${details.type}` +
+			`${details.name ? ' (' + details.name + ')' : ''} ` +
+			`${details.reason} (exitCode ${details.exitCode}) ======`
+	);
+});
+
 app.on('window-all-closed', () => {
 	// Don't quit when all windows are closed if we have a tray
 	if (tray && process.platform !== 'darwin') {
 		// Keep the app running with tray
 	} else {
-		cleanupAndQuit();
+		cleanupAndQuit('se cerraron todas las ventanas');
 	}
 });
 
@@ -498,23 +716,199 @@ function lockChecker() {
 	lockCheckerInterval = setInterval(() => {
 		// Leer el lock directamente del archivo, no del cache
 		const currentData = userData.getLockFromFile();
-		// Si currentData es undefined, significa que el archivo .glassnote fue borrado o corrompido
-		// También verificar si el valor del lock cambió
-		if (currentData === undefined || currentData.toString() != initialLock.toString()) {
-			cleanupAndQuit();
+		
+		// Esta es la via por la que la app se cerraba sin dejar rastro, y las dos causas no
+		// son la misma cosa: que el archivo no este es un problema del disco o de algo que
+		// lo borro, y que el lock haya cambiado significa que arranco otra instancia y esta
+		// le cede el lugar. Se distinguen en el log porque llevan a sitios muy distintos.
+		if (currentData === undefined) {
+			cleanupAndQuit('el lock no se pudo leer: .glassnote no esta o no tiene lock');
+			return;
+		}
+		if (currentData.toString() != initialLock.toString()) {
+			cleanupAndQuit(
+				`el lock cambio (mio ${initialLock}, en el archivo ${currentData}): arranco otra instancia`
+			);
 		}
 	}, 10000); // Check every 10 seconds
 }
 
-function cleanupAndQuit() {
+// El overlay deja pasar el mouse y solo se vuelve clickeable cuando el cursor esta encima
+// de algo interactivo. Quien decide eso es el renderer: escucha `mousemove` en el document,
+// compara la posicion contra los rectangulos de los elementos que registro, y pide apagar o
+// encender el passthrough. Para decidir, entonces, necesita ver el mouse.
+//
+// En Windows y macOS se lo da `forward: true`. En Linux esa opcion NO EXISTE: Electron le
+// pone al window una input shape de 1x1 px en X11 y el flag ni se mira (SetIgnoreMouseEvents
+// en native_window_views.cc solo lo usa bajo IS_WIN). Sin un solo evento de mouse la
+// posicion que guarda el renderer se queda en null para siempre, ningun elemento resulta
+// nunca "bajo el cursor", y por eso en Linux no responde un boton.
+//
+// Se emula: se lee la posicion global del cursor y se le inyecta al renderer un mouseMove
+// sintetico, que es exactamente lo que forwardea Windows. El hit-test sigue donde estan las
+// zonas —en el renderer—; desde aca solo se le cuenta donde esta el mouse.
+const SONDEO_CURSOR_MS = 30;
+// Cada cuanto se repite la posicion aunque el cursor no se haya movido.
+const REEMISION_QUIETO_MS = 400;
+
+// El passthrough efectivo sale de dos cosas: lo que pidio el renderer y si el cursor esta
+// siquiera sobre la ventana.
+//
+// Lo segundo no es un detalle: cuando el overlay esta clickeable y el cursor se va —a otro
+// monitor, por ejemplo— el renderer no recibe un mousemove mas, se queda con la ultima
+// posicion (encima del boton) y nunca devuelve el passthrough. El overlay se queda comiendo
+// TODOS los clics de esa pantalla.
+//
+// No es solo de X11. Medido en Windows con dos monitores: al salir la ventana NO llega
+// ningun mouseleave —se probo, y el evento recien aparece cuando el cursor vuelve—, asi que
+// el overlay queda clickeable todo el tiempo que estes en la otra pantalla. Ahi se cura
+// solo al volver, porque con la ventana clickeable los movimientos reales si le llegan;
+// en Linux quedaba trabado hasta reiniciar. Con un solo monitor no se dispara: el overlay
+// ocupa toda la pantalla y el cursor no tiene por donde salirse.
+//
+// Y avisarselo por un mouseMove sintetico no se puede: Chromium descarta los eventos
+// cuyas coordenadas caen fuera de la ventana. Asi que el "esta afuera" lo resuelve el
+// main, sin tocar lo que el renderer cree: cuando el cursor vuelve a entrar se reaplica
+// su decision tal cual, y desde ahi los eventos reales —que si llegan con la ventana
+// clickeable— lo ponen al dia.
+// El "siempre encima" se vuelve a pedir en cada show, y no alcanza con pedirlo una vez al
+// arrancar. Electron guarda el nivel de z-order como un estado suyo y solo baja a la API
+// del sistema cuando ESE estado cambia: si Windows le saca el TOPMOST a la ventana por su
+// cuenta, para Electron sigue estando arriba —isAlwaysOnTop() devuelve true— y no vuelve a
+// pedirlo nunca. De ahi el false y despues el true: es la unica forma de forzar que se
+// reemita.
+//
+// Antes esto no se notaba porque cada glass entraba con show(), que ademas de mostrar
+// ACTIVA la ventana, y activarla la sube igual. Al pasar a showInactive() —para no robarle
+// el teclado a lo que estes haciendo— se muestra sin activar, y con eso quedo a la vista
+// que el alwaysOnTop no se estaba reponiendo.
+//
+// En Linux no se toca: ahi el "arriba de todo" es _NET_WM_STATE_ABOVE y quitarlo y ponerlo
+// invita al gestor de ventanas a recolocar la ventana, que es justo lo que costo domar.
+function reafirmarAlwaysOnTop() {
+	if (!mainWindow || mainWindow.isDestroyed()) return;
+	if (process.platform === 'linux') return;
+	mainWindow.setAlwaysOnTop(false);
+	mainWindow.setAlwaysOnTop(true, 'screen-saver');
+}
+
+function aplicarPassthrough({ forzar = false } = {}) {
+	if (!mainWindow || mainWindow.isDestroyed()) return;
+	const ignorar = passthroughPedidoPorRenderer || cursorFueraDeLaVentana;
+	if (ignorar === ignorandoMouse && !forzar) return;
+	ignorandoMouse = ignorar;
+	mainWindow.setIgnoreMouseEvents(ignorar, { forward: true });
+}
+
+function pedirPassthrough(ignore) {
+	passthroughPedidoPorRenderer = ignore;
+	aplicarPassthrough();
+}
+
+function iniciarSondeoCursor() {
+	if (sondeoCursor) return;
+	const enLinux = process.platform === 'linux';
+	sondeoCursor = setInterval(() => {
+		if (!mainWindow || mainWindow.isDestroyed() || !mainWindow.isVisible()) return;
+
+		// En X11 screen.getCursorScreenPoint() no sirve: con la ventana ignorando el mouse
+		// Chromium se queda sin eventos y devuelve congelada la ultima posicion que vio
+		// (el porque, medido, esta en linuxCursor.js). Se le pregunta al servidor X. En
+		// Windows no hace falta: ahi la posicion sale del SO y viene siempre al dia.
+		const cursor = (enLinux ? cursorX11.posicion() : null) || screen.getCursorScreenPoint();
+		const area = mainWindow.getBounds();
+		const x = cursor.x - area.x;
+		const y = cursor.y - area.y;
+		const dentro = x >= 0 && y >= 0 && x < area.width && y < area.height;
+
+		if (!dentro !== cursorFueraDeLaVentana) {
+			cursorFueraDeLaVentana = !dentro;
+			aplicarPassthrough();
+		}
+		if (!dentro) return;
+
+		// De aca para abajo es solo de Linux. En Windows el `forward: true` de
+		// setIgnoreMouseEvents ya entrega los movimientos reales con la ventana ignorando
+		// el mouse —medido: el boton recibe mouseover y se puede clickear—, asi que
+		// inyectarlos seria duplicarlos.
+		if (!enLinux) return;
+
+		// Con el overlay ya clickeable los eventos reales llegan solos: inyectar seria
+		// duplicarlos.
+		if (!ignorandoMouse) return;
+
+		// Repetir el mismo punto en cada tick es ruido, pero callarse del todo mientras el
+		// cursor esta quieto rompe el otro caso: el menu se abre DEBAJO de un cursor que no
+		// se movio, no hay mousemove que lo cuente, y ese boton nace muerto. Se reemite cada
+		// tanto para que la UI que aparece sola se entere igual.
+		const ahora = Date.now();
+		const mismoPunto = x === ultimoPuntoEnviado.x && y === ultimoPuntoEnviado.y;
+		if (mismoPunto && ahora - ultimoEnvioMs < REEMISION_QUIETO_MS) return;
+		ultimoPuntoEnviado = { x, y };
+		ultimoEnvioMs = ahora;
+		mainWindow.webContents.sendInputEvent({ type: 'mouseMove', x, y });
+	}, SONDEO_CURSOR_MS);
+}
+
+function detenerSondeoCursor() {
+	cursorX11.detener();
+	if (!sondeoCursor) return;
+	clearInterval(sondeoCursor);
+	sondeoCursor = null;
+	ultimoPuntoEnviado = { x: null, y: null };
+	ultimoEnvioMs = 0;
+	cursorFueraDeLaVentana = false;
+}
+
+// Una ventana transparente en X11 necesita un compositor: sin el, el servidor X no sabe
+// mezclar el ARGB con lo que hay detras y la ventana se pinta OPACA. En un overlay a
+// pantalla completa eso no es un detalle estetico, es la pantalla entera tapada de blanco.
+// La app no puede arreglarlo desde adentro —es una pieza del escritorio, no suya—, pero
+// callarselo es peor: el equipo queda inservible y no hay una sola linea que lo explique.
+//
+// Solo se comprueba en XFCE, que es el unico escritorio comun que viene con el compositor
+// apagable (y apagado en varias instalaciones). GNOME, KDE y Cinnamon componen siempre.
+function avisarSiFaltaCompositor() {
+	if (process.platform !== 'linux') return;
+	if ((process.env.XDG_SESSION_TYPE || '') === 'wayland') return; // Wayland siempre compone
+	if (!(process.env.XDG_CURRENT_DESKTOP || '').toUpperCase().includes('XFCE')) return;
+
+	execFile('xfconf-query', ['-c', 'xfwm4', '-p', '/general/use_compositing'], (error, stdout) => {
+		if (error) return; // sin xfconf-query no hay nada que comprobar
+		if (stdout.trim() !== 'false') return;
+
+		const arreglo = 'xfconf-query -c xfwm4 -p /general/use_compositing -s true';
+		console.warn('[transparencia] XFCE tiene el compositor APAGADO: la ventana de glassnote se');
+		console.warn('[transparencia] dibuja opaca y tapa la pantalla. Se enciende con:');
+		console.warn(`[transparencia]   ${arreglo}`);
+		console.warn('[transparencia] o en Ajustes del gestor de ventanas > Compositor.');
+
+		try {
+			new Notification({
+				title: 'GlassNote: falta el compositor',
+				body: `Sin compositor la ventana se ve opaca y tapa la pantalla. Encendelo con:\n${arreglo}`,
+			}).show();
+		} catch (error) {
+			/* un escritorio sin notificaciones no puede tumbar el arranque */
+		}
+	});
+}
+
+function cleanupAndQuit(motivo) {
 	// Prevent multiple cleanup calls
 	if (isCleaningUp) {
 		return;
 	}
 	isCleaningUp = true;
+
+	// Cerrarse sin decir por que es lo que hacia imposible investigar los reinicios: en el
+	// log quedaba un silencio y despues el arranque siguiente, sin nada en el medio.
+	console.warn(`====== CIERRE VOLUNTARIO: ${motivo || 'sin motivo'} ======`);
+	marcarCierreLimpio(motivo || 'sin motivo');
 	
 	
 	// Clear intervals and timeouts
+	detenerSondeoCursor();
 	if (lockCheckerInterval) {
 		clearInterval(lockCheckerInterval);
 		lockCheckerInterval = null;
@@ -554,22 +948,22 @@ function cleanupAndQuit() {
 
 // Handle process signals for clean shutdown
 process.on('SIGINT', () => {
-	cleanupAndQuit();
+	cleanupAndQuit('SIGINT');
 });
 
 process.on('SIGTERM', () => {
-	cleanupAndQuit();
+	cleanupAndQuit('SIGTERM');
 });
 
 // Handle uncaught exceptions to prevent zombie processes
 process.on('uncaughtException', (error) => {
 	console.error('Uncaught exception:', error);
-	cleanupAndQuit();
+	cleanupAndQuit('excepcion no capturada');
 });
 
 process.on('unhandledRejection', (reason, promise) => {
 	console.error('Unhandled promise rejection:', reason);
-	cleanupAndQuit();
+	cleanupAndQuit('promesa rechazada sin manejar');
 });
 
 // Start lock checker after everything is initialized
@@ -577,143 +971,88 @@ process.on('unhandledRejection', (reason, promise) => {
 
 
 /**
- * Carga el HTML del renderer desde la fuente con versión SUPERIOR.
- *
- * Dos fuentes, y la division importa:
- *   - userData: lo que bajo el auto-update de S3. Es el canal EN CALIENTE: una version
- *     nueva del renderer llega ahi sin republicar el cliente ni tocar el binario.
- *   - baseline: el renderer que viaja con la instalacion. Es lo que ve una instalacion
- *     nueva antes de su primer update en caliente.
- *
- * Gana la version mas alta, sin importar de donde venga; empate, gana userData.
+ * Carga el HTML del renderer. Cual de las dos fuentes gana lo decide resolverRenderer()
+ * en rendererPaths.js, que es tambien de donde sale la version que muestra el menu.
+ */
+/**
+ * Abre el ConfigMenu. Es lo unico de la app que usa el teclado, y desde que los glasses
+ * se muestran con showInactive() la ventana ya no viene enfocada de arriba: hay que
+ * mostrarla y pedirle el foco a mano antes de avisarle al renderer.
  */
-// baselineRendererDir vive en rendererPaths.js: lo comparte con el updater del renderer.
+function abrirConfigMenu(vista) {
+	if (!mainWindow || mainWindow.isDestroyed()) return;
+	mainWindow.show();
+	mainWindow.focus();
+	mainWindow.webContents.send('show-config-menu', vista || 'review');
+}
 
 function loadRendererHtml(window, uuid) {
-  // Definir las dos fuentes a considerar con archivos HTML alternativos
-  const sources = [
-    {
-      name: 'userData',
-      dir: path.join(userData.getUserDataDir(), 'renderer'),
-      htmlFiles: ['glassnote.html'], // userData siempre usa glassnote.html
-      type: 'auto-update'
-    },
-    {
-      name: 'baseline',
-      dir: baselineRendererDir(),
-      htmlFiles: ['glassnote.html', 'index.html'], // Intenta glassnote.html primero, luego index.html
-      type: 'paquete'
-    }
-  ];
-
-
-  // Obtener versiones y verificar archivos HTML para ambas fuentes
-  const sourcesWithInfo = sources.map(source => {
-    const version = getRendererVersionFromPath(source.dir);
-    
-    // Buscar el primer archivo HTML que exista
-    let htmlPath = null;
-    let htmlFile = null;
-    for (const file of source.htmlFiles) {
-      const potentialPath = path.join(source.dir, file);
-      if (fs.existsSync(potentialPath)) {
-        htmlPath = potentialPath;
-        htmlFile = file;
-        break;
-      }
-    }
-    
-    const htmlExists = htmlPath !== null;
-    
-    return {
-      ...source,
-      version,
-      htmlPath,
-      htmlFile,
-      htmlExists
-    };
-  });
-
-  // Log de información encontrada
-  sourcesWithInfo.forEach(source => {
-    if (source.htmlExists) {
-    } else {
-      console.log(`  ${source.name}: versión ${source.version}, SIN ARCHIVO HTML`);
+  const { elegida, fuentes } = resolverRenderer();
+
+  for (const fuente of fuentes) {
+    if (!fuente.htmlPath) {
+      console.log(`  ${fuente.nombre}: versión ${fuente.version}, SIN ARCHIVO HTML`);
     }
-  });
-
-  // Comparar versiones para determinar cuál es superior
-  const versionComparison = compareVersions(
-    sourcesWithInfo[0].version,
-    sourcesWithInfo[1].version
-  );
-
-  // Determinar fuente con versión superior
-  let superiorSource;
-  if (versionComparison > 0) {
-    // userData tiene versión superior
-    superiorSource = sourcesWithInfo[0];
-  } else if (versionComparison < 0) {
-    // glassnote-renderer/dist tiene versión superior
-    superiorSource = sourcesWithInfo[1];
-  } else {
-    // Versiones iguales, priorizar userData (auto-update)
-    superiorSource = sourcesWithInfo[0];
   }
 
-  // Intentar cargar desde la fuente con versión superior
-  if (superiorSource.htmlExists) {
-    window.loadFile(superiorSource.htmlPath, {
+  if (elegida) {
+    window.loadFile(elegida.htmlPath, {
       query: { uuid: uuid, version: packageJson.version }
     });
+    // El menu de la bandeja muestra la version del renderer, y esta es la linea que la
+    // decide: rearmarlo aca es lo que hace que despues de un update en caliente el numero
+    // del menu sea el que se acaba de cargar y no el del arranque.
+    actualizarMenuTray();
     return;
   }
 
-  // Si la fuente con versión superior no tiene HTML, intentar la otra fuente
-  const otherSource = superiorSource.name === 'userData' ? sourcesWithInfo[1] : sourcesWithInfo[0];
-  
-  if (otherSource.htmlExists) {
-	
-    window.loadFile(otherSource.htmlPath, {
-      query: { uuid: uuid, version: packageJson.version }
-    });
-    return;
+  console.error('ERROR: No se encontró archivo HTML del renderer en ninguna fuente');
+  for (const fuente of fuentes) {
+    console.error(`${fuente.nombre} (${fuente.dir}) buscó:`, fuente.htmls.join(', '));
   }
 
-  // Si ninguna fuente tiene HTML, error
-  console.error('ERROR: No se encontró archivo HTML del renderer en ninguna fuente');
-  console.error('userData buscó:', sourcesWithInfo[0].htmlFiles.join(', '));
-  console.error(`baseline (${sourcesWithInfo[1].dir}) buscó:`, sourcesWithInfo[1].htmlFiles.join(', '));
-  
   // Error fatal - no hay renderer disponible
   console.error('ERROR FATAL: No se puede cargar el renderer');
-  // Intentar cargar una página de error o cerrar la aplicación
   window.loadURL('data:text/html,<h1>Error: No se pudo cargar el renderer</h1>');
 }
 
 /**
- * Compara dos versiones semánticas (formato: major.minor.patch)
- * Retorna 1 si version1 > version2
- * Retorna 0 si version1 == version2
- * Retorna -1 si version1 < version2
+ * El menu de la bandeja. Se rearma entero en vez de editarse porque Electron no deja
+ * cambiar la etiqueta de un item ya construido en Linux.
+ *
+ * Lleva las dos versiones a proposito: el cliente y el renderer se actualizan por vias
+ * distintas —npm una, el zip de S3 la otra— y se desincronizan seguido. Con un solo
+ * numero a la vista no habia forma de saber, mirando el equipo, cual de las dos partes
+ * era la vieja.
  */
-function compareVersions(version1, version2) {
-	const v1Parts = version1.split('.').map((part) => parseInt(part) || 0);
-	const v2Parts = version2.split('.').map((part) => parseInt(part) || 0);
-
-	// Comparar partes principales (major, minor, patch)
-	for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
-		const v1Part = v1Parts[i] || 0;
-		const v2Part = v2Parts[i] || 0;
-
-		if (v1Part > v2Part) return 1;
-		if (v1Part < v2Part) return -1;
-	}
-
-	return 0; // Las versiones son iguales
+function construirMenuTray(versionRenderer) {
+	return Menu.buildFromTemplate([
+		{
+			label: `glassnote v${packageJson.version}`,
+			enabled: false,
+		},
+		{
+			label: versionRenderer ? `renderer v${versionRenderer}` : 'renderer: no cargado',
+			enabled: false,
+		},
+		{ type: 'separator' },
+		{
+			label: 'Config Menu',
+			click: () => {
+				abrirConfigMenu('review');
+			}
+		}
+	]);
 }
 
-// getRendererVersionFromPath = rendererVersionFrom de rendererPaths.js (ver el require de arriba).
+function actualizarMenuTray() {
+	if (!tray || tray.isDestroyed()) return;
+	const versionRenderer = (resolverRenderer().elegida || {}).version;
+	tray.setToolTip(
+		`GlassNote v${packageJson.version}` + (versionRenderer ? ` · renderer v${versionRenderer}` : '')
+	);
+	tray.setContextMenu(construirMenuTray(versionRenderer));
+}
 
 /**
  * Recarga el main window después de una actualización del renderer
@@ -726,6 +1065,12 @@ function reloadMainWindow() {
 			localServer.updateMainWindow(mainWindow);
 		}
 
+		// El renderer que vuelve a cargar arranca creyendo que el overlay deja pasar el
+		// mouse. Si habia quedado clickeable, nadie se lo iba a devolver: el renderer solo
+		// avisa cuando CAMBIA de estado, y para el recien nacido no cambio nada. Se vuelve
+		// al estado inicial a mano para que las dos mitades arranquen de acuerdo.
+		pedirPassthrough(true);
+
 		loadRendererHtml(mainWindow, uuid);
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassnote/client",
-  "version": "2.4.11",
+  "version": "2.4.13",
   "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
   "main": "main.js",
   "publishConfig": {
@@ -30,6 +30,7 @@
     "autoupdate.js",
     "autoupdate_renderer.js",
     "rendererPaths.js",
+    "linuxCursor.js",
     "npmMode.js",
     "npmUpdate.js",
     "versionReport.js",
@@ -73,7 +74,7 @@
     "url": "git+ssh://git@intermarkec/intermarkec/glassnote-electron.git"
   },
   "dependencies": {
-    "@glassnote/renderer": "2.0.9",
+    "@glassnote/renderer": "2.0.12",
     "cors": "^2.8.5",
     "electron": "^29.4.6",
     "express": "^4.18.2",

package/rendererPaths.js

@@ -10,6 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const userData = require('./userData');
 
 // El baseline es la dependencia @glassnote/renderer, que npm resuelve sola. Pero si hay
 // un clon del renderer al lado —el flujo de quien lo desarrolla, con `npm run
@@ -59,4 +60,59 @@ function compareRendererVersions(a, b) {
 	return 0;
 }
 
-module.exports = { baselineRendererDir, rendererVersionFrom, compareRendererVersions };
+// Cual de los dos renderers se usa de verdad, con el mismo criterio para el que lo carga
+// y para el que solo quiere mostrar la version. Si fueran dos calculos, el numero del menu
+// terminaria mintiendo el dia que uno de los dos cambie.
+//
+//   - userData: lo que bajo el auto-update de S3. Es el canal EN CALIENTE: una version
+//     nueva llega ahi sin republicar el cliente ni tocar el binario.
+//   - baseline: el renderer que viaja con la instalacion, lo que ve un equipo recien
+//     instalado antes de su primer update en caliente.
+//
+// Gana la version mas alta venga de donde venga; si empatan gana userData. Pero una
+// fuente sin HTML no se puede cargar, asi que en ese caso se cae a la otra: la version
+// que se informa es la que de verdad esta corriendo, no la que gano la comparacion.
+function resolverRenderer() {
+	const fuentes = [
+		{
+			nombre: 'userData',
+			dir: path.join(userData.getUserDataDir(), 'renderer'),
+			htmls: ['glassnote.html'], // userData siempre usa glassnote.html
+		},
+		{
+			nombre: 'baseline',
+			dir: baselineRendererDir(),
+			htmls: ['glassnote.html', 'index.html'],
+		},
+	].map((fuente) => {
+		let htmlPath = null;
+		for (const archivo of fuente.htmls) {
+			const posible = path.join(fuente.dir, archivo);
+			if (fs.existsSync(posible)) {
+				htmlPath = posible;
+				break;
+			}
+		}
+		return { ...fuente, version: rendererVersionFrom(fuente.dir), htmlPath };
+	});
+
+	const [enCaliente, baseline] = fuentes;
+	const gana = compareRendererVersions(enCaliente.version, baseline.version) < 0 ? baseline : enCaliente;
+	const otra = gana === enCaliente ? baseline : enCaliente;
+
+	return { elegida: gana.htmlPath ? gana : otra.htmlPath ? otra : null, fuentes };
+}
+
+// La version del renderer que esta corriendo, o null si no hay ninguno cargable.
+function rendererVersionActiva() {
+	const { elegida } = resolverRenderer();
+	return elegida ? elegida.version : null;
+}
+
+module.exports = {
+	baselineRendererDir,
+	rendererVersionFrom,
+	compareRendererVersions,
+	resolverRenderer,
+	rendererVersionActiva,
+};