feat: add UI components for alert dialog, badge, checkbox, dialog, label, select, sheet, table, textarea

- Implemented AlertDialog component with overlay, content, header, footer, title, description, action, and cancel functionalities.
- Created Badge component with variant support for different styles.
- Developed Checkbox component with custom styling and indicator.
- Added Dialog component with trigger, close, overlay, content, header, footer, title, and description.
- Introduced Label component for form elements.
- Built Select component with trigger, content, group, item, label, separator, and scroll buttons.
- Created Sheet component with trigger, close, overlay, content, header, footer, title, and description.
- Implemented Table component with header, body, footer, row, head, cell, and caption.
- Added Textarea component with custom styling.
- Established API service for game management with CRUD operations and metadata search functionalities.
- Updated dependencies in package lock files.

backend/dist/src/app.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildApp = buildApp;
+const fastify_1 = __importDefault(require("fastify"));
+const cors_1 = __importDefault(require("@fastify/cors"));
+const helmet_1 = __importDefault(require("@fastify/helmet"));
+const rate_limit_1 = __importDefault(require("@fastify/rate-limit"));
+const health_1 = __importDefault(require("./routes/health"));
+const import_1 = __importDefault(require("./routes/import"));
+const games_1 = __importDefault(require("./routes/games"));
+const metadata_1 = __importDefault(require("./routes/metadata"));
+function buildApp() {
+    const app = (0, fastify_1.default)({
+        logger: false,
+    });
+    void app.register(cors_1.default, { origin: true });
+    void app.register(helmet_1.default);
+    void app.register(rate_limit_1.default, { max: 1000, timeWindow: '1 minute' });
+    void app.register(health_1.default, { prefix: '/api' });
+    void app.register(import_1.default, { prefix: '/api' });
+    void app.register(games_1.default, { prefix: '/api' });
+    void app.register(metadata_1.default, { prefix: '/api' });
+    return app;
+}
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-07
+ */

backend/dist/src/config.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMPORT_CONCURRENCY = void 0;
+const os_1 = __importDefault(require("os"));
+const envVal = Number.parseInt(process.env.IMPORT_CONCURRENCY ?? '', 10);
+exports.IMPORT_CONCURRENCY = Number.isFinite(envVal) && envVal > 0 ? envVal : Math.min(8, Math.max(1, os_1.default.cpus().length - 1));
+exports.default = exports.IMPORT_CONCURRENCY;

backend/dist/src/controllers/gamesController.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GamesController = void 0;
+const prisma_1 = require("../plugins/prisma");
+class GamesController {
+    /**
+     * Listar todos los juegos con sus plataformas y compras
+     */
+    static async listGames() {
+        return await prisma_1.prisma.game.findMany({
+            include: {
+                gamePlatforms: {
+                    include: {
+                        platform: true,
+                    },
+                },
+                purchases: true,
+            },
+            orderBy: {
+                title: 'asc',
+            },
+        });
+    }
+    /**
+     * Obtener un juego por ID
+     */
+    static async getGameById(id) {
+        const game = await prisma_1.prisma.game.findUnique({
+            where: { id },
+            include: {
+                gamePlatforms: {
+                    include: {
+                        platform: true,
+                    },
+                },
+                purchases: true,
+                artworks: true,
+                tags: true,
+            },
+        });
+        if (!game) {
+            throw new Error('Juego no encontrado');
+        }
+        return game;
+    }
+    /**
+     * Listar juegos por fuente (rom, manual, igdb, rawg, etc.)
+     */
+    static async listGamesBySource(source) {
+        return await prisma_1.prisma.game.findMany({
+            where: { source },
+            include: {
+                gamePlatforms: {
+                    include: {
+                        platform: true,
+                    },
+                },
+                purchases: true,
+            },
+            orderBy: {
+                title: 'asc',
+            },
+        });
+    }
+    /**
+     * Crear un juego nuevo
+     */
+    static async createGame(input) {
+        const { title, platformId, description, priceCents, currency, store, date, condition, source, sourceId, } = input;
+        // Generar slug basado en el título
+        const slug = title
+            .toLowerCase()
+            .replace(/\s+/g, '-')
+            .replace(/[^\w-]/g, '');
+        const gameData = {
+            title,
+            slug: `${slug}-${Date.now()}`, // Hacer slug único agregando timestamp
+            description: description || null,
+            source: source || 'manual',
+            sourceId: sourceId || null,
+        };
+        // Si se proporciona una plataforma, crearla en gamePlatforms
+        if (platformId) {
+            gameData.gamePlatforms = {
+                create: {
+                    platformId,
+                },
+            };
+        }
+        // Si se proporciona precio, crear en purchases
+        if (priceCents) {
+            gameData.purchases = {
+                create: {
+                    priceCents,
+                    currency: currency || 'USD',
+                    store: store || null,
+                    date: date ? new Date(date) : new Date(),
+                },
+            };
+        }
+        return await prisma_1.prisma.game.create({
+            data: gameData,
+            include: {
+                gamePlatforms: {
+                    include: {
+                        platform: true,
+                    },
+                },
+                purchases: true,
+            },
+        });
+    }
+    /**
+     * Actualizar un juego existente
+     */
+    static async updateGame(id, input) {
+        const { title, platformId, description, priceCents, currency, store, date, source, sourceId } = input;
+        const updateData = {};
+        if (title !== undefined) {
+            updateData.title = title;
+            // Regenerar slug si cambia el título
+            const slug = title
+                .toLowerCase()
+                .replace(/\s+/g, '-')
+                .replace(/[^\w-]/g, '');
+            updateData.slug = `${slug}-${Date.now()}`;
+        }
+        if (description !== undefined) {
+            updateData.description = description;
+        }
+        if (source !== undefined) {
+            updateData.source = source;
+        }
+        if (sourceId !== undefined) {
+            updateData.sourceId = sourceId;
+        }
+        const game = await prisma_1.prisma.game.update({
+            where: { id },
+            data: updateData,
+            include: {
+                gamePlatforms: {
+                    include: {
+                        platform: true,
+                    },
+                },
+                purchases: true,
+            },
+        });
+        // Si se actualiza plataforma, sincronizar
+        if (platformId !== undefined) {
+            // Eliminar relaciones antiguas
+            await prisma_1.prisma.gamePlatform.deleteMany({
+                where: { gameId: id },
+            });
+            // Crear nueva relación si se proporcionó platformId
+            if (platformId) {
+                await prisma_1.prisma.gamePlatform.create({
+                    data: {
+                        gameId: id,
+                        platformId,
+                    },
+                });
+            }
+        }
+        // Si se actualiza precio, agregar nueva compra (crear histórico)
+        if (priceCents !== undefined) {
+            await prisma_1.prisma.purchase.create({
+                data: {
+                    gameId: id,
+                    priceCents,
+                    currency: currency || 'USD',
+                    store: store || null,
+                    date: date ? new Date(date) : new Date(),
+                },
+            });
+        }
+        // Retornar el juego actualizado
+        return await prisma_1.prisma.game.findUniqueOrThrow({
+            where: { id },
+            include: {
+                gamePlatforms: {
+                    include: {
+                        platform: true,
+                    },
+                },
+                purchases: true,
+            },
+        });
+    }
+    /**
+     * Eliminar un juego (y sus relaciones en cascada)
+     */
+    static async deleteGame(id) {
+        // Validar que el juego existe
+        const game = await prisma_1.prisma.game.findUnique({ where: { id } });
+        if (!game) {
+            throw new Error('Juego no encontrado');
+        }
+        // Eliminar todas las relaciones (Prisma maneja cascada según schema)
+        await prisma_1.prisma.game.delete({
+            where: { id },
+        });
+        return { message: 'Juego eliminado correctamente' };
+    }
+}
+exports.GamesController = GamesController;
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-03-18
+ * Actualizado para soportar fuente (source) en juegos
+ */

backend/dist/src/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const app_1 = require("./app");
+dotenv_1.default.config();
+const port = Number(process.env.PORT ?? 3000);
+const app = (0, app_1.buildApp)();
+const start = async () => {
+    try {
+        await app.listen({ port, host: '0.0.0.0' });
+        // eslint-disable-next-line no-console
+        console.log(`Server listening on http://0.0.0.0:${port}`);
+    }
+    catch (err) {
+        app.log.error(err);
+        process.exit(1);
+    }
+};
+// Start only when run directly (avoids starting during tests)
+if (require.main === module) {
+    start();
+}
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-07
+ */

backend/dist/src/jobs/importRunner.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runner = exports.ImportRunner = void 0;
+const config_1 = require("../config");
+class ImportRunner {
+    constructor(concurrency) {
+        this.queue = [];
+        this.runningCount = 0;
+        this.completedCount = 0;
+        this.isRunning = false;
+        this.stopped = false;
+        this.concurrency = Math.max(1, concurrency ?? config_1.IMPORT_CONCURRENCY);
+    }
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.stopped = false;
+        this._processQueue();
+    }
+    async stopAndWait() {
+        this.stop();
+        // wait until any running tasks finish
+        while (this.runningCount > 0) {
+            await new Promise((res) => setImmediate(res));
+        }
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.isRunning = false;
+        this.stopped = true;
+        // reject and count all pending tasks (schedule rejection to avoid unhandled rejections)
+        while (this.queue.length > 0) {
+            const task = this.queue.shift();
+            this.completedCount++;
+            // attach a noop catch so Node doesn't treat the rejection as unhandled
+            if (task.promise) {
+                task.promise.catch(() => { });
+            }
+            setImmediate(() => {
+                try {
+                    task.reject(new Error('ImportRunner stopped'));
+                }
+                catch (e) {
+                    // noop
+                }
+            });
+        }
+    }
+    enqueue(fn) {
+        if (this.stopped) {
+            return Promise.reject(new Error('ImportRunner stopped'));
+        }
+        let resolveFn;
+        let rejectFn;
+        const p = new Promise((res, rej) => {
+            resolveFn = res;
+            rejectFn = rej;
+        });
+        this.queue.push({ fn, resolve: resolveFn, reject: rejectFn, promise: p });
+        // start or continue processing immediately so the first task begins right away
+        if (!this.isRunning) {
+            this.start();
+        }
+        else {
+            this._processQueue();
+        }
+        return p;
+    }
+    getStatus() {
+        return {
+            queued: this.queue.length,
+            running: this.runningCount,
+            completed: this.completedCount,
+            concurrency: this.concurrency,
+        };
+    }
+    _processQueue() {
+        if (!this.isRunning)
+            return;
+        while (this.runningCount < this.concurrency && this.queue.length > 0) {
+            const task = this.queue.shift();
+            const result = Promise.resolve().then(() => task.fn());
+            this.runningCount++;
+            result
+                .then((res) => {
+                this.runningCount--;
+                this.completedCount++;
+                try {
+                    task.resolve(res);
+                }
+                catch (e) {
+                    // noop
+                }
+                setImmediate(() => this._processQueue());
+            })
+                .catch((err) => {
+                this.runningCount--;
+                this.completedCount++;
+                console.error(err);
+                try {
+                    task.reject(err);
+                }
+                catch (e) {
+                    // noop
+                }
+                setImmediate(() => this._processQueue());
+            });
+        }
+    }
+}
+exports.ImportRunner = ImportRunner;
+exports.runner = new ImportRunner();
+exports.runner.start();
+exports.default = exports.runner;

backend/dist/src/lib/fileTypeDetector.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFormat = detectFormat;
+const path_1 = __importDefault(require("path"));
+function detectFormat(filename) {
+    const ext = path_1.default.extname(filename || '').toLowerCase();
+    if (!ext)
+        return 'bin';
+    const map = {
+        '.zip': 'zip',
+        '.7z': '7z',
+        '.chd': 'chd',
+    };
+    return map[ext] ?? ext.replace(/^\./, '');
+}
+exports.default = detectFormat;

backend/dist/src/plugins/prisma.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prisma = void 0;
+const client_1 = require("@prisma/client");
+const prisma = new client_1.PrismaClient();
+exports.prisma = prisma;
+exports.default = prisma;
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-07
+ */

backend/dist/src/routes/games.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const gamesController_1 = require("../controllers/gamesController");
+const gameValidator_1 = require("../validators/gameValidator");
+const zod_1 = require("zod");
+async function gamesRoutes(app) {
+    /**
+     * GET /api/games
+     * Listar todos los juegos
+     */
+    app.get('/games', async (request, reply) => {
+        const games = await gamesController_1.GamesController.listGames();
+        return reply.code(200).send(games);
+    });
+    /**
+     * GET /api/games/:id
+     * Obtener un juego por ID
+     */
+    app.get('/games/:id', async (request, reply) => {
+        try {
+            const game = await gamesController_1.GamesController.getGameById(request.params.id);
+            return reply.code(200).send(game);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('no encontrado')) {
+                return reply.code(404).send({
+                    error: 'Juego no encontrado',
+                });
+            }
+            throw error;
+        }
+    });
+    /**
+     * POST /api/games
+     * Crear un nuevo juego
+     */
+    app.post('/games', async (request, reply) => {
+        try {
+            // Validar entrada con Zod
+            const validated = gameValidator_1.createGameSchema.parse(request.body);
+            const game = await gamesController_1.GamesController.createGame(validated);
+            return reply.code(201).send(game);
+        }
+        catch (error) {
+            if (error instanceof zod_1.ZodError) {
+                return reply.code(400).send({
+                    error: 'Validación fallida',
+                    details: error.errors,
+                });
+            }
+            throw error;
+        }
+    });
+    /**
+     * PUT /api/games/:id
+     * Actualizar un juego existente
+     */
+    app.put('/games/:id', async (request, reply) => {
+        try {
+            // Validar entrada con Zod
+            const validated = gameValidator_1.updateGameSchema.parse(request.body);
+            const game = await gamesController_1.GamesController.updateGame(request.params.id, validated);
+            return reply.code(200).send(game);
+        }
+        catch (error) {
+            if (error instanceof zod_1.ZodError) {
+                return reply.code(400).send({
+                    error: 'Validación fallida',
+                    details: error.errors,
+                });
+            }
+            if (error instanceof Error && error.message.includes('not found')) {
+                return reply.code(404).send({
+                    error: 'Juego no encontrado',
+                });
+            }
+            throw error;
+        }
+    });
+    /**
+     * DELETE /api/games/:id
+     * Eliminar un juego
+     */
+    app.delete('/games/:id', async (request, reply) => {
+        try {
+            await gamesController_1.GamesController.deleteGame(request.params.id);
+            return reply.code(204).send();
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('no encontrado')) {
+                return reply.code(404).send({
+                    error: 'Juego no encontrado',
+                });
+            }
+            throw error;
+        }
+    });
+    /**
+     * GET /api/games/source/:source
+     * Listar juegos por fuente (rom, manual, igdb, rawg, etc.)
+     */
+    app.get('/games/source/:source', async (request, reply) => {
+        const games = await gamesController_1.GamesController.listGamesBySource(request.params.source);
+        return reply.code(200).send(games);
+    });
+}
+exports.default = gamesRoutes;
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-03-18
+ * Actualizado para soportar fuente (source) en juegos
+ */

backend/dist/src/routes/health.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = healthRoutes;
+async function healthRoutes(app) {
+    app.get('/health', async () => ({ status: 'ok' }));
+}
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-07
+ */

backend/dist/src/routes/import.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = importRoutes;
+const importRunner_1 = require("../jobs/importRunner");
+const importService_1 = require("../services/importService");
+async function importRoutes(app) {
+    app.post('/import/scan', async (request, reply) => {
+        const body = request.body;
+        // Encolar el job en background
+        setImmediate(() => {
+            importRunner_1.runner
+                .enqueue(async () => {
+                // no await here; background task. Pasamos el logger de Fastify para
+                // que los mensajes de advertencia se integren con el sistema de logs.
+                return (0, importService_1.importDirectory)({ dir: body?.dir, persist: body?.persist }, app.log);
+            })
+                .catch((err) => {
+                app.log.warn({ err }, 'Background import task failed');
+            });
+        });
+        // Responder inmediatamente
+        reply.code(202).send({ status: 'queued' });
+    });
+}

backend/dist/src/routes/metadata.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadataService = __importStar(require("../services/metadataService"));
+const zod_1 = require("zod");
+const zod_2 = require("zod");
+// Esquema de validación para parámetros de búsqueda
+const searchMetadataSchema = zod_1.z.object({
+    q: zod_1.z.string().min(1, 'El parámetro de búsqueda es requerido'),
+    platform: zod_1.z.string().optional(),
+});
+async function metadataRoutes(app) {
+    /**
+     * GET /api/metadata/search?q=query&platform=optional
+     * Buscar metadata de juegos
+     */
+    app.get('/metadata/search', async (request, reply) => {
+        try {
+            // Validar parámetros de query con Zod
+            const validated = searchMetadataSchema.parse(request.query);
+            // Llamar a metadataService
+            const result = await metadataService.enrichGame({
+                title: validated.q,
+                platform: validated.platform,
+            });
+            // Si hay resultado, devolver como array; si no, devolver array vacío
+            return reply.code(200).send(result ? [result] : []);
+        }
+        catch (error) {
+            if (error instanceof zod_2.ZodError) {
+                return reply.code(400).send({
+                    error: 'Parámetros de búsqueda inválidos',
+                    details: error.errors,
+                });
+            }
+            throw error;
+        }
+    });
+}
+exports.default = metadataRoutes;
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/src/services/archiveReader.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listArchiveEntries = listArchiveEntries;
+exports.streamArchiveEntry = streamArchiveEntry;
+/**
+ * Servicio: archiveReader
+ *
+ * Lista el contenido de contenedores comunes (ZIP, 7z) sin necesidad de
+ * extraerlos completamente. Intenta usar la utilidad `7z` (7-Zip) con la
+ * opción `-slt` para obtener un listado con metadatos; si falla y el archivo
+ * es ZIP, intenta usar `unzip -l` como fallback.
+ *
+ * La función principal exportada es `listArchiveEntries(filePath, logger)` y
+ * devuelve un array de objetos `{ name, size }` con las entradas encontradas.
+ *
+ * Nota: este servicio depende de binarios del sistema (`7z`, `unzip`) cuando
+ * se trabaja con formatos comprimidos. En entornos de CI/producción debe
+ * asegurarse la presencia de dichas utilidades o los tests deben mockear
+ * las llamadas a `child_process.exec`.
+ */
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+async function listArchiveEntries(filePath, logger = console) {
+    const ext = path_1.default.extname(filePath).toLowerCase().replace(/^\./, '');
+    if (!['zip', '7z'].includes(ext))
+        return [];
+    const execCmd = (cmd) => new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(cmd, (err, stdout, stderr) => {
+            if (err)
+                return reject(err);
+            resolve({ stdout: String(stdout), stderr: String(stderr) });
+        });
+    });
+    // Intentamos 7z -slt (salida técnica fácil de parsear)
+    const try7z = async () => {
+        const { stdout } = await execCmd(`7z l -slt ${JSON.stringify(filePath)}`);
+        const blocks = String(stdout).split(/\r?\n\r?\n/);
+        const entries = [];
+        for (const block of blocks) {
+            const lines = block.split(/\r?\n/);
+            const pathLine = lines.find((l) => l.startsWith('Path = '));
+            if (!pathLine)
+                continue;
+            const name = pathLine.replace(/^Path = /, '').trim();
+            const sizeLine = lines.find((l) => l.startsWith('Size = '));
+            const size = sizeLine ? parseInt(sizeLine.replace(/^Size = /, ''), 10) || 0 : 0;
+            entries.push({ name, size });
+        }
+        return entries;
+    };
+    try {
+        return await try7z();
+    }
+    catch (err) {
+        logger.warn?.({ err, filePath }, 'archiveReader: 7z failed, attempting fallback');
+        if (ext === 'zip') {
+            try {
+                const { stdout } = await execCmd(`unzip -l ${JSON.stringify(filePath)}`);
+                const lines = String(stdout).split(/\r?\n/);
+                const entries = [];
+                for (const line of lines) {
+                    // línea típica: "   12345  path/to/file.bin"
+                    const m = line.match(/^\s*(\d+)\s+(.+)$/);
+                    if (m) {
+                        const size = parseInt(m[1], 10);
+                        const name = m[2].trim();
+                        entries.push({ name, size });
+                    }
+                }
+                return entries;
+            }
+            catch (err2) {
+                logger.warn?.({ err2, filePath }, 'archiveReader: unzip fallback failed');
+                return [];
+            }
+        }
+        return [];
+    }
+}
+async function streamArchiveEntry(filePath, entryPath, logger = console) {
+    const ext = path_1.default.extname(filePath).toLowerCase().replace(/^\./, '');
+    if (!['zip', '7z'].includes(ext))
+        return null;
+    const waitForStreamOrError = (proc) => new Promise((resolve) => {
+        let settled = false;
+        const onProcError = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(null);
+        };
+        const onStdoutError = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(null);
+        };
+        const onData = () => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                proc.removeListener('error', onProcError);
+            }
+            catch (e) { }
+            if (proc.stdout && proc.stdout.removeListener) {
+                try {
+                    proc.stdout.removeListener('error', onStdoutError);
+                    proc.stdout.removeListener('readable', onData);
+                    proc.stdout.removeListener('data', onData);
+                }
+                catch (e) { }
+            }
+            resolve(proc.stdout);
+        };
+        proc.once('error', onProcError);
+        if (proc.stdout && proc.stdout.once) {
+            proc.stdout.once('error', onStdoutError);
+            proc.stdout.once('readable', onData);
+            proc.stdout.once('data', onData);
+        }
+        else {
+            // no stdout available
+            resolve(null);
+        }
+        proc.once('close', () => {
+            if (!settled) {
+                settled = true;
+                resolve(null);
+            }
+        });
+    });
+    // Try 7z first
+    try {
+        let proc;
+        try {
+            proc = (0, child_process_1.spawn)('7z', ['x', '-so', filePath, entryPath]);
+        }
+        catch (err) {
+            throw err;
+        }
+        const stream = await waitForStreamOrError(proc);
+        if (stream)
+            return stream;
+    }
+    catch (err) {
+        logger.warn?.({ err, filePath }, 'archiveReader: 7z spawn failed');
+    }
+    // Fallback for zip
+    if (ext === 'zip') {
+        try {
+            const proc2 = (0, child_process_1.spawn)('unzip', ['-p', filePath, entryPath]);
+            const stream2 = await waitForStreamOrError(proc2);
+            if (stream2)
+                return stream2;
+        }
+        catch (err2) {
+            logger.warn?.({ err2, filePath }, 'archiveReader: unzip spawn failed');
+        }
+    }
+    return null;
+}
+exports.default = { listArchiveEntries, streamArchiveEntry };

backend/dist/src/services/checksumService.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHashes = computeHashes;
+exports.computeHashesFromStream = computeHashesFromStream;
+/**
+ * Servicio: checksumService
+ *
+ * Calcula sumas y metadatos de un fichero de forma eficiente usando streams.
+ * Las funciones principales procesan el archivo en streaming para producir:
+ * - `md5` (hex)
+ * - `sha1` (hex)
+ * - `crc32` (hex, 8 caracteres)
+ * - `size` (bytes)
+ *
+ * `computeHashes(filePath)` devuelve un objeto con los valores anteriores y
+ * está pensado para usarse durante la importación/normalización de ROMs.
+ */
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = require("crypto");
+function makeCRCTable() {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            if (c & 1)
+                c = 0xedb88320 ^ (c >>> 1);
+            else
+                c = c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+}
+const CRC_TABLE = makeCRCTable();
+function updateCrc(crc, buf) {
+    let c = crc >>> 0;
+    for (let i = 0; i < buf.length; i++) {
+        c = (CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8)) >>> 0;
+    }
+    return c >>> 0;
+}
+async function computeHashes(filePath) {
+    return new Promise((resolve, reject) => {
+        const md5 = (0, crypto_1.createHash)('md5');
+        const sha1 = (0, crypto_1.createHash)('sha1');
+        let size = 0;
+        let crc = 0xffffffff >>> 0;
+        const rs = fs_1.default.createReadStream(filePath);
+        rs.on('error', (err) => reject(err));
+        rs.on('data', (chunk) => {
+            md5.update(chunk);
+            sha1.update(chunk);
+            size += chunk.length;
+            crc = updateCrc(crc, chunk);
+        });
+        rs.on('end', () => {
+            const md5sum = md5.digest('hex');
+            const sha1sum = sha1.digest('hex');
+            const final = (crc ^ 0xffffffff) >>> 0;
+            const crcHex = final.toString(16).padStart(8, '0').toLowerCase();
+            resolve({ size, md5: md5sum, sha1: sha1sum, crc32: crcHex });
+        });
+    });
+}
+async function computeHashesFromStream(rs) {
+    return new Promise((resolve, reject) => {
+        const md5 = (0, crypto_1.createHash)('md5');
+        const sha1 = (0, crypto_1.createHash)('sha1');
+        let size = 0;
+        let crc = 0xffffffff >>> 0;
+        let settled = false;
+        const cleanup = () => {
+            try {
+                rs.removeListener('error', onError);
+                rs.removeListener('data', onData);
+                rs.removeListener('end', onEnd);
+                rs.removeListener('close', onClose);
+            }
+            catch (e) { }
+        };
+        const finalize = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            const md5sum = md5.digest('hex');
+            const sha1sum = sha1.digest('hex');
+            const final = (crc ^ 0xffffffff) >>> 0;
+            const crcHex = final.toString(16).padStart(8, '0').toLowerCase();
+            resolve({ size, md5: md5sum, sha1: sha1sum, crc32: crcHex });
+        };
+        const onError = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(err);
+        };
+        const onData = (chunk) => {
+            md5.update(chunk);
+            sha1.update(chunk);
+            size += chunk.length;
+            crc = updateCrc(crc, chunk);
+        };
+        const onEnd = () => finalize();
+        const onClose = () => finalize();
+        rs.on('error', onError);
+        rs.on('data', onData);
+        rs.on('end', onEnd);
+        rs.on('close', onClose);
+    });
+}
+exports.default = computeHashes;

backend/dist/src/services/datVerifier.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDat = parseDat;
+exports.verifyHashesAgainstDat = verifyHashesAgainstDat;
+const fast_xml_parser_1 = require("fast-xml-parser");
+function ensureArray(v) {
+    if (v === undefined || v === null)
+        return [];
+    return Array.isArray(v) ? v : [v];
+}
+function normalizeHex(v) {
+    if (!v)
+        return undefined;
+    return v.trim().toLowerCase();
+}
+function parseDat(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        trimValues: true,
+    });
+    const parsed = parser.parse(xml);
+    const datafile = parsed?.datafile ?? parsed;
+    const rawGames = ensureArray(datafile?.game);
+    const games = rawGames.map((g) => {
+        // game name may be an attribute or a child node
+        const nameAttr = g?.name ?? g?.['@_name'] ?? g?.$?.name;
+        const romNodes = ensureArray(g?.rom);
+        const roms = romNodes.map((r) => {
+            const rname = r?.name ?? r?.['@_name'] ?? r?.['@name'];
+            const sizeRaw = r?.size ?? r?.['@_size'];
+            const parsedSize = sizeRaw != null ? Number(sizeRaw) : undefined;
+            return {
+                name: String(rname ?? ''),
+                size: typeof parsedSize === 'number' && !Number.isNaN(parsedSize) ? parsedSize : undefined,
+                crc: normalizeHex(r?.crc ?? r?.['@_crc'] ?? r?.CRC ?? r?.['CRC']),
+                md5: normalizeHex(r?.md5 ?? r?.['@_md5'] ?? r?.MD5 ?? r?.['MD5']),
+                sha1: normalizeHex(r?.sha1 ?? r?.['@_sha1'] ?? r?.SHA1 ?? r?.['SHA1']),
+            };
+        });
+        return {
+            name: String(nameAttr ?? ''),
+            roms,
+        };
+    });
+    return { games };
+}
+function verifyHashesAgainstDat(datDb, hashes) {
+    const cmp = {
+        crc: normalizeHex(hashes.crc),
+        md5: normalizeHex(hashes.md5),
+        sha1: normalizeHex(hashes.sha1),
+        size: hashes.size,
+    };
+    for (const g of datDb.games) {
+        for (const r of g.roms) {
+            if (cmp.crc && r.crc && cmp.crc === r.crc) {
+                return { gameName: g.name, romName: r.name, matchedOn: 'crc' };
+            }
+            if (cmp.md5 && r.md5 && cmp.md5 === r.md5) {
+                return { gameName: g.name, romName: r.name, matchedOn: 'md5' };
+            }
+            if (cmp.sha1 && r.sha1 && cmp.sha1 === r.sha1) {
+                return { gameName: g.name, romName: r.name, matchedOn: 'sha1' };
+            }
+            if (cmp.size !== undefined && r.size !== undefined && Number(cmp.size) === Number(r.size)) {
+                return { gameName: g.name, romName: r.name, matchedOn: 'size' };
+            }
+        }
+    }
+    return null;
+}

backend/dist/src/services/fsScanner.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanDirectory = scanDirectory;
+/**
+ * Servicio: fsScanner
+ *
+ * Este módulo proporciona la función `scanDirectory` que recorre recursivamente
+ * un directorio (ignorando archivos y carpetas que comienzan por `.`) y devuelve
+ * una lista de metadatos de ficheros encontrados. Cada entrada contiene el
+ * `path` completo, `filename`, `name`, `size`, `format` detectado por extensión
+ * y `isArchive` indicando si se trata de un contenedor (zip/7z/chd).
+ *
+ * Se usa desde el importService para listar las ROMs/archivos que deben ser
+ * procesados/hashed y persistidos.
+ */
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const fileTypeDetector_1 = require("../lib/fileTypeDetector");
+const archiveReader_1 = require("./archiveReader");
+const DEFAULT_ARCHIVE_MAX_ENTRIES = 1000;
+function getArchiveMaxEntries() {
+    const parsed = parseInt(process.env.ARCHIVE_MAX_ENTRIES ?? '', 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ARCHIVE_MAX_ENTRIES;
+}
+async function scanDirectory(dirPath) {
+    const results = [];
+    let archiveEntriesAdded = 0;
+    async function walk(dir) {
+        const entries = await fs_1.promises.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue; // ignore dotfiles
+            const full = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+                continue;
+            }
+            if (entry.isFile()) {
+                const stat = await fs_1.promises.stat(full);
+                const format = (0, fileTypeDetector_1.detectFormat)(entry.name);
+                const isArchive = ['zip', '7z', 'chd'].includes(format);
+                results.push({
+                    path: full,
+                    filename: entry.name,
+                    name: entry.name,
+                    size: stat.size,
+                    format,
+                    isArchive,
+                });
+                if (isArchive) {
+                    try {
+                        const entries = await (0, archiveReader_1.listArchiveEntries)(full);
+                        const maxEntries = getArchiveMaxEntries();
+                        for (const e of entries) {
+                            if (archiveEntriesAdded >= maxEntries)
+                                break;
+                            if (!e || !e.name)
+                                continue;
+                            // Normalize entry path using posix rules and avoid traversal/absolute paths
+                            const normalized = path_1.default.posix.normalize(e.name);
+                            const parts = normalized.split('/').filter(Boolean);
+                            if (parts.includes('..') || path_1.default.posix.isAbsolute(normalized))
+                                continue;
+                            results.push({
+                                path: `${full}::${normalized}`,
+                                containerPath: full,
+                                entryPath: normalized,
+                                filename: path_1.default.posix.basename(normalized),
+                                name: normalized,
+                                size: e.size,
+                                format: (0, fileTypeDetector_1.detectFormat)(normalized),
+                                isArchive: false,
+                                isArchiveEntry: true,
+                            });
+                            archiveEntriesAdded++;
+                        }
+                    }
+                    catch (err) {
+                        // log for diagnostics but continue
+                        try {
+                            // eslint-disable-next-line no-console
+                            console.debug('fsScanner: listArchiveEntries failed for', full, err);
+                        }
+                        catch (e) { }
+                    }
+                }
+            }
+        }
+    }
+    await walk(dirPath);
+    return results;
+}
+exports.default = scanDirectory;

backend/dist/src/services/igdbClient.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchGames = searchGames;
+exports.getGameById = getGameById;
+/**
+ * Cliente IGDB (Twitch OAuth)
+ * - `searchGames(query, platform?)`
+ * - `getGameById(id)`
+ */
+const undici_1 = require("undici");
+const AUTH_URL = 'https://id.twitch.tv/oauth2/token';
+const API_URL = 'https://api.igdb.com/v4';
+let cachedToken = null;
+async function getToken() {
+    if (cachedToken && Date.now() < cachedToken.expiresAt)
+        return cachedToken.token;
+    const clientId = process.env.IGDB_CLIENT_ID || process.env.TWITCH_CLIENT_ID;
+    const clientSecret = process.env.IGDB_CLIENT_SECRET || process.env.TWITCH_CLIENT_SECRET;
+    if (!clientId || !clientSecret)
+        return null;
+    try {
+        const params = new URLSearchParams({
+            client_id: clientId,
+            client_secret: clientSecret,
+            grant_type: 'client_credentials',
+        });
+        const res = await (0, undici_1.fetch)(`${AUTH_URL}?${params.toString()}`, { method: 'POST' });
+        if (!res.ok)
+            return null;
+        const json = await res.json();
+        const token = json.access_token;
+        const expires = Number(json.expires_in) || 0;
+        if (!token)
+            return null;
+        cachedToken = { token, expiresAt: Date.now() + Math.max(0, expires - 60) * 1000 };
+        return token;
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.debug('igdbClient.getToken error', err);
+        return null;
+    }
+}
+function mapIgdbHit(r) {
+    return {
+        id: r.id,
+        name: r.name,
+        slug: r.slug,
+        releaseDate: r.first_release_date
+            ? new Date(r.first_release_date * 1000).toISOString()
+            : undefined,
+        genres: Array.isArray(r.genres) ? r.genres : undefined,
+        platforms: Array.isArray(r.platforms) ? r.platforms : undefined,
+        coverUrl: r.cover?.url ?? undefined,
+        source: 'igdb',
+    };
+}
+async function searchGames(query, _platform) {
+    const clientId = process.env.IGDB_CLIENT_ID || process.env.TWITCH_CLIENT_ID;
+    const token = await getToken();
+    if (!clientId || !token)
+        return [];
+    const headers = {
+        'Client-ID': clientId,
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        'Content-Type': 'text/plain',
+    };
+    const body = `search "${query}"; fields id,name,slug,first_release_date,genres,platforms,cover; limit 10;`;
+    try {
+        const res = await (0, undici_1.fetch)(`${API_URL}/games`, { method: 'POST', headers, body });
+        if (!res.ok)
+            return [];
+        const json = await res.json();
+        if (!Array.isArray(json))
+            return [];
+        return json.map(mapIgdbHit);
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.debug('igdbClient.searchGames error', err);
+        return [];
+    }
+}
+async function getGameById(id) {
+    const clientId = process.env.IGDB_CLIENT_ID || process.env.TWITCH_CLIENT_ID;
+    const token = await getToken();
+    if (!clientId || !token)
+        return null;
+    const headers = {
+        'Client-ID': clientId,
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        'Content-Type': 'text/plain',
+    };
+    const body = `where id = ${id}; fields id,name,slug,first_release_date,genres,platforms,cover; limit 1;`;
+    try {
+        const res = await (0, undici_1.fetch)(`${API_URL}/games`, { method: 'POST', headers, body });
+        if (!res.ok)
+            return null;
+        const json = await res.json();
+        if (!Array.isArray(json) || json.length === 0)
+            return null;
+        return mapIgdbHit(json[0]);
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.debug('igdbClient.getGameById error', err);
+        return null;
+    }
+}
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/src/services/importService.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSlug = createSlug;
+exports.importDirectory = importDirectory;
+/**
+ * Servicio: importService
+ *
+ * Orquesta el proceso de importación de juegos desde un directorio:
+ * 1. Lista archivos usando `scanDirectory`.
+ * 2. Calcula hashes y tamaño con `computeHashes` (streaming).
+ * 3. Normaliza el nombre a un `slug` y, si `persist` es true, crea/obtiene
+ *    el `Game` correspondiente con source="rom".
+ *
+ * `importDirectory` devuelve un resumen con contadores `{ processed, createdCount, upserted }`.
+ */
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const fsScanner_1 = require("./fsScanner");
+const checksumService_1 = require("./checksumService");
+const archiveReader_1 = require("./archiveReader");
+const prisma_1 = __importDefault(require("../plugins/prisma"));
+/**
+ * Crea un `slug` a partir de un nombre legible. Usado para generar slugs
+ * por defecto al crear entradas `Game` cuando no existe la coincidencia.
+ */
+function createSlug(name) {
+    return name
+        .toString()
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+async function importDirectory(options, logger = console) {
+    const providedDir = options?.dir;
+    const dir = providedDir ?? process.env.ROMS_PATH ?? path_1.default.join(process.cwd(), 'roms');
+    const persist = options?.persist !== undefined ? options.persist : true;
+    // Si no se pasó explícitamente la ruta, validamos que exista y sea un directorio
+    if (!providedDir) {
+        try {
+            const stat = await fs_1.promises.stat(dir);
+            if (!stat.isDirectory()) {
+                logger.warn?.({ dir }, 'importDirectory: ruta no es un directorio');
+                return { processed: 0, createdCount: 0, upserted: 0 };
+            }
+        }
+        catch (err) {
+            logger.warn?.({ err, dir }, 'importDirectory: ruta no accesible, abortando import');
+            return { processed: 0, createdCount: 0, upserted: 0 };
+        }
+    }
+    let files = [];
+    try {
+        files = await (0, fsScanner_1.scanDirectory)(dir);
+    }
+    catch (err) {
+        logger.warn?.({ err, dir }, 'importDirectory: error listando directorio');
+        return { processed: 0, createdCount: 0, upserted: 0 };
+    }
+    let processed = 0;
+    let createdCount = 0;
+    let upserted = 0;
+    for (const file of files) {
+        processed++;
+        try {
+            let hashes;
+            if (file.isArchiveEntry) {
+                const stream = await (0, archiveReader_1.streamArchiveEntry)(file.containerPath, file.entryPath, logger);
+                if (!stream) {
+                    logger.warn?.({ file }, 'importDirectory: no se pudo extraer entrada del archive, saltando');
+                    continue;
+                }
+                hashes = await (0, checksumService_1.computeHashesFromStream)(stream);
+            }
+            else {
+                hashes = await (0, checksumService_1.computeHashes)(file.path);
+            }
+            const checksum = hashes.md5;
+            const size = hashes.size;
+            const baseName = path_1.default.parse(file.filename).name;
+            const slug = createSlug(baseName);
+            if (persist) {
+                // Buscar si ya existe un juego con este checksum (source=rom)
+                let game = await prisma_1.default.game.findFirst({
+                    where: {
+                        source: 'rom',
+                        romChecksum: checksum,
+                    },
+                });
+                if (!game) {
+                    // Crear nuevo juego con source="rom"
+                    game = await prisma_1.default.game.create({
+                        data: {
+                            title: baseName,
+                            slug: `${slug}-${Date.now()}`,
+                            source: 'rom',
+                            romPath: file.path,
+                            romFilename: file.filename,
+                            romSize: size,
+                            romChecksum: checksum,
+                            romFormat: file.format,
+                            romHashes: JSON.stringify(hashes),
+                            addedAt: new Date(),
+                            lastSeenAt: new Date(),
+                        },
+                    });
+                    createdCount++;
+                }
+                else {
+                    // Actualizar lastSeenAt si ya existe
+                    game = await prisma_1.default.game.update({
+                        where: { id: game.id },
+                        data: {
+                            lastSeenAt: new Date(),
+                            romHashes: JSON.stringify(hashes),
+                        },
+                    });
+                    upserted++;
+                }
+            }
+        }
+        catch (err) {
+            logger.warn?.({ err, file }, 'importDirectory: error procesando fichero, se continúa con el siguiente');
+            continue;
+        }
+    }
+    return { processed, createdCount, upserted };
+}
+exports.default = importDirectory;

backend/dist/src/services/metadataService.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichGame = enrichGame;
+/**
+ * metadataService
+ * - `enrichGame({ title, platform? })` -> intenta IGDB, RAWG, TheGamesDB
+ */
+const igdb = __importStar(require("./igdbClient"));
+const rawg = __importStar(require("./rawgClient"));
+const thegamesdb = __importStar(require("./thegamesdbClient"));
+function normalize(hit) {
+    const base = {
+        source: hit.source ?? 'unknown',
+        externalIds: {},
+        title: hit.name,
+        slug: hit.slug,
+        releaseDate: hit.releaseDate,
+        genres: hit.genres,
+        coverUrl: hit.coverUrl,
+    };
+    if (hit.source === 'igdb' && typeof hit.id === 'number')
+        base.externalIds.igdb = hit.id;
+    if (hit.source === 'rawg' && typeof hit.id === 'number')
+        base.externalIds.rawg = hit.id;
+    if (hit.source === 'thegamesdb' && typeof hit.id === 'number')
+        base.externalIds.thegamesdb = hit.id;
+    return base;
+}
+async function enrichGame(opts) {
+    const title = opts?.title;
+    if (!title)
+        return null;
+    // Prefer IGDB (higher priority)
+    try {
+        const igdbHits = await igdb.searchGames(title, opts.platform);
+        if (igdbHits && igdbHits.length)
+            return normalize(igdbHits[0]);
+    }
+    catch (e) {
+        // ignore and continue
+    }
+    try {
+        const rawgHits = await rawg.searchGames(title);
+        if (rawgHits && rawgHits.length)
+            return normalize(rawgHits[0]);
+    }
+    catch (e) {
+        // ignore
+    }
+    try {
+        const tgHits = await thegamesdb.searchGames(title);
+        if (tgHits && tgHits.length)
+            return normalize(tgHits[0]);
+    }
+    catch (e) {
+        // ignore
+    }
+    return null;
+}
+exports.default = { enrichGame };
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/src/services/rawgClient.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchGames = searchGames;
+exports.getGameById = getGameById;
+/**
+ * Cliente RAWG
+ * - `searchGames(query)`
+ * - `getGameById(id)`
+ */
+const undici_1 = require("undici");
+const API_BASE = 'https://api.rawg.io/api';
+async function searchGames(query) {
+    const key = process.env.RAWG_API_KEY;
+    if (!key)
+        return [];
+    try {
+        const url = `${API_BASE}/games?key=${encodeURIComponent(key)}&search=${encodeURIComponent(query)}&page_size=10`;
+        const res = await (0, undici_1.fetch)(url);
+        if (!res.ok)
+            return [];
+        const json = await res.json();
+        const hits = Array.isArray(json.results) ? json.results : [];
+        return hits.map((r) => ({
+            id: r.id,
+            name: r.name,
+            slug: r.slug,
+            releaseDate: r.released,
+            genres: Array.isArray(r.genres) ? r.genres.map((g) => g.name) : undefined,
+            platforms: r.platforms,
+            coverUrl: r.background_image ?? undefined,
+            source: 'rawg',
+        }));
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.debug('rawgClient.searchGames error', err);
+        return [];
+    }
+}
+async function getGameById(id) {
+    const key = process.env.RAWG_API_KEY;
+    if (!key)
+        return null;
+    try {
+        const url = `${API_BASE}/games/${encodeURIComponent(String(id))}?key=${encodeURIComponent(key)}`;
+        const res = await (0, undici_1.fetch)(url);
+        if (!res.ok)
+            return null;
+        const json = await res.json();
+        if (!json)
+            return null;
+        return {
+            id: json.id,
+            name: json.name,
+            slug: json.slug,
+            releaseDate: json.released,
+            genres: Array.isArray(json.genres) ? json.genres.map((g) => g.name) : undefined,
+            coverUrl: json.background_image ?? undefined,
+            source: 'rawg',
+        };
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.debug('rawgClient.getGameById error', err);
+        return null;
+    }
+}
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/src/services/thegamesdbClient.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchGames = searchGames;
+exports.getGameById = getGameById;
+/**
+ * Cliente TheGamesDB (simple wrapper)
+ * - `searchGames(query)`
+ * - `getGameById(id)`
+ */
+const undici_1 = require("undici");
+const API_BASE = 'https://api.thegamesdb.net';
+async function searchGames(query) {
+    const key = process.env.THEGAMESDB_API_KEY;
+    if (!key)
+        return [];
+    try {
+        const url = `${API_BASE}/v1/Games/ByGameName?name=${encodeURIComponent(query)}`;
+        const res = await (0, undici_1.fetch)(url, { headers: { 'Api-Key': key } });
+        if (!res.ok)
+            return [];
+        const json = await res.json();
+        const games = json?.data?.games ?? {};
+        const baseUrl = json?.data?.base_url?.original ?? '';
+        const hits = [];
+        for (const gid of Object.keys(games)) {
+            const g = games[gid];
+            hits.push({
+                id: Number(gid),
+                name: g?.game?.title ?? g?.title ?? String(gid),
+                slug: g?.game?.slug ?? undefined,
+                releaseDate: g?.game?.release_date ?? undefined,
+                genres: Array.isArray(g?.game?.genres) ? g.game.genres.map((x) => x.name) : undefined,
+                coverUrl: g?.game?.images?.boxart?.[0]?.thumb
+                    ? `${baseUrl}${g.game.images.boxart[0].thumb}`
+                    : undefined,
+                source: 'thegamesdb',
+            });
+        }
+        return hits;
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.debug('thegamesdbClient.searchGames error', err);
+        return [];
+    }
+}
+async function getGameById(id) {
+    const key = process.env.THEGAMESDB_API_KEY;
+    if (!key)
+        return null;
+    try {
+        const url = `${API_BASE}/v1/Games/ByGameID?id=${encodeURIComponent(String(id))}`;
+        const res = await (0, undici_1.fetch)(url, { headers: { 'Api-Key': key } });
+        if (!res.ok)
+            return null;
+        const json = await res.json();
+        const games = json?.data?.games ?? {};
+        const baseUrl = json?.data?.base_url?.original ?? '';
+        const firstKey = Object.keys(games)[0];
+        const g = games[firstKey];
+        if (!g)
+            return null;
+        return {
+            id: Number(firstKey),
+            name: g?.game?.title ?? g?.title ?? String(firstKey),
+            slug: g?.game?.slug ?? undefined,
+            releaseDate: g?.game?.release_date ?? undefined,
+            genres: Array.isArray(g?.game?.genres) ? g.game.genres.map((x) => x.name) : undefined,
+            coverUrl: g?.game?.images?.boxart?.[0]?.thumb
+                ? `${baseUrl}${g.game.images.boxart[0].thumb}`
+                : undefined,
+            source: 'thegamesdb',
+        };
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.debug('thegamesdbClient.getGameById error', err);
+        return null;
+    }
+}
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/src/validators/gameValidator.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateGameSchema = exports.createGameSchema = exports.GameSource = exports.GameCondition = void 0;
+const zod_1 = require("zod");
+// Enum para condiciones (Loose, CIB, New)
+exports.GameCondition = zod_1.z.enum(['Loose', 'CIB', 'New']).optional();
+// Enum para fuentes de juegos
+exports.GameSource = zod_1.z.enum(['manual', 'rom', 'igdb', 'rawg', 'thegamesdb']).optional();
+// Esquema de validación para crear un juego
+exports.createGameSchema = zod_1.z.object({
+    title: zod_1.z.string().min(1, 'El título es requerido').trim(),
+    platformId: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional().nullable(),
+    priceCents: zod_1.z.number().int().positive().optional(),
+    currency: zod_1.z.string().optional().default('USD'),
+    store: zod_1.z.string().optional(),
+    date: zod_1.z.string().optional(), // Acepta formato ISO (YYYY-MM-DD o ISO completo)
+    condition: exports.GameCondition,
+    source: zod_1.z.string().optional().default('manual'), // Fuente del juego
+    sourceId: zod_1.z.string().optional(), // ID en la fuente externa
+});
+// Esquema de validación para actualizar un juego (todos los campos son opcionales)
+exports.updateGameSchema = zod_1.z
+    .object({
+    title: zod_1.z.string().min(1).trim().optional(),
+    platformId: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional().nullable(),
+    priceCents: zod_1.z.number().int().positive().optional(),
+    currency: zod_1.z.string().optional(),
+    store: zod_1.z.string().optional(),
+    date: zod_1.z.string().optional(), // Acepta formato ISO (YYYY-MM-DD o ISO completo)
+    condition: exports.GameCondition,
+    source: zod_1.z.string().optional(), // Fuente del juego
+    sourceId: zod_1.z.string().optional(), // ID en la fuente externa
+})
+    .strict();
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/src/validators/romValidator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkGameSchema = void 0;
+const zod_1 = require("zod");
+// Esquema para vincular un juego a un ROM
+exports.linkGameSchema = zod_1.z.object({
+    gameId: zod_1.z.string().min(1, 'El ID del juego es requerido'),
+});
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */