silphscope 1.0.0

package/src/graphics/decode-1bpp.js

@@ -0,0 +1,15 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+export function decode1bppTile(tileBytes) {
+    const pixels = new Uint8Array(64);
+    for (let i = 0; i < 8; i++) {
+        const byte = tileBytes[i];
+        for (let bit = 0; bit < 8; bit++) {
+            const pixelIndex = i * 8 + bit;
+            const pixel = (byte >> bit) & 1;
+            pixels[pixelIndex] = pixel;
+        }
+    }
+    return pixels;
+}

package/src/graphics/decode-4bpp.js

@@ -0,0 +1,15 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+export function decode4bppTile(tileBytes) {
+    const pixels = new Uint8Array(64);
+    for (let i = 0; i < 32; i++) {
+        const byte = tileBytes[i];
+        const p1 = byte & 0xF;
+        const p2 = byte >> 4;
+        const pixelIndex = i * 2;
+        pixels[pixelIndex] = p1;
+        pixels[pixelIndex + 1] = p2;
+    }
+    return pixels;
+}

package/src/graphics/decode-palette.js

@@ -0,0 +1,17 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+export function decodePalette(data) {
+    const colors = [];
+    for (let i = 0; i < data.length; i += 2) {
+        const value = data[i] | (data[i + 1] << 8);
+        let r = value & 0x1F;
+        let g = (value >> 5) & 0x1F;
+        let b = (value >> 10) & 0x1F;
+        r = Math.floor((r * 255) / 31);
+        g = Math.floor((g * 255) / 31);
+        b = Math.floor((b * 255) / 31);
+        colors.push([r, g, b]);
+    }
+    return colors;
+}

package/src/graphics/extract.js

@@ -0,0 +1,24 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+import { lz77Decompress } from "./lz77-decompress.js";
+
+export function extract(asset, rom) {
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("extract(asset, rom) requires a ROM Buffer/Uint8Array as second argument");
+    }
+
+    const start = asset.offset;
+    if (rom[start] === 0x10) {
+        try {
+            const slice = rom.slice(start);
+            const data = lz77Decompress(slice);
+            return { ...asset, data, compressed: true };
+        } catch (e) {
+            console.warn(`lz77 failed for ${asset.name}... treating as raw :p`);
+        }
+    }
+
+    const slice = rom.slice(start, start + asset.size);
+    return { ...asset, data: slice, compressed: false };
+}

package/src/graphics/graphics-extractor-main.js

@@ -0,0 +1,70 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { renderMon } from "./render-mons.js";
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+
+function loadDefaultJson(relativePath) {
+    const absolutePath = path.join(currentDir, "..", relativePath);
+    return JSON.parse(fs.readFileSync(absolutePath, "utf-8"));
+}
+
+const assets = loadDefaultJson("../graphics-maps/fr-graphic-map.json");
+const mons = loadDefaultJson("../mon-data/monData.json");
+
+export async function renderAllMons(rom, options = {}) {
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderAllMons(rom, options) requires rom Buffer/Uint8Array as first argument");
+    }
+
+    const {
+        assets: providedAssets = assets,
+        mons: providedMons = mons,
+        outputDir = "./out",
+        icon = true,
+        footprint = true,
+    } = options;
+
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    for (const monName of Object.keys(providedMons)) {
+        await renderMon(monName, providedMons, providedAssets, rom, {
+            side: "front",
+            variant: "normal",
+            icon,
+            footprint,
+            outputDir,
+        });
+        await renderMon(monName, providedMons, providedAssets, rom, {
+            side: "front",
+            variant: "shiny",
+            icon: false,
+            footprint: false,
+            outputDir,
+        });
+        await renderMon(monName, providedMons, providedAssets, rom, {
+            side: "back",
+            variant: "normal",
+            icon: false,
+            footprint: false,
+            outputDir,
+        });
+        await renderMon(monName, providedMons, providedAssets, rom, {
+            side: "back",
+            variant: "shiny",
+            icon: false,
+            footprint: false,
+            outputDir,
+        });
+        console.log(`Done: ${monName}`);
+    }
+}
+
+export function loadDefaultRom() {
+    const romPath = path.resolve(process.cwd(), "../../pokefirered.gba");
+    return fs.readFileSync(romPath);
+}

package/src/graphics/lz77-decompress.js

@@ -0,0 +1,58 @@
+/* 
+ * Derivative work of lz77 decompression code (within the gbagfx tool) by YamaArashi(2015)
+ * Licensed under MIT. see NOTICE file in project root for full license.
+ * 
+ * JS port and modifications by chickenPoo, 2026
+ */
+
+export function lz77Decompress(src) { // in theory this should work like flawlessly unless I messed up my port lol
+    if (!src || src.length < 4) {
+        throw new Error("invalid lz77 data");
+    }
+    if (src[0] !== 0x10) {
+        throw new Error("not lz77 compressed data");
+    }
+    
+    const destSize = src[1] | (src[2] << 8) | (src[3] << 16);
+    const dest = new Uint8Array(destSize);
+    let srcPos = 4;
+    let destPos = 0;
+    
+    while (destPos < destSize) {
+        if (srcPos >= src.length) {
+            throw new Error("unexpected end of data");
+        }
+        
+        let flags = src[srcPos++];
+        
+        for (let i = 0; i < 8; i++) {
+            if (flags & 0x80) {
+                if (srcPos + 1 >= src.length) {
+                    throw new Error("unexpected end of data");
+                }
+                
+                const byte1 = src[srcPos++];
+                const byte2 = src[srcPos++];
+                const blockSize = (byte1 >> 4) + 3;
+                const blockDistance = (((byte1 & 0xF) << 8) | byte2) + 1;
+                let copySrc = destPos - blockDistance;
+                
+                if (copySrc < 0) {
+                    throw new Error("invalid back reference");
+                }
+                for (let j = 0; j < blockSize; j++) {
+                    if (destPos >= destSize) break;
+                    dest[destPos++] = dest[copySrc + j];
+                }
+            } else {
+                if (srcPos >= src.length) {
+                    throw new Error("unexpected end of data");
+                }
+                dest[destPos++] = src[srcPos++];
+            }
+            if (destPos >= destSize) break;
+            flags <<= 1;
+        }
+    }
+    return dest;
+}

package/src/graphics/render-mon-foot.js

@@ -0,0 +1,82 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+import { PNG } from "pngjs";
+import { extract } from "./extract.js";
+import { decode1bppTile } from "./decode-1bpp.js";
+import fs from "fs";
+
+const streamToBuffer = (stream) => new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", chunk => chunks.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+});
+
+export async function renderMonFoot(monName, mons, assets, rom, options = {}) {
+    const { outputDir = null } = options;
+
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderMonFoot(..., rom) requires a ROM Buffer/Uint8Array");
+    }
+
+    const mon = mons[monName];
+    if (!mon) {
+        throw new Error(`Missing mon entry for ${monName}`);
+    }
+
+    if (!mon.footprintPics && monName.includes("UNOWN")) return;
+
+    const footAsset = assets.find(a => a.name === mon.footprintPics);
+    if (!footAsset) {
+        throw new Error(`Missing foot asset for ${monName}`);
+    }
+
+    const footData = extract(footAsset, rom);
+    const tiles = [];
+    const tileSize = 8;
+    const numTiles = footData.data.length / tileSize;
+    const width = 16;
+    const height = 16;
+    const tilesPerRow = width / 8;
+
+    for (let i = 0; i < numTiles; i++) {
+        const start = i * tileSize;
+        const tileBytes = footData.data.slice(start, start + tileSize);
+        tiles.push(decode1bppTile(tileBytes));
+    }
+
+    const image = new Uint8ClampedArray(width * height * 4);
+    for (let t = 0; t < tiles.length; t++) {
+        const tile = tiles[t];
+        const tileX = t % tilesPerRow;
+        const tileY = Math.floor(t / tilesPerRow);
+        for (let py = 0; py < 8; py++) {
+            for (let px = 0; px < 8; px++) {
+                const pixelIndex = py * 8 + px;
+                const value = tile[pixelIndex];
+                const x = tileX * 8 + px;
+                const y = tileY * 8 + py;
+                const outIndex = (y * width + x) * 4;
+                const color = value ? 0 : 255;
+                image[outIndex] = color;
+                image[outIndex + 1] = color;
+                image[outIndex + 2] = color;
+                image[outIndex + 3] = value ? 255 : 0;
+            }
+        }
+    }
+
+    const png = new PNG({ width, height });
+    png.data = image;
+    const pngBuffer = await streamToBuffer(png.pack());
+
+    if (outputDir) {
+        const dir = `${outputDir}/${monName}`;
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        const fileName = `${dir}/footprint.png`;
+        fs.writeFileSync(fileName, pngBuffer);
+    }
+
+    return pngBuffer;
+}

package/src/graphics/render-mon-icon.js

@@ -0,0 +1,87 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+import { decode4bppTile } from "./decode-4bpp.js";
+import { decodePalette } from "./decode-palette.js";
+import { extract } from "./extract.js";
+import { PNG } from "pngjs";
+import fs from "fs";
+
+const streamToBuffer = (stream) => new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", chunk => chunks.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+});
+
+export async function renderMonIcon(monName, mons, assets, iconPalettes, rom, options = {}) {
+    const { outputDir = null } = options;
+
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderMonIcon(..., rom) requires a ROM Buffer/Uint8Array");
+    }
+
+    const mon = mons[monName];
+    if (!mon) {
+        throw new Error(`Missing mon entry for ${monName}`);
+    }
+
+    const iconAsset = assets.find(a => a.name === mon.Icon);
+    if (!iconAsset) throw new Error(`Missing icon asset for ${monName}`);
+
+    const iconData = extract(iconAsset, rom);
+    const palIndex = Number(mon.iconPalIndex);
+    const palSize = 32;
+    const palStart = palIndex * palSize;
+    const palEnd = palStart + palSize;
+    const rawIconPalData = extract(iconPalettes, rom);
+    const slicedPalData = rawIconPalData.data.slice(palStart, palEnd);
+    const palette = decodePalette(slicedPalData);
+
+    const tileSize = 32;
+    const numTiles = iconData.data.length / tileSize;
+    const width = 32;
+    const height = 64;
+    const tilesPerRow = width / 8;
+
+    const tiles = [];
+    for (let i = 0; i < numTiles; i++) {
+        const start = i * tileSize;
+        const tileBytes = iconData.data.slice(start, start + tileSize);
+        tiles.push(decode4bppTile(tileBytes));
+    }
+
+    const image = new Uint8ClampedArray(width * height * 4);
+    for (let t = 0; t < tiles.length; t++) {
+        const tile = tiles[t];
+        const tileX = t % tilesPerRow;
+        const tileY = Math.floor(t / tilesPerRow);
+        for (let py = 0; py < 8; py++) {
+            for (let px = 0; px < 8; px++) {
+                const pixelIndex = py * 8 + px;
+                const colorIndex = tile[pixelIndex];
+                const x = tileX * 8 + px;
+                const y = tileY * 8 + py;
+                const outIndex = (y * width + x) * 4;
+                const [r, g, b] = palette[colorIndex] || [0, 0, 0];
+                image[outIndex] = r;
+                image[outIndex + 1] = g;
+                image[outIndex + 2] = b;
+                image[outIndex + 3] = colorIndex === 0 ? 0 : 255;
+            }
+        }
+    }
+
+    const png = new PNG({ width, height });
+    png.data = image;
+    const pngBuffer = await streamToBuffer(png.pack());
+
+    if (outputDir) {
+        const dir = `${outputDir}/${monName}`;
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        const fileName = `${dir}/icon.png`;
+        fs.writeFileSync(fileName, pngBuffer);
+    }
+
+    return pngBuffer;
+}

package/src/graphics/render-mons.js

@@ -0,0 +1,104 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+import { PNG } from "pngjs";
+import fs from "fs";
+import { decode4bppTile } from "./decode-4bpp.js";
+import { decodePalette } from "./decode-palette.js";
+import { extract } from "./extract.js";
+import { renderMonIcon } from "./render-mon-icon.js";
+import { renderMonFoot } from "./render-mon-foot.js";
+
+const streamToBuffer = (stream) => new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", chunk => chunks.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+});
+
+export async function renderMon(monName, mons, assets, rom, options = {}) {
+    const {
+        side = "front",
+        variant = "normal",
+        icon = false,
+        footprint = false,
+        outputDir = null,
+    } = options;
+
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderMon(..., rom) requires a ROM Buffer/Uint8Array");
+    }
+
+    if (icon === true) {
+        const comboPal = assets.find(a => a.name === "gMonIconPalettes");
+        if (!comboPal) throw new Error("Missing gMonIconPalettes asset");
+        await renderMonIcon(monName, mons, assets, comboPal, rom, { outputDir });
+    }
+    if (footprint === true) {
+        await renderMonFoot(monName, mons, assets, rom, { outputDir });
+    }
+
+    const mon = mons[monName];
+    if (!mon) {
+        throw new Error(`Missing mon: ${monName}`);
+    }
+
+    const picName = side === "back" ? mon.backPics : mon.frontPics;
+    const monPic = assets.find(a => a.name === picName);
+    const palType = variant === "shiny" ? mon.shinyPalette : mon.normPalette;
+    const monPal = assets.find(a => a.name === palType);
+
+    if (!monPic || !monPal) {
+        throw new Error(`Missing assets for: ${monName}`);
+    }
+
+    const monImageData = extract(monPic, rom);
+    const rawMonPalData = extract(monPal, rom);
+    const tileSize = 32;
+    const numTiles = monImageData.data.length / tileSize;
+    const width = 64;
+    const height = 64;
+    const tilesPerRow = width / 8;
+    const monPalData = decodePalette(rawMonPalData.data);
+
+    const tiles = [];
+    for (let i = 0; i < numTiles; i++) {
+        const start = i * tileSize;
+        const tileBytes = monImageData.data.slice(start, start + tileSize);
+        tiles.push(decode4bppTile(tileBytes));
+    }
+
+    const image = new Uint8ClampedArray(width * height * 4);
+    for (let t = 0; t < tiles.length; t++) {
+        const tile = tiles[t];
+        const tileX = t % tilesPerRow;
+        const tileY = Math.floor(t / tilesPerRow);
+        for (let py = 0; py < 8; py++) {
+            for (let px = 0; px < 8; px++) {
+                const pixelIndex = py * 8 + px;
+                const colorIndex = tile[pixelIndex];
+                const x = tileX * 8 + px;
+                const y = tileY * 8 + py;
+                const outIndex = (y * width + x) * 4;
+                const [r, g, b] = monPalData[colorIndex] || [0, 0, 0];
+                image[outIndex] = r;
+                image[outIndex + 1] = g;
+                image[outIndex + 2] = b;
+                image[outIndex + 3] = colorIndex === 0 ? 0 : 255;
+            }
+        }
+    }
+
+    const png = new PNG({ width, height });
+    png.data = image;
+    const pngBuffer = await streamToBuffer(png.pack());
+
+    if (outputDir) {
+        const dir = `${outputDir}/${monName}`;
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        const fileName = `${dir}/${side}${variant === "shiny" ? "_shiny" : ""}.png`;
+        fs.writeFileSync(fileName, pngBuffer);
+    }
+
+    return pngBuffer;
+}

package/src/mon-data-parser.js

@@ -0,0 +1,113 @@
+import fs from "fs";
+import path from "path";
+
+const monFrontPicMap = path.resolve("../pokemon_graphics/front_pic_table.h");
+const monBackPicMap = path.resolve("../pokemon_graphics/back_pic_table.h");
+const monFootprintMap = path.resolve("../pokemon_graphics/footprint_table.h");
+const monPaletteMap = path.resolve("../pokemon_graphics/palette_table.h");
+const monShinyPaletteMap = path.resolve("../pokemon_graphics/shiny_palette_table.h");
+const monImageDimensionMap = path.resolve("../pokemon_graphics/front_pic_coordinates.h");
+const monIconPaletteIdxMap = path.resolve("../pokemon_icon.c");
+const frontPicLines = fs.readFileSync(monFrontPicMap, "utf-8").split("\n");
+const backPicLines = fs.readFileSync(monBackPicMap, "utf-8").split("\n");
+const footprintLines = fs.readFileSync(monFootprintMap, "utf8").split("\n");
+const paletteLines = fs.readFileSync(monPaletteMap, "utf-8").split("\n");
+const shinyPaletteLines = fs.readFileSync(monShinyPaletteMap, "utf-8").split("\n");
+const imageDimLines = fs.readFileSync(monImageDimensionMap, "utf-8").split("\n");
+const iconPalIdxLines = fs.readFileSync(monIconPaletteIdxMap, "utf-8").split("\n");
+const monData = {};
+
+function extractMonData(lines, category) {
+    for (let i = 0; i < lines.length; i++) {
+        let match;
+        let monName;
+        let secondArgument;
+        if (category !== "footprintPics" && category !== "imageDimensions" && category !== "iconPalIndex") {
+            match = lines[i].match(/\(([^,]+),\s*([^,]+)\)/);
+            if (match) {
+                monName = match[1];
+                secondArgument = match[2];
+            }
+        } else if (category === "footprintPics") {
+            match = lines[i].match(/\[(SPECIES_\w+)\]\s*=\s*(gMonFootprint_\w+)/);
+            if (match) {
+                monName = match[1].replace("SPECIES_", "");
+                secondArgument = match[2];
+            }
+        } else if (category === "imageDimensions" && lines[i].includes(".size = MON_COORDS_SIZE")) {
+            const prevLine = lines[i - 2];
+            match = lines[i].match(/MON_COORDS_SIZE\((\d+),\s*(\d+)\)/);
+            if (match) {
+                monName = prevLine.match(/\[(SPECIES_\w+)\]/)[1].replace("SPECIES_", "");
+                const width = match[1];
+                const height = match[2];
+                if (!monData[monName]) {
+                    monData[monName] = {};
+                }
+                monData[monName]["width"] = width;
+                monData[monName]["height"] = height;
+            }
+        } else if (category === "iconPalIndex") {
+            match = lines[i].match(/\[(SPECIES_\w+)\]\s*=\s*(\d+)\s*,?/);
+            if (match) {
+                monName = match[1].replace("SPECIES_", "");
+                secondArgument = match[2];
+            }
+        }
+        if (monName && secondArgument) {
+            if (!monData[monName]) {
+                monData[monName] = {};
+            }
+            if (!monData[monName][category]) {
+                monData[monName][category] = secondArgument;
+            }
+        }
+    }
+}
+
+extractMonData(frontPicLines, "frontPics");
+extractMonData(backPicLines, "backPics");
+extractMonData(paletteLines, "normPalette");
+extractMonData(shinyPaletteLines, "shinyPalette");
+extractMonData(footprintLines, "footprintPics");
+extractMonData(imageDimLines, "imageDimensions");
+extractMonData(iconPalIdxLines, "iconPalIndex");
+function uncapitalize(string) {
+    return string.charAt(0) + string.slice(1).toLowerCase();
+}
+Object.entries(monData).forEach(([monName]) => {
+    let monName2 = uncapitalize(monName);
+    if (monName2.includes("Old_unown_") || monName2.includes("None")) {
+        monName2 = "QuestionMark";
+    }
+    if (monName2.includes("Unown_")) {
+        monName2 = monName2.slice(0, 5) + monName2[6].toUpperCase() + monName2.slice(7);
+        if (monName2 === "UnownEmark") {
+            monName2 = "UnownExclamationMark";
+        } else if (monName2 === "UnownQmark") {
+            monName2 = "UnownQuestionMark";
+        }
+    }
+    if (monName2.includes("Nidoran")) {
+        if (monName2.includes("Nidoran_f")) {
+            monName2 = "NidoranF";
+        }
+        if (monName2.includes("Nidoran_m")) {
+            monName2 = "NidoranM";
+        }
+    }
+    if (monName2.includes("Mr_mime")) {
+        monName2 = "Mrmime";
+    }
+    if (monName2 === "Unown") {
+        monName2 = "UnownA";
+    }
+    if (monName2 === "Ho_oh") {
+        monName2 = "HoOh";
+    }
+    console.log(monName2);
+    const iconName = `gMonIcon_${monName2}`
+    monData[monName]["Icon"] = iconName;
+})
+
+fs.writeFileSync("../mon-data/monData.json", JSON.stringify(monData, null, 2));

package/src/rom-map-parser.js

@@ -0,0 +1,85 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+import fs from "fs";
+import path from "path";
+
+const frRomMap = path.resolve("../rom-maps/pokefirered.map");
+const lines = fs.readFileSync(frRomMap, "utf-8").split("\n");
+const symbols = [];
+
+for (const line of lines) {
+    const match = line.match(/^\s*0x([0-9a-fA-F]+)\s+([A-Za-z0-9_]+)$/);
+    if (!match) continue;
+
+    const address = parseInt(match[1], 16);
+    const name = match[2];
+    if (!name.startsWith('g')) continue;
+
+    if (address >= 0x08d00000 && address <= 0x08ffffff) {
+        symbols.push({ name, address });
+    }
+}
+/**
+ *   
+{
+"name": "gMonIconPalettes",
+"address": 138229568,
+"size": 96,
+"offset": 4011840,
+"type": "palette"
+},
+{
+"name": "gMonIconPaletteIndices",
+"address": 138231424,
+"size": 440,
+"offset": 4013696,
+"type": "palette"
+},
+
+just leaving these here... they are used for the firered icon palettes and I am too lazy to add
+this to the "parser" for now... so yea :p
+ */
+
+symbols.sort((a, b) => a.address - b.address);
+
+const romEnd = 0x09ffffff;
+
+function findNextAddressFromLines(currentAddress, lines) {
+    for (const line of lines) {
+        const match = line.match(/0x([0-9a-fA-F]+)/);
+        if (!match) continue;
+
+        const addr = parseInt(match[1], 16);
+        if (addr > currentAddress) return addr;
+    }
+    return null;
+}
+
+for (let i = 0; i < symbols.length; i++) {
+    const current = symbols[i];
+    const next = symbols[i + 1];
+    current.size = next
+        ? next.address - current.address
+        : romEnd - current.address; // really not needed anymore since like I actually fixed the thing instead of relying on this garbage thingy
+    current.offset = current.address - 0x08000000;
+    if (!next) {
+        const nextAddress = findNextAddressFromLines(current.address, lines);
+        current.size = nextAddress
+            ? nextAddress - current.address
+            : 0;
+    }
+}
+
+function classifyType(name) {
+    if (name.includes('Pal')) return "palette";
+    if (name.includes("Tilemap")) return "tilemap";
+    if (name.includes("Gfx") || name.includes("Pic")) return "gfx";
+    return "unknown";
+}
+
+for (const sym of symbols) {
+    sym.type = classifyType(sym.name);
+}
+
+fs.writeFileSync("../graphics-maps/fr-graphic-map.json", JSON.stringify(symbols, null, 2));