@gaialabs/core 0.2.3 → 0.2.5

package/dist/index.cjs

@@ -1,6 +1,847 @@
-let fs = require("fs");
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 let _supabase_supabase_js = require("@supabase/supabase-js");
 
+//#region snes/addressingModes.json
+var addressingModes_default = {
+	Absolute: {
+		"shorthand": "abs",
+		"operands": ["Offset"],
+		"size": 3,
+		"formatString": "${0:X4}",
+		"parseRegex": "^\\$([A-Fa-f0-9]{4}|&[A-Za-z0-9-+_]+)$",
+		"instructions": {
+			"ADC": 109,
+			"AND": 45,
+			"ASL": 14,
+			"BIT": 44,
+			"CMP": 205,
+			"CPX": 236,
+			"CPY": 204,
+			"DEC": 206,
+			"EOR": 77,
+			"INC": 238,
+			"JMP": 76,
+			"JSR": 32,
+			"LDA": 173,
+			"LDX": 174,
+			"LDY": 172,
+			"LSR": 78,
+			"ORA": 13,
+			"PEA": 244,
+			"ROL": 46,
+			"ROR": 110,
+			"SBC": 237,
+			"STA": 141,
+			"STX": 142,
+			"STY": 140,
+			"STZ": 156,
+			"TRB": 28,
+			"TSB": 12
+		}
+	},
+	AbsoluteIndexedX: {
+		"shorthand": "abs_x",
+		"operands": ["Offset"],
+		"size": 3,
+		"formatString": "${0:X4}, X",
+		"parseRegex": "^(\\$[A-Fa-f0-9]{4}|\\$?&[A-Za-z0-9-+_]+),\\s?[Xx]$",
+		"instructions": {
+			"ADC": 125,
+			"AND": 61,
+			"ASL": 30,
+			"BIT": 60,
+			"CMP": 221,
+			"DEC": 222,
+			"EOR": 93,
+			"INC": 254,
+			"LDA": 189,
+			"LDY": 188,
+			"LSR": 94,
+			"ORA": 29,
+			"ROL": 62,
+			"ROR": 126,
+			"SBC": 253,
+			"STA": 157,
+			"STZ": 158
+		}
+	},
+	AbsoluteIndexedY: {
+		"shorthand": "abs_y",
+		"operands": ["Offset"],
+		"size": 3,
+		"formatString": "${0:X4}, Y",
+		"parseRegex": "^(\\$[A-Fa-f0-9]{4}|\\$?&[A-Za-z0-9-+_]+),\\s?[Yy]$",
+		"instructions": {
+			"ADC": 121,
+			"AND": 57,
+			"CMP": 217,
+			"EOR": 89,
+			"LDA": 185,
+			"LDX": 190,
+			"ORA": 25,
+			"SBC": 249,
+			"STA": 153
+		}
+	},
+	AbsoluteIndirect: {
+		"shorthand": "abs_ind",
+		"operands": ["Offset"],
+		"size": 3,
+		"formatString": "(${0})",
+		"parseRegex": "^\\((\\$[A-Fa-f0-9]{4}|\\$?&[A-Za-z0-9-+_]+)\\)$",
+		"instructions": { "JMP": 108 }
+	},
+	AbsoluteIndirectLong: {
+		"shorthand": "abs_indl",
+		"operands": ["Offset"],
+		"size": 3,
+		"formatString": "[${0}]",
+		"parseRegex": "^\\[(\\$[A-Fa-f0-9]{4}|\\$?&[A-Za-z0-9-+_]+)\\]$",
+		"instructions": { "JML": 220 }
+	},
+	AbsoluteIndexedIndirect: {
+		"shorthand": "abs_x_ind",
+		"operands": ["Offset"],
+		"size": 3,
+		"formatString": "(${0}, X)",
+		"parseRegex": "^\\((\\$[A-Fa-f0-9]{4}|\\$?&[A-Za-z0-9-+_]+),\\s*[Xx]\\)$",
+		"instructions": {
+			"JMP": 124,
+			"JSR": 252
+		}
+	},
+	AbsoluteLong: {
+		"shorthand": "long",
+		"operands": ["Address"],
+		"size": 4,
+		"formatString": "${0:X6}",
+		"parseRegex": "^\\$([A-Fa-f0-9]{6}|\\@[A-Za-z0-9-+_]+)$",
+		"instructions": {
+			"ADC": 111,
+			"AND": 47,
+			"CMP": 207,
+			"EOR": 79,
+			"JML": 92,
+			"JSL": 34,
+			"LDA": 175,
+			"ORA": 15,
+			"SBC": 239,
+			"STA": 143
+		}
+	},
+	AbsoluteLongIndexedX: {
+		"shorthand": "long_x",
+		"operands": ["Address"],
+		"size": 4,
+		"formatString": "${0:X6}, X",
+		"parseRegex": "^(\\$[A-Fa-f0-9]{6}|\\$?@[A-Za-z0-9-+_]+),\\s?[Xx]$",
+		"instructions": {
+			"ADC": 127,
+			"AND": 63,
+			"CMP": 223,
+			"EOR": 95,
+			"LDA": 191,
+			"ORA": 31,
+			"SBC": 255,
+			"STA": 159
+		}
+	},
+	DirectPage: {
+		"shorthand": "dp",
+		"operands": ["Direct"],
+		"size": 2,
+		"formatString": "${0:X2}",
+		"parseRegex": "^\\$([A-Fa-f0-9]{2})$",
+		"instructions": {
+			"ADC": 101,
+			"AND": 37,
+			"ASL": 6,
+			"BIT": 36,
+			"CMP": 197,
+			"CPX": 228,
+			"CPY": 196,
+			"DEC": 198,
+			"EOR": 69,
+			"INC": 230,
+			"LDA": 165,
+			"LDX": 166,
+			"LDY": 164,
+			"LSR": 70,
+			"ORA": 5,
+			"ROL": 38,
+			"ROR": 102,
+			"SBC": 229,
+			"STA": 133,
+			"STX": 134,
+			"STY": 132,
+			"STZ": 100,
+			"TRB": 20,
+			"TSB": 4
+		}
+	},
+	DirectPageIndexedX: {
+		"shorthand": "dp_x",
+		"operands": ["Direct"],
+		"size": 2,
+		"formatString": "${0:X2}, X",
+		"parseRegex": "^\\$([A-Fa-f0-9]{2}),\\s?[Xx]$",
+		"instructions": {
+			"ADC": 117,
+			"AND": 53,
+			"ASL": 22,
+			"BIT": 52,
+			"CMP": 213,
+			"DEC": 214,
+			"EOR": 85,
+			"INC": 246,
+			"LDA": 181,
+			"LDY": 180,
+			"LSR": 86,
+			"ORA": 21,
+			"ROL": 54,
+			"ROR": 118,
+			"SBC": 245,
+			"STA": 149,
+			"STY": 148,
+			"STZ": 116
+		}
+	},
+	DirectPageIndexedY: {
+		"shorthand": "dp_y",
+		"operands": ["Direct"],
+		"size": 2,
+		"formatString": "${0:X2}, Y",
+		"parseRegex": "^\\$([A-Fa-f0-9]{2}),\\s?[Yy]$",
+		"instructions": {
+			"LDX": 182,
+			"STX": 150
+		}
+	},
+	DirectPageIndirect: {
+		"shorthand": "dp_ind",
+		"operands": ["Direct"],
+		"size": 2,
+		"formatString": "(${0:X2})",
+		"parseRegex": "^\\(\\$([A-Fa-f0-9]{2})\\)$",
+		"instructions": {
+			"ADC": 114,
+			"AND": 50,
+			"CMP": 210,
+			"EOR": 82,
+			"LDA": 178,
+			"ORA": 18,
+			"PEI": 212,
+			"SBC": 242,
+			"STA": 146
+		}
+	},
+	DirectPageIndirectLong: {
+		"shorthand": "dp_indl",
+		"operands": ["Direct"],
+		"size": 2,
+		"formatString": "[${0:X2}]",
+		"parseRegex": "^\\[\\$([A-Fa-f0-9]{2})\\]$",
+		"instructions": {
+			"ADC": 103,
+			"AND": 39,
+			"CMP": 199,
+			"EOR": 71,
+			"LDA": 167,
+			"ORA": 7,
+			"SBC": 231,
+			"STA": 135
+		}
+	},
+	DirectPageIndexedIndirectX: {
+		"shorthand": "dp_x_ind",
+		"operands": ["Direct"],
+		"size": 2,
+		"formatString": "(${0:X2}, X)",
+		"parseRegex": "^\\(\\$([A-Fa-f0-9]{2}),\\s?[Xx]\\)$",
+		"instructions": {
+			"ADC": 97,
+			"AND": 33,
+			"CMP": 193,
+			"EOR": 65,
+			"LDA": 161,
+			"ORA": 1,
+			"SBC": 225,
+			"STA": 129
+		}
+	},
+	DirectPageIndirectIndexedY: {
+		"shorthand": "dp_ind_y",
+		"operands": ["Direct"],
+		"size": 2,
+		"formatString": "(${0:X2}), Y",
+		"parseRegex": "^\\(\\$([A-Fa-f0-9]{2})\\),\\s?[Yy]$",
+		"instructions": {
+			"ADC": 113,
+			"AND": 49,
+			"CMP": 209,
+			"EOR": 81,
+			"LDA": 177,
+			"ORA": 17,
+			"SBC": 241,
+			"STA": 145
+		}
+	},
+	DirectPageIndirectLongIndexedY: {
+		"shorthand": "dp_indl_y",
+		"operands": ["Direct"],
+		"size": 2,
+		"formatString": "[${0:X2}], Y",
+		"parseRegex": "^\\[\\$([A-Fa-f0-9]{2})\\],\\s?[Yy]$",
+		"instructions": {
+			"ADC": 119,
+			"AND": 55,
+			"CMP": 215,
+			"EOR": 87,
+			"LDA": 183,
+			"ORA": 23,
+			"SBC": 247,
+			"STA": 151
+		}
+	},
+	Immediate: {
+		"shorthand": "imm",
+		"operands": ["Immediate"],
+		"size": 2,
+		"formatString": "#${0:X2}",
+		"parseRegex": "^#(\\$[A-Fa-f0-9]{2,4}|\\$?[&^*][A-Za-z0-9-+_]+)$",
+		"instructions": {
+			"ADC": 105,
+			"AND": 41,
+			"BIT": 137,
+			"CMP": 201,
+			"CPX": 224,
+			"CPY": 192,
+			"EOR": 73,
+			"LDA": 169,
+			"LDX": 162,
+			"LDY": 160,
+			"ORA": 9,
+			"REP": 194,
+			"SBC": 233,
+			"SEP": 226
+		}
+	},
+	Implied: {
+		"shorthand": "imp",
+		"operands": [],
+		"size": 1,
+		"formatString": null,
+		"parseRegex": null,
+		"instructions": {
+			"CLC": 24,
+			"CLD": 216,
+			"CLI": 88,
+			"CLV": 184,
+			"DEX": 202,
+			"DEY": 136,
+			"INX": 232,
+			"INY": 200,
+			"NOP": 234,
+			"SEC": 56,
+			"SED": 248,
+			"SEI": 120,
+			"STP": 219,
+			"TAX": 170,
+			"TAY": 168,
+			"TCD": 91,
+			"TCS": 27,
+			"TDC": 123,
+			"TSC": 59,
+			"TSX": 186,
+			"TXA": 138,
+			"TXS": 154,
+			"TXY": 155,
+			"TYA": 152,
+			"TYX": 187,
+			"WAI": 203,
+			"WDM": 66,
+			"XBA": 235,
+			"XCE": 251
+		}
+	},
+	Accumulator: {
+		"shorthand": "acc",
+		"operands": [],
+		"size": 1,
+		"formatString": null,
+		"parseRegex": null,
+		"instructions": {
+			"ASL": 10,
+			"DEC": 58,
+			"INC": 26,
+			"LSR": 74,
+			"ROL": 42,
+			"ROR": 106
+		}
+	},
+	PCRelative: {
+		"shorthand": "rel",
+		"operands": ["Relative"],
+		"size": 2,
+		"formatString": "{0}",
+		"parseRegex": "^([A-Za-z_][A-Za-z0-9_]*|\\$[A-Fa-f0-9]{2})$",
+		"instructions": {
+			"BPL": 16,
+			"BMI": 48,
+			"BRA": 128,
+			"BCC": 144,
+			"BCS": 176,
+			"BNE": 208,
+			"BEQ": 240,
+			"BVC": 80,
+			"BVS": 112
+		}
+	},
+	PCRelativeLong: {
+		"shorthand": "rel16",
+		"operands": ["RelativeLong"],
+		"size": 3,
+		"formatString": "{0}",
+		"parseRegex": "^([A-Za-z_][A-Za-z0-9_]*|\\$[A-Fa-f0-9]{4})$",
+		"instructions": {
+			"BRL": 130,
+			"PER": 98
+		}
+	},
+	StackRelative: {
+		"shorthand": "stkr",
+		"operands": ["Byte"],
+		"size": 2,
+		"formatString": "${0:X2}, S",
+		"parseRegex": "^\\$([A-Fa-f0-9]{2}),\\s?[Ss]$",
+		"instructions": {
+			"ADC": 99,
+			"AND": 35,
+			"CMP": 195,
+			"EOR": 67,
+			"LDA": 163,
+			"ORA": 3,
+			"SBC": 227,
+			"STA": 131
+		}
+	},
+	StackRelativeIndirectIndexedY: {
+		"shorthand": "stkr_ind_y",
+		"operands": ["Byte"],
+		"size": 2,
+		"formatString": "(${0:X2}, S), Y",
+		"parseRegex": "^\\(\\$([A-Fa-f0-9]{2}),\\s?[Ss]\\),\\s?[Yy]$",
+		"instructions": {
+			"ADC": 115,
+			"AND": 51,
+			"CMP": 211,
+			"EOR": 83,
+			"LDA": 179,
+			"ORA": 19,
+			"SBC": 243,
+			"STA": 147
+		}
+	},
+	BlockMove: {
+		"shorthand": "src_dest",
+		"operands": ["Byte", "Byte"],
+		"size": 3,
+		"formatString": "#${0:X2}, #${1:X2}",
+		"parseRegex": "^#\\$([A-Fa-f0-9]{2}|\\^[A-Za-z0-9-+_]+),\\s?#\\$([A-Fa-f0-9]{2}|\\^[A-Za-z0-9-+_]+)$",
+		"instructions": {
+			"MVN": 84,
+			"MVP": 68
+		}
+	},
+	StackInterrupt: {
+		"shorthand": "stk_int",
+		"operands": ["Byte"],
+		"size": 2,
+		"formatString": "#${0:X2}",
+		"parseRegex": "^#\\$([A-Fa-f0-9]{2})$",
+		"instructions": {
+			"BRK": 0,
+			"COP": 2
+		}
+	},
+	Stack: {
+		"shorthand": "stk",
+		"operands": [],
+		"size": 1,
+		"formatString": null,
+		"parseRegex": null,
+		"instructions": {
+			"PHA": 72,
+			"PHB": 139,
+			"PHD": 11,
+			"PHK": 75,
+			"PHP": 8,
+			"PHX": 218,
+			"PHY": 90,
+			"PLA": 104,
+			"PLB": 171,
+			"PLD": 43,
+			"PLP": 40,
+			"PLX": 250,
+			"PLY": 122,
+			"RTI": 64,
+			"RTL": 107,
+			"RTS": 96
+		}
+	}
+};
+
+//#endregion
+//#region snes/vectors.json
+var vectors_default = {
+	"8448": "INIDISP",
+	"8449": "OBJSEL",
+	"8450": "OAMADDL",
+	"8451": "OAMADDH",
+	"8452": "OAMDATA",
+	"8453": "BGMODE",
+	"8454": "MOSAIC",
+	"8455": "BG1SC",
+	"8456": "BG2SC",
+	"8457": "BG3SC",
+	"8458": "BG4SC",
+	"8459": "BG12NBA",
+	"8460": "BG34NBA",
+	"8461": "BG1HOFS",
+	"8462": "BG1VOFS",
+	"8463": "BG2HOFS",
+	"8464": "BG2VOFS",
+	"8465": "BG3HOFS",
+	"8466": "BG3VOFS",
+	"8467": "BG4HOFS",
+	"8468": "BG4VOFS",
+	"8469": "VMAIN",
+	"8470": "VMADDL",
+	"8471": "VMADDH",
+	"8472": "VMDATAL",
+	"8473": "VMDATAH",
+	"8474": "M7SEL",
+	"8475": "M7A",
+	"8476": "M7B",
+	"8477": "M7C",
+	"8478": "M7D",
+	"8479": "M7X",
+	"8480": "M7Y",
+	"8481": "CGADD",
+	"8482": "CGDATA",
+	"8483": "W12SEL",
+	"8484": "W34SEL",
+	"8485": "WOBJSEL",
+	"8486": "WH0",
+	"8487": "WH1",
+	"8488": "WH2",
+	"8489": "WH3",
+	"8490": "WBGLOG",
+	"8491": "WOBJLOG",
+	"8492": "_TM",
+	"8493": "_TS",
+	"8494": "TMW",
+	"8495": "TSW",
+	"8496": "CGWSEL",
+	"8497": "CGADSUB",
+	"8498": "COLDATA",
+	"8499": "SETINI",
+	"8500": "MPYL",
+	"8501": "MPYM",
+	"8502": "MPYH",
+	"8503": "SLHV",
+	"8504": "OAMDATAREAD",
+	"8505": "VMDATALREAD",
+	"8506": "VMDATAHREAD",
+	"8507": "CGDATAREAD",
+	"8508": "OPHCT",
+	"8509": "OPVCT",
+	"8510": "STAT77",
+	"8511": "STAT78",
+	"8512": "APUIO0",
+	"8513": "APUIO1",
+	"8514": "APUIO2",
+	"8515": "APUIO3",
+	"8576": "WMDATA",
+	"8577": "WMADDL",
+	"8578": "WMADDM",
+	"8579": "WMADDH",
+	"16406": "JOYSER0",
+	"16407": "JOYSER1",
+	"16896": "NMITIMEN",
+	"16897": "WRIO",
+	"16898": "WRMPYA",
+	"16899": "WRMPYB",
+	"16900": "WRDIVL",
+	"16901": "WRDIVH",
+	"16902": "WRDIVB",
+	"16903": "HTIMEL",
+	"16904": "HTIMEH",
+	"16905": "VTIMEL",
+	"16906": "VTIMEH",
+	"16907": "MDMAEN",
+	"16908": "HDMAEN",
+	"16909": "MEMSEL",
+	"16912": "RDNMI",
+	"16913": "TIMEUP",
+	"16914": "HVBJOY",
+	"16915": "RDIO",
+	"16916": "RDDIVL",
+	"16917": "RDDIVH",
+	"16918": "RDMPYL",
+	"16919": "RDMPYH",
+	"16920": "JOY1L",
+	"16921": "JOY1H",
+	"16922": "JOY2L",
+	"16923": "JOY2H",
+	"16924": "JOY3L",
+	"16925": "JOY3H",
+	"16926": "JOY4L",
+	"16927": "JOY4H",
+	"17152": "DMAP0",
+	"17153": "BBAD0",
+	"17154": "A1T0L",
+	"17155": "A1T0H",
+	"17156": "A1B0",
+	"17157": "DAS0L",
+	"17158": "DAS0H",
+	"17159": "DASB0",
+	"17160": "A2A0L",
+	"17161": "A2A0H",
+	"17162": "NLTR0",
+	"17168": "DMAP1",
+	"17169": "BBAD1",
+	"17170": "A1T1L",
+	"17171": "A1T1H",
+	"17172": "A1B1",
+	"17173": "DAS1L",
+	"17174": "DAS1H",
+	"17175": "DASB1",
+	"17176": "A2A1L",
+	"17177": "A2A1H",
+	"17178": "NLTR1",
+	"17184": "DMAP2",
+	"17185": "BBAD2",
+	"17186": "A1T2L",
+	"17187": "A1T2H",
+	"17188": "A1B2",
+	"17189": "DAS2L",
+	"17190": "DAS2H",
+	"17191": "DASB2",
+	"17192": "A2A2L",
+	"17193": "A2A2H",
+	"17194": "NLTR2",
+	"17200": "DMAP3",
+	"17201": "BBAD3",
+	"17202": "A1T3L",
+	"17203": "A1T3H",
+	"17204": "A1B3",
+	"17205": "DAS3L",
+	"17206": "DAS3H",
+	"17207": "DASB3",
+	"17208": "A2A3L",
+	"17209": "A2A3H",
+	"17210": "NLTR3",
+	"17216": "DMAP4",
+	"17217": "BBAD4",
+	"17218": "A1T4L",
+	"17219": "A1T4H",
+	"17220": "A1B4",
+	"17221": "DAS4L",
+	"17222": "DAS4H",
+	"17223": "DASB4",
+	"17224": "A2A4L",
+	"17225": "A2A4H",
+	"17226": "NLTR4",
+	"17232": "DMAP5",
+	"17233": "BBAD5",
+	"17234": "A1T5L",
+	"17235": "A1T5H",
+	"17236": "A1B5",
+	"17237": "DAS5L",
+	"17238": "DAS5H",
+	"17239": "DASB5",
+	"17240": "A2A5L",
+	"17241": "A2A5H",
+	"17242": "NLTR5",
+	"17248": "DMAP6",
+	"17249": "BBAD6",
+	"17250": "A1T6L",
+	"17251": "A1T6H",
+	"17252": "A1B6",
+	"17253": "DAS6L",
+	"17254": "DAS6H",
+	"17255": "DASB6",
+	"17256": "A2A6L",
+	"17257": "A2A6H",
+	"17258": "NLTR6",
+	"17264": "DMAP7",
+	"17265": "BBAD7",
+	"17266": "A1T7L",
+	"17267": "A1T7H",
+	"17268": "A1B7",
+	"17269": "DAS7L",
+	"17270": "DAS7H",
+	"17271": "DASB7",
+	"17272": "A2A7L",
+	"17273": "A2A7H",
+	"17274": "NLTR7"
+};
+
+//#endregion
+//#region snes/headers.json
+var headers_default = [{
+	"address": 65456,
+	"condition": "values.developerId === 51",
+	"parts": [
+		{
+			"name": "makerCode",
+			"size": 2,
+			"type": "string"
+		},
+		{
+			"name": "gameCode",
+			"size": 4,
+			"type": "string"
+		},
+		{
+			"name": "reserved",
+			"size": 10,
+			"type": "byte",
+			"value": 0
+		}
+	]
+}, {
+	"address": 65472,
+	"parts": [
+		{
+			"name": "gameTitle",
+			"size": 21,
+			"type": "string"
+		},
+		{
+			"name": "mapMode",
+			"size": 1,
+			"type": "byte"
+		},
+		{
+			"name": "chipset",
+			"size": 1,
+			"type": "byte"
+		},
+		{
+			"name": "romSize",
+			"size": 1,
+			"type": "byte"
+		},
+		{
+			"name": "ramSize",
+			"size": 1,
+			"type": "byte"
+		},
+		{
+			"name": "countryCode",
+			"size": 1,
+			"type": "byte"
+		},
+		{
+			"name": "developerId",
+			"size": 1,
+			"type": "byte"
+		},
+		{
+			"name": "gameVersion",
+			"size": 1,
+			"type": "byte"
+		},
+		{
+			"name": "compliment",
+			"size": 2,
+			"type": "word"
+		},
+		{
+			"name": "checksum",
+			"size": 2,
+			"type": "word"
+		},
+		{
+			"name": "reserved",
+			"size": 4,
+			"type": "byte",
+			"value": 0
+		},
+		{
+			"name": "nativeCop",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "nativeBrk",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "nativeAbort",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "nativeNmi",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "reserved",
+			"size": 2,
+			"type": "byte",
+			"value": 0
+		},
+		{
+			"name": "nativeIrq",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "reserved",
+			"size": 4,
+			"type": "byte",
+			"value": 0
+		},
+		{
+			"name": "emulationCop",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "reserved",
+			"size": 2,
+			"type": "byte",
+			"value": 0
+		},
+		{
+			"name": "emulationAbort",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "emulationNmi",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "emulationReset",
+			"size": 2,
+			"type": "entry"
+		},
+		{
+			"name": "emulationBrk",
+			"size": 2,
+			"type": "entry"
+		}
+	]
+}];
+
+//#endregion
 //#region src/rom/state.ts
 /**
 * Lightweight ROM state placeholder used during early development.
@@ -808,23 +1649,6 @@ var CompressionRegistry = class {
 //#endregion
 //#region src/types/files.ts
 /**
-* Types that should have a compression header by default but should not be compressed
-*/
-const UNCOMPRESSED_TYPES = [
-	"Bitmap",
-	"Tilemap",
-	"Tileset",
-	"Spritemap",
-	"Meta17"
-];
-/**
-* Type guard to check if a type is an uncompressed type
-* Works with both BinType enum values and string values
-*/
-function isUncompressedType(type) {
-	return UNCOMPRESSED_TYPES.includes(type);
-}
-/**
 * Chunk file for ROM processing
 * Converted from GaiaLib/Types/ChunkFile.cs
 */
@@ -851,7 +1675,7 @@ var ChunkFile = class {
 		this.size = size;
 		this.location = location;
 		this.mnemonics = {};
-		this.compressed = isUncompressedType(type.type) ? false : void 0;
+		this.compressed = type.compressed;
 		this.type = type;
 	}
 };
@@ -897,7 +1721,7 @@ function enrichWithRawDataFromDbFile(rom, chunkFile, compression, dbFile, fileTy
 	}
 	let length = dbFile.end - start;
 	let fileData;
-	if (dbFile.compressed === true) {
+	if (dbFile.compressed === true && compression) {
 		const expanded = compression.expand(rom, start, length);
 		fileData = combineHeader(expanded, 0, expanded.length, header, fileType.type);
 	} else {
@@ -950,12 +1774,12 @@ var ChunkFileUtils = class {
 	*/
 	static calculateSize(chunkFile) {
 		if (!chunkFile.parts) {
-			let size$1 = chunkFile.rawData?.length ?? chunkFile.size;
+			let size = chunkFile.rawData?.length ?? chunkFile.size;
 			if (chunkFile.type.header === -2 || chunkFile.compressed === false) {
-				size$1 += 2;
-				chunkFile.size = size$1;
+				size += 2;
+				chunkFile.size = size;
 			}
-			return size$1;
+			return size;
 		}
 		let size = 0;
 		for (let x = 0; x < chunkFile.parts.length; x++) {
@@ -1697,18 +2521,18 @@ var DbFile = class {
 	group;
 	scene;
 	constructor(data) {
-		this.name = data.name ?? "";
-		this.type = data.type ?? "";
-		this.start = data.start ?? void 0;
-		this.end = data.end ?? 0;
+		if (!data.name) throw new Error("Name is required");
+		if (!data.type) throw new Error("Type is required");
+		if (typeof data.start !== "number") throw new Error("Start is required");
+		if (typeof data.end !== "number") throw new Error("End is required");
+		this.name = data.name;
+		this.type = data.type;
+		this.start = data.start;
+		this.end = data.end;
 		this.compressed = data.compressed ?? void 0;
 		this.upper = data.upper ?? void 0;
 		this.group = data.group || void 0;
 		this.scene = data.scene || void 0;
-		if (!this.name) throw new Error("Name is required");
-		if (!this.type) throw new Error("Type is required");
-		if (this.start === void 0) throw new Error("Start is required");
-		if (!this.end) throw new Error("End is required");
 	}
 };
 var DbFileType = class {
@@ -1718,6 +2542,7 @@ var DbFileType = class {
 	isPatch;
 	isBlock;
 	header;
+	compressed;
 	constructor(data) {
 		this.name = data.name ?? "";
 		this.extension = data.extension ?? "";
@@ -1725,6 +2550,7 @@ var DbFileType = class {
 		this.isPatch = data.isPatch ?? false;
 		this.isBlock = data.isBlock ?? false;
 		this.header = data.header ?? 0;
+		this.compressed = data.compressed ?? void 0;
 		if (!this.name) throw new Error("Name is required");
 		if (!this.extension) throw new Error("Extension is required");
 		if (!this.type) throw new Error("Type is required");
@@ -1764,17 +2590,17 @@ var DbAddressingMode = class {
 	parseRegex;
 	instructions;
 	constructor(data) {
-		this.name = data.name ?? "";
-		this.shorthand = data.shorthand ?? "";
+		if (!data.name) throw new Error("Addressing mode name is required");
+		if (!data.shorthand) throw new Error("Addressing mode shorthand is required");
+		if (!data.instructions) throw new Error("Addressing mode instructions are required");
+		if (!data.size) throw new Error("Addressing mode size is required");
+		this.name = data.name;
+		this.shorthand = data.shorthand;
 		this.operands = data.operands ?? [];
 		this.size = data.size ?? 1;
 		this.formatString = data.formatString ?? void 0;
 		this.parseRegex = data.parseRegex ?? void 0;
-		this.instructions = data.instructions ?? void 0;
-		if (!this.name) throw new Error("Addressing mode name is required");
-		if (!this.shorthand) throw new Error("Addressing mode shorthand is required");
-		if (!this.instructions) throw new Error("Addressing mode instructions are required");
-		if (!this.size) throw new Error("Addressing mode size is required");
+		this.instructions = data.instructions;
 	}
 };
 
@@ -1790,14 +2616,16 @@ var DbStringCommand = class {
 	types;
 	delimiter;
 	halt;
+	dictionary;
 	constructor(data) {
-		this.id = data.id ?? void 0;
-		this.name = data.name ?? "";
+		if (typeof data.id !== "number") throw new Error("Id is required");
+		if (!data.name) throw new Error("Name is required");
+		this.id = data.id;
+		this.name = data.name;
 		this.types = data.types ?? [];
 		this.delimiter = data.delimiter ?? void 0;
 		this.halt = data.halt ?? false;
-		if (!this.id && this.id !== 0) throw new Error("Id is required");
-		if (!this.name) throw new Error("Name is required");
+		this.dictionary = data.dictionary ?? void 0;
 	}
 };
 var DbStringDictionary = class {
@@ -1807,14 +2635,14 @@ var DbStringDictionary = class {
 	name;
 	entries;
 	constructor(data) {
+		if (typeof data.base !== "number" && typeof data.command !== "number") throw new Error("Base or command is required");
+		if (!data.name) throw new Error("Name is required");
+		if (!data.entries || data.entries.length === 0) throw new Error("Entries is required");
 		this.base = data.base ?? void 0;
 		this.range = data.range ?? 0;
 		this.command = data.command ?? void 0;
-		this.name = data.name ?? "";
-		this.entries = data.entries ?? void 0;
-		if (this.base === void 0 && this.command === void 0) throw new Error("Base or command is required");
-		if (!this.name) throw new Error("Name is required");
-		if (!this.entries) throw new Error("Entries is required");
+		this.name = data.name;
+		this.entries = data.entries;
 		if (this.base !== void 0) this.range = this.base + this.entries.length;
 	}
 };
@@ -1826,8 +2654,6 @@ var DbStringType = class {
 	name;
 	delimiter;
 	terminator;
-	shiftType;
-	characterMap;
 	commands;
 	commandLookup;
 	layers;
@@ -1835,13 +2661,15 @@ var DbStringType = class {
 	dictionaries;
 	dictionaryLookup;
 	constructor(data) {
-		this.name = data.name ?? "";
-		this.delimiter = data.delimiter ?? "";
-		this.terminator = data.terminator ?? 0;
-		this.shiftType = data.shiftType ?? void 0;
-		this.characterMap = data.characterMap;
+		if (!data.name) throw new Error("Name is required");
+		if (!data.delimiter) throw new Error("Delimiter is required");
+		if (typeof data.terminator !== "number") throw new Error("Terminator is required");
+		if (!data.layers || !data.layers.length) throw new Error("Layers are required");
+		this.name = data.name;
+		this.delimiter = data.delimiter;
+		this.terminator = data.terminator;
 		this.commands = data.commands ?? {};
-		this.layers = data.layers ?? [];
+		this.layers = data.layers;
 		this.greedyTerminator = data.greedyTerminator ?? false;
 		this.dictionaries = data.dictionaries ?? {};
 		this.commandLookup = Object.values(this.commands).reduce((acc, x) => {
@@ -1850,12 +2678,8 @@ var DbStringType = class {
 		}, {});
 		this.dictionaryLookup = Object.values(this.dictionaries).flatMap((y) => y.entries.map((z, ix) => ({
 			text: z,
-			id: y.command << 8 | y.base + ix
+			id: (y.command ?? 0) | (y.base ?? 0 + ix)
 		}))).sort((a, b) => b.text.length - a.text.length);
-		if (!this.name) throw new Error("Name is required");
-		if (!this.delimiter) throw new Error("Delimiter is required");
-		if (!this.terminator && this.terminator !== 0) throw new Error("Terminator is required");
-		if (!this.characterMap) throw new Error("Character map is required");
 	}
 };
 /**
@@ -1893,13 +2717,13 @@ var CopDef = class {
 	parts;
 	halt;
 	constructor(data) {
-		this.name = data.name ?? void 0;
-		this.id = data.id ?? void 0;
+		if (!data.name) throw new Error("Name is required");
+		if (typeof data.id !== "number") throw new Error("ID is required");
+		this.name = data.name;
+		this.id = data.id;
 		this.parts = data.parts ?? [];
 		this.halt = data.halt ?? false;
 		this.size = data.size ?? 0;
-		if (!this.name) throw new Error("Name is required");
-		if (this.id === void 0) throw new Error("ID is required");
 	}
 };
 
@@ -2049,13 +2873,17 @@ async function listDirectory(dirPath, options = {}) {
 			for (const item of items) {
 				const itemPath = pathModule.join(fullPath, item);
 				const stats = await stat(itemPath);
+				const isFile = stats.isFile();
+				const extIx = isFile ? item.indexOf(".") : -1;
+				const ext = extIx > 0 ? item.substring(extIx + 1) : null;
 				const entry = {
-					name: item,
+					name: extIx > 0 ? item.substring(0, extIx) : item,
 					path: itemPath,
-					isDirectory: stats.isDirectory(),
-					isFile: stats.isFile()
+					extension: ext,
+					isFile,
+					isDirectory: stats.isDirectory()
 				};
-				if (extension && entry.isFile && !entry.name.endsWith(extension)) continue;
+				if (extension && ext !== extension) continue;
 				if (filter && !filter(entry)) continue;
 				entries.push(entry);
 				if (recursive && entry.isDirectory) {
@@ -2298,129 +3126,6 @@ function decodeBase64String(base64String) {
 	}
 }
 
-//#endregion
-//#region src/utils/debug-export.ts
-/**
-* Debug utility to export processing results as JSON for comparison
-*/
-var DebugExporter = class {
-	/**
-	* Export chunk files to JSON for comparison with C# output
-	*/
-	static exportChunkFiles(files, filename) {
-		const exportData = {
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			totalFiles: files.length,
-			files: files.map((file) => ({
-				name: file.name,
-				type: file.type,
-				size: file.size,
-				location: file.location,
-				bank: file.bank,
-				upper: file.upper,
-				compressed: file.compressed,
-				hasTextData: !!file.textData,
-				textDataLength: file.textData?.length || 0,
-				hasParts: !!file.parts,
-				partsCount: file.parts?.length || 0,
-				hasIncludes: !!file.includes,
-				includesCount: file.includes?.size || 0,
-				includesList: file.includes ? Array.from(file.includes).sort() : [],
-				parts: file.parts?.map((part) => ({
-					label: part.label,
-					location: part.location,
-					size: part.size,
-					objListCount: part.objList?.length || 0,
-					hasObjList: !!part.objList,
-					objList: part.objList?.map((obj) => ({
-						location: obj.location,
-						size: obj.size,
-						hasObject: !!obj.object,
-						objectType: obj.object?.constructor?.name || "unknown"
-					})) || []
-				})) || []
-			}))
-		};
-		try {
-			(0, fs.writeFileSync)(filename, JSON.stringify(exportData, null, 2));
-			console.log(`📄 Exported ${files.length} files to ${filename}`);
-		} catch (error) {
-			console.error(`❌ Failed to export to ${filename}:`, error);
-		}
-	}
-	/**
-	* Export patch application summary
-	*/
-	static exportPatchSummary(originalFiles, patchedFiles, patches, filename) {
-		const summary = {
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			originalFileCount: originalFiles.length,
-			patchedFileCount: patchedFiles.length,
-			patchCount: patches.length,
-			patches: patches.map((patch) => ({
-				name: patch.name,
-				partsCount: patch.parts?.length || 0,
-				includesCount: patch.includes?.size || 0,
-				includes: patch.includes ? Array.from(patch.includes).sort() : []
-			})),
-			sizeChanges: patchedFiles.map((file) => {
-				const original = originalFiles.find((f) => f.name === file.name);
-				return {
-					name: file.name,
-					originalSize: original?.size || 0,
-					patchedSize: file.size || 0,
-					sizeDelta: (file.size || 0) - (original?.size || 0),
-					originalPartsCount: original?.parts?.length || 0,
-					patchedPartsCount: file.parts?.length || 0,
-					partsCountDelta: (file.parts?.length || 0) - (original?.parts?.length || 0)
-				};
-			}).filter((change) => change.sizeDelta !== 0 || change.partsCountDelta !== 0)
-		};
-		try {
-			(0, fs.writeFileSync)(filename, JSON.stringify(summary, null, 2));
-			console.log(`📊 Exported patch summary to ${filename}`);
-		} catch (error) {
-			console.error(`❌ Failed to export patch summary to ${filename}:`, error);
-		}
-	}
-	/**
-	* Export layout debugging information
-	*/
-	static exportLayoutDebug(files, filename) {
-		const layoutData = {
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			totalFiles: files.length,
-			filesWithSize: files.filter((f) => (f.size || 0) > 0).length,
-			filesWithoutSize: files.filter((f) => (f.size || 0) === 0).length,
-			asmFiles: files.filter((f) => !!f.parts).length,
-			binaryFiles: files.filter((f) => !f.parts).length,
-			files: files.map((file) => ({
-				name: file.name,
-				size: file.size || 0,
-				hasSize: (file.size || 0) > 0,
-				isAsm: !!file.parts,
-				bank: file.bank,
-				upper: file.upper,
-				location: file.location,
-				partsCount: file.parts?.length || 0
-			})).sort((a, b) => {
-				const aAsm = a.isAsm ? 0 : 1;
-				const bAsm = b.isAsm ? 0 : 1;
-				if (aAsm !== bAsm) return aAsm - bAsm;
-				if (b.size !== a.size) return b.size - a.size;
-				return a.location - b.location;
-			}),
-			zeroSizeFiles: files.filter((f) => (f.size || 0) === 0).map((f) => f.name)
-		};
-		try {
-			(0, fs.writeFileSync)(filename, JSON.stringify(layoutData, null, 2));
-			console.log(`🏗️  Exported layout debug info to ${filename}`);
-		} catch (error) {
-			console.error(`❌ Failed to export layout debug to ${filename}:`, error);
-		}
-	}
-};
-
 //#endregion
 //#region src/utils/index.ts
 /**
@@ -2532,16 +3237,16 @@ var DbPart = class {
 	bank;
 	order;
 	constructor(data) {
-		this.name = data.name ?? "";
-		this.start = data.start ?? void 0;
-		this.end = data.end ?? 0;
-		this.type = data.type ?? "";
+		if (typeof data.start !== "number") throw new Error("Start is required");
+		if (!data.name) throw new Error("Name is required");
+		if (!data.end) throw new Error("End is required");
+		if (!data.type) throw new Error("Struct is required");
+		this.name = data.name;
+		this.start = data.start;
+		this.end = data.end;
+		this.type = data.type;
 		this.bank = data.bank ?? void 0;
 		this.order = data.order ?? void 0;
-		if (!this.name) throw new Error("Name is required");
-		if (this.start === void 0) throw new Error("Start is required");
-		if (!this.end) throw new Error("End is required");
-		if (!this.type) throw new Error("Struct is required");
 	}
 };
 
@@ -2787,7 +3492,6 @@ var PostProcessor = class {
 //#region src/rom/extraction/writer.ts
 const isWindows = (() => {
 	if (typeof process !== "undefined" && process.platform) return process.platform === "win32";
-	if (typeof navigator !== "undefined" && navigator.userAgent) return navigator.userAgent.includes("Windows");
 	return false;
 })();
 const NEWLINE = isWindows ? "\r\n" : "\n";
@@ -3251,13 +3955,13 @@ var AsmReader = class AsmReader {
 	clearDestinationRegister(code, reg) {
 		switch (code.mnem) {
 			case "LDA":
-				reg.value["accumulator"] = void 0;
+				delete reg.value["accumulator"];
 				break;
 			case "LDX":
-				reg.value["xIndex"] = void 0;
+				delete reg.value["xIndex"];
 				break;
 			case "LDY":
-				reg.value["yIndex"] = void 0;
+				delete reg.value["yIndex"];
 				break;
 		}
 	}
@@ -3350,14 +4054,17 @@ var TypeParser = class {
 					name: targetType.name,
 					parts
 				};
-				for (let i = 0; i < memberCount; i++) parts[i] = this.parseType(types[i], null, depth + 1, bank);
+				for (let i = 0; i < memberCount; i++) parts[i] = this.parseType(types[i], reg, depth + 1, bank);
 				if (discOffset !== void 0 && discOffset === this._romDataReader.position - prevPosition) this._romDataReader.position++;
 				objects.push(def);
 			}
 			let checkPosition = startPosition;
-			while (++checkPosition < this._romDataReader.position) if (this._referenceManager.containsStruct(checkPosition)) {
-				this._romDataReader.position = checkPosition;
-				break;
+			while (++checkPosition < this._romDataReader.position) {
+				const struct = this._referenceManager.tryGetStruct(checkPosition);
+				if (struct.found && struct.chunkType !== "Code") {
+					this._romDataReader.position = checkPosition;
+					break;
+				}
 			}
 			if (!this._blockReader.partCanContinue()) break;
 		}
@@ -3689,8 +4396,9 @@ var BlockReader = class {
 	* Creates assembly ChunkFiles from DbBlocks (enriched with parts)
 	*/
 	createChunkFilesFromDbBlocks() {
+		const fileType = Object.values(this._root.fileTypes).find((x) => x.isBlock);
 		for (const block of this._root.blocks) {
-			const chunkFile = createChunkFileFromDbBlock(block, Object.values(this._root.fileTypes).find((x) => x.isBlock), this._root.config.memoryMode);
+			const chunkFile = createChunkFileFromDbBlock(block, fileType, this._root.config.memoryMode);
 			this._enrichedChunks.push(chunkFile);
 		}
 	}
@@ -3849,6 +4557,7 @@ var RomLayout = class RomLayout {
 				let offset = 0;
 				while (remain > 0 && this.sfxFiles.length) {
 					const file = this.sfxFiles.shift();
+					if (!file) continue;
 					file.location = start + offset;
 					console.log(`  ${file.location.toString(16).toUpperCase().padStart(6, "0")}: ${file.name}`);
 					offset += file.size;
@@ -3961,12 +4670,15 @@ var RomProcessor = class RomProcessor {
 	async repack(allFiles) {
 		const patches = [];
 		const asmFiles = [];
+		const compression = this.writer.root.compression;
+		const canCompress = !!compression;
+		const conditionFiles = [];
 		for (const file of allFiles) {
 			if (file.type.type === "Patch") patches.push(file);
 			else if (file.type.type !== "Assembly") {
-				if (file.compressed === true) if (this.writer.root.config.uncompress) file.compressed = false;
+				if (file.compressed === true && canCompress) if (this.writer.root.config.uncompress) file.compressed = false;
 				else {
-					let newData = this.writer.root.compression.compact(file.rawData, file.type.header);
+					let newData = compression.compact(file.rawData, file.type.header);
 					if (file.type.header) newData = new Uint8Array([...file.rawData.slice(0, file.type.header), ...newData]);
 					file.rawData = newData;
 					file.size = newData.length;
@@ -3974,27 +4686,34 @@ var RomProcessor = class RomProcessor {
 				continue;
 			}
 			asmFiles.push(file);
-			if (!file.parts) {
-				const { blocks, includes, reqBank } = new Assembler(this.writer.root, file.textData).parseAssembly();
-				file.parts = blocks;
-				file.includes = includes;
-				file.bank = reqBank ?? void 0;
-			}
+			conditionFiles.push(file.name);
+		}
+		for (const file of asmFiles) if (!file.parts) {
+			const { blocks, includes, reqBank } = new Assembler(this.writer.root, file.textData, conditionFiles).parseAssembly();
+			file.parts = blocks;
+			file.includes = includes;
+			file.bank = reqBank ?? void 0;
 		}
 		RomProcessor.applyPatches(asmFiles, patches);
 		for (const file of allFiles) ChunkFileUtils.calculateSize(file);
 		const pages = new RomLayout(allFiles, this.writer.root).organize();
 		for (const file of asmFiles) ChunkFileUtils.rebase(file);
+		const masterLookup = /* @__PURE__ */ new Map();
 		for (const f of asmFiles) {
 			const includeBlocks = asmFiles.filter((x) => f.includes?.has(x.name.toUpperCase())).flatMap((x) => x.parts).filter((b) => !!b.label);
 			f.includeLookup = /* @__PURE__ */ new Map();
 			for (const b of includeBlocks) if (b.label) f.includeLookup.set(b.label.toUpperCase(), b);
-			for (const b of (f.parts || []).filter((x) => !!x.label)) if (b.label) f.includeLookup.set(b.label.toUpperCase(), b);
+			for (const b of f.parts) if (b.label) {
+				const nameUpper = b.label.toUpperCase();
+				masterLookup.set(nameUpper, b.location);
+				f.includeLookup.set(nameUpper, b);
+			}
 		}
-		const blockLookup = /* @__PURE__ */ new Map();
-		for (const f of allFiles) blockLookup.set(f.name.toUpperCase(), f.location);
+		const fileLookup = /* @__PURE__ */ new Map();
+		for (const f of allFiles) fileLookup.set(f.name.toUpperCase(), f.location);
 		this.writer.allocate(pages);
-		for (const file of allFiles) await this.writer.writeFile(file, blockLookup);
+		for (const file of allFiles) await this.writer.writeFile(file, fileLookup);
+		return masterLookup;
 	}
 	static applyPatches(asmFiles, patches) {
 		for (const patch of patches.filter((x) => x.includes && x.includes.size > 0)) {
@@ -4040,19 +4759,13 @@ var RomWriter = class {
 	bpsPath;
 	outBuffer;
 	romSize;
-	cartName;
-	makerCode;
 	root;
-	constructor(root, cartName, makerCode) {
-		this.cartName = cartName;
-		this.makerCode = makerCode;
+	constructor(root) {
 		this.root = root;
 	}
 	async repack(files) {
-		await new RomProcessor(this).repack(files);
-		this.writeHeader();
-		this.writeEntryPoints(files.filter((x) => !!x.parts));
-		this.writeChecksum();
+		const masterLookup = await new RomProcessor(this).repack(files);
+		this.writeHeaders(masterLookup);
 		return this.outBuffer;
 	}
 	allocate(pages) {
@@ -4066,36 +4779,93 @@ var RomWriter = class {
 		this.romSize = bits;
 		this.outBuffer = new Uint8Array(target);
 	}
-	writeHeader() {
+	writeHeaders(masterLookup) {
+		const values = this.prepareHeaderValues();
+		for (const header of this.root.headers) {
+			if (header.condition && !eval(header.condition)) continue;
+			this.writeHeader(header, values, masterLookup);
+		}
+		this.writeChecksum(values);
+	}
+	prepareHeaderValues() {
+		const values = { ...this.root.config };
+		values.romSize = this.romSize;
+		values.checksum = 0;
+		values.compliment = 65535;
+		values.mapMode = 32 | (values.cpuMode === CpuMode.Fast ? 16 : 0) | (values.memoryMode === MemoryMapMode.Hi ? 1 : values.memoryMode === MemoryMapMode.ExHi ? 5 : 0);
+		return values;
+	}
+	writeHeader(header, values, masterLookup) {
 		const buf = this.outBuffer;
-		let pos = this.root.config.memoryMode === MemoryMapMode.Lo ? 32688 : 65456;
-		this.writeAscii(this.makerCode.padEnd(6, " "), pos);
-		pos += 6;
-		for (let i = 0; i < 10; i++) buf[pos++] = 0;
-		this.writeAscii(this.cartName.toUpperCase().padEnd(21, " "), pos);
-		pos += 21;
-		buf[pos++] = 32 | (this.root.config.cpuMode === CpuMode.Fast ? 16 : 0) | (this.root.config.memoryMode === MemoryMapMode.Hi ? 1 : this.root.config.memoryMode === MemoryMapMode.ExHi ? 5 : 0);
-		buf[pos++] = this.root.config.chipset;
-		buf[pos++] = this.romSize;
-		buf[pos++] = this.root.config.ramSize;
-		buf[pos++] = 1;
-		buf[pos++] = 51;
-		buf[pos++] = 0;
-	}
-	writeChecksum() {
+		let pos = new Address(header.bank, header.address, this.root.config.memoryMode).toLocation();
+		for (const part of header.parts) {
+			let type = part.type;
+			let value = part.value ?? values[part.name] ?? (type === "string" ? "" : 0);
+			let size = part.size;
+			if (!size) if (!type) {
+				if (typeof value === "string") throw new Error(`String size for ${part.name} is not specified`);
+				if (typeof value === "number") if (value <= 255) {
+					size = 1;
+					type = "byte";
+				} else {
+					size = 2;
+					type = "word";
+				}
+			} else switch (type) {
+				case "byte":
+					size = 1;
+					break;
+				case "word":
+				case "entry":
+					size = 2;
+					break;
+				case "string": throw new Error(`String size for ${part.name} is not specified`);
+				default: throw new Error(`Invalid type ${type} for ${part.name}`);
+			}
+			switch (part.type) {
+				case "string":
+					value = value.toString();
+					value = value.length > size ? value.substring(0, size) : value.padEnd(size, " ");
+					this.writeAscii(value, pos);
+					break;
+				case "byte":
+					buf[pos] = value & 255;
+					break;
+				case "entry":
+					let location = 0;
+					if (typeof value === "string") location = value === "" ? 0 : masterLookup.get(value.toUpperCase()) ?? 0;
+					else if (typeof value === "number") location = value;
+					value = location;
+				case "word":
+					buf[pos] = value & 255;
+					buf[pos + 1] = value >> 8 & 255;
+					break;
+			}
+			part.value = value;
+			part.size = size;
+			part.type = type;
+			pos += size;
+		}
+	}
+	writeChecksum(values) {
 		const buf = this.outBuffer;
-		let pos = this.root.config.memoryMode === MemoryMapMode.Lo ? 32732 : 65500;
-		buf[pos] = 255;
-		buf[pos + 1] = 255;
-		buf[pos + 2] = 0;
-		buf[pos + 3] = 0;
 		let sum = 0;
 		for (let i = 0; i < buf.length; i++) sum += buf[i];
-		buf[pos + 2] = sum & 255;
-		buf[pos + 3] = sum >> 8 & 255;
 		const comp = ~sum;
-		buf[pos] = comp & 255;
-		buf[pos + 1] = comp >> 8 & 255;
+		for (const header of this.root.headers) {
+			if (header.condition && !eval(header.condition)) continue;
+			let pos = new Address(header.bank, header.address, this.root.config.memoryMode).toLocation();
+			for (const part of header.parts) {
+				if (part.name === "checksum") {
+					buf[pos] = sum & 255;
+					buf[pos + 1] = sum >> 8 & 255;
+				} else if (part.name === "compliment") {
+					buf[pos] = comp & 255;
+					buf[pos + 1] = comp >> 8 & 255;
+				}
+				pos += part.size;
+			}
+		}
 	}
 	writeEntryPoints(asmFiles) {
 		const buf = this.outBuffer;
@@ -4110,7 +4880,7 @@ var RomWriter = class {
 			}
 		}
 	}
-	async writeFile(file, _chunkLookup) {
+	async writeFile(file, fileLookup) {
 		const start = file.location;
 		let pos = start;
 		const buf = this.outBuffer;
@@ -4140,7 +4910,7 @@ var RomWriter = class {
 			}
 		} else if (file.parts && file.parts.length > 0) {
 			if (file.parts[0].location !== file.location && (file.location || 0) !== 0) throw new Error("Assembly was not based properly");
-			this.parseAssembly(file.parts, _chunkLookup, file.includeLookup);
+			this.parseAssembly(file.parts, fileLookup, file.includeLookup);
 		}
 		return pos - start;
 	}
@@ -4152,11 +4922,12 @@ var RomWriter = class {
 	* Parse assembly blocks and write binary data to output buffer
 	* Converted from ext/GaiaLib/Rom/Rebuild/RomWriter.cs ParseAssembly method
 	*/
-	parseAssembly(blocks, chunkLookup, includeLookup) {
+	parseAssembly(blocks, fileLookup, includeLookup) {
 		if (!blocks) throw new Error("Assembly has not been parsed");
 		const buf = this.outBuffer;
 		let bix = 0;
 		for (const block of blocks) {
+			let oldPos = null;
 			let position = block.location;
 			const objList = block.objList;
 			let oix = 0;
@@ -4164,7 +4935,7 @@ var RomWriter = class {
 			const processObject = (obj, parentOp) => {
 				let currentObj = obj;
 				while (true) if (Array.isArray(currentObj)) {
-					for (const obj$1 of currentObj) processObject(obj$1, parentOp);
+					for (const obj of currentObj) processObject(obj, parentOp);
 					break;
 				} else if (this.isTableEntry(currentObj)) {
 					currentObj = currentObj.object;
@@ -4201,29 +4972,32 @@ var RomWriter = class {
 						label = label.substring(0, operatorIdx);
 					}
 					const labelUpper = label.toUpperCase();
-					let target;
+					let target = null;
 					if (includeLookup.has(labelUpper)) {
 						target = includeLookup.get(labelUpper);
 						loc = target.location;
-					} else if (chunkLookup.has(labelUpper)) loc = chunkLookup.get(labelUpper);
+					} else if (fileLookup.has(labelUpper)) loc = fileLookup.get(labelUpper);
 					else {
 						if (label.startsWith("#")) label = label.substring(1);
 						if (label.startsWith("$")) label = label.substring(1);
 						if (isRelative && label.length > 4) throw new Error(`Invalid relative operand '${label}'`);
-						else switch (label.length) {
-							case 1:
-							case 2:
-								currentObj = new Byte(parseInt(label, 16));
-								continue;
-							case 3:
-							case 4:
-								currentObj = new Word(parseInt(label, 16));
-								continue;
-							case 5:
-							case 6:
-								currentObj = new Long(parseInt(label, 16));
-								continue;
-							default: throw new Error(`Invalid operand '${label}'`);
+						else {
+							let num;
+							switch (label.length) {
+								case 1:
+								case 2:
+									currentObj = new Byte(parseInt(label, 16));
+									continue;
+								case 3:
+								case 4:
+									currentObj = new Word(parseInt(label, 16));
+									continue;
+								case 5:
+								case 6:
+									currentObj = new Long(parseInt(label, 16));
+									continue;
+								default: throw new Error(`Invalid operand '${label}'`);
+							}
 						}
 					}
 					let type = isRelative ? parentOp?.size === 3 ? AddressType.WRelative : AddressType.Relative : Address.typeFromCode(str[0]);
@@ -4233,7 +5007,7 @@ var RomWriter = class {
 						if (type === AddressType.Unknown && !(loc < 128 || loc >= 4194176)) throw new Error("Relative out of range");
 					}
 					if (offset !== null) loc += offset;
-					else if (useMarker && target) {
+					else if (useMarker && target instanceof AsmBlock) {
 						let markerOffset = 0;
 						for (const part of target.objList) if (this.isStringMarker(part)) {
 							loc += markerOffset;
@@ -4320,6 +5094,36 @@ var RomWriter = class {
 	}
 };
 
+//#endregion
+//#region src/database/header.ts
+var DbHeader = class {
+	bank;
+	address;
+	condition;
+	parts;
+	constructor(data) {
+		if (typeof data.address !== "number") throw new Error("Address is required");
+		if (!data.parts || !data.parts.length) throw new Error("Parts are required");
+		this.bank = data.bank ?? 0;
+		this.address = data.address;
+		this.condition = data.condition ?? void 0;
+		this.parts = data.parts.map((p) => new DbHeaderPart(p));
+	}
+};
+var DbHeaderPart = class {
+	name;
+	size;
+	type;
+	value;
+	constructor(data) {
+		if (!data.name) throw new Error("Name is required");
+		this.name = data.name;
+		this.size = data.size ?? 0;
+		this.type = data.type ?? "";
+		this.value = data.value ?? void 0;
+	}
+};
+
 //#endregion
 //#region src/database/root.ts
 /**
@@ -4329,33 +5133,6 @@ var DbRootUtils = class {
 	/**
 	* JSON serialization options
 	*/
-	/**
-	* Load database from a single file
-	*/
-	static async fromFolder(folderPath, systemPath) {
-		return this.fromGameModule(await this.gameModuleFromFolder(folderPath, systemPath));
-	}
-	/**
-	* Load database from folder structure
-	*/
-	static async gameModuleFromFolder(folderPath, systemPath) {
-		return {
-			mnemonics: await readJsonFile(`${folderPath}/mnemonics.json`),
-			overrides: await readJsonFile(`${folderPath}/overrides.json`),
-			rewrites: await readJsonFile(`${folderPath}/rewrites.json`),
-			blocks: await readJsonFile(`${folderPath}/blocks.json`),
-			files: await readJsonFile(`${folderPath}/files.json`),
-			config: await readJsonFile(`${folderPath}/config.json`),
-			labels: await readJsonFile(`${folderPath}/labels.json`),
-			structs: await readJsonFile(`${folderPath}/structs.json`),
-			copdef: await readJsonFile(`${folderPath}/copdef.json`),
-			addrModes: await readJsonFile(`${systemPath}/addressingModes.json`),
-			strings: await readJsonFile(`${folderPath}/stringTypes.json`),
-			transforms: await readJsonFile(`${folderPath}/transforms.json`),
-			groups: await readJsonFile(`${folderPath}/groups.json`),
-			fileTypes: await readJsonFile(`${folderPath}/fileTypes.json`)
-		};
-	}
 	static fromGameModule(module) {
 		const opCodes = {};
 		const opLookup = {};
@@ -4399,7 +5176,7 @@ var DbRootUtils = class {
 		const groupLookup = Object.entries(module.groups).reduce((acc, x) => {
 			const groupData = x[1];
 			const groupName = x[0];
-			const scenes = Object.entries(groupData.scenes).reduce((acc$1, y) => {
+			const scenes = Object.entries(groupData.scenes ?? {}).reduce((acc, y) => {
 				const sceneData = y[1];
 				const sceneName = y[0];
 				const scene = new DbScene({
@@ -4407,8 +5184,8 @@ var DbRootUtils = class {
 					name: sceneName
 				});
 				sceneLookup[scene.id] = scene;
-				acc$1[sceneName] = scene;
-				return acc$1;
+				acc[sceneName] = scene;
+				return acc;
 			}, {});
 			acc[groupName] = new DbGroup({
 				...groupData,
@@ -4429,19 +5206,25 @@ var DbRootUtils = class {
 		const stringLookup = Object.entries(module.strings).reduce((acc, x) => {
 			const stringType = x[1];
 			const name = x[0];
-			const commands = Object.entries(stringType.commands ?? {}).reduce((acc$1, y) => {
-				acc$1[y[0]] = new DbStringCommand({
+			const commands = Object.entries(stringType.commands ?? {}).reduce((acc, y) => {
+				acc[y[0]] = new DbStringCommand({
 					...y[1],
 					name: y[0]
 				});
-				return acc$1;
+				return acc;
 			}, {});
-			const dictionaries = Object.entries(stringType.dictionaries ?? {}).reduce((acc$1, y) => {
-				acc$1[y[0]] = new DbStringDictionary({
+			const dictionaries = Object.entries(stringType.dictionaries ?? {}).reduce((acc, y) => {
+				const dictionary = new DbStringDictionary({
 					...y[1],
 					name: y[0]
 				});
-				return acc$1;
+				acc[y[0]] = dictionary;
+				if (dictionary.command !== void 0) commands[dictionary.command] = new DbStringCommand({
+					id: dictionary.command,
+					name: dictionary.name,
+					dictionary
+				});
+				return acc;
 			}, {});
 			const st = new DbStringType({
 				...stringType,
@@ -4486,15 +5269,13 @@ var DbRootUtils = class {
 			return acc;
 		}, {});
 		const cfg = module.config;
-		const compression = cfg.compression ? CompressionAlgorithms[cfg.compression]() : null;
+		const compression = cfg.compression ? CompressionAlgorithms[cfg.compression]() : void 0;
 		return {
+			headers: module.headers.map((h) => new DbHeader(h)),
 			mnemonics: module.mnemonics,
 			overrides: module.overrides,
 			rewrites: module.rewrites,
-			labels: module.labels.reduce((acc, x) => {
-				acc[x.location] = x.label;
-				return acc;
-			}, {}),
+			labels: module.labels,
 			structs: structLookup,
 			blocks: blocksArray.sort((a, b) => {
 				const orderA = a.order ?? 0;
@@ -4522,17 +5303,13 @@ var DbRootUtils = class {
 	}
 	static async applyFolder(root, folderPath, sourceFiles = []) {
 		const chunkFiles = sourceFiles;
-		const folderEntries = await listDirectory(folderPath);
-		for (const entry of folderEntries) if (entry.isDirectory) await this.applyFolder(root, entry.path, chunkFiles);
-		else {
-			const index = entry.name.indexOf(".");
-			if (!index) continue;
-			const name = entry.name.substring(0, index);
-			const extension = entry.name.substring(index + 1);
-			const type = root.fileExtLookup[extension];
+		const folderEntries = await listDirectory(folderPath, { recursive: true });
+		for (const entry of folderEntries) {
+			if (!entry.isFile || !entry.extension) continue;
+			const type = root.fileExtLookup[entry.extension];
 			if (!type) continue;
-			const existing = chunkFiles.find((x) => x.name === name && x.type.type === type.type);
-			const chunkFile = existing ?? new ChunkFile(name, 0, 0, type);
+			const existing = chunkFiles.find((x) => x.name === entry.name && x.type.type === type.type);
+			const chunkFile = existing ?? new ChunkFile(entry.name, 0, 0, type);
 			if (chunkFile.type.type === "Assembly" || chunkFile.type.type === "Patch") {
 				const chunkData = await readFileAsText(entry.path);
 				chunkFile.textData = chunkData;
@@ -4543,7 +5320,7 @@ var DbRootUtils = class {
 				chunkFile.size = chunkData.length;
 			}
 			if (!existing) {
-				const sourceFile = root.files.find((x) => x.name === name && x.type === type.type);
+				const sourceFile = root.files.find((x) => x.name === entry.name && x.type === type.type);
 				if (sourceFile) {
 					chunkFile.location = sourceFile.start;
 					chunkFile.upper = sourceFile.upper;
@@ -4573,7 +5350,7 @@ var DbRootUtils = class {
 	static async rebuildAllContent(root, inPath, outPath) {
 		var sourceFiles = [];
 		for (const path of inPath) sourceFiles = await this.applyFolder(root, path, sourceFiles);
-		await saveFileAsBinary(outPath, await new RomWriter(root, "TEST", "TEST").repack(sourceFiles));
+		await saveFileAsBinary(outPath, await new RomWriter(root).repack(sourceFiles));
 		return sourceFiles;
 	}
 };
@@ -4585,12 +5362,12 @@ var DbOverride = class {
 	register;
 	value;
 	constructor(values) {
-		this.location = values.location ?? 0;
-		this.register = values.register ?? "";
-		this.value = values.value ?? void 0;
-		if (!this.location) throw new Error("Location is required");
-		if (!this.register) throw new Error("Register is required");
-		if (this.value === void 0) throw new Error("Value is required");
+		if (typeof values.value !== "number") throw new Error("Value is required");
+		if (typeof values.location !== "number") throw new Error("Location is required");
+		if (!values.register) throw new Error("Register is required");
+		this.location = values.location;
+		this.register = values.register;
+		this.value = values.value;
 	}
 };
 
@@ -4621,7 +5398,8 @@ var StringReader = class StringReader {
 		this._romDataReader = blockReader._romDataReader;
 	}
 	resolveCommand(cmd, builder) {
-		if (cmd.types && cmd.types.length > 0) {
+		if (cmd.dictionary) builder.push(cmd.dictionary.entries[this._romDataReader.readByte() - (cmd.dictionary.base ?? 0)]);
+		else if (cmd.types && cmd.types.length > 0) {
 			builder.push(`[${cmd.name}`);
 			let first = true;
 			for (const t of cmd.types) {
@@ -4664,8 +5442,8 @@ var StringReader = class StringReader {
 		const dictionaries = stringType.dictionaries;
 		const builder = [];
 		const strLoc = this._romDataReader.position;
-		const map = stringType.characterMap;
 		const terminator = stringType.terminator;
+		let currentLayer = stringType.layers[0];
 		do {
 			const c = this._romDataReader.readByte();
 			if (c === terminator) {
@@ -4678,14 +5456,31 @@ var StringReader = class StringReader {
 				if (cmd.halt) break;
 			} else {
 				let found = false;
-				for (const dictionary of Object.values(dictionaries)) if (c >= dictionary.base && c <= dictionary.range) {
+				for (const dictionary of Object.values(dictionaries)) if (dictionary.base !== void 0 && c >= dictionary.base && c <= dictionary.range) {
 					builder.push(dictionary.entries[c - dictionary.base]);
 					found = true;
 					break;
 				}
 				if (!found) {
-					const index = DbStringTypeUtils.getShiftDown(stringType.shiftType)(c);
-					if (index >= 0 && index < map.length) builder.push(map[index]);
+					for (const layer of stringType.layers) if (layer.on !== void 0) {
+						if (c === layer.on) {
+							currentLayer = layer;
+							found = true;
+							break;
+						}
+					} else if (c >= (layer.base ?? 0) && c <= (layer.range ?? 255)) {
+						let index = c - (layer.base ?? 0);
+						if (index >= 0 && index < layer.map.length) {
+							if (layer.shift) index = DbStringTypeUtils.getShiftDown(layer.shift)(index);
+							builder.push(layer.map[index]);
+							found = true;
+							break;
+						}
+					}
+				}
+				if (!found) {
+					const index = currentLayer.shift ? DbStringTypeUtils.getShiftDown(currentLayer.shift)(c) : c - (currentLayer.base ?? 0);
+					if (index >= 0 && index < currentLayer.map.length) builder.push(currentLayer.map[index]);
 					else builder.push(`[${c.toString(16).toUpperCase()}]`);
 				}
 			}
@@ -4748,6 +5543,7 @@ var StringProcessor = class {
 	root;
 	stringCharLookup;
 	testRegex;
+	inShift = false;
 	constructor(context) {
 		this.context = context;
 		this.root = context.root;
@@ -4762,10 +5558,10 @@ var StringProcessor = class {
 			str = this.context.lineBuffer.substring(1, endIx);
 			this.context.lineBuffer = this.context.lineBuffer.substring(endIx + 1).replace(/^[\s,\t]+/, "");
 			if (this.context.lineBuffer.startsWith("(")) {
-				const endIx$1 = this.context.lineBuffer.indexOf(")");
-				if (endIx$1 >= 0) {
-					fixedStr = parseInt(this.context.lineBuffer.substring(1, endIx$1), 10);
-					this.context.lineBuffer = this.context.lineBuffer.substring(endIx$1 + 1).replace(/^[\s,\t]+/, "");
+				const endIx = this.context.lineBuffer.indexOf(")");
+				if (endIx >= 0) {
+					fixedStr = parseInt(this.context.lineBuffer.substring(1, endIx), 10);
+					this.context.lineBuffer = this.context.lineBuffer.substring(endIx + 1).replace(/^[\s,\t]+/, "");
 				}
 			}
 		} else {
@@ -4799,6 +5595,7 @@ var StringProcessor = class {
 		const stringType = this.stringCharLookup[typeChar];
 		const dictionary = stringType.dictionaryLookup;
 		const cmdLookup = stringType.commands;
+		let currentLayer = stringType.layers[0];
 		let lastCmd = null;
 		for (const entry of dictionary) {
 			let index;
@@ -4808,7 +5605,7 @@ var StringProcessor = class {
 			const c = str[x];
 			if (c === "[") {
 				const endIx = str.indexOf("]", x + 1);
-				const parts = str.substring(x + 1, endIx).split(/* @__PURE__ */ new RegExp(`[${[
+				const parts = str.substring(x + 1, endIx).split(new RegExp(`[${[
 					":",
 					",",
 					" "
@@ -4834,7 +5631,21 @@ var StringProcessor = class {
 				}
 			}
 			lastCmd = null;
-			if (this.applyLayers(c, stringType)) continue;
+			let found = false;
+			for (const layer of stringType.layers) {
+				for (let i = 0, len = layer.map.length; i < len; i++) if (c === layer.map[i]) {
+					if (layer.on !== void 0 && currentLayer !== layer) {
+						this.memBuffer.push(layer.on);
+						currentLayer = layer;
+					}
+					let value = i + (layer.base ?? 0);
+					if (layer.shift) value = DbStringTypeUtils.getShiftUp(layer.shift)(value);
+					this.memBuffer.push(value);
+					found = true;
+					break;
+				}
+				if (found) break;
+			}
 		}
 		if (this.fixedStr) {
 			let count = this.fixedStr - this.totalSize;
@@ -4842,23 +5653,6 @@ var StringProcessor = class {
 		} else if (lastCmd === null || !lastCmd.halt) this.memBuffer.push(stringType.terminator);
 		this.flushBuffer(stringType, true);
 	}
-	applyLayers(c, stringType) {
-		if (this.applyMap(c, stringType.characterMap, DbStringTypeUtils.getShiftUp(stringType.shiftType))) return true;
-		if (stringType.layers) {
-			for (const layer of stringType.layers) if (this.applyMap(c, layer.map, (x) => x + layer.base)) return true;
-		}
-		return false;
-	}
-	applyMap(c, map, shift) {
-		for (let i = 0, len = map.length; i < len; i++) {
-			const v = map[i];
-			if (v != null && c === v[0]) {
-				this.memBuffer.push(shift(i));
-				return true;
-			}
-		}
-		return false;
-	}
 	processStringCommand(cmd, stringType, parts) {
 		const hasPointer = cmd.types.includes(MemberType.Address) || cmd.types.includes(MemberType.Offset);
 		if (hasPointer) this.flushBuffer(stringType, true);
@@ -5004,7 +5798,6 @@ var AssemblerState = class AssemblerState {
 		}
 		const location = parseInt(hex, 16);
 		this.context.blocks.push(this.context.currentBlock = new AsmBlock(location));
-		this.context.blockIndex++;
 	}
 	static doMath(operand) {
 		const ix = operand.search(/[-+]/);
@@ -5033,7 +5826,6 @@ var AssemblerState = class AssemblerState {
 		const newBlock = new AsmBlock(this.context.currentBlock.location + this.context.currentBlock.size, 0, this.root.stringDelimiters.includes(operand[0]), mnemonic);
 		this.context.blocks.push(newBlock);
 		this.context.currentBlock = newBlock;
-		this.context.blockIndex++;
 		if (labelChar === ":") this.context.lineBuffer = this.context.lineBuffer.substring(1);
 		else if (labelChar === "[" || labelChar === "{") {
 			this.context.lineBuffer = operand.substring(1).replace(/^[\s,\t]+/, "");
@@ -5120,8 +5912,8 @@ var AssemblerState = class AssemblerState {
 				}
 				this.context.lineBuffer = "";
 				if (!operand) {
-					const opCode$1 = codes.find((x) => this.root.addrLookup[x.mode].size === 1);
-					this.context.currentBlock.objList.push(new Op(opCode$1, 0, [], 1));
+					const opCode = codes.find((x) => this.root.addrLookup[x.mode].size === 1);
+					this.context.currentBlock.objList.push(new Op(opCode, 0, [], 1));
 					this.context.currentBlock.size++;
 					continue;
 				}
@@ -5197,16 +5989,20 @@ var Assembler = class {
 	tags = new SortedMap();
 	currentBlock = null;
 	lineCount = 0;
-	blockIndex = 0;
 	lastDelimiter = null;
 	reqBank = null;
 	eof = false;
 	strDelimRegex;
-	constructor(dbRoot, textData) {
+	conditionFiles;
+	inCondition = false;
+	exitCondition = false;
+	failCondition = false;
+	constructor(dbRoot, textData, conditionFiles) {
 		this.root = dbRoot;
 		this.lines = textData.split(/\r?\n/);
 		this.stringProcessor = new StringProcessor(this);
-		this.strDelimRegex = /* @__PURE__ */ new RegExp(`[${this.root.stringDelimiters.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("")}]`);
+		this.strDelimRegex = new RegExp(`[${this.root.stringDelimiters.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("")}]`);
+		this.conditionFiles = conditionFiles;
 	}
 	parseAssembly() {
 		this.blocks.push(this.currentBlock = new AsmBlock());
@@ -5245,6 +6041,10 @@ var Assembler = class {
 				this.lineBuffer = "";
 				continue;
 			}
+			if (this.failCondition) {
+				this.lineBuffer = "";
+				continue;
+			}
 			if (this.lineBuffer[0] === "!") {
 				this.processTags();
 				this.lineBuffer = "";
@@ -5264,7 +6064,7 @@ var Assembler = class {
 	processDirectives() {
 		let endIx = this.lineBuffer.search(RomProcessingConstants.COMMA_SPACE_REGEX);
 		if (endIx < 0) endIx = this.lineBuffer.length;
-		const value = this.lineBuffer.substring(endIx).replace(/^[\s,\t]+/, "");
+		let value = this.lineBuffer.substring(endIx).replace(/^[\s,\t]+/, "");
 		switch (this.lineBuffer.substring(1, endIx).toUpperCase()) {
 			case "BANK":
 				this.reqBank = parseInt(value, 16);
@@ -5272,6 +6072,45 @@ var Assembler = class {
 			case "INCLUDE":
 				if (value.length > 0) this.includes.add(value.toUpperCase().replace(/'/g, ""));
 				break;
+			case "IF":
+				if (this.inCondition) throw new Error("IF without ENDIF");
+				value = value.replace(/'/g, "");
+				if (!value) throw new Error("IF without condition");
+				this.inCondition = true;
+				if (!this.conditionFiles.includes(value)) {
+					this.failCondition = true;
+					this.exitCondition = false;
+				} else {
+					this.failCondition = false;
+					this.exitCondition = true;
+				}
+				break;
+			case "ELSEIF":
+				if (!this.inCondition) throw new Error("ELSEIF without IF");
+				value = value.replace(/'/g, "");
+				if (!value) throw new Error("ELSEIF without condition");
+				if (this.exitCondition || !this.conditionFiles.includes(value)) this.failCondition = true;
+				else {
+					this.exitCondition = true;
+					this.failCondition = false;
+				}
+				break;
+			case "ELSE":
+				if (!this.inCondition) throw new Error("ELSE without IF");
+				if (value) throw new Error("ELSE with condition");
+				if (this.exitCondition) this.failCondition = true;
+				else {
+					this.failCondition = false;
+					this.exitCondition = true;
+				}
+				break;
+			case "ENDIF":
+				if (!this.inCondition) throw new Error("ENDIF without IF");
+				if (value) throw new Error("ENDIF with condition");
+				this.failCondition = false;
+				this.exitCondition = false;
+				this.inCondition = false;
+				break;
 		}
 	}
 	processTags() {
@@ -5572,7 +6411,13 @@ async function fromSupabaseById(baseRomBranchId) {
           config,
           files,
           blocks,
-          fixups,
+          rewrites,
+          transforms,
+          overrides,
+          labels,
+          mnemonics,
+          fileTypes,
+          groups,
           strings,
           structs,
           createdAt,
@@ -5585,7 +6430,6 @@ async function fromSupabaseById(baseRomBranchId) {
             notes,
             platformId,
             addressingModes,
-            instructionSet,
             vectors,
             types,
             createdAt,
@@ -5686,9 +6530,15 @@ async function fromSupabaseByName(options) {
           coplib,
           files,
           blocks,
-          fixups,
+          rewrites,
+          transforms,
+          overrides,
+          labels,
+          mnemonics,
+          fileTypes,
           strings,
           structs,
+          groups,
           createdAt,
           updatedAt,
           platformBranch:PlatformBranch!inner(
@@ -5699,8 +6549,8 @@ async function fromSupabaseByName(options) {
             notes,
             platformId,
             addressingModes,
-            instructionSet,
             vectors,
+            headers,
             types,
             createdAt,
             updatedAt
@@ -5905,7 +6755,13 @@ async function fromSupabaseByProject(projectName, branchId) {
             coplib,
             files,
             blocks,
-            fixups,
+            rewrites,
+            transforms,
+            overrides,
+            labels,
+            mnemonics,
+            fileTypes,
+            groups,
             strings,
             structs,
             createdAt,
@@ -5940,8 +6796,8 @@ async function fromSupabaseByProject(projectName, branchId) {
               notes,
               platformId,
               addressingModes,
-              instructionSet,
               vectors,
+              headers,
               types,
               createdAt,
               updatedAt,
@@ -5967,14 +6823,8 @@ async function fromSupabaseByProject(projectName, branchId) {
 		});
 		const baseRomBranch = branchData.baseRomBranch;
 		const projectFiles = await loadProjectFiles(branchData.id);
-		const baseRomFiles = await loadBaseRomFiles(baseRomBranch.id);
+		await loadBaseRomFiles(baseRomBranch.id);
 		fileQueryTime = performance.now() - branchStart - branchQueryTime;
-		const payload = {
-			projectBranch: branchData,
-			projectFiles,
-			baseRomBranch,
-			baseRomFiles
-		};
 		const totalTime = performance.now() - startTime;
 		const stats = {
 			branchQueryTime,
@@ -5983,7 +6833,23 @@ async function fromSupabaseByProject(projectName, branchId) {
 			fileCount: projectFiles.length
 		};
 		console.log("Project ROM load stats:", stats);
-		return payload;
+		return {
+			mnemonics: baseRomBranch.gameRomBranch.mnemonics,
+			overrides: baseRomBranch.gameRomBranch.overrides,
+			rewrites: baseRomBranch.gameRomBranch.rewrites,
+			blocks: baseRomBranch.gameRomBranch.blocks,
+			files: baseRomBranch.gameRomBranch.files,
+			config: baseRomBranch.gameRomBranch.config,
+			labels: baseRomBranch.gameRomBranch.labels,
+			structs: baseRomBranch.gameRomBranch.structs,
+			copdef: baseRomBranch.gameRomBranch.coplib,
+			strings: baseRomBranch.gameRomBranch.strings,
+			transforms: baseRomBranch.gameRomBranch.transforms,
+			groups: baseRomBranch.gameRomBranch.groups,
+			fileTypes: baseRomBranch.gameRomBranch.fileTypes,
+			addrModes: baseRomBranch.gameRomBranch.platformBranch.addressingModes,
+			headers: baseRomBranch.gameRomBranch.platformBranch.headers
+		};
 	} catch (error) {
 		if (error instanceof SupabaseFromError) throw error;
 		throw new SupabaseFromError(`Failed to load Project data: ${error instanceof Error ? error.message : "Unknown error"}`, SupabaseErrorCode.NETWORK_ERROR, {
@@ -6012,7 +6878,13 @@ async function fromSupabaseByGameRom(gameName, regionName, platformName, branchI
         config,
         files,
         blocks,
-        fixups,
+        rewrites,
+        transforms,
+        overrides,
+        labels,
+        mnemonics,
+        fileTypes,
+        groups,
         strings,
         structs,
         createdAt,
@@ -6047,7 +6919,7 @@ async function fromSupabaseByGameRom(gameName, regionName, platformName, branchI
           isActive,
           platformId,
           addressingModes,
-          instructionSet,
+          headers,
           vectors,
           types,
           createdAt,
@@ -6171,6 +7043,7 @@ async function summaryFromSupabaseByProject(projectName) {
           version,
           isActive,
           notes,
+          fileTypes,
           baseRomId,
           gameRomBranchId,
           createdAt,
@@ -6268,17 +7141,21 @@ async function summaryFromSupabaseByProject(projectName) {
 //#region src/rom/generator.ts
 var RomGenerator = class {
 	projectName;
-	crc = 0;
-	branchId = "";
+	crc;
 	dbRoot = {};
 	sourceData = new Uint8Array();
-	constructor(projectName) {
+	constructor(projectName, crc) {
 		this.projectName = projectName;
+		this.crc = crc ?? 0;
 	}
-	async initialize() {
-		var projectData = await summaryFromSupabaseByProject(this.projectName);
-		this.crc = projectData.baseRomBranch.gameRomBranch.gameRom.crc;
-		this.branchId = projectData.id;
+	async validateAndDownload(sourceData) {
+		if (crc32_buffer(sourceData) === this.crc) {
+			const moduleData = await fromSupabaseByProject(this.projectName);
+			this.dbRoot = DbRootUtils.fromGameModule(moduleData);
+			this.sourceData = sourceData;
+			return true;
+		}
+		return false;
 	}
 	async generateProject(modules, manualFiles, unshiftManualFiles = false) {
 		if (!this.dbRoot) throw new Error("Database not initialized");
@@ -6294,45 +7171,20 @@ var RomGenerator = class {
 		if (unshiftManualFiles) for (const file of manualFiles ?? []) this.applyPatchFile(file, chunkFiles, asmFiles, patchFiles);
 		for (const module of modules) for (const file of moduleLookup.get(module)) this.applyPatchFile(file, chunkFiles, asmFiles, patchFiles);
 		if (!unshiftManualFiles) for (const file of manualFiles ?? []) this.applyPatchFile(file, chunkFiles, asmFiles, patchFiles);
-		this.assembleCodeFromText(asmFiles);
-		RomProcessor.applyPatches(asmFiles, patchFiles);
-		for (const asm of chunkFiles) ChunkFileUtils.calculateSize(asm);
-		const pages = new RomLayout(chunkFiles, this.dbRoot).organize();
-		for (const file of asmFiles) ChunkFileUtils.rebase(file);
-		this.generateAsmIncludeLookups(asmFiles);
-		const blockLookup = /* @__PURE__ */ new Map();
-		for (const f of chunkFiles) blockLookup.set(f.name.toUpperCase(), f.location);
-		return await this.writeRom(blockLookup, chunkFiles, asmFiles, pages);
+		return await new RomWriter(this.dbRoot).repack(chunkFiles);
 	}
 	applyProjectInit(chunkFiles, asmFiles, patchFiles) {
 		const moduleLookup = /* @__PURE__ */ new Map();
 		for (const chunkFile of this.dbRoot.projectFiles) {
 			console.log(`Processing patch: ${chunkFile.name}`);
 			if (chunkFile.group) {
-				let modArray;
-				if (!moduleLookup.has(chunkFile.group)) moduleLookup.set(chunkFile.group, modArray = []);
-				else modArray = moduleLookup.get(chunkFile.group);
+				let modArray = moduleLookup.get(chunkFile.group);
+				if (!modArray) moduleLookup.set(chunkFile.group, modArray = []);
 				modArray.push(chunkFile);
 			} else this.applyPatchFile(chunkFile, chunkFiles, asmFiles, patchFiles);
 		}
 		return moduleLookup;
 	}
-	assembleCodeFromText(asmFiles) {
-		for (const block of asmFiles) {
-			const { blocks, includes, reqBank } = new Assembler(this.dbRoot, block.textData).parseAssembly();
-			block.parts = blocks;
-			block.includes = includes;
-			block.bank = reqBank ?? void 0;
-		}
-	}
-	generateAsmIncludeLookups(asmFiles) {
-		for (const f of asmFiles) {
-			const includeBlocks = asmFiles.filter((x) => f.includes?.has(x.name.toUpperCase())).flatMap((x) => x.parts).filter((b) => !!b.label);
-			f.includeLookup = /* @__PURE__ */ new Map();
-			for (const b of includeBlocks) if (b.label) f.includeLookup.set(b.label.toUpperCase(), b);
-			for (const b of (f.parts || []).filter((x) => !!x.label)) if (b.label) f.includeLookup.set(b.label.toUpperCase(), b);
-		}
-	}
 	applyPatchFile(chunkFile, chunkFiles, asmFiles, patchFiles) {
 		console.log(`Processing patch: ${chunkFile.name}`);
 		const existing = chunkFiles.find((x) => x.name === chunkFile.name);
@@ -6347,15 +7199,6 @@ var RomGenerator = class {
 			existing.size = chunkFile.size;
 		} else chunkFiles.push(chunkFile);
 	}
-	async writeRom(blockLookup, chunkFiles, asmFiles, pages) {
-		const romWriter = new RomWriter(this.dbRoot, "GAIALABS", "01JG  ");
-		romWriter.allocate(pages);
-		for (const file of chunkFiles) await romWriter.writeFile(file, blockLookup);
-		romWriter.writeHeader();
-		romWriter.writeEntryPoints(asmFiles);
-		romWriter.writeChecksum();
-		return romWriter.outBuffer;
-	}
 };
 
 //#endregion
@@ -6590,26 +7433,12 @@ var SpriteMap = class SpriteMap {
 
 //#endregion
 //#region src/index.ts
-/**
-* GaiaCore - Universal ROM processing engine
-* 
-* This package provides the core functionality for ROM processing
-* that can run in both browser (Web Worker) and Node.js environments.
-* 
-* High-level APIs:
-* - RomProcessor: Unified ROM processing workflows
-* - ProjectManager: Complete project lifecycle management
-* 
-* Low-level modules:
-* - ROM: ROM state management, project configuration
-* - Assembly: 65816 instruction set, stack operations
-* - Compression: QuintetLZ compression algorithm
-* - Sprites: Sprite animation system
-*/
-const GAIA_CORE_VERSION = "0.1.6";
-const isPlatformBrowser = typeof window !== "undefined";
+const snes = {
+	addressingModes: addressingModes_default,
+	vectors: vectors_default,
+	headers: headers_default
+};
 const isPlatformNode = typeof process !== "undefined" && process.versions?.node;
-const isPlatformWebWorker = typeof importScripts !== "undefined";
 
 //#endregion
 exports.Address = Address;
@@ -6639,6 +7468,8 @@ exports.DbBlock = DbBlock;
 exports.DbFile = DbFile;
 exports.DbFileType = DbFileType;
 exports.DbGroup = DbGroup;
+exports.DbHeader = DbHeader;
+exports.DbHeaderPart = DbHeaderPart;
 exports.DbOverride = DbOverride;
 exports.DbPart = DbPart;
 exports.DbRootUtils = DbRootUtils;
@@ -6649,8 +7480,6 @@ exports.DbStringType = DbStringType;
 exports.DbStringTypeUtils = DbStringTypeUtils;
 exports.DbStruct = DbStruct;
 exports.DbTransform = DbTransform;
-exports.DebugExporter = DebugExporter;
-exports.GAIA_CORE_VERSION = GAIA_CORE_VERSION;
 exports.LocationWrapper = LocationWrapper;
 exports.Long = Long;
 exports.MapExt = MapExt;
@@ -6722,9 +7551,7 @@ exports.getSupabaseClient = getSupabaseClient;
 exports.hexToBytes = hexToBytes;
 exports.hexToUint8Array = hexToUint8Array;
 exports.indexOfAny = indexOfAny;
-exports.isPlatformBrowser = isPlatformBrowser;
 exports.isPlatformNode = isPlatformNode;
-exports.isPlatformWebWorker = isPlatformWebWorker;
 exports.isValidBase64 = isValidBase64;
 exports.listDirectory = listDirectory;
 exports.readFileAsBinary = readFileAsBinary;
@@ -6734,6 +7561,7 @@ exports.removeDirectory = removeDirectory;
 exports.resetSupabaseClient = resetSupabaseClient;
 exports.saveFileAsBinary = saveFileAsBinary;
 exports.saveFileAsText = saveFileAsText;
+exports.snes = snes;
 exports.summaryFromSupabaseByProject = summaryFromSupabaseByProject;
 exports.uint8ArrayToBase64 = uint8ArrayToBase64;
 exports.validateEnvironmentVariables = validateEnvironmentVariables;