@gaialabs/core 0.2.11 → 0.2.13

package/dist/index.cjs

@@ -936,10 +936,12 @@ var ProcessorStateManager = class {
 var RomDataReader = class {
 	romData;
 	position;
-	constructor(romData) {
+	offset;
+	constructor(romData, offset = 0) {
 		if (!romData) throw new Error("romData cannot be null");
 		this.romData = romData;
 		this.position = 0;
+		this.offset = offset;
 	}
 	readByte() {
 		return this.romData[this.position++];
@@ -1247,6 +1249,7 @@ let MemberType = /* @__PURE__ */ function(MemberType) {
 	MemberType["Address"] = "Address";
 	MemberType["Binary"] = "Binary";
 	MemberType["Code"] = "Code";
+	MemberType["Branch"] = "Branch";
 	MemberType["Location"] = "Location";
 	return MemberType;
 }({});
@@ -1670,31 +1673,63 @@ var ChunkFile = class {
 	mnemonics;
 	group;
 	scene;
-	constructor(name, size, location, type) {
+	base;
+	referenceManager;
+	constructor(type, name, size = 0, location = 0) {
+		this.type = type;
 		this.name = name;
 		this.size = size;
 		this.location = location;
 		this.mnemonics = {};
 		this.compressed = type.compressed;
-		this.type = type;
+	}
+	enrichWithRawDataFromDbFile(file, rom, compression) {
+		this.upper = file.upper ?? this.upper;
+		this.size = file.end - file.start;
+		this.location = file.start;
+		this.base = file.base ?? this.type.base ?? this.base;
+		this.group = file.group ?? this.group;
+		this.scene = file.scene ?? this.scene;
+		this.compressed = file.compressed;
+		let start = this.location;
+		let header = null;
+		const fileType = this.type;
+		if (fileType.header) {
+			header = new Uint8Array(rom.slice(start, start + fileType.header));
+			start += fileType.header;
+		}
+		let length = this.size;
+		let fileData;
+		if (this.compressed === true && compression) {
+			const expanded = compression.expand(rom, start, length);
+			fileData = combineHeader(expanded, 0, expanded.length, header, fileType.type);
+		} else {
+			if (this.compressed !== void 0) {
+				start += 2;
+				length -= 2;
+			}
+			fileData = combineHeader(rom, start, length, header, fileType.type);
+		}
+		this.rawData = fileData;
+		this.size = fileData.length;
+	}
+	enrichWithAsmBlocksFromDbBlock(block, memoryMode) {
+		this.group = block.group;
+		this.scene = block.scene;
+		this.parts = [];
+		this.size = 0;
+		if (!block.parts?.length) throw new Error(`Block ${block.name} has no parts`);
+		this.location = block.parts[0].start;
+		this.bank = block.movable ? void 0 : memoryMode === MemoryMapMode.Lo ? this.location >> 15 : this.location >> 16;
+		this.transforms = block.transforms;
+		this.postProcess = block.postProcess;
+		for (const part of block.parts) {
+			const asmBlock = new AsmBlock(part.start, part.end - part.start, false, part.name, part.type || void 0, part.bank);
+			this.size += asmBlock.size;
+			this.parts.push(asmBlock);
+		}
 	}
 };
-function createChunkFileFromDbFile(rom, compression, dbFile, fileType) {
-	const chunkFile = new ChunkFile(dbFile.name, dbFile.end - dbFile.start, dbFile.start, fileType);
-	chunkFile.compressed = dbFile.compressed;
-	chunkFile.upper = dbFile.upper;
-	chunkFile.group = dbFile.group;
-	chunkFile.scene = dbFile.scene;
-	enrichWithRawDataFromDbFile(rom, chunkFile, compression, dbFile, fileType);
-	return chunkFile;
-}
-function createChunkFileFromDbBlock(block, fileType, memoryMode) {
-	const chunkFile = new ChunkFile(block.name, 0, 0, fileType);
-	chunkFile.group = block.group;
-	chunkFile.scene = block.scene;
-	enrichWithPartsFromDbBlock(chunkFile, block, memoryMode);
-	return chunkFile;
-}
 function combineHeader(data, position, length, header, type) {
 	let totalLength = length + (header ? header.length : 0);
 	if (type === BinType.Palette && length < 512) totalLength += 512 - length;
@@ -1710,48 +1745,6 @@ function combineHeader(data, position, length, header, type) {
 	return result;
 }
 /**
-* Enriches ChunkFile with raw binary data from DbFile
-*/
-function enrichWithRawDataFromDbFile(rom, chunkFile, compression, dbFile, fileType) {
-	let start = dbFile.start;
-	let header = null;
-	if (fileType.header) {
-		header = new Uint8Array(rom.slice(start, start + fileType.header));
-		start += fileType.header;
-	}
-	let length = dbFile.end - start;
-	let fileData;
-	if (dbFile.compressed === true && compression) {
-		const expanded = compression.expand(rom, start, length);
-		fileData = combineHeader(expanded, 0, expanded.length, header, fileType.type);
-	} else {
-		if (dbFile.compressed !== void 0) {
-			start += 2;
-			length -= 2;
-		}
-		fileData = combineHeader(rom, start, length, header, fileType.type);
-	}
-	chunkFile.rawData = fileData;
-	chunkFile.size = fileData.length;
-}
-/**
-* Enriches ChunkFile with AsmBlock parts from DbBlock
-*/
-function enrichWithPartsFromDbBlock(chunkFile, block, memoryMode) {
-	chunkFile.parts = [];
-	chunkFile.size = 0;
-	if (!block.parts?.length) throw new Error(`Block ${block.name} has no parts`);
-	chunkFile.location = block.parts[0].start;
-	chunkFile.bank = block.movable ? void 0 : memoryMode === MemoryMapMode.Lo ? chunkFile.location >> 15 : chunkFile.location >> 16;
-	chunkFile.transforms = block.transforms;
-	chunkFile.postProcess = block.postProcess;
-	for (const part of block.parts) {
-		const asmBlock = new AsmBlock(part.start, part.end - part.start, false, part.name, part.type || void 0, part.bank);
-		chunkFile.size += asmBlock.size;
-		chunkFile.parts.push(asmBlock);
-	}
-}
-/**
 * Chunk file utilities
 */
 var ChunkFileUtils = class {
@@ -1773,16 +1766,11 @@ var ChunkFileUtils = class {
 	* Calculate the total size of all blocks
 	*/
 	static calculateSize(chunkFile) {
-		if (!chunkFile.parts) {
-			let size = chunkFile.rawData?.length ?? chunkFile.size;
-			if (chunkFile.type.header === -2 || chunkFile.compressed === false) {
-				size += 2;
-				chunkFile.size = size;
-			}
-			return size;
-		}
 		let size = 0;
-		for (let x = 0; x < chunkFile.parts.length; x++) {
+		if (chunkFile.rawData) {
+			size = chunkFile.rawData.length;
+			if (chunkFile.type.header === -2 || chunkFile.compressed === false) size += 2;
+		} else if (chunkFile.parts) for (let x = 0; x < chunkFile.parts.length; x++) {
 			const block = chunkFile.parts[x];
 			if (x > 0 && !block.label) break;
 			size += block.size || 0;
@@ -1801,7 +1789,7 @@ var ChunkFileUtils = class {
 			block,
 			part
 		];
-		for (const otherBlock of root) if (otherBlock !== block) {
+		for (const otherBlock of root) if (otherBlock !== block && !otherBlock.type.struct) {
 			const [otherIsInside, otherPart] = this.isInsideWithPart(otherBlock, location);
 			if (otherIsInside) return [
 				true,
@@ -1987,6 +1975,7 @@ var ReferenceManager = class {
 	}
 	createTypeName(type, location) {
 		let name = type.toLowerCase();
+		if (name === "branch") name = "loc";
 		while (name.length > 0 && BlockReaderConstants.POINTER_CHARACTERS.includes(name[0])) name = name.substring(1) + "_list";
 		return `${name}_${location.toString(16).toUpperCase().padStart(6, "0")}`;
 	}
@@ -2364,6 +2353,7 @@ var AddressingModeHandler = class {
 	}
 	handlePCRelativeMode(operands, nextAddress, reg, isLong) {
 		const relative = isLong ? nextAddress + this._dataReader.readShort() : nextAddress + this._dataReader.readSByte();
+		this._blockReader._referenceManager.tryAddStruct(relative, "Branch");
 		this._blockReader.updateRegisterState(relative, reg);
 		operands.push(new LocationWrapper(relative, isLong ? AddressType.WRelative : AddressType.Relative));
 	}
@@ -2987,7 +2977,7 @@ var StringReader = class StringReader {
 		this._romDataReader = blockReader._romDataReader;
 	}
 	resolveCommand(cmd, builder) {
-		if (cmd.dictionary) builder.push(cmd.dictionary.entries[this._romDataReader.readByte() - (cmd.dictionary.base ?? 0)]);
+		if (cmd.dictionary) builder.push(`[${cmd.dictionary.commandName ?? cmd.dictionary.command?.toString(16).padEnd(2, "0").toUpperCase()}:${this._romDataReader.readByte().toString(16).padEnd(2, "0").toUpperCase()}]`);
 		else if (cmd.types && cmd.types.length > 0) {
 			builder.push(`[${cmd.name}`);
 			let first = true;
@@ -3028,7 +3018,7 @@ var StringReader = class StringReader {
 	}
 	parseString(stringType, fixedSize) {
 		const commands = stringType.commandLookup;
-		const dictionaries = stringType.dictionaries;
+		stringType.dictionaries;
 		const builder = [];
 		const strLoc = this._romDataReader.position;
 		const terminator = stringType.terminator;
@@ -3045,23 +3035,17 @@ var StringReader = class StringReader {
 				if (cmd.halt) break;
 			} else {
 				let found = false;
-				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) {
-					for (const layer of stringType.layers) if (layer.on !== void 0) {
-						if (c === layer.on) {
-							currentLayer = layer;
-							found = true;
-							break;
-						}
-					} else if (layer.base && c >= layer.base && c < layer.base + layer.map.length) {
-						builder.push(layer.map[c - layer.base]);
+				for (const layer of stringType.layers) if (layer.on !== void 0) {
+					if (c === layer.on) {
+						currentLayer = layer;
+						builder.push("[--]");
 						found = true;
 						break;
 					}
+				} else if (layer.base && c >= layer.base && c < layer.base + layer.map.length) {
+					builder.push(layer.map[c - layer.base]);
+					found = true;
+					break;
 				}
 				if (!found) {
 					let index = c - (currentLayer.base ?? 0);
@@ -3090,28 +3074,26 @@ var StringReader = class StringReader {
 		let str = sw.string;
 		let ix = indexOfAny(str, StringReader.STRING_REFERENCE_CHARACTERS);
 		while (ix >= 0) {
-			if (ix + 6 < str.length) {
-				const hexStr = str.substring(ix + 1, ix + 7);
-				const sloc = parseInt(hexStr, 16);
-				if (!isNaN(sloc)) {
-					if (new Address(sloc >> 16 & 255, sloc & 65535, this._blockReader._root.config.memoryMode).isROM) {
-						this._blockReader.resolveInclude(sloc, false);
-						const name = this._blockReader.resolveName(sloc, AddressType.Unknown, false);
-						const opix = indexOfAny(name, RomProcessingConstants.OPERATORS);
-						if (opix > 0) {
-							const offsetStr = name.substring(opix + 1);
-							let offset;
-							if (offsetStr === "M") offset = this._blockReader._referenceManager.markerTable.get(sloc) || 0;
-							else offset = parseInt(offsetStr, 16) || 0;
-							if (name[opix] === "-") offset = -offset;
-							name.substring(0, opix);
-							const target = sloc - offset;
-							const [isOutside, block, part] = ChunkFileUtils.isOutsideWithPart(this._blockReader._enrichedChunks, this._blockReader._currentChunk, sloc);
-							if (part != null) {
-								const entry = part.objList?.find((x) => typeof x === "object" && x !== null && "location" in x && "object" in x && x.location === target);
-								if (entry && entry.object) entry.object.marker = offset;
-							}
-						}
+			if (ix + 6 >= str.length) break;
+			const hexStr = str.substring(ix + 1, ix + 7);
+			const sloc = parseInt(hexStr, 16);
+			if (isNaN(sloc)) break;
+			if (new Address(sloc >> 16 & 255, sloc & 65535, this._blockReader._root.config.memoryMode).isROM) {
+				this._blockReader.resolveInclude(sloc, false);
+				const name = this._blockReader._referenceManager.resolveName(sloc, AddressType.Unknown, false);
+				const opix = indexOfAny(name, RomProcessingConstants.OPERATORS);
+				if (opix > 0) {
+					const offsetStr = name.substring(opix + 1);
+					let offset;
+					if (offsetStr === "M") offset = this._blockReader._referenceManager.markerTable.get(sloc) || 0;
+					else offset = parseInt(offsetStr, 16) || 0;
+					if (name[opix] === "-") offset = -offset;
+					name.substring(0, opix);
+					const target = sloc - offset;
+					const [isOutside, block, part] = ChunkFileUtils.isOutsideWithPart(this._blockReader._enrichedChunks, this._blockReader._currentChunk, sloc);
+					if (part != null) {
+						const entry = part.objList?.find((x) => typeof x === "object" && x !== null && "location" in x && "object" in x && x.location === target);
+						if (entry && entry.object) entry.object.marker = offset;
 					}
 				}
 			}
@@ -3161,7 +3143,8 @@ var TypeParser = class {
 			case MemberType.Address: return this.parseLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), null, AddressType.Address);
 			case MemberType.Location: return this.parseLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), null, AddressType.Location);
 			case MemberType.Binary: return this.parseBinary(fixedSize);
-			case MemberType.Code: return this.parseCode(reg);
+			case MemberType.Code:
+			case MemberType.Branch: return this.parseCode(reg);
 			default: throw new Error("Invalid member type");
 		}
 		const parentType = this._blockReader._root.structs[fixedTypeName];
@@ -3195,7 +3178,7 @@ var TypeParser = class {
 			let checkPosition = startPosition;
 			while (++checkPosition < this._romDataReader.position) {
 				const struct = this._referenceManager.tryGetStruct(checkPosition);
-				if (struct.found && struct.chunkType !== "Code") {
+				if (struct.found && struct.chunkType !== "Code" && struct.chunkType !== "Branch") {
 					this._romDataReader.position = checkPosition;
 					break;
 				}
@@ -3226,16 +3209,18 @@ var TypeParser = class {
 	}
 	parseLocation(offset, bank, typeName, addrType) {
 		if ((bank === void 0 || bank === null) && offset === 0) return new Word(offset);
+		offset -= this._romDataReader.offset;
 		let adrs;
 		let loc;
-		if (addrType === AddressType.Location) loc = offset | bank << 16;
+		if (addrType === AddressType.Location || this._romDataReader.offset) loc = offset | bank << 16;
 		else {
 			adrs = new Address(bank ?? Address.resolveBank(this._romDataReader.position, this._blockReader._root.config.memoryMode), offset, this._blockReader._root.config.memoryMode);
 			if (!adrs.isROM) return adrs;
 			loc = adrs.toLocation();
 		}
-		if (typeName && !this._blockReader._root.rewrites[loc]) {
-			this._referenceManager.tryAddStruct(loc, typeName);
+		if (typeName && (this._romDataReader.offset || !this._blockReader._root.rewrites[loc])) {
+			const oldStruct = this._referenceManager.structTable.get(loc);
+			if (!oldStruct || oldStruct === "Branch") this._referenceManager.structTable.set(loc, typeName);
 			const referenceName = `${typeName.toLowerCase()}_${loc.toString(16).toUpperCase().padStart(6, "0")}`;
 			this._referenceManager.tryAddName(loc, referenceName);
 		}
@@ -3246,7 +3231,10 @@ var TypeParser = class {
 		let first = true;
 		while (this._romDataReader.position < this._blockReader._partEnd) {
 			if (first) first = false;
-			else if (this._referenceManager.containsStruct(this._romDataReader.position)) break;
+			else {
+				const struct = this._referenceManager.structTable.get(this._romDataReader.position);
+				if (struct && struct !== "Branch") break;
+			}
 			if (reg) this._blockReader.hydrateRegisters(reg);
 			const op = this._blockReader._asmReader.parseAsm(reg);
 			opList.push(op);
@@ -3421,8 +3409,6 @@ var BlockReader = class {
 		this._stringReader = new StringReader(this);
 		this._asmReader = new AsmReader(this);
 		this._typeParser = new TypeParser(this);
-		this.initializeOverrides();
-		this.initializeFileReferences();
 	}
 	/**
 	* Processes predefined overrides for registers and bank notes
@@ -3472,9 +3458,6 @@ var BlockReader = class {
 	/**
 	* Resolves name for a location (delegated to ReferenceManager)
 	*/
-	resolveName(location, type, isBranch) {
-		return this._referenceManager.resolveName(location, type, isBranch);
-	}
 	/**
 	* Resolves include for a location
 	*/
@@ -3493,7 +3476,8 @@ var BlockReader = class {
 	* Notes a type at a location and manages chunk references
 	*/
 	noteType(loc, type, silent = false, reg) {
-		this._referenceManager.tryAddStruct(loc, type);
+		const oldStruct = this._referenceManager.structTable.get(loc);
+		if (!oldStruct || oldStruct === "Branch") this._referenceManager.structTable.set(loc, type);
 		const nameResult = this._referenceManager.tryGetName(loc);
 		let name;
 		if (!nameResult.found) {
@@ -3533,10 +3517,14 @@ var BlockReader = class {
 		return this._romDataReader.position < this._partEnd && !this._referenceManager.containsStruct(this._romDataReader.position);
 	}
 	analyzeAndResolve() {
+		console.log("analyzeAndResolve started");
+		this.initializeOverrides();
+		this.initializeFileReferences();
 		this.createChunkFilesFromDatabase();
 		this.initializeBlocksAndParts();
 		this.analyzeChunkFiles();
 		this.resolveReferences();
+		console.log("analyzeAndResolve complete");
 		return this._enrichedChunks;
 	}
 	/**
@@ -3546,6 +3534,7 @@ var BlockReader = class {
 	* Initializes blocks and parts with base references
 	*/
 	initializeBlocksAndParts() {
+		console.log("initializeBlocksAndParts");
 		for (const block of this._enrichedChunks) for (const part of block.parts || []) {
 			if (part.structName) this._referenceManager.tryAddStruct(part.location, part.structName);
 			if (part.label) this._referenceManager.tryAddName(part.location, part.label);
@@ -3600,6 +3589,7 @@ var BlockReader = class {
 	* Creates ChunkFile objects from database structure
 	*/
 	createChunkFilesFromDatabase() {
+		console.log("createChunkFilesFromDatabase");
 		this._enrichedChunks = [];
 		this.createChunkFilesFromSfx();
 		this.createChunkFilesFromDbFiles();
@@ -3644,7 +3634,7 @@ var BlockReader = class {
 			const size = getSize();
 			const startPos = pos + offset;
 			const data = getBytes(size);
-			const chunk = new ChunkFile(`sfx${i.toString(16).toUpperCase().padStart(2, "0")}`, size, startPos, fileType);
+			const chunk = new ChunkFile(fileType, `sfx${i.toString(16).toUpperCase().padStart(2, "0")}`, size, startPos);
 			chunk.rawData = data;
 			chunk.group = "sfx";
 			this._enrichedChunks.push(chunk);
@@ -3655,7 +3645,9 @@ var BlockReader = class {
 	*/
 	createChunkFilesFromDbFiles() {
 		for (const dbFile of this._root.files) {
-			const chunkFile = createChunkFileFromDbFile(this._romDataReader.romData, this._root.compression, dbFile, this._root.fileTypes[dbFile.type]);
+			const fileType = this._root.fileTypes[dbFile.type];
+			const chunkFile = new ChunkFile(fileType, dbFile.name);
+			chunkFile.enrichWithRawDataFromDbFile(dbFile, this._romDataReader.romData, this._root.compression);
 			this._enrichedChunks.push(chunkFile);
 		}
 	}
@@ -3665,7 +3657,8 @@ var BlockReader = class {
 	createChunkFilesFromDbBlocks() {
 		const fileType = Object.values(this._root.fileTypes).find((x) => x.isBlock);
 		for (const block of this._root.blocks) {
-			const chunkFile = createChunkFileFromDbBlock(block, fileType, this._root.config.memoryMode);
+			const chunkFile = new ChunkFile(fileType, block.name);
+			chunkFile.enrichWithAsmBlocksFromDbBlock(block, this._root.config.memoryMode);
 			this._enrichedChunks.push(chunkFile);
 		}
 	}
@@ -3673,22 +3666,43 @@ var BlockReader = class {
 	* Analyzes only assembly ChunkFiles (those with parts from DbBlocks)
 	*/
 	analyzeChunkFiles() {
-		const assemblyChunks = this._enrichedChunks.filter((chunk) => chunk.type.type === "Assembly");
-		for (const chunkFile of assemblyChunks) {
+		console.log("analyzeChunkFiles");
+		for (const chunkFile of this._enrichedChunks) {
+			if (!chunkFile.type.isBlock) continue;
+			chunkFile.referenceManager = this._referenceManager;
 			this._currentChunk = chunkFile;
 			for (const asmBlock of chunkFile.parts || []) {
 				this._currentAsmBlock = asmBlock;
 				this.processPart(asmBlock);
 			}
 		}
+		const oldState = this._referenceManager;
+		const oldReader = this._romDataReader;
+		const oldTypeParser = this._typeParser;
+		for (const chunkFile of this._enrichedChunks) {
+			if (!chunkFile.type.struct) continue;
+			this._currentChunk = chunkFile;
+			const asmBlock = new AsmBlock(0, chunkFile.size, false, chunkFile.name, chunkFile.type.struct);
+			chunkFile.parts = [asmBlock];
+			this._currentAsmBlock = asmBlock;
+			this._referenceManager = chunkFile.referenceManager = new ReferenceManager(this._root);
+			this._romDataReader = new RomDataReader(chunkFile.rawData, chunkFile.base ?? 0);
+			this._typeParser = new TypeParser(this);
+			this.processPart(asmBlock);
+		}
+		this._referenceManager = oldState;
+		this._romDataReader = oldReader;
+		this._typeParser = oldTypeParser;
 	}
 	/**
 	* Resolves references in assembly ChunkFiles only
 	*/
 	resolveReferences() {
+		console.log("resolveReferences");
 		for (const chunkFile of this._enrichedChunks) {
+			if (!chunkFile.type.isBlock) continue;
 			this._currentChunk = chunkFile;
-			for (const asmBlock of chunkFile.parts || []) {
+			for (const asmBlock of chunkFile.parts) {
 				this._currentAsmBlock = asmBlock;
 				this.resolveObject(asmBlock.objList, false);
 			}
@@ -3878,6 +3892,7 @@ var BlockWriter = class {
 	generateAsm(block) {
 		if (!block.parts) throw new Error("Invalid block structure for generateAsm");
 		const lines = [];
+		this._referenceManager = block.referenceManager;
 		if (block.bank !== void 0) lines.push(`?BANK ${block.bank.toString(16).toUpperCase().padStart(2, "0")}`);
 		const includes = ChunkFileUtils.getIncludes(block);
 		if (includes && includes.length > 0) {
@@ -3922,11 +3937,11 @@ var BlockWriter = class {
 		}
 		if (typeof obj === "number") {
 			if (op.mode === "Immediate") return obj;
-			return this._blockReader.resolveName(obj, AddressType.Address, isBranch);
+			return this._referenceManager.resolveName(obj, AddressType.Address, isBranch);
 		}
 		if (this.getObjectType(obj) === ObjectType.LocationWrapper) {
 			const lw = obj;
-			return this._blockReader.resolveName(lw.location, lw.type, isBranch);
+			return this._referenceManager.resolveName(lw.location, lw.type, isBranch);
 		}
 		if (this.getObjectType(obj) === ObjectType.Address) {
 			const addr = obj;
@@ -3978,7 +3993,7 @@ var BlockWriter = class {
 				objLines = this.writeOpArray(obj, depth);
 				break;
 			case ObjectType.LocationWrapper:
-				objLines = [this._blockReader.resolveName(obj.location, obj.type, isBranch)];
+				objLines = [this._referenceManager.resolveName(obj.location, obj.type, isBranch)];
 				break;
 			case ObjectType.Address:
 				objLines = isArray ? [`$#${obj.offset.toString(16).toUpperCase().padStart(4, "0")}`] : [`$${obj.toString()}`];
@@ -4096,7 +4111,7 @@ var BlockWriter = class {
 				const adrs = new Address(rawAddr >> 16 & 255, rawAddr & 65535, this._blockReader._root.config.memoryMode);
 				const addressType = char === "^" ? AddressType.Offset : AddressType.Address;
 				let name = "";
-				if (adrs.isROM) name = this._blockReader.resolveName(adrs.toLocation(), addressType, false);
+				if (adrs.isROM) name = this._referenceManager.resolveName(adrs.toLocation(), addressType, false);
 				else if (addressType === AddressType.Offset) name = adrs.offset.toString(16).toUpperCase().padStart(4, "0");
 				else name = adrs.toString();
 				str = str.replace(str.substring(ix, ix + 7), name);
@@ -4113,10 +4128,10 @@ var BlockWriter = class {
 			let six = 0;
 			let mix = 0;
 			while (mix < marker) if (str[six] === "[") {
-				const eix = str.indexOf("]", ++six);
-				const parts = str.substring(six, eix).split(/[,: ]/);
+				const eix = str.indexOf("]", six);
+				const parts = str.substring(six + 1, eix).split(/[,: ]/);
 				const cmd = stringObj.type.commands[parts[0]];
-				if (cmd && cmd.types) for (const t of cmd.types) switch (t) {
+				if (cmd) for (const t of cmd.types) switch (t) {
 					case MemberType.Byte:
 						mix += 1;
 						break;
@@ -4133,6 +4148,7 @@ var BlockWriter = class {
 						break;
 					default: throw new Error("Unsupported member type");
 				}
+				else mix += parts.length - 1;
 				six = eix + 1;
 				mix++;
 			} else {
@@ -4141,6 +4157,18 @@ var BlockWriter = class {
 			}
 			str = str.substring(0, six) + "[::]" + str.substring(six);
 		}
+		const dictionaries = stringObj.type.dictionaries;
+		for (const dictionary of Object.values(dictionaries)) {
+			const commandName = `[${dictionary.commandName ?? dictionary.command?.toString(16).padEnd(2, "0").toUpperCase()}:`;
+			let cmdIx;
+			while ((cmdIx = str.indexOf(commandName)) >= 0) {
+				const endIx = str.indexOf("]", cmdIx);
+				const strIx = parseInt(str.substring(cmdIx + commandName.length, endIx), 16);
+				const newText = dictionary.entries[strIx];
+				str = str.substring(0, cmdIx) + newText + str.substring(endIx + 1);
+			}
+		}
+		str = str.replace(/\[--\]/g, "");
 		const sizeParam = stringObj.fixedSize ? `(${stringObj.fixedSize})` : "";
 		return [`${refChar}${str}${refChar}${sizeParam}`];
 	}
@@ -4225,8 +4253,8 @@ var RomLayout = class RomLayout {
 			return parseInt(a.name.substring(a.name.length - 2, a.name.length), 16) - parseInt(b.name.substring(b.name.length - 2, b.name.length), 16);
 		}) : [];
 		this.unmatchedFiles = files.filter((x) => (x.size || 0) > 0).filter((x) => this.sfxPackType === "Individual" || x.type.type !== "Sound").sort((a, b) => {
-			const aAsm = a.parts ? 0 : 1;
-			const bAsm = b.parts ? 0 : 1;
+			const aAsm = a.rawData ? 1 : 0;
+			const bAsm = b.rawData ? 1 : 0;
 			if (aAsm !== bAsm) return aAsm - bAsm;
 			if (b.size !== a.size) return b.size - a.size;
 			if (a.location !== b.location) return a.location - b.location;
@@ -4276,7 +4304,7 @@ var RomLayout = class RomLayout {
 						start += RomProcessingConstants.PAGE_SIZE;
 						page++;
 						if (offset) {
-							const newFile = new ChunkFile(file.name + "_2", file.size, file.location, Object.values(this.root.fileTypes).find((x) => x.type === BinType.Binary));
+							const newFile = new ChunkFile(Object.values(this.root.fileTypes).find((x) => x.type === BinType.Binary), file.name + "_2", file.size, file.location);
 							const end = file.rawData.length - offset;
 							newFile.rawData = file.rawData.slice(end);
 							newFile.size = newFile.rawData.length;
@@ -4366,106 +4394,13 @@ var RomLayout = class RomLayout {
 	}
 };
 
-//#endregion
-//#region src/rom/rebuild/processor.ts
-/**
-* ROM rebuild processor
-* Converted from ext/GaiaLib/Rom/Rebuild/RomProcessor.cs
-*/
-var RomProcessor = class RomProcessor {
-	writer;
-	constructor(writer) {
-		this.writer = writer;
-	}
-	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 && canCompress) if (this.writer.root.config.uncompress) file.compressed = false;
-				else {
-					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;
-				}
-				continue;
-			}
-			asmFiles.push(file);
-			conditionFiles.push(file.name);
-		}
-		for (const file of asmFiles) {
-			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) if (b.label) {
-				const nameUpper = b.label.toUpperCase();
-				masterLookup.set(nameUpper, b.location);
-				f.includeLookup.set(nameUpper, b);
-			}
-		}
-		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, fileLookup);
-		return masterLookup;
-	}
-	static applyPatches(asmFiles, patches) {
-		for (const patch of patches.filter((x) => x.includes && x.includes.size > 0)) {
-			let file = null;
-			let dstIx = -1;
-			const inc = asmFiles.filter((x) => patch.includes.has(x.name.toUpperCase()));
-			for (let ix = 0; patch.parts && ix < patch.parts.length;) {
-				const block = patch.parts[ix];
-				let match = null;
-				if (block.label) for (const i of inc) {
-					if (!i.parts) continue;
-					for (let y = 0; y < i.parts.length; y++) {
-						const check = i.parts[y];
-						if (check.label === block.label) {
-							file = i;
-							dstIx = y;
-							match = check;
-							break;
-						}
-					}
-				}
-				if (match) file.parts[dstIx++] = block;
-				else if (dstIx >= 0) file.parts.splice(dstIx++, 0, block);
-				else {
-					ix++;
-					continue;
-				}
-				file.includes = file.includes || /* @__PURE__ */ new Set();
-				file.includes.add(patch.name.toUpperCase());
-				patch.parts.splice(ix, 1);
-			}
-		}
-	}
-};
-
 //#endregion
 //#region src/rom/rebuild/writer.ts
 /**
 * ROM writer (binary)
 * Converted from ext/GaiaLib/Rom/Rebuild/RomWriter.cs (subset: binary write only)
 */
-var RomWriter = class {
+var RomWriter = class RomWriter {
 	bpsPath;
 	outBuffer;
 	romSize;
@@ -4473,8 +4408,8 @@ var RomWriter = class {
 	constructor(root) {
 		this.root = root;
 	}
-	async repack(files) {
-		const masterLookup = await new RomProcessor(this).repack(files);
+	async repack(files, modules) {
+		const masterLookup = await new RomProcessor(this).repack(files, modules);
 		this.writeHeaders(masterLookup);
 		return this.outBuffer;
 	}
@@ -4620,7 +4555,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, fileLookup, file.includeLookup);
+			RomWriter.parseAssembly(this.root, file.parts, fileLookup, file.includeLookup, this.outBuffer, void 0);
 		}
 		return pos - start;
 	}
@@ -4632,12 +4567,10 @@ 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, fileLookup, includeLookup) {
+	static parseAssembly(root, blocks, fileLookup, includeLookup, outBuffer, addrOffset) {
 		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;
@@ -4652,13 +4585,13 @@ var RomWriter = class {
 					continue;
 				} else if (currentObj instanceof Op) {
 					const op = currentObj;
-					buf[position++] = op.code & 255;
+					outBuffer[position++] = op.code & 255;
 					opos += op.size;
 					for (const operand of op.operands) processObject(operand, op);
 					break;
 				} else if (currentObj instanceof Uint8Array) {
 					const arr = currentObj;
-					for (let i = 0; i < arr.length; i++) buf[position + i] = arr[i];
+					for (let i = 0; i < arr.length; i++) outBuffer[position + i] = arr[i];
 					position += arr.length;
 					opos += arr.length;
 					break;
@@ -4670,7 +4603,7 @@ var RomWriter = class {
 					if (ix > 0) label = label.substring(ix);
 					let loc;
 					const isRelative = parentOp && (parentOp.mode === "PCRelative" || parentOp.mode === "PCRelativeLong");
-					const operatorIdx = this.indexOfAny(label, RomProcessingConstants.OPERATORS);
+					const operatorIdx = RomWriter.indexOfAny(label, RomProcessingConstants.OPERATORS);
 					let offset = null;
 					let useMarker = false;
 					if (operatorIdx > 0) {
@@ -4719,12 +4652,13 @@ var RomWriter = class {
 					if (offset !== null) loc += offset;
 					else if (useMarker && target instanceof AsmBlock) {
 						let markerOffset = 0;
-						for (const part of target.objList) if (this.isStringMarker(part)) {
+						for (const part of target.objList) if (RomWriter.isStringMarker(part)) {
 							loc += markerOffset;
 							break;
 						} else markerOffset += RomProcessingConstants.getSize(part);
 					}
-					if (!isRelative && type !== AddressType.Location) loc = Address.fromLocation(loc, this.root.config.memoryMode, this.root.config.cpuMode).toInt();
+					if (addrOffset !== void 0) loc += addrOffset;
+					else if (!isRelative && type !== AddressType.Location) loc = Address.fromLocation(loc, root.config.memoryMode, root.config.cpuMode).toInt();
 					switch (type) {
 						case AddressType.Offset:
 						case AddressType.WRelative:
@@ -4749,7 +4683,7 @@ var RomWriter = class {
 				} else if (currentObj instanceof TypedNumber) {
 					let value = currentObj.value;
 					for (let i = 0; i < currentObj.size; i++) {
-						buf[position++] = value & 255;
+						outBuffer[position++] = value & 255;
 						value >>= 8;
 					}
 					break;
@@ -4757,26 +4691,26 @@ var RomWriter = class {
 					const num = currentObj;
 					const size = parentOp?.size ?? 0;
 					if (num <= 255 && size <= 2) {
-						buf[position] = num & 255;
+						outBuffer[position] = num & 255;
 						position++;
 					} else if (num <= 65535 && size <= 3) {
-						buf[position] = num & 255;
-						buf[position + 1] = num >> 8 & 255;
+						outBuffer[position] = num & 255;
+						outBuffer[position + 1] = num >> 8 & 255;
 						position += 2;
 					} else if (num <= 16777215 && size <= 4) {
-						buf[position] = num & 255;
-						buf[position + 1] = num >> 8 & 255;
-						buf[position + 2] = num >> 16 & 255;
+						outBuffer[position] = num & 255;
+						outBuffer[position + 1] = num >> 8 & 255;
+						outBuffer[position + 2] = num >> 16 & 255;
 						position += 3;
 					} else {
-						buf[position] = num & 255;
-						buf[position + 1] = num >> 8 & 255;
-						buf[position + 2] = num >> 16 & 255;
-						buf[position + 3] = num >> 24 & 255;
+						outBuffer[position] = num & 255;
+						outBuffer[position + 1] = num >> 8 & 255;
+						outBuffer[position + 2] = num >> 16 & 255;
+						outBuffer[position + 3] = num >> 24 & 255;
 						position += 4;
 					}
 					break;
-				} else if (this.isStringMarker(currentObj)) break;
+				} else if (RomWriter.isStringMarker(currentObj)) break;
 				else throw new Error(`Unable to process '${currentObj}'`);
 			};
 			for (const obj of objList) {
@@ -4789,21 +4723,121 @@ var RomWriter = class {
 	/**
 	* Helper method to find index of any character from an array in a string
 	*/
-	indexOfAny(str, chars) {
+	static indexOfAny(str, chars) {
 		for (let i = 0; i < str.length; i++) if (chars.includes(str[i])) return i;
 		return -1;
 	}
 	/**
 	* Helper method to check if an object is a StringMarker
 	*/
-	isStringMarker(obj) {
+	static isStringMarker(obj) {
 		return typeof obj === "object" && obj !== null && "offset" in obj;
 	}
-	isTableEntry(obj) {
+	static isTableEntry(obj) {
 		return typeof obj === "object" && obj !== null && "location" in obj && "object" in obj;
 	}
 };
 
+//#endregion
+//#region src/rom/rebuild/processor.ts
+/**
+* ROM rebuild processor
+* Converted from ext/GaiaLib/Rom/Rebuild/RomProcessor.cs
+*/
+var RomProcessor = class RomProcessor {
+	writer;
+	constructor(writer) {
+		this.writer = writer;
+	}
+	async repack(allFiles, modules) {
+		const patches = [];
+		const asmFiles = [];
+		const compression = this.writer.root.compression;
+		const canCompress = !!compression;
+		const conditionFiles = [];
+		if (modules) conditionFiles.push(...modules);
+		const dummyMap = /* @__PURE__ */ new Map();
+		for (const file of allFiles) {
+			conditionFiles.push(file.name);
+			if (file.type.isPatch) {
+				patches.push(file);
+				asmFiles.push(file);
+			} else if (file.type.isBlock) asmFiles.push(file);
+			else if (!file.type.struct) continue;
+			const { blocks, includes, reqBank } = new Assembler(this.writer.root, file.textData, conditionFiles).parseAssembly();
+			file.parts = blocks;
+			file.includes = includes;
+			file.bank = reqBank ?? void 0;
+			if (file.type.struct) {
+				file.includeLookup = /* @__PURE__ */ new Map();
+				for (const b of file.parts) if (b.label) file.includeLookup.set(b.label.toUpperCase(), b);
+				file.rawData = void 0;
+				file.rawData = new Uint8Array(ChunkFileUtils.calculateSize(file));
+				RomWriter.parseAssembly(this.writer.root, file.parts, dummyMap, file.includeLookup, file.rawData, file.type.base ?? 0);
+			}
+		}
+		for (const file of allFiles) if (file.compressed === true && canCompress) if (this.writer.root.config.uncompress) file.compressed = false;
+		else {
+			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;
+		}
+		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) if (b.label) {
+				const nameUpper = b.label.toUpperCase();
+				masterLookup.set(nameUpper, b.location);
+				f.includeLookup.set(nameUpper, b);
+			}
+		}
+		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, fileLookup);
+		return masterLookup;
+	}
+	static applyPatches(asmFiles, patches) {
+		for (const patch of patches.filter((x) => x.includes && x.includes.size > 0)) {
+			let file = null;
+			let dstIx = -1;
+			const inc = asmFiles.filter((x) => patch.includes.has(x.name.toUpperCase()));
+			for (let ix = 0; patch.parts && ix < patch.parts.length;) {
+				const block = patch.parts[ix];
+				let match = null;
+				if (block.label) for (const i of inc) {
+					if (!i.parts) continue;
+					for (let y = 0; y < i.parts.length; y++) {
+						const check = i.parts[y];
+						if (check.label === block.label) {
+							file = i;
+							dstIx = y;
+							match = check;
+							break;
+						}
+					}
+				}
+				if (match) file.parts[dstIx++] = block;
+				else if (dstIx >= 0) file.parts.splice(dstIx++, 0, block);
+				else {
+					ix++;
+					continue;
+				}
+				file.includes = file.includes || /* @__PURE__ */ new Set();
+				file.includes.add(patch.name.toUpperCase());
+				patch.parts.splice(ix, 1);
+			}
+		}
+	}
+};
+
 //#endregion
 //#region src/rom/rebuild/string-processor.ts
 /**
@@ -4962,7 +4996,6 @@ var StringProcessor = class {
 				break;
 			case MemberType.Offset:
 			case MemberType.Address:
-				this.flushBuffer(stringType, false);
 				this.context.currentBlock.objList.push(parts[pix]);
 				this.context.currentBlock.size += cmd.types[y] === MemberType.Offset ? 2 : 3;
 				break;
@@ -5520,6 +5553,7 @@ var DbFile = class {
 	upper;
 	group;
 	scene;
+	base;
 	constructor(data) {
 		if (!data.name) throw new Error("Name is required");
 		if (!data.type) throw new Error("Type is required");
@@ -5533,6 +5567,7 @@ var DbFile = class {
 		this.upper = data.upper ?? void 0;
 		this.group = data.group || void 0;
 		this.scene = data.scene || void 0;
+		this.base = data.base ?? void 0;
 	}
 };
 var DbFileType = class {
@@ -5543,17 +5578,21 @@ var DbFileType = class {
 	isBlock;
 	header;
 	compressed;
+	struct;
+	base;
 	constructor(data) {
-		this.name = data.name ?? "";
-		this.extension = data.extension ?? "";
-		this.type = data.type ?? "";
+		if (!data.name) throw new Error("Name is required");
+		if (!data.extension) throw new Error("Extension is required");
+		if (!data.type) throw new Error("Type is required");
+		this.name = data.name;
+		this.extension = data.extension;
+		this.type = data.type;
 		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");
+		this.struct = data.struct ?? void 0;
+		this.base = data.base ?? void 0;
 	}
 };
 
@@ -5629,21 +5668,18 @@ var DbStringCommand = class {
 	}
 };
 var DbStringDictionary = class {
-	base;
-	range;
 	command;
+	commandName;
 	name;
 	entries;
 	constructor(data) {
-		if (typeof data.base !== "number" && typeof data.command !== "number") throw new Error("Base or command is required");
+		if (typeof data.command !== "number") throw new Error("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.commandName = data.commandName ?? void 0;
 		this.name = data.name;
 		this.entries = data.entries;
-		if (this.base !== void 0) this.range = this.base + this.entries.length;
 	}
 };
 /**
@@ -5678,7 +5714,7 @@ var DbStringType = class {
 		}, {});
 		this.dictionaryLookup = Object.values(this.dictionaries).flatMap((y) => y.entries.map((z, ix) => ({
 			text: z,
-			id: (y.command ?? 0) << 8 | (y.base ?? 0 + ix)
+			id: (y.command ?? 0) << 8 | ix
 		}))).sort((a, b) => b.text.length - a.text.length);
 	}
 };
@@ -6085,7 +6121,7 @@ var DbRootUtils = class {
 		const cfg = module.config;
 		const compression = cfg.compression ? CompressionAlgorithms[cfg.compression]() : void 0;
 		const baseRomChunks = module.baseRomFiles ?? module.supaBaseRomFiles?.map((file) => {
-			const chunkFile = new ChunkFile(file.name, 0, 0, fileTypeLookup[file.type]);
+			const chunkFile = new ChunkFile(fileTypeLookup[file.type], file.name);
 			if (file.isText) {
 				chunkFile.textData = file.text ?? void 0;
 				chunkFile.size = file.text?.length ?? 0;
@@ -6096,7 +6132,7 @@ var DbRootUtils = class {
 			return chunkFile;
 		});
 		const projectChunks = module.projectFiles ?? module.supaProjectFiles?.map((file) => {
-			const chunkFile = new ChunkFile(file.name, 0, 0, fileTypeLookup[file.type]);
+			const chunkFile = new ChunkFile(fileTypeLookup[file.type], file.name);
 			chunkFile.group = file.module ?? void 0;
 			if (file.isText) {
 				chunkFile.textData = file.text ?? void 0;
@@ -6140,7 +6176,7 @@ var DbRootUtils = class {
 			projectFiles: projectChunks
 		};
 	}
-	static async applyFolder(root, folderPath, sourceFiles = []) {
+	static async applyFolder(root, folderPath, sourceFiles = [], group) {
 		const chunkFiles = sourceFiles;
 		const folderEntries = await listDirectory(folderPath, { recursive: true });
 		for (const entry of folderEntries) {
@@ -6148,8 +6184,9 @@ var DbRootUtils = class {
 			const type = root.fileExtLookup[entry.extension];
 			if (!type) continue;
 			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 chunkFile = existing ?? new ChunkFile(type, entry.name);
+			if (group) chunkFile.group = group;
+			if (chunkFile.type.isBlock || chunkFile.type.isPatch || chunkFile.type.struct) {
 				const chunkData = await readFileAsText(entry.path);
 				chunkFile.textData = chunkData;
 				chunkFile.size = chunkData.length;
@@ -6178,7 +6215,7 @@ var DbRootUtils = class {
 			const ext = block.type.extension;
 			const filePath = `${outPath}/${block.group ? block.group + "/" : ""}${block.scene ? block.scene + "/" : ""}${block.name}${ext ? "." + ext : ""}`;
 			if (block.parts?.length) {
-				if (!block.textData) block.textData = writer.generateAsm(block);
+				block.textData = writer.generateAsm(block);
 				await saveFileAsText(filePath, block.textData);
 			} else {
 				if (!block.rawData) continue;
@@ -7096,6 +7133,7 @@ async function summaryFromSupabaseByProject(projectName) {
             notes,
             gameRomId,
             platformBranchId,
+            fileTypes,
             createdAt,
             updatedAt,
             gameRom:GameRom!inner(
@@ -7179,6 +7217,20 @@ var RomGenerator = class {
 		this.projectName = projectName;
 		this.crc = crc;
 	}
+	async validateAndLoad(sourceData, gameModule, baseRomPath, modulePath) {
+		const calc = crc32_buffer(sourceData);
+		if (this.crc !== calc) return false;
+		this.dbRoot = DbRootUtils.fromGameModule(gameModule);
+		let moduleFiles = [];
+		for (const entry of await listDirectory(modulePath)) {
+			if (!entry.isDirectory) continue;
+			moduleFiles.push(...await DbRootUtils.applyFolder(this.dbRoot, entry.path, [], entry.name));
+		}
+		this.dbRoot.baseRomFiles = await DbRootUtils.applyFolder(this.dbRoot, baseRomPath);
+		this.dbRoot.projectFiles = moduleFiles;
+		this.sourceData = sourceData;
+		return true;
+	}
 	async validateAndDownload(sourceData) {
 		const calc = crc32_buffer(sourceData);
 		if (this.crc !== calc) return false;
@@ -7192,16 +7244,16 @@ var RomGenerator = class {
 		if (!this.sourceData) throw new Error("Source data not initialized");
 		const reader = new BlockReader(this.sourceData, this.dbRoot);
 		const chunkFiles = reader.analyzeAndResolve();
-		const asmFiles = chunkFiles.filter((b) => b.type.type === "Assembly");
+		const asmFiles = chunkFiles.filter((b) => b.type.isBlock);
 		const patchFiles = [];
 		const writer = new BlockWriter(reader);
-		for (const block of asmFiles) block.textData = writer.generateAsm(block);
+		for (const block of chunkFiles) if (block.parts?.length) block.textData = writer.generateAsm(block);
 		for (const chunkFile of this.dbRoot.baseRomFiles) this.applyPatchFile(chunkFile, chunkFiles, asmFiles, patchFiles);
 		const moduleLookup = this.applyProjectInit(chunkFiles, asmFiles, patchFiles);
 		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);
-		return await new RomWriter(this.dbRoot).repack(chunkFiles);
+		return await new RomWriter(this.dbRoot).repack(chunkFiles, modules);
 	}
 	applyProjectInit(chunkFiles, asmFiles, patchFiles) {
 		const moduleLookup = /* @__PURE__ */ new Map();
@@ -7220,7 +7272,7 @@ var RomGenerator = class {
 		const existing = chunkFiles.find((x) => x.name === chunkFile.name);
 		if (chunkFile.textData) if (existing) existing.textData = chunkFile.textData;
 		else {
-			if (chunkFile.type.type === "Patch") patchFiles.push(chunkFile);
+			if (chunkFile.type.isPatch) patchFiles.push(chunkFile);
 			asmFiles.push(chunkFile);
 			chunkFiles.push(chunkFile);
 		}
@@ -7555,11 +7607,10 @@ exports.base64ToUint8Array = base64ToUint8Array;
 exports.binaryToUtf8String = binaryToUtf8String;
 exports.bytesToHex = bytesToHex;
 exports.clamp = clamp;
+exports.combineHeader = combineHeader;
 exports.crc32_buffer = crc32_buffer;
 exports.crc32_text_utf16 = crc32_text_utf16;
 exports.crc32_text_utf8 = crc32_text_utf8;
-exports.createChunkFileFromDbBlock = createChunkFileFromDbBlock;
-exports.createChunkFileFromDbFile = createChunkFileFromDbFile;
 exports.createDbPath = createDbPath;
 exports.createSupabaseClient = createSupabaseClient;
 exports.createTempDirectory = createTempDirectory;