roomie 1.0.3 → 1.1.0

package/README.md

@@ -2,71 +2,107 @@
 
 ![GitHub Sponsors](https://img.shields.io/github/sponsors/nikitacontreras?style=flat-square&label=sponsor%20me&link=https%3A%2F%2Fgithub.com%2Fsponsors%2Fnikitacontreras) ![NPM Version](https://img.shields.io/npm/v/roomie?style=flat-square)
 
+---
 
+## Introduction
 
-Roomie is a library for analyzing basic metadata of ROM files from various classic consoles. It allows extracting relevant information such as the game name, region, code, ROM and RAM size, version, and other console-specific data.
+**roomie** is a powerful and lightweight library for extracting metadata from ROM files of classic gaming consoles. It supports multiple systems, handles **NES 2.0** headers, calculates **CRC32** and **SHA1** hashes, and can even read ROMs directly from **ZIP** archives.
+
+Designed for simplicity and accuracy, **roomie** identifies systems via header magic words or file extensions and provides detailed information about mappers, co-processors, regions, and save types.
+
+---
+
+## Features
+
+- **ZIP Support**: Load ROMs directly from `.zip` files.
+- **Hardware Detection**: Identifies NES Mappers, GB MBCs, SNES Co-processors, and GBA Save types.
+- **NES 2.0**: Full support for modern NES header specifications.
+- **Hashing**: Built-in SHA1 and CRC32 calculation.
+- **Exports**: Generate `JSON` or `Gamelist XML` (EmulationStation compatible) strings.
+
+---
 
 ## Installation
 
+Install via npm:
+
 ```bash
 npm install roomie
 ```
 
+---
+
 ## Usage
 
-Roomie supports both CommonJS and ES Module import styles depending on your project setup.
+**roomie** supports both CommonJS (CJS) and ES Modules (ESM).
 
-### CommonJS (CJS)
+### Basic Example (Async/Await)
 
-```js
-const { Roomie } = require('roomie');
+```ts
+import Roomie from "roomie";
 
-const romPath = "/path/to/game.sfc";
-const roomie = new Roomie(romPath);
+const roomie = new Roomie();
 
-roomie.on("loaded", (info) => {
-  console.log("ROM Information:", info);
-});
+// Load from a file path (supports .zip)
+await roomie.load("./Super Mario World.zip");
+
+console.log(roomie.info);
+/*
+{
+  system: 'sfc',
+  hash: { sha1: '...', crc32: 'b19ed489' },
+  sfc: { rom: { type: 'LoROM', size: 2048000 }, ram: 8000 },
+  ...
+}
+*/
+
+// Export to EmulationStation gamelist format
+console.log(roomie.toGamelistXML());
 ```
 
-### ES Modules (ESM)
+---
 
-```ts
-import Roomie from "roomie";
+## Supported Consoles
 
-const romPath = "/path/to/game.sfc";
-const roomie = new Roomie(romPath);
+| Console | System Key | Description |
+|---------|------------|-------------|
+| **NES / Famicom** | `nes` | iNES & **NES 2.0** support. Detects Mappers (MMC1, MMC3, etc). |
+| **Super Nintendo** | `sfc` | Detects LoROM/HiROM, Co-processors (SuperFX, SA-1, DSP). |
+| **Nintendo 64** | `n64` | Header parsing, region detection, and byte-swapping support. |
+| **Game Boy / Color** | `gb` | Detects MBC types, RAM size, and GBC/SGB features. |
+| **Game Boy Advance** | `gba` | Extract Game ID and identifies Save Type (SRAM/Flash/EEPROM). |
+| **Nintendo DS** | `nds` | Game code, region, unit code (DSi), and device capacity. |
+| **Sega Genesis** | `genesis` | Reads Domestic/Overseas names, serials, and regions. |
+| **Master System / GG** | `sms` / `gg` | Header detection (TMR SEGA), product code, and region. |
+| **WonderSwan / Color** | `ws` / `wsc` | End-of-ROM header parsing for game ID and model. |
+| **PC Engine** | `pce` | Basic identification for TurboGrafx-16 systems. |
 
-roomie.on("loaded", (info) => {
-  console.log("ROM Information:", info);
-});
+---
 
-await roomie.load(romPath); // Load ROM from file path
+## API Reference
 
-const romBuffer = Buffer.from([...]); // Load ROM from a Buffer
-await roomie.load(romBuffer);
+### Methods
 
-console.log(roomie.info);
-```
+- **`await load(pathOrBuffer: string | Buffer)`**: Loads a ROM. If it's a ZIP, it extracts the first ROM entry.
+- **`toJSON(): string`**: Returns the `RomInfo` object as a formatted JSON string.
+- **`toGamelistXML(): string`**: Returns an XML string compatible with EmulationStation's `gamelist.xml`.
 
-## Supported Consoles
+### Properties
 
-Roomie supports metadata extraction from the following systems:
+- **`info: RomInfo`**: Comprehensive metadata object.
+- **`system: string`**: The detected system key (e.g., `"sfc"`, `"nes"`).
+- **`hash: { sha1, crc32 }`**: Calculated hashes of the ROM (excluding ZIP overhead).
+- **`cartridge`**: System-specific details (Mappers, MBC, Save Types).
 
-- **Nintendo DS (NDS):** Retrieves data such as the game name, region, game code, ROM and RAM size, version, among others.
-- **Game Boy Advance (GBA):** Extracts information about the title, game code, region, ROM and RAM size, version, etc.
-- **Game Boy (GB):** Provides details about the title, cartridge type, ROM and RAM size, and other metadata.
-- **Super Nintendo / Super Famicom (SNES/SFC):** Detects the ROM type (HiROM/LoROM), game name, region, code, ROM size, and other specific fields.
+---
 
-## API
+## Error Handling
 
-- `new Roomie(path: string | Buffer)` – Creates an instance and immediately loads the specified ROM file or buffer. Emits the `'loaded'` event when the information is available.
-- `await roomie.load(pathOrBuffer: string | Buffer)` – Loads or reloads a different ROM file from a file path or a Buffer.
-- `roomie.info: RomInfo` – Object with the analyzed ROM metadata, including system, size, game code, region, and other specific fields.
-- `roomie.rom: Buffer` – Contains the raw bytes of the loaded ROM file.
-- `roomie.system: "nds" | "gba" | "gb" | "sfc"` – Detected system based on the file extension and content.
+- `unknown_file`: System extension not supported.
+- `unknown_bytes`: Bytes don't match any known system header.
+- `no_rom_in_zip`: ZIP file loaded but no valid ROM found inside.
 
-If the system cannot be identified, the library throws errors with codes `unknown_file` (when loading from a path) or `unknown_bytes` (when loading from a Buffer).
+---
 
 ## License
 

package/dist/roomie.d.ts

@@ -6,6 +6,7 @@ export interface RomInfo {
     size: number;
     hash: {
         sha1: string;
+        crc32: string;
     };
     gameCode?: string;
     region?: string;
@@ -24,6 +25,30 @@ export interface RomInfo {
         country?: string;
         version?: string;
     };
+    nes?: {
+        version: "1.0" | "2.0";
+        mapper: number;
+        submapper?: number;
+        prgRomSize: number;
+        chrRomSize: number;
+        prgRamSize?: number;
+        prgNvramSize?: number;
+        chrRamSize?: number;
+        chrNvramSize?: number;
+        timing?: string;
+        consoleType?: string;
+    };
+    genesis?: {
+        version?: string;
+        serial?: string;
+        region?: string;
+        description?: string;
+    };
+    sms?: {
+        version?: string;
+        region?: string;
+        serial?: string;
+    };
 }
 export declare class Roomie extends EventEmitter {
     private _path;
@@ -35,7 +60,7 @@ export declare class Roomie extends EventEmitter {
     region?: string;
     gamecode?: string;
     cartridge?: Record<string, unknown>;
-    constructor(path: string);
+    constructor(path?: string);
     private detectSystemFromPath;
     private readGameCode;
     private computeRegion;
@@ -50,5 +75,7 @@ export declare class Roomie extends EventEmitter {
     get system(): SupportedSystem;
     get path(): string;
     get rom(): Buffer;
+    toJSON(): string;
+    toGamelistXML(): string;
 }
 export default Roomie;

package/dist/roomie.js

@@ -1,13 +1,17 @@
+import path from "node:path";
 import { EventEmitter } from "node:events";
 import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
+import AdmZip from "adm-zip";
 import { regions } from "./tables/regions.js";
 import { specs } from "./tables/specs.js";
 import { isHiRomBuffer } from "./systems/snes.js";
+import { crc32 } from "./utils/crc32.js";
 export class Roomie extends EventEmitter {
     constructor(path) {
         super();
-        this.load(path);
+        if (path)
+            this.load(path);
     }
     detectSystemFromPath(p) {
         const ext = p.toLowerCase().split(".").pop();
@@ -21,8 +25,21 @@ export class Roomie extends EventEmitter {
             return "sfc";
         if (ext === "z64" || ext === "n64")
             return "n64";
-        // Default to sfc to keep compatibility with original intent; could be improved.
-        return "sfc";
+        if (ext === "nes")
+            return "nes";
+        if (ext === "md" || ext === "gen" || ext === "smd")
+            return "genesis";
+        if (ext === "sms")
+            return "sms";
+        if (ext === "gg")
+            return "gg";
+        if (ext === "pce")
+            return "pce";
+        if (ext === "ws")
+            return "ws";
+        if (ext === "wsc")
+            return "wsc";
+        return false;
     }
     readGameCode(system) {
         const b = this._rom;
@@ -90,6 +107,21 @@ export class Roomie extends EventEmitter {
                     return regionMap[regionByte] || "Unknown";
                 }
                 return undefined;
+            case "nes":
+                if (this._rom.length >= 16) {
+                    const b = this._rom;
+                    const isNes2 = (b[7] & 0x0C) === 0x08;
+                    if (isNes2) {
+                        const timing = b[12] & 0x03;
+                        switch (timing) {
+                            case 0: return "NTSC";
+                            case 1: return "PAL";
+                            case 2: return "Multi-region";
+                            case 3: return "Dendy";
+                        }
+                    }
+                }
+                return undefined;
         }
     }
     computeSfcInfo() {
@@ -166,6 +198,19 @@ export class Roomie extends EventEmitter {
                         return b.subarray(0x20, 0x34).toString("ascii").replace(/\0/g, "").trim();
                     }
                     break;
+                case "nes":
+                    return "NES ROM";
+                case "genesis":
+                    if (b.length >= 0x150) {
+                        return b.subarray(0x120, 0x150).toString("ascii").trim();
+                    }
+                    break;
+                case "sms":
+                case "gg":
+                    return "SEGA MASTER/GG ROM";
+                case "ws":
+                case "wsc":
+                    return "WONDERSWAN ROM";
             }
         }
         catch { }
@@ -230,18 +275,32 @@ export class Roomie extends EventEmitter {
             case "gba": {
                 const code = this._gamecode();
                 const region = this._region();
+                // GBA Save Type identification (heuristic scanning)
+                const saveTypePatterns = ["SRAM_V", "EEPROM_V", "FLASH_V", "FLASH512_V", "FLASH1M_V"];
+                let saveType = "Unknown";
+                const romStr = b.subarray(0, Math.min(b.length, 0x100000)).toString("ascii"); // Scan first 1MB
+                for (const pattern of saveTypePatterns) {
+                    if (romStr.includes(pattern)) {
+                        saveType = pattern.split("_")[0];
+                        break;
+                    }
+                }
                 return {
                     system: "gba",
                     gameCode: code,
                     region,
+                    saveType,
                     size: b.length,
                 };
             }
             case "gb": {
                 const region = this._region();
+                const mbcCode = b.length >= 0x148 ? b[0x147].toString(16).padStart(2, "0") : undefined;
+                const mbc = mbcCode ? specs.gb_mbc?.[mbcCode] : undefined;
                 return {
                     system: "gb",
                     region,
+                    mbc,
                     size: b.length,
                 };
             }
@@ -283,6 +342,107 @@ export class Roomie extends EventEmitter {
                     size: b.length,
                 };
             }
+            case "nes": {
+                if (b.length < 16)
+                    return { system: "nes", size: b.length };
+                const isNes2 = (b[7] & 0x0C) === 0x08;
+                const mapper = isNes2
+                    ? (b[6] >> 4) | (b[7] & 0xF0) | ((b[8] & 0x0F) << 8)
+                    : (b[6] >> 4) | (b[7] & 0xF0);
+                const nesInfo = {
+                    version: isNes2 ? "2.0" : "1.0",
+                    mapper,
+                    size: b.length
+                };
+                const getNesSize = (lsb, msbNibble, baseUnit) => {
+                    if (msbNibble === 0x0F) {
+                        const multiplier = (lsb & 0x03) * 2 + 1;
+                        const exponent = (lsb >> 2);
+                        return Math.pow(2, exponent) * multiplier;
+                    }
+                    return ((msbNibble << 8) | lsb) * baseUnit;
+                };
+                if (isNes2) {
+                    nesInfo.submapper = b[8] >> 4;
+                    nesInfo.prgRomSize = getNesSize(b[4], b[9] & 0x0F, 16384);
+                    nesInfo.chrRomSize = getNesSize(b[5], (b[9] >> 4) & 0x0F, 8192);
+                    const prgRamShift = b[10] & 0x0F;
+                    const prgNvramShift = (b[10] >> 4) & 0x0F;
+                    if (prgRamShift > 0)
+                        nesInfo.prgRamSize = 64 << prgRamShift;
+                    if (prgNvramShift > 0)
+                        nesInfo.prgNvramSize = 64 << prgNvramShift;
+                    const chrRamShift = b[11] & 0x0F;
+                    const chrNvramShift = (b[11] >> 4) & 0x0F;
+                    if (chrRamShift > 0)
+                        nesInfo.chrRamSize = 64 << chrRamShift;
+                    if (chrNvramShift > 0)
+                        nesInfo.chrNvramSize = 64 << chrNvramShift;
+                    const timingCodes = ["NTSC", "PAL", "Multi-region", "Dendy"];
+                    nesInfo.timing = timingCodes[b[12] & 0x03];
+                    const consoleTypes = ["NES/Famicom", "Vs. System", "PlayChoice-10", "Extended"];
+                    nesInfo.consoleType = consoleTypes[b[7] & 0x03];
+                    nesInfo.mapperName = specs.nes?.mappers?.[mapper.toString()];
+                }
+                else {
+                    nesInfo.prgRomSize = b[4] * 16384;
+                    nesInfo.chrRomSize = b[5] * 8192;
+                    nesInfo.mapperName = specs.nes?.mappers?.[mapper.toString()];
+                }
+                return {
+                    system: "nes",
+                    ...nesInfo
+                };
+            }
+            case "genesis": {
+                if (b.length < 0x200)
+                    return { system: "genesis", size: b.length };
+                const region = b.subarray(0x1F0, 0x200).toString("ascii").trim();
+                const serial = b.subarray(0x180, 0x18E).toString("ascii").trim();
+                const overseasName = b.subarray(0x150, 0x180).toString("ascii").trim();
+                return {
+                    system: "genesis",
+                    serial,
+                    region,
+                    overseasName,
+                    size: b.length
+                };
+            }
+            case "sms":
+            case "gg": {
+                const off = b.length >= 0x8000 ? 0x7FF0 : (b.length >= 0x4000 ? 0x3FF0 : 0x1FF0);
+                if (b.length < off + 16)
+                    return { system: this._system, size: b.length };
+                const product = b.subarray(off + 12, off + 14).toString("hex");
+                const regionByte = b[off + 15] >> 4;
+                const region = regionByte >= 4 ? "Export" : "Japan";
+                return {
+                    system: this._system,
+                    product,
+                    region,
+                    size: b.length
+                };
+            }
+            case "ws":
+            case "wsc": {
+                if (b.length < 10)
+                    return { system: this._system, size: b.length };
+                const off = b.length - 10;
+                const publisher = b[off];
+                const model = b[off + 1] === 0 ? "WS" : "WSC";
+                const gameId = b[off + 2];
+                const version = b[off + 3];
+                const region = b[off + 4] === 0 ? "Japan" : "Export";
+                return {
+                    system: this._system,
+                    publisher,
+                    model,
+                    gameId,
+                    version,
+                    region,
+                    size: b.length
+                };
+            }
             default:
                 return undefined;
         }
@@ -291,78 +451,154 @@ export class Roomie extends EventEmitter {
         return this.computeRegion(this._system, this._gamecode());
     }
     async load(pathOrBuffer) {
+        let b;
         if (typeof pathOrBuffer === "string") {
             this._path = pathOrBuffer;
-            this._rom = await fs.readFile(pathOrBuffer);
-            this._system = this.detectSystemFromPath(pathOrBuffer);
-            if (!this._system) {
-                throw new Error("unknown_file");
+            const fileBuffer = await fs.readFile(pathOrBuffer);
+            // Check if it's a ZIP by extension or magic
+            if (pathOrBuffer.toLowerCase().endsWith(".zip") || (fileBuffer.length > 4 && fileBuffer.readUInt32BE(0) === 0x504B0304)) {
+                const zip = new AdmZip(fileBuffer);
+                const entries = zip.getEntries();
+                // Look for the first entry that doesn't look like junk
+                const romEntry = entries.find((e) => !e.isDirectory && !e.entryName.match(/\.(txt|jpg|png|xml|db|url)$|^\./i));
+                if (!romEntry)
+                    throw new Error("no_rom_in_zip");
+                b = zip.readFile(romEntry);
             }
+            else {
+                b = fileBuffer;
+            }
+            this._rom = b;
+            const detected = this.detectSystemFromPath(pathOrBuffer);
+            this._system = detected || "sfc"; // Fallback to be handled by buffer check if needed
         }
         else {
-            this._rom = pathOrBuffer;
             this._path = "in-memory";
-            const b = this._rom;
-            let detected = undefined;
-            // Check NDS: game code at 0x0C-0x10 ASCII uppercase letters/digits
-            if (b.length >= 0x10) {
-                const code = b.subarray(0x0C, 0x10).toString("ascii");
-                if (/^[A-Z0-9]{4}$/.test(code)) {
-                    detected = "nds";
-                }
+            // Check if buffer is a ZIP
+            if (pathOrBuffer.length > 4 && pathOrBuffer.readUInt32BE(0) === 0x504B0304) {
+                const zip = new AdmZip(pathOrBuffer);
+                const entries = zip.getEntries();
+                const romEntry = entries.find((e) => !e.isDirectory && !e.entryName.match(/\.(txt|jpg|png|xml|db|url)$|^\./i));
+                if (!romEntry)
+                    throw new Error("no_rom_in_zip");
+                b = zip.readFile(romEntry);
             }
-            // Check GBA: game code at 0xAC-0xB0 ASCII uppercase letters/digits
-            if (!detected && b.length >= 0xB0) {
-                const code = b.subarray(0xAC, 0xB0).toString("ascii");
-                if (/^[A-Z0-9]{4}$/.test(code)) {
-                    detected = "gba";
-                }
+            else {
+                b = pathOrBuffer;
             }
-            // Check GB: game code at 0x0134-0x0143 ASCII valid characters
-            if (!detected && b.length >= 0x0143) {
-                const code = b.subarray(0x0134, 0x0143).toString("ascii");
-                if (/^[A-Z0-9]{4,9}$/.test(code)) {
-                    detected = "gb";
-                }
+            this._rom = b;
+        }
+        const romBuffer = this._rom;
+        let detected = undefined;
+        // Check system from bytes (more reliable than extension for ZIPs)
+        // -------------------------------------------------------------
+        // Check NDS: game code at 0x0C-0x10 ASCII uppercase letters/digits
+        if (romBuffer.length >= 0x10) {
+            const code = romBuffer.subarray(0x0C, 0x10).toString("ascii");
+            if (/^[A-Z0-9]{4}$/.test(code)) {
+                detected = "nds";
+            }
+        }
+        // Check GBA: game code at 0xAC-0xB0 ASCII uppercase letters/digits
+        if (!detected && b.length >= 0xB0) {
+            const code = b.subarray(0xAC, 0xB0).toString("ascii");
+            if (/^[A-Z0-9]{4}$/.test(code)) {
+                detected = "gba";
             }
-            // Check N64: ASCII text at 0x20-0x2E
-            if (!detected && b.length >= 0x2F) {
-                const code = b.subarray(0x20, 0x2F).toString("ascii");
-                if (/^[\x20-\x7E]+$/.test(code) && code.trim().length > 0) {
-                    detected = "n64";
+        }
+        // Check GB: game code at 0x0134-0x0143 ASCII valid characters
+        if (!detected && b.length >= 0x0143) {
+            const code = b.subarray(0x0134, 0x0143).toString("ascii");
+            if (/^[A-Z0-9]{4,9}$/.test(code)) {
+                detected = "gb";
+            }
+        }
+        // Check NES: starts with "NES\x1a"
+        if (!detected && b.length >= 4) {
+            if (b[0] === 0x4E && b[1] === 0x45 && b[2] === 0x53 && b[3] === 0x1A) {
+                detected = "nes";
+            }
+        }
+        // Check N64: ASCII text at 0x20-0x2E AND Magic Word at 0x00
+        if (!detected && b.length >= 0x2F) {
+            const magic = b.readUInt32BE(0);
+            // Common N64 magic values (Big Endian, Byte Swapped, Little Endian)
+            if (magic === 0x80371240 || magic === 0x37804012 || magic === 0x40123780) {
+                detected = "n64";
+            }
+        }
+        // Check SFC: verify checksum or markup before falling back
+        if (!detected && b.length >= 0x8000) {
+            if (isHiRomBuffer(b)) {
+                detected = "sfc";
+            }
+            else {
+                // LoROM check
+                const titleOff = 0x7FC0;
+                if (b.length > titleOff + 20) {
+                    const title = b.subarray(titleOff, titleOff + 20).toString('ascii');
+                    if (/^[\x20-\x7E\s]+$/.test(title) && title.trim().length > 0) {
+                        detected = "sfc";
+                    }
                 }
             }
-            // Check SFC: use isHiRomBuffer heuristic
-            if (!detected) {
-                if (b.length > 0x8000 && (isHiRomBuffer(b) || !isHiRomBuffer(b))) {
-                    detected = "sfc";
+        }
+        // Check Genesis: "SEGA" at 0x100
+        if (!detected && b.length >= 0x104) {
+            const magic = b.subarray(0x100, 0x104).toString("ascii");
+            if (magic === "SEGA") {
+                detected = "genesis";
+            }
+        }
+        // Check SMS/GG: "TMR SEGA" at 0x7FF0, 0x3FF0 or 0x1FF0
+        if (!detected) {
+            for (const off of [0x7FF0, 0x3FF0, 0x1FF0]) {
+                if (b.length >= off + 8 && b.subarray(off, off + 8).toString("ascii") === "TMR SEGA") {
+                    detected = b.length >= 0x8000 ? "sms" : "gg"; // Heuristic
+                    break;
                 }
             }
-            if (!detected) {
-                throw new Error("unknown_bytes");
+        }
+        // Check WSC: check model byte near end
+        if (!detected && b.length >= 0x8000) {
+            const off = b.length - 10;
+            if (b[off + 1] === 0 || b[off + 1] === 1) { // 0=WS, 1=WSC
+                // WSC check is a bit weak without developer ID check, but let's use it as heuristic
+                // maybe only if extension also matches? 
             }
-            this._system = detected;
         }
+        if (!detected) {
+            throw new Error("unknown_bytes");
+        }
+        this._system = detected;
         const sha1 = createHash("sha1").update(this._rom).digest("hex");
+        const crc = crc32(this._rom);
         const gameCode = this.readGameCode(this._system);
         const info = {
             path: this._path,
             system: this._system,
             size: this._rom.length,
-            hash: { sha1 },
+            hash: { sha1, crc32: crc },
             gameCode,
             region: this.computeRegion(this._system, gameCode),
         };
         if (this._system === "sfc") {
             info.sfc = this.computeSfcInfo();
         }
-        if (this._system === "n64") {
+        else if (this._system === "n64") {
             info.n64 = {
                 name: this._name(),
                 country: this._region(),
                 version: this._rom.length > 0x3F ? this._rom[0x3F].toString() : undefined,
             };
         }
+        else {
+            // Generic assignment for new systems (nes, genesis, sms, gg, etc)
+            const cart = this._cartridge();
+            if (cart) {
+                info[this._system] = cart;
+            }
+        }
         this._info = info;
         this.name = this._name();
         this.gameid = this._gameid();
@@ -375,5 +611,32 @@ export class Roomie extends EventEmitter {
     get system() { return this._system; }
     get path() { return this._path; }
     get rom() { return this._rom; }
+    toJSON() {
+        return JSON.stringify(this._info, null, 2);
+    }
+    toGamelistXML() {
+        const info = this._info;
+        const name = this.name || path.basename(this._path);
+        const cart = this.cartridge || {};
+        let hardware = "None";
+        if (cart.mapperName)
+            hardware = `Mapper ${cart.mapper} (${cart.mapperName})`;
+        else if (cart.mbc)
+            hardware = `MBC (${cart.mbc})`;
+        else if (cart.rom?.type)
+            hardware = `Type (${cart.rom.type})`;
+        else if (cart.saveType)
+            hardware = `Save (${cart.saveType})`;
+        return `<?xml version="1.0"?>
+<gameList>
+  <game>
+    <path>${this._path}</path>
+    <name>${name}</name>
+    <desc>System: ${info.system}, Hardware: ${hardware}</desc>
+    <hash>${info.hash.sha1}</hash>
+    <crc32>${info.hash.crc32}</crc32>
+  </game>
+</gameList>`;
+    }
 }
 export default Roomie;

package/dist/tables/specs.d.ts

@@ -217,5 +217,56 @@ export declare const specs: {
             };
         };
     };
+    readonly nes: {
+        readonly mappers: {
+            readonly "0": "NROM";
+            readonly "1": "MMC1";
+            readonly "2": "UxROM";
+            readonly "3": "CNROM";
+            readonly "4": "MMC3";
+            readonly "5": "MMC5";
+            readonly "7": "AxROM";
+            readonly "9": "MMC2";
+            readonly "10": "MMC4";
+            readonly "11": "Color Dreams";
+            readonly "13": "CPROM";
+            readonly "15": "100-in-1 Contra Function 16";
+            readonly "16": "Bandai FCG-1/2 / LZ93D50";
+            readonly "18": "Jaleco SS88006";
+            readonly "19": "Namco 163";
+            readonly "21": "VRC4a/4c";
+            readonly "22": "VRC2a";
+        };
+    };
+    readonly gb_mbc: {
+        readonly "00": "ROM ONLY";
+        readonly "01": "MBC1";
+        readonly "02": "MBC1+RAM";
+        readonly "03": "MBC1+RAM+BATTERY";
+        readonly "05": "MBC2";
+        readonly "06": "MBC2+BATTERY";
+        readonly "08": "ROM+RAM";
+        readonly "09": "ROM+RAM+BATTERY";
+        readonly "0b": "MMM01";
+        readonly "0c": "MMM01+RAM";
+        readonly "0d": "MMM01+RAM+BATTERY";
+        readonly "0f": "MBC3+TIMER+BATTERY";
+        readonly "10": "MBC3+TIMER+RAM+BATTERY";
+        readonly "11": "MBC3";
+        readonly "12": "MBC3+RAM";
+        readonly "13": "MBC3+RAM+BATTERY";
+        readonly "19": "MBC5";
+        readonly "1a": "MBC5+RAM";
+        readonly "1b": "MBC5+RAM+BATTERY";
+        readonly "1c": "MBC5+RUMBLE";
+        readonly "1d": "MBC5+RUMBLE+RAM";
+        readonly "1e": "MBC5+RUMBLE+RAM+BATTERY";
+        readonly "20": "MBC6";
+        readonly "22": "MBC7+SENSOR+RUMBLE+RAM+BATTERY";
+        readonly fc: "POCKET CAMERA";
+        readonly fd: "BANDAI TAMA5";
+        readonly fe: "HuC3";
+        readonly ff: "HuC1+RAM+BATTERY";
+    };
 };
 export type SupportedSystemsForSpecs = keyof typeof specs;

package/dist/tables/specs.js

@@ -57,5 +57,56 @@ export const specs = {
             "31": { type: "HiROM", speed: "3.58MHz" },
             "32": { type: "ExHiROM", speed: "3.58MHz" },
         }
+    },
+    nes: {
+        mappers: {
+            "0": "NROM",
+            "1": "MMC1",
+            "2": "UxROM",
+            "3": "CNROM",
+            "4": "MMC3",
+            "5": "MMC5",
+            "7": "AxROM",
+            "9": "MMC2",
+            "10": "MMC4",
+            "11": "Color Dreams",
+            "13": "CPROM",
+            "15": "100-in-1 Contra Function 16",
+            "16": "Bandai FCG-1/2 / LZ93D50",
+            "18": "Jaleco SS88006",
+            "19": "Namco 163",
+            "21": "VRC4a/4c",
+            "22": "VRC2a",
+        }
+    },
+    gb_mbc: {
+        "00": "ROM ONLY",
+        "01": "MBC1",
+        "02": "MBC1+RAM",
+        "03": "MBC1+RAM+BATTERY",
+        "05": "MBC2",
+        "06": "MBC2+BATTERY",
+        "08": "ROM+RAM",
+        "09": "ROM+RAM+BATTERY",
+        "0b": "MMM01",
+        "0c": "MMM01+RAM",
+        "0d": "MMM01+RAM+BATTERY",
+        "0f": "MBC3+TIMER+BATTERY",
+        "10": "MBC3+TIMER+RAM+BATTERY",
+        "11": "MBC3",
+        "12": "MBC3+RAM",
+        "13": "MBC3+RAM+BATTERY",
+        "19": "MBC5",
+        "1a": "MBC5+RAM",
+        "1b": "MBC5+RAM+BATTERY",
+        "1c": "MBC5+RUMBLE",
+        "1d": "MBC5+RUMBLE+RAM",
+        "1e": "MBC5+RUMBLE+RAM+BATTERY",
+        "20": "MBC6",
+        "22": "MBC7+SENSOR+RUMBLE+RAM+BATTERY",
+        "fc": "POCKET CAMERA",
+        "fd": "BANDAI TAMA5",
+        "fe": "HuC3",
+        "ff": "HuC1+RAM+BATTERY"
     }
 };

package/dist/types.d.ts

@@ -1 +1 @@
-export type SupportedSystem = "nds" | "gba" | "gb" | "sfc" | "n64";
+export type SupportedSystem = "nds" | "gba" | "gb" | "sfc" | "n64" | "nes" | "genesis" | "sms" | "gg" | "pce" | "ws" | "wsc";

package/dist/utils/crc32.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Standard CRC32 implementation for Node.js Buffers/TypedArrays.
+ */
+export declare function crc32(buffer: Buffer | Uint8Array): string;

package/dist/utils/crc32.js

@@ -0,0 +1,18 @@
+/**
+ * Standard CRC32 implementation for Node.js Buffers/TypedArrays.
+ */
+export function crc32(buffer) {
+    const table = new Int32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let j = 0; j < 8; j++) {
+            c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+        }
+        table[i] = c;
+    }
+    let crc = -1;
+    for (let i = 0; i < buffer.length; i++) {
+        crc = (crc >>> 8) ^ table[(crc ^ buffer[i]) & 0xFF];
+    }
+    return ((crc ^ -1) >>> 0).toString(16).padStart(8, '0').toLowerCase();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roomie",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "ROM metadata helper",
   "license": "MIT",
   "type": "module",
@@ -14,6 +14,9 @@
       "default": "./dist/index.mjs"
     }
   },
+  "dependencies": {
+    "adm-zip": "^0.5.10"
+  },
   "engines": {
     "node": ">=18"
   },
@@ -28,6 +31,7 @@
     "prepare": "npm run clean && npm run build"
   },
   "devDependencies": {
+    "@types/adm-zip": "^0.5.8",
     "@types/node": "^20.10.0",
     "rimraf": "^5.0.0",
     "typescript": "^5.6.0"