@gaialabs/core 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -1,309 +1,6 @@
-import { BitStream, RomProcessingConstants, BinType, AddressingMode, RegisterType, Address, DbBlockUtils, BlockReaderConstants, createTableEntry, LocationWrapper, createWord, createByte, StatusFlags, AddressSpace, AddressType, MemberType, readFileAsBinary, DbRootUtils, readJsonFile, getDirectory } from 'gaia-shared';
-import { promises } from 'fs';
-import { join } from 'path';
+import { BitStream, RomProcessingConstants, Op, RegisterType, Address, ChunkFileUtils, BlockReaderConstants, createTableEntry, ChunkFile, BinType, createChunkFileFromDbFile, createChunkFileFromDbBlock, LocationWrapper, CompressionRegistry, Word, Byte, StatusFlags, AddressSpace, AddressType, MemberType, readJsonFile, getDirectory, TypedNumber, AsmBlock, Long, crc32_buffer, DbRootUtils } from '@gaialabs/shared';
 
-// src/api/RomProcessor.ts
-
-// src/sprites/SpriteFrame.ts
-var SpriteFrame = class {
-  constructor(duration = 0, groupIndex = 0, groupOffset = 0) {
-    this.duration = duration;
-    this.groupIndex = groupIndex;
-    this.groupOffset = groupOffset;
-  }
-};
-
-// src/sprites/SpritePart.ts
-var SpritePart = class {
-  constructor() {
-    this.isLarge = false;
-    this.xOffset = 0;
-    this.xOffsetMirror = 0;
-    this.yOffset = 0;
-    this.yOffsetMirror = 0;
-    this.vMirror = false;
-    this.hMirror = false;
-    this.someOffset = 0;
-    this.paletteIndex = 0;
-    this.tileIndex = 0;
-  }
-};
-
-// src/sprites/SpriteGroup.ts
-var SpriteGroup = class {
-  constructor() {
-    this.xOffset = 0;
-    this.xOffsetMirror = 0;
-    this.yOffset = 0;
-    this.yOffsetMirror = 0;
-    this.xRecoilHitboxOffset = 0;
-    this.yRecoilHitboxOffset = 0;
-    this.xRecoilHitboxTilesize = 0;
-    this.yRecoilHitboxTilesize = 0;
-    this.xHostileHitboxOffset = 0;
-    this.xHostileHitboxSize = 0;
-    this.yHostileHitboxOffset = 0;
-    this.yHostileHitboxSize = 0;
-    this.parts = [];
-  }
-};
-
-// src/sprites/SpriteMap.ts
-var SpriteMap = class _SpriteMap {
-  constructor() {
-    this.frameSets = [];
-    this.groups = [];
-  }
-  /**
-   * Create a SpriteMap from binary data
-   * @param data Binary data buffer
-   * @returns SpriteMap instance
-   */
-  static fromBytes(data) {
-    let position = 0;
-    const getByte = () => {
-      if (position >= data.length) return 0;
-      return data[position++];
-    };
-    const getUshort = () => {
-      if (position + 1 >= data.length) return 0;
-      const low = data[position++];
-      const high = data[position++];
-      return low | high << 8;
-    };
-    const spriteMap = new _SpriteMap();
-    const setOffsets = /* @__PURE__ */ new Set();
-    const groupOffsets = /* @__PURE__ */ new Set();
-    position = 0;
-    while (!setOffsets.has(position)) {
-      const offset = getUshort() - 16384;
-      setOffsets.add(offset);
-    }
-    for (const offStart of setOffsets) {
-      position = offStart;
-      const frameList = [];
-      while (true) {
-        const duration = getUshort();
-        if (duration === 65535) {
-          break;
-        }
-        const groupOffset = getUshort() - 16384;
-        frameList.push(new SpriteFrame(duration, 0, groupOffset));
-        groupOffsets.add(groupOffset);
-      }
-      spriteMap.frameSets.push(frameList);
-    }
-    let grpIx = 0;
-    const sortedGroupOffsets = Array.from(groupOffsets).sort((a, b) => a - b);
-    for (const offStart of sortedGroupOffsets) {
-      position = offStart;
-      for (const set of spriteMap.frameSets) {
-        for (const frame of set) {
-          if (frame.groupOffset === offStart) {
-            frame.groupIndex = grpIx;
-          }
-        }
-      }
-      const grp = new SpriteGroup();
-      grp.xOffset = getByte();
-      grp.xOffsetMirror = getByte();
-      grp.yOffset = getByte();
-      grp.yOffsetMirror = getByte();
-      grp.xRecoilHitboxOffset = getByte();
-      grp.yRecoilHitboxOffset = getByte();
-      grp.xRecoilHitboxTilesize = getByte();
-      grp.yRecoilHitboxTilesize = getByte();
-      grp.xHostileHitboxOffset = getByte();
-      grp.xHostileHitboxSize = getByte();
-      grp.yHostileHitboxOffset = getByte();
-      grp.yHostileHitboxSize = getByte();
-      let numParts = getByte();
-      while (numParts-- > 0) {
-        const part = new SpritePart();
-        part.isLarge = getByte() !== 0;
-        part.xOffset = getByte();
-        part.xOffsetMirror = getByte();
-        part.yOffset = getByte();
-        part.yOffsetMirror = getByte();
-        const props = getUshort();
-        part.vMirror = (props & 32768) !== 0;
-        part.hMirror = (props & 16384) !== 0;
-        part.someOffset = props >> 12 & 3;
-        part.paletteIndex = props >> 9 & 7;
-        part.tileIndex = props & 511;
-        grp.parts.push(part);
-      }
-      spriteMap.groups.push(grp);
-      grpIx++;
-    }
-    return spriteMap;
-  }
-  /**
-   * Convert this SpriteMap to binary data
-   * @returns Binary data buffer
-   */
-  toBytes() {
-    let size = this.frameSets.length * 2;
-    for (const set of this.frameSets) {
-      size += set.length * 4 + 2;
-    }
-    for (const grp of this.groups) {
-      size += grp.parts.length * 7 + 13;
-    }
-    const buffer = new Uint8Array(size);
-    let position = 0;
-    const writeShort = (val) => {
-      buffer[position++] = val & 255;
-      buffer[position++] = val >> 8 & 255;
-    };
-    const writeLoc = (val) => writeShort(val + 16384);
-    let pos = this.frameSets.length << 1;
-    const groupPos = new Array(this.groups.length);
-    for (const set of this.frameSets) {
-      writeLoc(pos);
-      pos += (set.length << 2) + 2;
-    }
-    for (let i = 0; i < this.groups.length; i++) {
-      groupPos[i] = pos;
-      pos += this.groups[i].parts.length * 7 + 13;
-    }
-    for (const set of this.frameSets) {
-      for (const frm of set) {
-        writeShort(frm.duration);
-        writeLoc(groupPos[frm.groupIndex]);
-      }
-      writeShort(65535);
-    }
-    for (const grp of this.groups) {
-      buffer[position++] = grp.xOffset;
-      buffer[position++] = grp.xOffsetMirror;
-      buffer[position++] = grp.yOffset;
-      buffer[position++] = grp.yOffsetMirror;
-      buffer[position++] = grp.xRecoilHitboxOffset;
-      buffer[position++] = grp.yRecoilHitboxOffset;
-      buffer[position++] = grp.xRecoilHitboxTilesize;
-      buffer[position++] = grp.yRecoilHitboxTilesize;
-      buffer[position++] = grp.xHostileHitboxOffset;
-      buffer[position++] = grp.xHostileHitboxSize;
-      buffer[position++] = grp.yHostileHitboxOffset;
-      buffer[position++] = grp.yHostileHitboxSize;
-      buffer[position++] = grp.parts.length;
-      for (const prt of grp.parts) {
-        buffer[position++] = prt.isLarge ? 1 : 0;
-        buffer[position++] = prt.xOffset;
-        buffer[position++] = prt.xOffsetMirror;
-        buffer[position++] = prt.yOffset;
-        buffer[position++] = prt.yOffsetMirror;
-        const accum = (prt.vMirror ? 32768 : 0) | (prt.hMirror ? 16384 : 0) | (prt.someOffset & 3) << 12 | (prt.paletteIndex & 7) << 9 | prt.tileIndex;
-        writeShort(accum);
-      }
-    }
-    return buffer.slice(0, position);
-  }
-};
-
-// src/rom/state.ts
-var RomState = class _RomState {
-  constructor() {
-    // Hardware memory buffers
-    this.cgram = new Uint8Array(512);
-    // Color palette RAM
-    this.vram = new Uint8Array(65536);
-    // Video RAM
-    // Tileset data
-    this.mainTileset = new Uint8Array(2048);
-    this.effectTileset = new Uint8Array(2048);
-    // Tilemap data
-    this.mainTilemap = new Uint8Array(8192);
-    this.mainTilemapW = 0;
-    this.mainTilemapH = 0;
-    this.effectTilemap = new Uint8Array(8192);
-    this.effectTilemapW = 0;
-    this.effectTilemapH = 0;
-  }
-  static {
-    // Sprite data
-    this.spriteMap = null;
-  }
-  static {
-    this.spriteMapPath = null;
-  }
-  /**
-   * Strip address space prefixes from names
-   */
-  static stripName(name) {
-    const addressSpace = ["@", "&", "^", "#", "$", "%", "*"];
-    while (name.length > 0 && addressSpace.includes(name[0])) {
-      name = name.substring(1);
-    }
-    return name;
-  }
-  /**
-   * Create ROM state from scene metadata
-   * Simplified version of the C# implementation
-   */
-  static async fromScene(baseDir, root, metaFile, id) {
-    const state = new _RomState();
-    return state;
-  }
-  /**
-   * Process scene command (simplified version)
-   * TODO: Implement full command processing
-   */
-  static async processCommand(state, command, params, getResource) {
-    switch (command) {
-      case 2:
-        break;
-      case 3:
-        break;
-      case 4:
-        break;
-      case 5:
-        break;
-      case 6:
-        break;
-      case 16:
-        if (params.length > 0) {
-          const spritePath = getResource(params[0], BinType.Spritemap);
-          try {
-            const data = await readFileAsBinary(spritePath);
-            _RomState.spriteMap = SpriteMap.fromBytes(data);
-            _RomState.spriteMapPath = spritePath;
-          } catch (error) {
-            console.warn(`Failed to load sprite map: ${spritePath}`, error);
-          }
-        }
-        break;
-    }
-  }
-};
-var RomStateUtils = class {
-  /**
-   * Create empty ROM state
-   */
-  static createEmpty() {
-    return new RomState();
-  }
-  /**
-   * Clear all data in ROM state
-   */
-  static clear(state) {
-    state.cgram.fill(0);
-    state.vram.fill(0);
-    state.mainTileset.fill(0);
-    state.effectTileset.fill(0);
-    state.mainTilemap.fill(0);
-    state.effectTilemap.fill(0);
-    state.mainTilesetPath = void 0;
-    state.effectTilesetPath = void 0;
-    state.mainTilemapPath = void 0;
-    state.effectTilemapPath = void 0;
-    state.mainTilemapW = 0;
-    state.mainTilemapH = 0;
-    state.effectTilemapW = 0;
-    state.effectTilemapH = 0;
-  }
-};
+// src/rom/project.ts
 var QuintetLZ = class _QuintetLZ {
   static {
     this.DICTIONARY_SIZE = 256;
@@ -427,13 +124,111 @@ var QuintetLZ = class _QuintetLZ {
     return outputBuffer.slice(0, finalSize);
   }
 };
+function registerCompressionProviders() {
+  CompressionRegistry.register("QuintetLZ", () => new QuintetLZ());
+}
+registerCompressionProviders();
 
-// src/rom/extraction/processor.ts
-var ProcessorStateManager = class {
-  constructor() {
-    this.accumulatorFlags = /* @__PURE__ */ new Map();
-    this.indexFlags = /* @__PURE__ */ new Map();
-    this.bankNotes = /* @__PURE__ */ new Map();
+// src/rom/project.ts
+var ProjectRoot = class _ProjectRoot {
+  constructor(config) {
+    this.config = config;
+    this.name = config.name;
+    this.romPath = config.romPath;
+    this.baseDir = config.baseDir;
+    this.system = config.system;
+    this.database = config.database;
+    this.flipsPath = config.flipsPath;
+    this.resources = config.resources;
+    this.databasePath = config.databasePath;
+    this.systemPath = config.systemPath;
+    this.compression = config.compression;
+  }
+  /**
+   * Load project from file or directory
+   */
+  static async load(path) {
+    path = path || "./project.json";
+    try {
+      const config = await readJsonFile(path);
+      if (!config.baseDir) {
+        config.baseDir = await getDirectory(path);
+      }
+      return new _ProjectRoot(config);
+    } catch (error) {
+      console.warn(`Failed to load project file: ${error}. Using directory-based configuration.`);
+    }
+    const defaultConfig = {
+      name: "GaiaLabs",
+      baseDir: path,
+      flipsPath: process?.env?.flips_path,
+      romPath: process?.env?.rom_path || "",
+      database: "us",
+      databasePath: `${path}/db/us`,
+      systemPath: `${path}/db/snes`,
+      resources: {}
+    };
+    return new _ProjectRoot(defaultConfig);
+  }
+  // /**
+  //  * Build the ROM (simplified)
+  //  */
+  // public async build(files: ChunkFile[], entryPoints: DbEntryPoint[]): Promise<void> {
+  //   // Build ROM using rebuild writer
+  //   const writer = new RomWriter(entryPoints, this.config.cartName, this.config.makerCode);
+  //   await writer.repack(files);
+  // }
+  /**
+   * Dump database and extract ROM data with comprehensive assembly processing
+   */
+  // public async dumpDatabase(): Promise<ChunkFile[]> {
+  //   // Load database and ROM data
+  //   const root = await DbRootUtils.fromFolder(this.databasePath!, this.systemPath!);
+  //   const rom = await readFileAsBinary(this.romPath);
+  //   //root.paths = this.resources;
+  //   const chunkReader = new BlockReader(rom, root);
+  //   const chunkFiles = chunkReader.analyzeAndResolve();
+  //   const blockWriter = new BlockWriter(chunkReader);
+  //   const writtenFiles = blockWriter.generateAllAsm(chunkFiles);
+  //   return chunkFiles;
+  // }
+};
+
+// src/rom/state.ts
+var RomState = class _RomState {
+  constructor() {
+    // Basic memory buffers
+    this.cgram = new Uint8Array(512);
+    // Color palette RAM
+    this.vram = new Uint8Array(65536);
+  }
+  // Video RAM
+  /**
+   * Create ROM state from scene metadata.
+   * Parameters are currently unused but kept for future implementation.
+   */
+  static async fromScene(_baseDir, _root, _metaFile, _id) {
+    return new _RomState();
+  }
+};
+var RomStateUtils = class {
+  /** Create an empty ROM state */
+  static createEmpty() {
+    return new RomState();
+  }
+  /** Clear all data in the given ROM state */
+  static clear(state) {
+    state.cgram.fill(0);
+    state.vram.fill(0);
+  }
+};
+
+// src/rom/extraction/processor.ts
+var ProcessorStateManager = class {
+  constructor() {
+    this.accumulatorFlags = /* @__PURE__ */ new Map();
+    this.indexFlags = /* @__PURE__ */ new Map();
+    this.bankNotes = /* @__PURE__ */ new Map();
     this.stackPositions = /* @__PURE__ */ new Map();
   }
   /**
@@ -443,15 +238,15 @@ var ProcessorStateManager = class {
   hydrateRegisters(position, reg) {
     const acc = this.accumulatorFlags.get(position);
     if (acc !== void 0) {
-      reg.accumulatorFlag = acc;
+      reg.accumulatorFlag = acc ?? void 0;
     }
     const ind = this.indexFlags.get(position);
     if (ind !== void 0) {
-      reg.indexFlag = ind;
+      reg.indexFlag = ind ?? void 0;
     }
     const bnk = this.bankNotes.get(position);
     if (bnk !== void 0) {
-      reg.dataBank = bnk;
+      reg.dataBank = bnk ?? void 0;
     }
     const stack = this.stackPositions.get(position);
     if (stack !== void 0) {
@@ -811,7 +606,7 @@ var CopCommandProcessor = class {
     for (const partStr of copDef.parts) {
       const addrType = Address.typeFromCode(partStr[0]);
       const isPtr = addrType !== AddressType.Unknown;
-      const referenceType = isPtr ? partStr.substring(1) : this._blockReader._currentPart?.struct ?? "Binary";
+      const referenceType = isPtr ? partStr.substring(1) : this._blockReader._currentAsmBlock.structName ?? "Binary";
       const memberTypeName = isPtr ? addrType.toString() : partStr;
       const memberType = this.tryParseMemberType(memberTypeName);
       if (memberType === null) {
@@ -851,9 +646,9 @@ var CopCommandProcessor = class {
   readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType) {
     switch (memberType) {
       case MemberType.Byte:
-        return createByte(this._romDataReader.readByte());
+        return new Byte(this._romDataReader.readByte());
       case MemberType.Word:
-        return createWord(this._romDataReader.readUShort());
+        return new Word(this._romDataReader.readUShort());
       case MemberType.Offset:
         return this.createCopLocation(this._romDataReader.readUShort(), null, partStr, isPtr, referenceType, addrType);
       case MemberType.Address:
@@ -864,7 +659,7 @@ var CopCommandProcessor = class {
   }
   createCopLocation(offset, bank, partStr, isPtr, otherStr, type) {
     if (bank === null && offset === 0) {
-      return createWord(offset);
+      return new Word(offset);
     }
     const addr = new Address(bank ?? this._romDataReader.position >> 16, offset);
     if (addr.space === AddressSpace.ROM) {
@@ -910,51 +705,54 @@ var AddressingModeHandler = class {
   processAddressingMode(code, context, reg) {
     const operands = [];
     switch (code.mode) {
-      case AddressingMode.Stack:
-      case AddressingMode.Implied:
+      case "Stack":
+      case "Implied":
+      case "Accumulator":
         this.handleStackOrImpliedMode(code.mnem, reg);
         break;
-      case AddressingMode.Immediate:
+      case "Immediate":
         this.handleImmediateMode(code.mnem, context.size, operands, reg);
         break;
-      case AddressingMode.AbsoluteIndirect:
-      case AddressingMode.AbsoluteIndirectLong:
-      case AddressingMode.AbsoluteIndexedIndirect:
-      case AddressingMode.Absolute:
-      case AddressingMode.AbsoluteIndexedX:
-      case AddressingMode.AbsoluteIndexedY:
+      case "AbsoluteIndirect":
+      case "AbsoluteIndirectLong":
+      case "AbsoluteIndexedIndirect":
+      case "Absolute":
+      case "AbsoluteIndexedX":
+      case "AbsoluteIndexedY":
         this.handleAbsoluteMode(code.mnem, void 0, context.nextAddress, reg.dataBank, operands, reg);
         break;
-      case AddressingMode.AbsoluteLong:
-      case AddressingMode.AbsoluteLongIndexedX:
+      case "AbsoluteLong":
+      case "AbsoluteLongIndexedX":
         this.handleAbsoluteLongMode(code.mnem, operands, reg);
         break;
-      case AddressingMode.BlockMove:
+      case "BlockMove":
         this.handleBlockMoveMode(operands, context);
         break;
-      case AddressingMode.DirectPage:
-      case AddressingMode.DirectPageIndexedIndirectX:
-      case AddressingMode.DirectPageIndexedX:
-      case AddressingMode.DirectPageIndexedY:
-      case AddressingMode.DirectPageIndirect:
-      case AddressingMode.DirectPageIndirectIndexedY:
-      case AddressingMode.DirectPageIndirectLong:
-      case AddressingMode.DirectPageIndirectLongIndexedY:
+      case "DirectPage":
+      case "DirectPageIndexedIndirectX":
+      case "DirectPageIndexedX":
+      case "DirectPageIndexedY":
+      case "DirectPageIndirect":
+      case "DirectPageIndirectIndexedY":
+      case "DirectPageIndirectLong":
+      case "DirectPageIndirectLongIndexedY":
         this.handleDirectPageMode(operands);
         break;
-      case AddressingMode.PCRelative:
+      case "PCRelative":
         this.handlePCRelativeMode(operands, context.nextAddress, reg, false);
         break;
-      case AddressingMode.PCRelativeLong:
+      case "PCRelativeLong":
         this.handlePCRelativeMode(operands, context.nextAddress, reg, true);
         break;
-      case AddressingMode.StackRelative:
-      case AddressingMode.StackRelativeIndirectIndexedY:
+      case "StackRelative":
+      case "StackRelativeIndirectIndexedY":
         this.handleStackRelativeMode(operands);
         break;
-      case AddressingMode.StackInterrupt:
+      case "StackInterrupt":
         this.handleStackInterruptMode(code.mnem, operands, context);
         break;
+      default:
+        throw new Error(`Unknown addressing mode: ${code}`);
     }
     return operands;
   }
@@ -964,7 +762,7 @@ var AddressingModeHandler = class {
     this.updateRegisterForImmediateInstruction(mnemonic, operand, reg);
   }
   readImmediateOperand(size) {
-    return size === 3 ? createWord(this._dataReader.readUShort()) : createByte(this._dataReader.readByte());
+    return size === 3 ? new Word(this._dataReader.readUShort()) : new Byte(this._dataReader.readByte());
   }
   updateRegisterForImmediateInstruction(mnemonic, operand, reg) {
     const value = typeof operand === "number" ? operand : operand.value;
@@ -1016,12 +814,12 @@ var AddressingModeHandler = class {
     }
   }
   handleBlockMoveMode(operands, context) {
-    operands.push(createByte(this._dataReader.readByte()));
+    operands.push(new Byte(this._dataReader.readByte()));
     context.xForm2 = this._transformProcessor.getTransform();
-    operands.push(createByte(this._dataReader.readByte()));
+    operands.push(new Byte(this._dataReader.readByte()));
   }
   handleDirectPageMode(operands) {
-    operands.push(createByte(this._dataReader.readByte()));
+    operands.push(new Byte(this._dataReader.readByte()));
   }
   handlePCRelativeMode(operands, nextAddress, reg, isLong) {
     const relative = isLong ? nextAddress + this._dataReader.readShort() : nextAddress + this._dataReader.readSByte();
@@ -1029,11 +827,11 @@ var AddressingModeHandler = class {
     operands.push(new LocationWrapper(relative, AddressType.Relative));
   }
   handleStackRelativeMode(operands) {
-    operands.push(createByte(this._dataReader.readByte()));
+    operands.push(new Byte(this._dataReader.readByte()));
   }
   handleStackInterruptMode(mnemonic, operands, context) {
     const cmd = this._dataReader.readByte();
-    operands.push(cmd);
+    operands.push(new Byte(cmd));
     if (mnemonic === "COP") {
       const copDef = this._blockReader._root.copDef[cmd];
       if (!copDef) {
@@ -1167,169 +965,6 @@ var TransformProcessor = class _TransformProcessor {
     return match ? parseInt(match[1], 16) : null;
   }
 };
-var SfxReader = class {
-  constructor(romData, dbRoot) {
-    this._romData = romData;
-    this._dbRoot = dbRoot;
-    this._location = dbRoot.config.sfxLocation;
-    this._count = dbRoot.config.sfxCount;
-  }
-  /**
-   * Reads a byte from the rom data
-   */
-  readByte() {
-    if ((this._location & Address.UPPER_BANK) !== 0) {
-      this._location += Address.UPPER_BANK;
-    }
-    return this._romData[this._location++];
-  }
-  /**
-   * Reads a short from the rom data
-   */
-  readShort() {
-    return this.readByte() | this.readByte() << 8;
-  }
-  /**
-   * Extracts the sfx from the rom data to the given output path
-   */
-  async extract(outPath) {
-    const res = this.getPath(BinType.Sound);
-    if (res?.folder) {
-      outPath = `${outPath}/${res.folder}`;
-    }
-    const isNode = typeof window === "undefined";
-    const fs2 = isNode ? await import('fs') : null;
-    if (isNode) {
-      fs2.mkdirSync(outPath, { recursive: true });
-    }
-    for (let i = 0; i < this._count; i++) {
-      const size = this.readShort();
-      const filePath = `${outPath}/sfx${i.toString(16).padStart(2, "0").toUpperCase()}.${res?.extension || "bin"}`;
-      if (isNode) {
-        if (fs2.existsSync(filePath)) {
-          this._location += size;
-        } else {
-          const sfxData = new Uint8Array(size);
-          for (let x = 0; x < size; x++) {
-            sfxData[x] = this.readByte();
-          }
-          fs2.writeFileSync(filePath, sfxData);
-        }
-      } else {
-        this._location += size;
-      }
-    }
-  }
-  /**
-   * Gets the path information for a binary type
-   * TODO: This should be implemented in DbRoot
-   */
-  getPath(binType) {
-    switch (binType) {
-      case BinType.Sound:
-        return { folder: "sound", extension: "sfc" };
-      default:
-        return null;
-    }
-  }
-};
-var FileReader = class _FileReader {
-  static {
-    this.PALETTE_MIN_SIZE = 512;
-  }
-  constructor(romData, dbRoot, provider) {
-    this._romData = romData;
-    this._dbRoot = dbRoot;
-    this._compression = provider;
-  }
-  /**
-   * Extracts all files from the ROM to the given output path
-   */
-  async extract(outPath) {
-    const isNode = typeof window === "undefined";
-    const fs2 = isNode ? await import('fs') : null;
-    for (const file of this._dbRoot.files) {
-      let start = file.start;
-      const res = this.getPath(file.type);
-      let filePath = outPath;
-      if (res.folder) {
-        filePath = `${outPath}/${res.folder}`;
-        if (isNode) {
-          fs2.mkdirSync(filePath, { recursive: true });
-        }
-      }
-      filePath = `${filePath}/${file.name}.${res.extension}`;
-      if (isNode && fs2.existsSync(filePath)) {
-        continue;
-      }
-      let header = null;
-      if (file.type === BinType.Tilemap) {
-        header = new Uint8Array([this._romData[start++], this._romData[start++]]);
-      } else if (file.type === BinType.Meta17) {
-        header = new Uint8Array([
-          this._romData[start++],
-          this._romData[start++],
-          this._romData[start++],
-          this._romData[start++]
-        ]);
-      }
-      let length = file.end - start;
-      let fileData;
-      if (file.compressed === true) {
-        const data = this._compression.expand(this._romData, start, length);
-        fileData = this.processFileData(data, 0, data.length, header, file.type);
-      } else {
-        if (file.compressed !== null) {
-          start += 2;
-          length -= 2;
-        }
-        fileData = this.processFileData(this._romData, start, length, header, file.type);
-      }
-      if (isNode) {
-        fs2.writeFileSync(filePath, fileData);
-      }
-    }
-  }
-  processFileData(data, position, length, header, type) {
-    let totalLength = length;
-    let headerLength = 0;
-    if (header) {
-      headerLength = header.length;
-      totalLength += headerLength;
-    }
-    if (type === BinType.Palette) {
-      const remain = _FileReader.PALETTE_MIN_SIZE - length;
-      if (remain > 0) {
-        totalLength += remain;
-      }
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    if (header) {
-      result.set(header, offset);
-      offset += headerLength;
-    }
-    result.set(data.slice(position, position + length), offset);
-    offset += length;
-    if (type === BinType.Palette) {
-      const remain = _FileReader.PALETTE_MIN_SIZE - length;
-      if (remain > 0) {
-        result.fill(0, offset, offset + remain);
-      }
-    }
-    return result;
-  }
-  /**
-   * Gets the path information for a binary type from DbRoot configuration
-   */
-  getPath(binType) {
-    const pathConfig = this._dbRoot.paths[binType] || this._dbRoot.paths[BinType.Unknown];
-    return {
-      folder: pathConfig.folder,
-      extension: pathConfig.extension
-    };
-  }
-};
 
 // src/utils/index.ts
 function indexOfAny(str, chars, startIndex = 0) {
@@ -1480,12 +1115,11 @@ var StringReader = class _StringReader {
               }
               name.substring(0, opix);
               const target = sloc - offset;
-              const [isOutside, prt] = DbBlockUtils.isOutsideWithPart(this._blockReader._currentBlock, sloc);
-              if (prt != null) {
-                const root = prt.objectRoot;
-                const entry = root?.find((x) => x.Location === target);
-                if (entry && entry.Object) {
-                  entry.Object.marker = 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;
                 }
               }
             }
@@ -1519,9 +1153,9 @@ var TypeParser = class {
     if (mType !== null) {
       switch (mType) {
         case MemberType.Byte:
-          return createByte(this._romDataReader.readByte());
+          return new Byte(this._romDataReader.readByte());
         case MemberType.Word:
-          return createWord(this.parseWordSafe());
+          return new Word(this.parseWordSafe());
         case MemberType.Offset:
           return this.parseLocation(this._romDataReader.readUShort(), bank, null, AddressType.Offset);
         case MemberType.Address:
@@ -1563,7 +1197,7 @@ var TypeParser = class {
         const parts = new Array(memberCount);
         const def = { name: targetType.name, parts };
         for (let i = 0; i < memberCount; i++) {
-          parts[i] = this.parseType(types[i], null, depth + 1);
+          parts[i] = this.parseType(types[i], null, depth + 1, bank);
         }
         if (discOffset !== void 0 && discOffset === this._romDataReader.position - prevPosition) {
           this._romDataReader.position++;
@@ -1611,8 +1245,8 @@ var TypeParser = class {
     return outBuffer;
   }
   parseLocation(offset, bank, typeName, addrType) {
-    if (bank === void 0 && offset === 0) {
-      return createWord(offset);
+    if ((bank === void 0 || bank === null) && offset === 0) {
+      return new Word(offset);
     }
     const resolvedBank = bank ?? this._romDataReader.position >> 16;
     const adrs = new Address(resolvedBank, offset);
@@ -1620,8 +1254,8 @@ var TypeParser = class {
       return adrs;
     }
     const loc = adrs.toInt();
-    if (this._blockReader._currentBlock && DbBlockUtils.isInside(this._blockReader._currentBlock, loc) && !this._blockReader._root.rewrites[loc]) {
-      const resolvedTypeName = typeName ?? this._blockReader._currentPart?.struct ?? "Binary";
+    if (this._blockReader._currentChunk && ChunkFileUtils.isInside(this._blockReader._currentChunk, loc) && !this._blockReader._root.rewrites[loc]) {
+      const resolvedTypeName = typeName ?? this._blockReader._currentAsmBlock.structName ?? "Binary";
       this._referenceManager.tryAddStruct(loc, resolvedTypeName);
       const referenceName = `${resolvedTypeName.toLowerCase()}_${loc.toString(16).toUpperCase().padStart(6, "0")}`;
       this._referenceManager.tryAddName(loc, referenceName);
@@ -1638,7 +1272,7 @@ var TypeParser = class {
         break;
       }
       if (reg) {
-        this._blockReader.HydrateRegisters(reg);
+        this._blockReader.hydrateRegisters(reg);
       }
       const op = this._blockReader._asmReader.parseAsm(reg);
       opList.push(op);
@@ -1646,6 +1280,93 @@ var TypeParser = class {
     return opList;
   }
 };
+var AsmReader = class _AsmReader {
+  static {
+    // Constants
+    this.PROCESSOR_FLAG_MASK = 223;
+  }
+  static {
+    this.ACCUMULATOR_OP_MASK = 15;
+  }
+  static {
+    this.ACCUMULATOR_OP_VALUE = 9;
+  }
+  static {
+    this.VARIABLE_SIZE_INDICATOR = -2;
+  }
+  static {
+    this.TWO_BYTES_SIZE = 2;
+  }
+  static {
+    this.THREE_BYTES_SIZE = 3;
+  }
+  constructor(blockReader) {
+    this._blockReader = blockReader;
+    this._transformProcessor = new TransformProcessor(blockReader);
+    this._addressingModeHandler = new AddressingModeHandler(blockReader, this._transformProcessor);
+    this._romDataReader = blockReader._romDataReader;
+  }
+  parseAsm(reg) {
+    const opStart = this._romDataReader.position;
+    const opCode = this._romDataReader.readByte();
+    const code = this._blockReader._root.opCodes[opCode];
+    if (!code) {
+      throw new Error("Unknown OpCode");
+    }
+    const operationContext = this.initializeOperation(code, reg, opStart);
+    const operands = this._addressingModeHandler.processAddressingMode(code, operationContext, reg);
+    this._transformProcessor.applyTransforms(operationContext.xForm1, operationContext.xForm2, operands);
+    const op = new Op(
+      code,
+      opStart,
+      operands,
+      this._romDataReader.position - opStart
+    );
+    if (operationContext.copDef) {
+      op.copDef = operationContext.copDef;
+    }
+    return op;
+  }
+  clearDestinationRegister(code, reg) {
+    switch (code.mnem) {
+      case "LDA":
+        reg.accumulator = void 0;
+        break;
+      case "LDX":
+        reg.xIndex = void 0;
+        break;
+      case "LDY":
+        reg.yIndex = void 0;
+        break;
+    }
+  }
+  initializeOperation(code, reg, loc) {
+    const size = this.calculateInstructionSize(code, reg);
+    const next = loc + size;
+    this.clearDestinationRegister(code, reg);
+    const context = new OperationContext();
+    context.size = size;
+    context.nextAddress = next;
+    context.xForm1 = this._transformProcessor.getTransform();
+    context.xForm2 = null;
+    context.copDef = null;
+    return context;
+  }
+  calculateInstructionSize(code, reg) {
+    const addrMode = this._blockReader._root.addrLookup[code.mode];
+    let size = addrMode.size;
+    if (size === _AsmReader.VARIABLE_SIZE_INDICATOR || code.mode === "Immediate") {
+      if ((code.code & _AsmReader.PROCESSOR_FLAG_MASK) === 194) {
+        size = _AsmReader.TWO_BYTES_SIZE;
+      } else if ((code.code & _AsmReader.ACCUMULATOR_OP_MASK) === _AsmReader.ACCUMULATOR_OP_VALUE) {
+        size = reg.accumulatorFlag ?? false ? _AsmReader.TWO_BYTES_SIZE : _AsmReader.THREE_BYTES_SIZE;
+      } else {
+        size = reg.indexFlag ?? false ? _AsmReader.TWO_BYTES_SIZE : _AsmReader.THREE_BYTES_SIZE;
+      }
+    }
+    return size;
+  }
+};
 
 // src/assembly/Stack.ts
 var Stack = class {
@@ -1726,510 +1447,49 @@ var Registers = class {
     this.stack.reset();
   }
 };
-
-// src/assembly/Op.ts
-var Op = class {
-  constructor(code, location = 0, operands = [], size = 1) {
-    this.code = code;
-    this.location = location;
-    this.operands = operands;
-    this.size = size;
-  }
-  /**
-   * Get the formatted string representation of this operation
-   */
-  toString() {
-    const mnem = this.code.mnem;
-    const op = this.operands;
-    if (!op || op.length === 0) {
-      return mnem;
-    }
-    const operandStrings = op.map((operand) => String(operand));
-    return `${mnem} ${operandStrings.join(", ")}`;
-  }
-};
-var OpCode = class {
-  constructor(code, mnem, mode, size) {
-    this.code = code;
-    this.mnem = mnem;
-    this.mode = mode;
-    this.size = size;
-  }
-};
-var ALL_OPCODES = {
-  // ADC - Add with Carry
-  105: new OpCode(105, "ADC", AddressingMode.Immediate, -2),
-  109: new OpCode(109, "ADC", AddressingMode.Absolute, 3),
-  111: new OpCode(111, "ADC", AddressingMode.AbsoluteLong, 4),
-  101: new OpCode(101, "ADC", AddressingMode.DirectPage, 2),
-  114: new OpCode(114, "ADC", AddressingMode.DirectPageIndirect, 2),
-  103: new OpCode(103, "ADC", AddressingMode.DirectPageIndirectLong, 2),
-  125: new OpCode(125, "ADC", AddressingMode.AbsoluteIndexedX, 3),
-  127: new OpCode(127, "ADC", AddressingMode.AbsoluteLongIndexedX, 4),
-  121: new OpCode(121, "ADC", AddressingMode.AbsoluteIndexedY, 3),
-  117: new OpCode(117, "ADC", AddressingMode.DirectPageIndexedX, 2),
-  97: new OpCode(97, "ADC", AddressingMode.DirectPageIndexedIndirectX, 2),
-  113: new OpCode(113, "ADC", AddressingMode.DirectPageIndirectIndexedY, 2),
-  119: new OpCode(119, "ADC", AddressingMode.DirectPageIndirectLongIndexedY, 2),
-  99: new OpCode(99, "ADC", AddressingMode.StackRelative, 2),
-  115: new OpCode(115, "ADC", AddressingMode.StackRelativeIndirectIndexedY, 2),
-  // AND - Logical AND
-  41: new OpCode(41, "AND", AddressingMode.Immediate, -2),
-  45: new OpCode(45, "AND", AddressingMode.Absolute, 3),
-  47: new OpCode(47, "AND", AddressingMode.AbsoluteLong, 4),
-  37: new OpCode(37, "AND", AddressingMode.DirectPage, 2),
-  50: new OpCode(50, "AND", AddressingMode.DirectPageIndirect, 2),
-  39: new OpCode(39, "AND", AddressingMode.DirectPageIndirectLong, 2),
-  61: new OpCode(61, "AND", AddressingMode.AbsoluteIndexedX, 3),
-  63: new OpCode(63, "AND", AddressingMode.AbsoluteLongIndexedX, 4),
-  57: new OpCode(57, "AND", AddressingMode.AbsoluteIndexedY, 3),
-  53: new OpCode(53, "AND", AddressingMode.DirectPageIndexedX, 2),
-  33: new OpCode(33, "AND", AddressingMode.DirectPageIndexedIndirectX, 2),
-  49: new OpCode(49, "AND", AddressingMode.DirectPageIndirectIndexedY, 2),
-  55: new OpCode(55, "AND", AddressingMode.DirectPageIndirectLongIndexedY, 2),
-  35: new OpCode(35, "AND", AddressingMode.StackRelative, 2),
-  51: new OpCode(51, "AND", AddressingMode.StackRelativeIndirectIndexedY, 2),
-  // ASL - Arithmetic Shift Left
-  10: new OpCode(10, "ASL", AddressingMode.Accumulator, 1),
-  14: new OpCode(14, "ASL", AddressingMode.Absolute, 3),
-  6: new OpCode(6, "ASL", AddressingMode.DirectPage, 2),
-  30: new OpCode(30, "ASL", AddressingMode.AbsoluteIndexedX, 3),
-  22: new OpCode(22, "ASL", AddressingMode.DirectPageIndexedX, 2),
-  // Branch instructions
-  16: new OpCode(16, "BPL", AddressingMode.PCRelative, 2),
-  48: new OpCode(48, "BMI", AddressingMode.PCRelative, 2),
-  128: new OpCode(128, "BRA", AddressingMode.PCRelative, 2),
-  130: new OpCode(130, "BRL", AddressingMode.PCRelativeLong, 3),
-  144: new OpCode(144, "BCC", AddressingMode.PCRelative, 2),
-  176: new OpCode(176, "BCS", AddressingMode.PCRelative, 2),
-  208: new OpCode(208, "BNE", AddressingMode.PCRelative, 2),
-  240: new OpCode(240, "BEQ", AddressingMode.PCRelative, 2),
-  80: new OpCode(80, "BVC", AddressingMode.PCRelative, 2),
-  112: new OpCode(112, "BVS", AddressingMode.PCRelative, 2),
-  // BIT - Bit Test
-  137: new OpCode(137, "BIT", AddressingMode.Immediate, -2),
-  44: new OpCode(44, "BIT", AddressingMode.Absolute, 3),
-  36: new OpCode(36, "BIT", AddressingMode.DirectPage, 2),
-  60: new OpCode(60, "BIT", AddressingMode.AbsoluteIndexedX, 3),
-  52: new OpCode(52, "BIT", AddressingMode.DirectPageIndexedX, 2),
-  // BRK - Break
-  0: new OpCode(0, "BRK", AddressingMode.StackInterrupt, 2),
-  // Clear flag instructions
-  24: new OpCode(24, "CLC", AddressingMode.Implied, 1),
-  216: new OpCode(216, "CLD", AddressingMode.Implied, 1),
-  88: new OpCode(88, "CLI", AddressingMode.Implied, 1),
-  184: new OpCode(184, "CLV", AddressingMode.Implied, 1),
-  // CMP - Compare Accumulator
-  201: new OpCode(201, "CMP", AddressingMode.Immediate, -2),
-  205: new OpCode(205, "CMP", AddressingMode.Absolute, 3),
-  207: new OpCode(207, "CMP", AddressingMode.AbsoluteLong, 4),
-  197: new OpCode(197, "CMP", AddressingMode.DirectPage, 2),
-  210: new OpCode(210, "CMP", AddressingMode.DirectPageIndirect, 2),
-  199: new OpCode(199, "CMP", AddressingMode.DirectPageIndirectLong, 2),
-  221: new OpCode(221, "CMP", AddressingMode.AbsoluteIndexedX, 3),
-  223: new OpCode(223, "CMP", AddressingMode.AbsoluteLongIndexedX, 4),
-  217: new OpCode(217, "CMP", AddressingMode.AbsoluteIndexedY, 3),
-  213: new OpCode(213, "CMP", AddressingMode.DirectPageIndexedX, 2),
-  193: new OpCode(193, "CMP", AddressingMode.DirectPageIndexedIndirectX, 2),
-  209: new OpCode(209, "CMP", AddressingMode.DirectPageIndirectIndexedY, 2),
-  215: new OpCode(215, "CMP", AddressingMode.DirectPageIndirectLongIndexedY, 2),
-  195: new OpCode(195, "CMP", AddressingMode.StackRelative, 2),
-  211: new OpCode(211, "CMP", AddressingMode.StackRelativeIndirectIndexedY, 2),
-  // COP - Coprocessor Instruction
-  2: new OpCode(2, "COP", AddressingMode.StackInterrupt, 2),
-  // CPX - Compare X Register
-  224: new OpCode(224, "CPX", AddressingMode.Immediate, -2),
-  236: new OpCode(236, "CPX", AddressingMode.Absolute, 3),
-  228: new OpCode(228, "CPX", AddressingMode.DirectPage, 2),
-  // CPY - Compare Y Register
-  192: new OpCode(192, "CPY", AddressingMode.Immediate, -2),
-  204: new OpCode(204, "CPY", AddressingMode.Absolute, 3),
-  196: new OpCode(196, "CPY", AddressingMode.DirectPage, 2),
-  // DEC - Decrement
-  58: new OpCode(58, "DEC", AddressingMode.Accumulator, 1),
-  206: new OpCode(206, "DEC", AddressingMode.Absolute, 3),
-  198: new OpCode(198, "DEC", AddressingMode.DirectPage, 2),
-  222: new OpCode(222, "DEC", AddressingMode.AbsoluteIndexedX, 3),
-  214: new OpCode(214, "DEC", AddressingMode.DirectPageIndexedX, 2),
-  // DEX/DEY - Decrement Index Registers
-  202: new OpCode(202, "DEX", AddressingMode.Implied, 1),
-  136: new OpCode(136, "DEY", AddressingMode.Implied, 1),
-  // EOR - Exclusive OR
-  73: new OpCode(73, "EOR", AddressingMode.Immediate, -2),
-  77: new OpCode(77, "EOR", AddressingMode.Absolute, 3),
-  79: new OpCode(79, "EOR", AddressingMode.AbsoluteLong, 4),
-  69: new OpCode(69, "EOR", AddressingMode.DirectPage, 2),
-  82: new OpCode(82, "EOR", AddressingMode.DirectPageIndirect, 2),
-  71: new OpCode(71, "EOR", AddressingMode.DirectPageIndirectLong, 2),
-  93: new OpCode(93, "EOR", AddressingMode.AbsoluteIndexedX, 3),
-  95: new OpCode(95, "EOR", AddressingMode.AbsoluteLongIndexedX, 4),
-  89: new OpCode(89, "EOR", AddressingMode.AbsoluteIndexedY, 3),
-  85: new OpCode(85, "EOR", AddressingMode.DirectPageIndexedX, 2),
-  65: new OpCode(65, "EOR", AddressingMode.DirectPageIndexedIndirectX, 2),
-  81: new OpCode(81, "EOR", AddressingMode.DirectPageIndirectIndexedY, 2),
-  87: new OpCode(87, "EOR", AddressingMode.DirectPageIndirectLongIndexedY, 2),
-  67: new OpCode(67, "EOR", AddressingMode.StackRelative, 2),
-  83: new OpCode(83, "EOR", AddressingMode.StackRelativeIndirectIndexedY, 2),
-  // INC - Increment
-  26: new OpCode(26, "INC", AddressingMode.Accumulator, 1),
-  238: new OpCode(238, "INC", AddressingMode.Absolute, 3),
-  230: new OpCode(230, "INC", AddressingMode.DirectPage, 2),
-  254: new OpCode(254, "INC", AddressingMode.AbsoluteIndexedX, 3),
-  246: new OpCode(246, "INC", AddressingMode.DirectPageIndexedX, 2),
-  // INX/INY - Increment Index Registers
-  232: new OpCode(232, "INX", AddressingMode.Implied, 1),
-  200: new OpCode(200, "INY", AddressingMode.Implied, 1),
-  // JMP/JML - Jump
-  76: new OpCode(76, "JMP", AddressingMode.Absolute, 3),
-  108: new OpCode(108, "JMP", AddressingMode.AbsoluteIndirect, 3),
-  124: new OpCode(124, "JMP", AddressingMode.AbsoluteIndexedIndirect, 3),
-  92: new OpCode(92, "JML", AddressingMode.AbsoluteLong, 4),
-  220: new OpCode(220, "JML", AddressingMode.AbsoluteIndirectLong, 3),
-  // JSR/JSL - Jump to Subroutine
-  32: new OpCode(32, "JSR", AddressingMode.Absolute, 3),
-  252: new OpCode(252, "JSR", AddressingMode.AbsoluteIndexedIndirect, 3),
-  34: new OpCode(34, "JSL", AddressingMode.AbsoluteLong, 4),
-  // LDA - Load Accumulator
-  169: new OpCode(169, "LDA", AddressingMode.Immediate, -2),
-  173: new OpCode(173, "LDA", AddressingMode.Absolute, 3),
-  175: new OpCode(175, "LDA", AddressingMode.AbsoluteLong, 4),
-  165: new OpCode(165, "LDA", AddressingMode.DirectPage, 2),
-  178: new OpCode(178, "LDA", AddressingMode.DirectPageIndirect, 2),
-  167: new OpCode(167, "LDA", AddressingMode.DirectPageIndirectLong, 2),
-  189: new OpCode(189, "LDA", AddressingMode.AbsoluteIndexedX, 3),
-  191: new OpCode(191, "LDA", AddressingMode.AbsoluteLongIndexedX, 4),
-  185: new OpCode(185, "LDA", AddressingMode.AbsoluteIndexedY, 3),
-  181: new OpCode(181, "LDA", AddressingMode.DirectPageIndexedX, 2),
-  161: new OpCode(161, "LDA", AddressingMode.DirectPageIndexedIndirectX, 2),
-  177: new OpCode(177, "LDA", AddressingMode.DirectPageIndirectIndexedY, 2),
-  183: new OpCode(183, "LDA", AddressingMode.DirectPageIndirectLongIndexedY, 2),
-  163: new OpCode(163, "LDA", AddressingMode.StackRelative, 2),
-  179: new OpCode(179, "LDA", AddressingMode.StackRelativeIndirectIndexedY, 2),
-  // LDX - Load X Register
-  162: new OpCode(162, "LDX", AddressingMode.Immediate, -2),
-  174: new OpCode(174, "LDX", AddressingMode.Absolute, 3),
-  166: new OpCode(166, "LDX", AddressingMode.DirectPage, 2),
-  190: new OpCode(190, "LDX", AddressingMode.AbsoluteIndexedY, 3),
-  182: new OpCode(182, "LDX", AddressingMode.DirectPageIndexedY, 2),
-  // LDY - Load Y Register
-  160: new OpCode(160, "LDY", AddressingMode.Immediate, -2),
-  172: new OpCode(172, "LDY", AddressingMode.Absolute, 3),
-  164: new OpCode(164, "LDY", AddressingMode.DirectPage, 2),
-  188: new OpCode(188, "LDY", AddressingMode.AbsoluteIndexedX, 3),
-  180: new OpCode(180, "LDY", AddressingMode.DirectPageIndexedX, 2),
-  // LSR - Logical Shift Right
-  74: new OpCode(74, "LSR", AddressingMode.Accumulator, 1),
-  78: new OpCode(78, "LSR", AddressingMode.Absolute, 3),
-  70: new OpCode(70, "LSR", AddressingMode.DirectPage, 2),
-  94: new OpCode(94, "LSR", AddressingMode.AbsoluteIndexedX, 3),
-  86: new OpCode(86, "LSR", AddressingMode.DirectPageIndexedX, 2),
-  // MVN/MVP - Block Move
-  84: new OpCode(84, "MVN", AddressingMode.BlockMove, 3),
-  68: new OpCode(68, "MVP", AddressingMode.BlockMove, 3),
-  // NOP - No Operation
-  234: new OpCode(234, "NOP", AddressingMode.Implied, 1),
-  // ORA - Logical OR
-  9: new OpCode(9, "ORA", AddressingMode.Immediate, -2),
-  13: new OpCode(13, "ORA", AddressingMode.Absolute, 3),
-  15: new OpCode(15, "ORA", AddressingMode.AbsoluteLong, 4),
-  5: new OpCode(5, "ORA", AddressingMode.DirectPage, 2),
-  18: new OpCode(18, "ORA", AddressingMode.DirectPageIndirect, 2),
-  7: new OpCode(7, "ORA", AddressingMode.DirectPageIndirectLong, 2),
-  29: new OpCode(29, "ORA", AddressingMode.AbsoluteIndexedX, 3),
-  31: new OpCode(31, "ORA", AddressingMode.AbsoluteLongIndexedX, 4),
-  25: new OpCode(25, "ORA", AddressingMode.AbsoluteIndexedY, 3),
-  21: new OpCode(21, "ORA", AddressingMode.DirectPageIndexedX, 2),
-  1: new OpCode(1, "ORA", AddressingMode.DirectPageIndexedIndirectX, 2),
-  17: new OpCode(17, "ORA", AddressingMode.DirectPageIndirectIndexedY, 2),
-  23: new OpCode(23, "ORA", AddressingMode.DirectPageIndirectLongIndexedY, 2),
-  3: new OpCode(3, "ORA", AddressingMode.StackRelative, 2),
-  19: new OpCode(19, "ORA", AddressingMode.StackRelativeIndirectIndexedY, 2),
-  // Push instructions
-  244: new OpCode(244, "PEA", AddressingMode.Absolute, 3),
-  212: new OpCode(212, "PEI", AddressingMode.DirectPageIndirect, 2),
-  98: new OpCode(98, "PER", AddressingMode.PCRelativeLong, 3),
-  72: new OpCode(72, "PHA", AddressingMode.Stack, 1),
-  139: new OpCode(139, "PHB", AddressingMode.Stack, 1),
-  11: new OpCode(11, "PHD", AddressingMode.Stack, 1),
-  75: new OpCode(75, "PHK", AddressingMode.Stack, 1),
-  8: new OpCode(8, "PHP", AddressingMode.Stack, 1),
-  218: new OpCode(218, "PHX", AddressingMode.Stack, 1),
-  90: new OpCode(90, "PHY", AddressingMode.Stack, 1),
-  // Pull instructions
-  104: new OpCode(104, "PLA", AddressingMode.Stack, 1),
-  171: new OpCode(171, "PLB", AddressingMode.Stack, 1),
-  43: new OpCode(43, "PLD", AddressingMode.Stack, 1),
-  40: new OpCode(40, "PLP", AddressingMode.Stack, 1),
-  250: new OpCode(250, "PLX", AddressingMode.Stack, 1),
-  122: new OpCode(122, "PLY", AddressingMode.Stack, 1),
-  // REP - Reset Status Bits
-  194: new OpCode(194, "REP", AddressingMode.Immediate, 2),
-  // ROL - Rotate Left
-  42: new OpCode(42, "ROL", AddressingMode.Accumulator, 1),
-  46: new OpCode(46, "ROL", AddressingMode.Absolute, 3),
-  38: new OpCode(38, "ROL", AddressingMode.DirectPage, 2),
-  62: new OpCode(62, "ROL", AddressingMode.AbsoluteIndexedX, 3),
-  54: new OpCode(54, "ROL", AddressingMode.DirectPageIndexedX, 2),
-  // ROR - Rotate Right
-  106: new OpCode(106, "ROR", AddressingMode.Accumulator, 1),
-  110: new OpCode(110, "ROR", AddressingMode.Absolute, 3),
-  102: new OpCode(102, "ROR", AddressingMode.DirectPage, 2),
-  126: new OpCode(126, "ROR", AddressingMode.AbsoluteIndexedX, 3),
-  118: new OpCode(118, "ROR", AddressingMode.DirectPageIndexedX, 2),
-  // Return instructions
-  64: new OpCode(64, "RTI", AddressingMode.Stack, 1),
-  107: new OpCode(107, "RTL", AddressingMode.Stack, 1),
-  96: new OpCode(96, "RTS", AddressingMode.Stack, 1),
-  // SBC - Subtract with Carry
-  233: new OpCode(233, "SBC", AddressingMode.Immediate, -2),
-  237: new OpCode(237, "SBC", AddressingMode.Absolute, 3),
-  239: new OpCode(239, "SBC", AddressingMode.AbsoluteLong, 4),
-  229: new OpCode(229, "SBC", AddressingMode.DirectPage, 2),
-  242: new OpCode(242, "SBC", AddressingMode.DirectPageIndirect, 2),
-  231: new OpCode(231, "SBC", AddressingMode.DirectPageIndirectLong, 2),
-  253: new OpCode(253, "SBC", AddressingMode.AbsoluteIndexedX, 3),
-  255: new OpCode(255, "SBC", AddressingMode.AbsoluteLongIndexedX, 4),
-  249: new OpCode(249, "SBC", AddressingMode.AbsoluteIndexedY, 3),
-  245: new OpCode(245, "SBC", AddressingMode.DirectPageIndexedX, 2),
-  225: new OpCode(225, "SBC", AddressingMode.DirectPageIndexedIndirectX, 2),
-  241: new OpCode(241, "SBC", AddressingMode.DirectPageIndirectIndexedY, 2),
-  247: new OpCode(247, "SBC", AddressingMode.DirectPageIndirectLongIndexedY, 2),
-  227: new OpCode(227, "SBC", AddressingMode.StackRelative, 2),
-  243: new OpCode(243, "SBC", AddressingMode.StackRelativeIndirectIndexedY, 2),
-  // Set flag instructions
-  56: new OpCode(56, "SEC", AddressingMode.Implied, 1),
-  248: new OpCode(248, "SED", AddressingMode.Implied, 1),
-  120: new OpCode(120, "SEI", AddressingMode.Implied, 1),
-  226: new OpCode(226, "SEP", AddressingMode.Immediate, 2),
-  // STA - Store Accumulator
-  141: new OpCode(141, "STA", AddressingMode.Absolute, 3),
-  143: new OpCode(143, "STA", AddressingMode.AbsoluteLong, 4),
-  133: new OpCode(133, "STA", AddressingMode.DirectPage, 2),
-  146: new OpCode(146, "STA", AddressingMode.DirectPageIndirect, 2),
-  135: new OpCode(135, "STA", AddressingMode.DirectPageIndirectLong, 2),
-  157: new OpCode(157, "STA", AddressingMode.AbsoluteIndexedX, 3),
-  159: new OpCode(159, "STA", AddressingMode.AbsoluteLongIndexedX, 4),
-  153: new OpCode(153, "STA", AddressingMode.AbsoluteIndexedY, 3),
-  149: new OpCode(149, "STA", AddressingMode.DirectPageIndexedX, 2),
-  129: new OpCode(129, "STA", AddressingMode.DirectPageIndexedIndirectX, 2),
-  145: new OpCode(145, "STA", AddressingMode.DirectPageIndirectIndexedY, 2),
-  151: new OpCode(151, "STA", AddressingMode.DirectPageIndirectLongIndexedY, 2),
-  131: new OpCode(131, "STA", AddressingMode.StackRelative, 2),
-  147: new OpCode(147, "STA", AddressingMode.StackRelativeIndirectIndexedY, 2),
-  // STP - Stop
-  219: new OpCode(219, "STP", AddressingMode.Implied, 1),
-  // STX - Store X Register
-  142: new OpCode(142, "STX", AddressingMode.Absolute, 3),
-  134: new OpCode(134, "STX", AddressingMode.DirectPage, 2),
-  150: new OpCode(150, "STX", AddressingMode.DirectPageIndexedY, 2),
-  // STY - Store Y Register
-  140: new OpCode(140, "STY", AddressingMode.Absolute, 3),
-  132: new OpCode(132, "STY", AddressingMode.DirectPage, 2),
-  148: new OpCode(148, "STY", AddressingMode.DirectPageIndexedX, 2),
-  // STZ - Store Zero
-  156: new OpCode(156, "STZ", AddressingMode.Absolute, 3),
-  100: new OpCode(100, "STZ", AddressingMode.DirectPage, 2),
-  158: new OpCode(158, "STZ", AddressingMode.AbsoluteIndexedX, 3),
-  116: new OpCode(116, "STZ", AddressingMode.DirectPageIndexedX, 2),
-  // Transfer instructions
-  170: new OpCode(170, "TAX", AddressingMode.Implied, 1),
-  168: new OpCode(168, "TAY", AddressingMode.Implied, 1),
-  91: new OpCode(91, "TCD", AddressingMode.Implied, 1),
-  27: new OpCode(27, "TCS", AddressingMode.Implied, 1),
-  123: new OpCode(123, "TDC", AddressingMode.Implied, 1),
-  28: new OpCode(28, "TRB", AddressingMode.Absolute, 3),
-  20: new OpCode(20, "TRB", AddressingMode.DirectPage, 2),
-  12: new OpCode(12, "TSB", AddressingMode.Absolute, 3),
-  4: new OpCode(4, "TSB", AddressingMode.DirectPage, 2),
-  59: new OpCode(59, "TSC", AddressingMode.Implied, 1),
-  186: new OpCode(186, "TSX", AddressingMode.Implied, 1),
-  138: new OpCode(138, "TXA", AddressingMode.Implied, 1),
-  154: new OpCode(154, "TXS", AddressingMode.Implied, 1),
-  155: new OpCode(155, "TXY", AddressingMode.Implied, 1),
-  152: new OpCode(152, "TYA", AddressingMode.Implied, 1),
-  187: new OpCode(187, "TYX", AddressingMode.Implied, 1),
-  // Miscellaneous
-  203: new OpCode(203, "WAI", AddressingMode.Implied, 1),
-  66: new OpCode(66, "WDM", AddressingMode.Implied, 1),
-  235: new OpCode(235, "XBA", AddressingMode.Implied, 1),
-  251: new OpCode(251, "XCE", AddressingMode.Implied, 1)
-};
-var GROUPED_OPCODES = {};
-for (const opcode of Object.values(ALL_OPCODES)) {
-  if (!GROUPED_OPCODES[opcode.mnem]) {
-    GROUPED_OPCODES[opcode.mnem] = [];
-  }
-  GROUPED_OPCODES[opcode.mnem].push(opcode);
-}
-var ADDRESSING_REGEX = {
-  [AddressingMode.DirectPageIndexedIndirectX]: /^\(\$([A-Fa-f0-9]{2}),\s?[Xx]\)$/,
-  [AddressingMode.StackRelative]: /^\$([A-Fa-f0-9]{2}),\s?[Ss]$/,
-  [AddressingMode.StackInterrupt]: /^#\$([A-Fa-f0-9]{2})$/,
-  [AddressingMode.DirectPage]: /^\$([A-Fa-f0-9]{2})$/,
-  [AddressingMode.DirectPageIndirectLong]: /^\[\$([A-Fa-f0-9]{2})\]$/,
-  [AddressingMode.Immediate]: /^#(\$[A-Fa-f0-9]{2,4}|\$?[&^*][A-Za-z0-9-+_]+)$/,
-  [AddressingMode.Absolute]: /^\$([A-Fa-f0-9]{4}|&[A-Za-z0-9-+_]+)$/,
-  [AddressingMode.AbsoluteLong]: /^\$([A-Fa-f0-9]{6}|\@[A-Za-z0-9-+_]+)$/,
-  [AddressingMode.DirectPageIndirectIndexedY]: /^\(\$([A-Fa-f0-9]{2})\),\s?[Yy]$/,
-  [AddressingMode.DirectPageIndirect]: /^\(\$([A-Fa-f0-9]{2})\)$/,
-  [AddressingMode.StackRelativeIndirectIndexedY]: /^\(\$([A-Fa-f0-9]{2}),\s?[Ss]\),\s?[Yy]$/,
-  [AddressingMode.DirectPageIndexedX]: /^\$([A-Fa-f0-9]{2}),\s?[Xx]$/,
-  [AddressingMode.DirectPageIndirectLongIndexedY]: /^\[\$([A-Fa-f0-9]{2})\],\s?[Yy]$/,
-  [AddressingMode.AbsoluteIndexedY]: /^(\$[A-Fa-f0-9]{4}|\$?&[A-Za-z0-9-+_]+),\s?[Yy]$/,
-  [AddressingMode.AbsoluteIndexedX]: /^(\$[A-Fa-f0-9]{4}|\$?&[A-Za-z0-9-+_]+),\s?[Xx]$/,
-  [AddressingMode.AbsoluteLongIndexedX]: /^(\$[A-Fa-f0-9]{6}|\$?@[A-Za-z0-9-+_]+),\s?[Xx]$/,
-  [AddressingMode.AbsoluteIndexedIndirect]: /^\((\$[A-Fa-f0-9]{4}|\$?&[A-Za-z0-9-+_]+),\s*[Xx]\)$/,
-  [AddressingMode.BlockMove]: /^#\$([A-Fa-f0-9]{2}|\^[A-Za-z0-9-+_]+),\s?#\$([A-Fa-f0-9]{2}|\^[A-Za-z0-9-+_]+)$/,
-  // Default entries for other addressing modes
-  [AddressingMode.Implied]: /^$/,
-  [AddressingMode.Accumulator]: /^[Aa]$/,
-  [AddressingMode.PCRelative]: /^/,
-  [AddressingMode.PCRelativeLong]: /^/,
-  [AddressingMode.AbsoluteIndirect]: /^/,
-  [AddressingMode.AbsoluteIndirectLong]: /^/,
-  [AddressingMode.DirectPageIndexedY]: /^/,
-  [AddressingMode.Stack]: /^/
-};
-var HEX_REGEX = /[^A-Fa-f0-9]/g;
-var OpCodeUtils = class {
-  /**
-   * Get all available opcodes
-   */
-  static getAllOpcodes() {
-    return Object.values(ALL_OPCODES);
+registerCompressionProviders();
+var BlockReader = class {
+  constructor(romData, root) {
+    // Current Processing State (Database)
+    //public _currentBlock!: DbBlock;
+    //public _currentPart: DbPart | null = null;
+    this._partEnd = 0;
+    // ChunkFile Processing State
+    this._currentChunk = null;
+    this._currentAsmBlock = null;
+    this._enrichedChunks = [];
+    this._romDataReader = new RomDataReader(romData);
+    this._stateManager = new ProcessorStateManager();
+    this._referenceManager = new ReferenceManager(root);
+    this._root = root;
+    this._stringReader = new StringReader(this);
+    this._asmReader = new AsmReader(this);
+    this._typeParser = new TypeParser(this);
+    this.initializeOverrides();
+    this.initializeFileReferences();
   }
-  /**
-   * Get opcodes by mnemonic
-   */
-  static getByMnemonic(mnemonic) {
-    return GROUPED_OPCODES[mnemonic] || [];
+  static {
+    // Constants
+    this.REF_SEARCH_MAX_RANGE = 416;
   }
-  /**
-   * Find opcode by hex value
-   */
-  static findByCode(code) {
-    return ALL_OPCODES[code];
+  static {
+    this.BANK_MASK_CHECK = 64;
   }
-};
-
-// src/rom/extraction/asm.ts
-var AsmReader = class _AsmReader {
   static {
-    // Constants
-    this.ACCUMULATOR_OP_MASK = 15;
+    this.BYTE_DELIMITER_THRESHOLD = 256;
   }
   static {
-    this.ACCUMULATOR_OP_VALUE = 9;
+    this.BANK_HIGH_MEMORY_1 = 126;
   }
   static {
-    this.VARIABLE_SIZE_INDICATOR = -2;
+    this.BANK_HIGH_MEMORY_2 = 127;
   }
   static {
-    this.TWO_BYTES_SIZE = 2;
+    this.POINTER_CHARACTERS = ["&", "@"];
   }
   static {
-    this.THREE_BYTES_SIZE = 3;
-  }
-  constructor(blockReader) {
-    this._blockReader = blockReader;
-    this._transformProcessor = new TransformProcessor(blockReader);
-    this._addressingModeHandler = new AddressingModeHandler(blockReader, this._transformProcessor);
-    this._romDataReader = blockReader._romDataReader;
-  }
-  parseAsm(reg) {
-    const opStart = this._romDataReader.position;
-    const opCode = this._romDataReader.readByte();
-    const code = this._blockReader._root.opCodes[opCode];
-    if (!code) {
-      throw new Error("Unknown OpCode");
-    }
-    const operationContext = this.initializeOperation(code, reg, opStart);
-    const operands = this._addressingModeHandler.processAddressingMode(code, operationContext, reg);
-    this._transformProcessor.applyTransforms(operationContext.xForm1, operationContext.xForm2, operands);
-    const op = new Op(
-      code,
-      opStart,
-      operands,
-      this._romDataReader.position - opStart
-    );
-    if (operationContext.copDef) {
-      op.copDef = operationContext.copDef;
-    }
-    return op;
-  }
-  clearDestinationRegister(code, reg) {
-    switch (code.mnem) {
-      case "LDA":
-        reg.accumulator = void 0;
-        break;
-      case "LDX":
-        reg.xIndex = void 0;
-        break;
-      case "LDY":
-        reg.yIndex = void 0;
-        break;
-    }
-  }
-  initializeOperation(code, reg, loc) {
-    const size = this.calculateInstructionSize(code, reg);
-    const next = loc + size;
-    this.clearDestinationRegister(code, reg);
-    const context = new OperationContext();
-    context.size = size;
-    context.nextAddress = next;
-    context.xForm1 = this._transformProcessor.getTransform();
-    context.xForm2 = null;
-    context.copDef = null;
-    return context;
-  }
-  calculateInstructionSize(code, reg) {
-    let size = code.size;
-    if (size === _AsmReader.VARIABLE_SIZE_INDICATOR) {
-      if ((code.code & _AsmReader.ACCUMULATOR_OP_MASK) === _AsmReader.ACCUMULATOR_OP_VALUE) {
-        size = reg.accumulatorFlag ?? false ? _AsmReader.TWO_BYTES_SIZE : _AsmReader.THREE_BYTES_SIZE;
-      } else {
-        size = reg.indexFlag ?? false ? _AsmReader.TWO_BYTES_SIZE : _AsmReader.THREE_BYTES_SIZE;
-      }
-    }
-    return size;
-  }
-};
-var BlockReader = class {
-  constructor(romData, root) {
-    this._currentPart = null;
-    this._partEnd = 0;
-    this._romDataReader = new RomDataReader(romData);
-    this._stateManager = new ProcessorStateManager();
-    this._referenceManager = new ReferenceManager(root);
-    this._root = root;
-    this._stringReader = new StringReader(this);
-    this._asmReader = new AsmReader(this);
-    this._typeParser = new TypeParser(this);
-    this.initializeOverrides();
-    this.initializeFileReferences();
-  }
-  static {
-    // Constants
-    this.REF_SEARCH_MAX_RANGE = 416;
-  }
-  static {
-    this.BANK_MASK_CHECK = 64;
-  }
-  static {
-    this.BYTE_DELIMITER_THRESHOLD = 256;
-  }
-  static {
-    this.BANK_HIGH_MEMORY_1 = 126;
-  }
-  static {
-    this.BANK_HIGH_MEMORY_2 = 127;
-  }
-  static {
-    this.POINTER_CHARACTERS = ["&", "@"];
-  }
-  static {
-    // Location regex pattern: _([A-Fa-f0-9]{6})
-    this.LOCATION_REGEX = /_([A-Fa-f0-9]{6})/;
+    // Location regex pattern: _([A-Fa-f0-9]{6})
+    this.LOCATION_REGEX = /_([A-Fa-f0-9]{6})/;
   }
   // Backward Compatibility Properties
   get AccumulatorFlags() {
@@ -2288,9 +1548,6 @@ var BlockReader = class {
       return;
     }
     let offset = addr.offset;
-    if (offset === 1750) {
-      console.log(this._root.mnemonics[offset]);
-    }
     const label = this._root.mnemonics[offset];
     if (!label) {
       return;
@@ -2303,9 +1560,7 @@ var BlockReader = class {
         opnd = -opnd;
       offset -= opnd;
     }
-    if (this._currentBlock.mnemonics) {
-      this._currentBlock.mnemonics[offset] = label.substring(0, ix >= 0 ? ix : label.length);
-    }
+    this._currentChunk.mnemonics[offset] = label.substring(0, ix >= 0 ? ix : label.length);
   }
   /**
    * Resolves name for a location (delegated to ReferenceManager)
@@ -2317,21 +1572,9 @@ var BlockReader = class {
    * Resolves include for a location
    */
   resolveInclude(loc, isBranch) {
-    if (DbBlockUtils.isOutside(this._currentBlock, loc) && this._currentPart) {
-      let foundPart = null;
-      for (const block of this._root.blocks) {
-        for (const part of block.parts) {
-          if (loc >= part.start && loc < part.end) {
-            foundPart = part;
-            break;
-          }
-        }
-        if (foundPart) break;
-      }
-      if (foundPart) {
-        this._currentPart.includes = this._currentPart.includes || /* @__PURE__ */ new Set();
-        this._currentPart.includes.add(foundPart);
-      }
+    const [outside, foundBlock, foundPart] = ChunkFileUtils.isOutsideWithPart(this._enrichedChunks, this._currentChunk, loc);
+    if (outside && foundBlock && foundPart) {
+      this._currentAsmBlock.includes.add({ block: foundBlock, part: foundPart });
     } else if (isBranch && !this._referenceManager.tryGetName(loc).found) {
       const name = `loc_${loc.toString(16).toUpperCase().padStart(6, "0")}`;
       this._referenceManager.tryAddName(loc, name);
@@ -2390,34 +1633,37 @@ var BlockReader = class {
   partCanContinue() {
     return this._romDataReader.position < this._partEnd && !this._referenceManager.containsStruct(this._romDataReader.position);
   }
-  /**
-   * Main analysis entry point
-   */
   analyzeAndResolve() {
-    this.analyzeBlocks();
+    this.createChunkFilesFromDatabase();
+    this.initializeBlocksAndParts();
+    this.analyzeChunkFiles();
     this.resolveReferences();
+    return this._enrichedChunks;
   }
   /**
    * Analyzes all blocks in the ROM
    */
-  analyzeBlocks() {
-    this.initializeBlocksAndParts();
-    for (const block of this._root.blocks) {
-      this._currentBlock = block;
-      for (const part of block.parts) {
-        this.processPart(part);
-      }
-    }
-  }
+  // private analyzeBlocks(): void {
+  //   this.initializeBlocksAndParts();
+  //   for (const chunk of this._enrichedChunks) {
+  //     this._currentChunk = chunk;
+  //     for (const part of chunk.parts || []) {
+  //       this.processPart(part);
+  //     }
+  //   }
+  // }
   /**
    * Initializes blocks and parts with base references
    */
   initializeBlocksAndParts() {
-    for (const block of this._root.blocks) {
-      for (const part of block.parts) {
-        part.includes = /* @__PURE__ */ new Set();
-        this._referenceManager.tryAddStruct(part.start, part.struct);
-        this._referenceManager.tryAddName(part.start, part.name);
+    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);
+        }
       }
     }
   }
@@ -2425,10 +1671,10 @@ var BlockReader = class {
    * Processes a single part
    */
   processPart(part) {
-    this._currentPart = part;
-    this._romDataReader.position = part.start;
-    this._partEnd = part.end;
-    let current = part.struct || BlockReaderConstants.BINARY_TYPE;
+    this._currentAsmBlock = part;
+    this._romDataReader.position = part.location;
+    this._partEnd = part.location + part.size;
+    let current = part.structName || BlockReaderConstants.BINARY_TYPE;
     const chunks = [];
     const reg = new Registers();
     const bank = part.bank;
@@ -2445,7 +1691,7 @@ var BlockReader = class {
       chunks.push(last);
       this.processNewEntry(current, reg, bank, last);
     }
-    part.objectRoot = chunks;
+    part.objList = chunks;
   }
   /**
    * Processes a continuous entry (same type as previous)
@@ -2468,14 +1714,110 @@ var BlockReader = class {
     last.object = res;
   }
   /**
-   * Resolves all references after analysis
+   * Creates ChunkFile objects from database structure
+   */
+  createChunkFilesFromDatabase() {
+    this._enrichedChunks = [];
+    this.createChunkFilesFromSfx();
+    this.createChunkFilesFromDbFiles();
+    this.createChunkFilesFromDbBlocks();
+  }
+  /**
+   * Creates binary ChunkFiles from DbFiles (enriched with rawData)
+   */
+  createChunkFilesFromSfx() {
+    let pos = this._root.config.sfxLocation;
+    const count = this._root.config.sfxCount;
+    const romData = this._romDataReader.romData;
+    const getSize = () => romData[pos++] | romData[pos++] << 8;
+    for (let i = 0; i < count; i++) {
+      const size = getSize();
+      const startPos = pos;
+      let remaining = size;
+      let end = pos + remaining;
+      let data;
+      if (end & RomProcessingConstants.PAGE_SIZE) {
+        const endLen = end & 32767;
+        remaining -= endLen;
+        data = romData.slice(pos, pos + remaining);
+        pos += remaining + RomProcessingConstants.PAGE_SIZE;
+        end = pos + endLen;
+        const data2 = romData.slice(pos, end);
+        data = new Uint8Array([...data, ...data2]);
+      } else {
+        data = romData.slice(pos, end);
+      }
+      pos = end;
+      const chunk = new ChunkFile(`sfx${i.toString(16).toUpperCase().padStart(2, "0")}`, size, startPos, BinType.Sound);
+      chunk.rawData = data;
+      this._enrichedChunks.push(chunk);
+    }
+  }
+  /**
+   * Creates binary ChunkFiles from DbFiles (enriched with rawData)
    */
-  resolveReferences() {
+  createChunkFilesFromDbFiles() {
+    for (const dbFile of this._root.files) {
+      const chunkFile = createChunkFileFromDbFile(this._romDataReader.romData, this._root.compression, dbFile);
+      this._enrichedChunks.push(chunkFile);
+    }
+  }
+  /**
+   * Creates assembly ChunkFiles from DbBlocks (enriched with parts)
+   */
+  createChunkFilesFromDbBlocks() {
     for (const block of this._root.blocks) {
-      this._currentBlock = block;
-      for (const part of block.parts) {
-        this._currentPart = part;
-        this.resolveObject(part.objectRoot, false);
+      const chunkFile = createChunkFileFromDbBlock(block);
+      this._enrichedChunks.push(chunkFile);
+    }
+  }
+  /**
+   * Analyzes only assembly ChunkFiles (those with parts from DbBlocks)
+   */
+  analyzeChunkFiles() {
+    const assemblyChunks = this._enrichedChunks.filter((chunk) => chunk.type === BinType.Assembly);
+    for (const chunkFile of assemblyChunks) {
+      this._currentChunk = chunkFile;
+      for (const asmBlock of chunkFile.parts || []) {
+        this._currentAsmBlock = asmBlock;
+        this.processPart(asmBlock);
+      }
+    }
+  }
+  // /**
+  //  * Processes a single AsmBlock (similar to processPart)
+  //  */
+  // private processAsmBlock(asmBlock: AsmBlock): void {
+  //   this._romDataReader.position = asmBlock.location;
+  //   this._partEnd = asmBlock.location + asmBlock.size;
+  //   let current = asmBlock.structName || BlockReaderConstants.BINARY_TYPE;
+  //   const chunks: TableEntry[] = [];
+  //   const reg = new Registers();
+  //   const bank = this._currentAsmBlock?.bank;
+  //   let last: TableEntry | null = null;
+  //   while (this._romDataReader.position < this._partEnd) {
+  //     const structResult = this._referenceManager.tryGetStruct(this._romDataReader.position);
+  //     if (structResult.found) {
+  //       current = structResult.chunkType!;
+  //     } else if (last !== null) {
+  //       this.processContinuousEntry(current, reg, bank, last);
+  //       continue;
+  //     }
+  //     last = createTableEntry(this._romDataReader.position);
+  //     chunks.push(last);
+  //     this.processNewEntry(current, reg, bank, last);
+  //   }
+  //   asmBlock.objList = chunks;
+  // }
+  /**
+   * Resolves references in assembly ChunkFiles only
+   */
+  resolveReferences() {
+    for (const chunkFile of this._enrichedChunks) {
+      this._currentChunk = chunkFile;
+      for (const asmBlock of chunkFile.parts || []) {
+        this._currentAsmBlock = asmBlock;
+        this.resolveObject(asmBlock.objList, false);
       }
     }
   }
@@ -2536,7 +1878,7 @@ var BlockReader = class {
    * Checks if an operation is a branch operation
    */
   isBranchOperation(op) {
-    return op.code.mode === AddressingMode.PCRelative || op.code.mode === AddressingMode.PCRelativeLong || op.code.mnem[0] === "J";
+    return op.mode === "PCRelative" || op.mode === "PCRelativeLong" || op.mnem[0] === "J";
   }
   /**
    * Hydrates registers with stored state
@@ -2544,12 +1886,6 @@ var BlockReader = class {
   hydrateRegisters(reg) {
     this._stateManager.hydrateRegisters(this._romDataReader.position, reg);
   }
-  /**
-   * PascalCase wrapper for hydrateRegisters (for C# compatibility)
-   */
-  HydrateRegisters(reg) {
-    this.hydrateRegisters(reg);
-  }
 };
 var PostProcessor = class {
   constructor(reader) {
@@ -2591,7 +1927,10 @@ var PostProcessor = class {
   Lookup(block, keyIx, valueIx) {
     const kix = parseInt(keyIx.trim());
     const vix = parseInt(valueIx.trim());
-    const table = block.parts[0].objectRoot;
+    if (!block.parts || block.parts.length === 0) {
+      throw new Error("Invalid block structure for Lookup post process");
+    }
+    const table = block.parts[0]?.objList;
     const tableEntry = table && table[0];
     const entries = tableEntry?.object;
     if (!tableEntry || !entries) {
@@ -2629,16 +1968,17 @@ var PostProcessor = class {
       newParts.push({ location: loc, object: value });
       this._referenceManager.nameTable.set(loc, name);
       while (newList.length <= key) {
-        newList.push(createWord(0));
+        newList.push(new Word(0));
       }
       newList[key] = `&${name}`;
       eIx++;
     }
-    block.parts[0].objectRoot = newParts;
+    block.parts[0].objList = newParts;
   }
 };
 
 // src/rom/extraction/writer.ts
+var NEWLINE = process.platform === "win32" ? "\r\n" : "\n";
 var ObjectType = /* @__PURE__ */ ((ObjectType2) => {
   ObjectType2["TableEntryArray"] = "TableEntryArray";
   ObjectType2["StructDef"] = "StructDef";
@@ -2662,28 +2002,46 @@ var BlockWriter = class {
     this._referenceManager = reader._referenceManager;
     this._postProcessor = new PostProcessor(reader);
   }
-  async writeBlocks(outPath) {
-    const res = DbRootUtils.getPath(this._root, BinType.Assembly);
-    const folderPath = join(outPath, res.folder);
-    for (const block of this._root.blocks) {
-      const groupedFolderPath = block.group ? join(folderPath, block.group) : folderPath;
-      await promises.mkdir(groupedFolderPath, { recursive: true });
-      const outFile = join(groupedFolderPath, `${block.name}.${res.extension}`);
-      try {
-        await promises.access(outFile);
-        continue;
-      } catch {
-      }
-      const content = this.generateAsm(block);
-      await promises.writeFile(outFile, content);
+  // async writeBlocks(outPath: string): Promise<void> {
+  //   const res = DbRootUtils.getPath(this._root, BinType.Assembly);
+  //   const folderPath = join(outPath, res.folder);
+  //   for (const block of this._root.blocks) {
+  //     const groupedFolderPath = block.group 
+  //       ? join(folderPath, block.group)
+  //       : folderPath;
+  //     await fs.mkdir(groupedFolderPath, { recursive: true });
+  //     const outFile = join(groupedFolderPath, `${block.name}.${res.extension}`);
+  //     // Check if file exists, skip if it does
+  //     try {
+  //       await fs.access(outFile);
+  //       continue;
+  //     } catch {
+  //       // File doesn't exist, continue with creation
+  //     }
+  //     const content = this.generateAsm(block);
+  //     await fs.writeFile(outFile, content);
+  //   }
+  // }
+  generateAllAsm(chunkFiles) {
+    const lines = [];
+    for (const block of chunkFiles) {
+      lines.push({
+        name: block.name,
+        group: block.group,
+        text: this.generateAsm(block)
+      });
     }
+    return lines;
   }
   generateAsm(block) {
+    if (!block.parts) {
+      throw new Error("Invalid block structure for generateAsm");
+    }
     const lines = [];
-    if (!block.movable && block.parts.length > 0) {
-      lines.push(`?BANK ${(block.parts[0].start >> 16).toString(16).toUpperCase().padStart(2, "0")}`);
+    if (block.bank !== void 0) {
+      lines.push(`?BANK ${block.bank.toString(16).toUpperCase().padStart(2, "0")}`);
     }
-    const includes = DbBlockUtils.getIncludes(block);
+    const includes = ChunkFileUtils.getIncludes(block);
     if (includes && includes.length > 0) {
       lines.push("");
       for (const inc of includes) {
@@ -2699,15 +2057,15 @@ var BlockWriter = class {
       }
     }
     this._postProcessor.process(block);
-    for (const part of block.parts) {
+    for (const part of block.parts || []) {
       this._currentPart = part;
       this._isInline = true;
       lines.push("");
       lines.push("---------------------------------------------");
-      const objectLines = this.writeObject(part.objectRoot, -1);
+      const objectLines = this.writeObject(part.objList, -1);
       lines.push(...objectLines);
     }
-    let content = lines.join("\r\n");
+    let content = lines.join(NEWLINE);
     if (block.transforms) {
       for (const x of block.transforms) {
         if (x.key && x.value) {
@@ -2716,6 +2074,9 @@ var BlockWriter = class {
         }
       }
     }
+    if (process.platform !== "win32") {
+      content = content.replace(/\r/g, "");
+    }
     return content;
   }
   getMnemonicsForBlock(block) {
@@ -2725,10 +2086,12 @@ var BlockWriter = class {
     return Object.entries(block.mnemonics).map(([k, v]) => [v, parseInt(k, 10)]).sort((a, b) => a[1] - b[1]);
   }
   resolveOperand(op, obj, isBranch = false) {
-    this.getObjectType(obj);
+    if (obj instanceof TypedNumber) {
+      const len = obj.size * 2;
+      return obj.value.toString(16).toUpperCase().padStart(len, "0");
+    }
     if (typeof obj === "number") {
-      if (op.size === 3) ;
-      if (op.code.mode === AddressingMode.Immediate) {
+      if (op.mode === "Immediate") {
         return obj;
       }
       return this._blockReader.resolveName(obj, AddressType.Address, isBranch);
@@ -2750,15 +2113,7 @@ var BlockWriter = class {
       }
       return addr.offset;
     }
-    if (obj && typeof obj === "object" && obj._tag && "value" in obj) {
-      const typed = obj;
-      if (typed._tag === "Byte" || typed._tag === "Word" || typed._tag === "TypedNumber") {
-        return obj;
-      }
-      if (typeof typed.value === "number" && op.code.mode !== AddressingMode.Immediate) {
-        const resolved = this._blockReader.resolveName(typed.value, AddressType.Address, isBranch);
-        return { ...typed, value: resolved };
-      }
+    if (obj && obj instanceof TypedNumber) {
       return obj;
     }
     return obj;
@@ -2768,11 +2123,11 @@ var BlockWriter = class {
       return "String" /* String */;
     }
     if (obj._tag) {
-      if (obj._tag === "Byte" || obj._tag === "Word") {
-        return "TypedNumber" /* TypedNumber */;
-      }
       return obj._tag;
     }
+    if (obj instanceof TypedNumber) {
+      return "TypedNumber" /* TypedNumber */;
+    }
     if (Array.isArray(obj)) {
       if (obj.length > 0) {
         if (obj[0] && typeof obj[0] === "object" && "location" in obj[0] && "object" in obj[0]) {
@@ -2887,7 +2242,7 @@ var BlockWriter = class {
     this._isInline = true;
     for (const part of structObj.parts) {
       const partLines = this.writeObject(part, depth);
-      parts.push(partLines.join("\r\n"));
+      parts.push(partLines.join(NEWLINE));
     }
     const line = `${structObj.name} < ${parts.join(", ")} >`;
     this._isInline = isInline;
@@ -2909,7 +2264,7 @@ var BlockWriter = class {
           lines.push(`  ${labelResult.referenceName}:`);
         }
       }
-      let opLine = `    ${op.code.mnem} `;
+      let opLine = `    ${op.mnem} `;
       if (op.copDef) {
         opLine += `[${op.copDef.mnem}]`;
         if (op.operands && op.operands.length > 1) {
@@ -2921,26 +2276,18 @@ var BlockWriter = class {
           opLine += ` ( ${operandStrings.join(", ")} )`;
         }
       } else if (op.operands && op.operands.length > 0) {
-        if (op.code.mnem === "COP") {
-          const operand = op.operands[0];
-          if (typeof operand === "number") {
-            opLine += `[${operand.toString(16).toUpperCase().padStart(2, "0")}]`;
-          } else {
-            opLine += `[${operand}]`;
+        const isBr = op.mnem[0] === "J" || op.mode === "PCRelative" || op.mode === "PCRelativeLong";
+        const resolvedOperand = this.resolveOperand(op, op.operands[0], isBr);
+        const format = this._root.addrLookup[op.mode]?.formatString;
+        if (format) {
+          let actualFormat = format;
+          if (op.mode === "Immediate" && op.size === 3) {
+            actualFormat = format.replace("X2", "X4");
           }
+          const resolvedSecondOperand = op.operands.length > 1 ? this.resolveOperand(op, op.operands[1], isBr) : void 0;
+          opLine += this.formatOperand(actualFormat, [resolvedOperand, resolvedSecondOperand]);
         } else {
-          const isBr = op.code.mnem[0] === "J" || op.code.mode === AddressingMode.PCRelative || op.code.mode === AddressingMode.PCRelativeLong;
-          const resolvedOperand = this.resolveOperand(op, op.operands[0], isBr);
-          const format = this._root.config.asmFormats?.[op.code.mode];
-          if (format) {
-            let actualFormat = format;
-            if (op.code.mode === AddressingMode.Immediate && op.size === 3) {
-              actualFormat = format.replace("X2", "X4");
-            }
-            opLine += this.formatOperand(actualFormat, [resolvedOperand, ...op.operands.slice(1)]);
-          } else {
-            opLine += this.formatDefaultOperand(resolvedOperand, op.size);
-          }
+          opLine += this.formatDefaultOperand(resolvedOperand, op.size);
         }
       }
       lines.push(opLine);
@@ -2953,7 +2300,7 @@ var BlockWriter = class {
     if (typeof operand === "string") {
       return operand;
     }
-    if (operand && typeof operand === "object" && operand._tag && "value" in operand) {
+    if (operand && operand instanceof TypedNumber) {
       return this.formatTypedNumber(operand);
     }
     if (typeof operand === "number") {
@@ -3031,7 +2378,7 @@ var BlockWriter = class {
   }
   writeArray(arr, depth) {
     const lines = [];
-    const indent = "  ".repeat(depth);
+    const indent = "  ".repeat(Math.max(0, depth));
     const isInline = this._isInline;
     lines.push("[");
     this._isInline = false;
@@ -3056,16 +2403,10 @@ var BlockWriter = class {
     return [`#$${num.toString(16).toUpperCase().padStart(6, "0")}`];
   }
   formatTypedNumber(num) {
-    let size = 1;
-    if ("size" in num) {
-      size = num.size;
-    } else if (num._tag === "Word") {
-      size = 2;
-    }
     if (typeof num.value === "number") {
-      const width = size * 2;
+      const width = num.size * 2;
       const hex = num.value.toString(16).toUpperCase().padStart(width, "0");
-      return size === 1 ? `#${hex}` : `#$${hex}`;
+      return num.size === 1 ? `#${hex}` : `#$${hex}`;
     }
     return `#${num.value}`;
   }
@@ -3093,469 +2434,1590 @@ var BlockWriter = class {
     });
   }
 };
-
-// src/rom/project.ts
-var ProjectRoot = class _ProjectRoot {
-  constructor(config) {
-    this.config = config;
-    this.name = config.name;
-    this.romPath = config.romPath;
-    this.baseDir = config.baseDir;
-    this.system = config.system;
-    this.database = config.database;
-    this.flipsPath = config.flipsPath;
-    this.resources = config.resources;
-    this.databasePath = config.databasePath;
-    this.systemPath = config.systemPath;
-    this.compression = config.compression;
+var RomLayout = class _RomLayout {
+  constructor(files) {
+    this.bestResult = new Array(512).fill(0);
+    this.bestSample = new Array(512).fill(0);
+    this.currentBank = 0;
+    this.currentUpper = false;
+    this.bestDepth = 0;
+    this.bestOffset = 0;
+    this.bestRemain = 0;
+    this.unmatchedFiles = Array.from(files).filter((x) => (x.size || 0) > 0).sort((a, b) => {
+      const aAsm = a.parts ? 0 : 1;
+      const bAsm = b.parts ? 0 : 1;
+      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;
+      return a.name.localeCompare(b.name);
+    });
   }
-  /**
-   * Get compression provider
-   */
-  getCompression() {
-    const compressionType = this.compression || "QuintetLZ";
-    switch (compressionType) {
-      case "QuintetLZ":
-      default:
-        return new QuintetLZ();
+  static {
+    this.MIN_ACCEPTED_REMAINING = 32;
+  }
+  organize() {
+    for (let page = 0; page < 128; page++) {
+      if (this.unmatchedFiles.length === 0) break;
+      let remain = RomProcessingConstants.PAGE_SIZE;
+      if (page === 1) remain -= RomProcessingConstants.SNES_HEADER_SIZE;
+      this.currentUpper = (page & 1) !== 0;
+      this.currentBank = page >> 1;
+      this.bestDepth = 0;
+      this.bestRemain = remain;
+      this.bestOffset = 0;
+      const start = page << 15;
+      this.testDepth(0, 0, remain, this.currentUpper);
+      if (this.currentUpper) {
+        this.bestOffset = this.bestDepth;
+        this.testDepth(0, this.bestDepth, this.bestRemain, false);
+      }
+      let position = start;
+      for (let i = 0; i < this.bestDepth; ) {
+        const file = this.unmatchedFiles[this.bestResult[i++]];
+        file.location = position;
+        console.log(`  ${position.toString(16).toUpperCase().padStart(6, "0")}: ${file.name}`);
+        position += file.size || 0;
+      }
+      console.log(`Page ${start.toString(16).toUpperCase().padStart(6, "0")} matched with ${this.bestDepth} files ${this.bestRemain} remaining`);
+      this.commitPage();
+    }
+    if (this.unmatchedFiles.length > 0) {
+      const names = this.unmatchedFiles.map((x) => x.name).join("\r\n");
+      throw new Error(`Unable to match ${this.unmatchedFiles.length} files\r
+${names}`);
+    }
+  }
+  testDepth(startIndex, depth, remain, asmMode) {
+    for (let fileIndex = startIndex; fileIndex < this.unmatchedFiles.length; fileIndex++) {
+      const file = this.unmatchedFiles[fileIndex];
+      const fileSize = file.size || 0;
+      if (fileSize > remain) continue;
+      if (file.parts) {
+        if (!asmMode) {
+          if (!this.currentUpper || (file.bank ?? -1) >= 0) continue;
+        } else if (file.bank !== this.currentBank) {
+          continue;
+        }
+      } else if (asmMode) {
+        continue;
+      } else if (file.upper && !this.currentUpper) {
+        continue;
+      }
+      let inList = false;
+      for (let y = this.bestOffset; --y >= 0; ) {
+        if (this.bestResult[y] === fileIndex) {
+          inList = true;
+          break;
+        }
+      }
+      if (inList) continue;
+      this.bestSample[depth] = fileIndex;
+      const newRemain = remain - fileSize;
+      if (newRemain < this.bestRemain) {
+        this.bestRemain = newRemain;
+        this.bestDepth = depth + 1;
+        for (let i = this.bestOffset; i < this.bestDepth; i++) {
+          this.bestResult[i] = this.bestSample[i];
+        }
+      }
+      if (newRemain < _RomLayout.MIN_ACCEPTED_REMAINING) return true;
+      if (this.testDepth(fileIndex + 1, depth + 1, newRemain, asmMode)) return true;
     }
+    return true;
   }
-  /**
-   * Load project from file or directory
-   */
-  static async load(path) {
-    path = path || "./project.json";
-    try {
-      const config = await readJsonFile(path);
-      if (!config.baseDir) {
-        config.baseDir = getDirectory(path);
+  commitPage() {
+    if (this.bestOffset > 0) {
+      for (let i = this.bestDepth; --i >= 0; ) {
+        let lastY = 0;
+        let lastX = 0;
+        let y = 0;
+        for (let x = this.bestDepth; --x >= 0; ) {
+          y = this.bestResult[x];
+          if (y > lastY) {
+            lastY = y;
+            lastX = x;
+          }
+        }
+        this.bestResult[lastX] = 0;
+        this.unmatchedFiles.splice(lastY, 1);
+      }
+    } else {
+      for (let i = this.bestDepth; --i >= 0; ) {
+        this.unmatchedFiles.splice(this.bestResult[i], 1);
       }
-      return new _ProjectRoot(config);
-    } catch (error) {
-      console.warn(`Failed to load project file: ${error}. Using directory-based configuration.`);
     }
-    const defaultConfig = {
-      name: "GaiaLabs",
-      baseDir: path,
-      flipsPath: process?.env?.flips_path,
-      romPath: process?.env?.rom_path || "",
-      database: "us",
-      databasePath: `${path}/db/us`,
-      systemPath: `${path}/db/snes`,
-      resources: {}
-    };
-    return new _ProjectRoot(defaultConfig);
-  }
-  /**
-   * Build the ROM (simplified)
-   */
-  async build() {
-    throw new Error("ROM building not yet implemented");
-  }
-  /**
-   * Dump database and extract ROM data
-   */
-  async dumpDatabase() {
-    const root = await DbRootUtils.fromFolder(this.databasePath, this.systemPath);
-    const data = await readFileAsBinary(this.romPath);
-    root.paths = this.resources;
-    const fileReader = new FileReader(data, root, this.getCompression());
-    await fileReader.extract(this.baseDir);
-    const sfxReader = new SfxReader(data, root);
-    await sfxReader.extract(this.baseDir);
-    const blockReader = new BlockReader(data, root);
-    blockReader.analyzeAndResolve();
-    const blockWriter = new BlockWriter(blockReader);
-    await blockWriter.writeBlocks(this.baseDir);
-    return root;
   }
 };
-
-// src/api/RomProcessor.ts
 var RomProcessor = class _RomProcessor {
-  constructor(projectConfig) {
-    this.dbRoot = null;
-    this.romData = null;
-    this.romState = null;
-    this.projectRoot = new ProjectRoot(projectConfig);
-  }
-  /**
-   * Create ROM processor from project file or directory
-   */
-  static async fromProject(path) {
-    const projectRoot = await ProjectRoot.load(path);
-    return new _RomProcessor(projectRoot.config);
+  constructor(writer) {
+    this.writer = writer;
+  }
+  async repack(allFiles) {
+    const patches = allFiles.filter((x) => x.type === BinType.Patch);
+    const asmFiles = allFiles.filter((x) => !!x.parts);
+    _RomProcessor.applyPatches(asmFiles, patches);
+    for (const asm of asmFiles) {
+      ChunkFileUtils.calculateSize(asm);
+    }
+    const layout = new RomLayout(allFiles);
+    layout.organize();
+    for (const file of asmFiles) {
+      ChunkFileUtils.rebase(file);
+    }
+    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);
+      }
+    }
+    const blockLookup = /* @__PURE__ */ new Map();
+    for (const f of allFiles) {
+      blockLookup.set(f.name.toUpperCase(), f.location);
+    }
+    for (const file of allFiles) {
+      await this.writer.writeFile(file, blockLookup);
+    }
+    const entryBlocks = asmFiles.filter((x) => (x.bank ?? -1) === 0).flatMap((x) => x.parts || []).filter((b) => !!b.label);
+    for (const ep of this.writer.entryPoints) {
+      const match = entryBlocks.find((b) => b.label === ep.name);
+      if (match) this.writer.writeTransform(ep.location, match.location & 65535);
+    }
+  }
+  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);
+      }
+    }
   }
-  /**
-   * Load ROM data from file or URL
-   */
-  async loadRom(romPath) {
-    const path = romPath || this.projectRoot.romPath;
-    if (!path) {
-      throw new Error("ROM path not specified");
+};
+var RomWriter = class {
+  constructor(entryPoints, cartName, makerCode) {
+    this.cartName = cartName;
+    this.makerCode = makerCode;
+    this.entryPoints = entryPoints;
+    this.outBuffer = new Uint8Array(4194304);
+  }
+  async repack(files) {
+    const processor = new RomProcessor(this);
+    await processor.repack(files);
+    this.writeHeader();
+    this.writeEntryPoints(files.filter((x) => !!x.parts));
+    this.writeChecksum();
+    return this.outBuffer;
+  }
+  writeHeader() {
+    const buf = this.outBuffer;
+    let pos = 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++] = 49;
+    buf[pos++] = 2;
+    buf[pos++] = 12;
+    buf[pos++] = 3;
+    buf[pos++] = 1;
+    buf[pos++] = 51;
+    buf[pos++] = 0;
+  }
+  writeChecksum() {
+    const buf = this.outBuffer;
+    let sum = 0;
+    for (let i = 0; i < buf.length; i++) sum += buf[i] & 255;
+    buf[65502] = sum & 255;
+    buf[65503] = sum >> 8 & 255;
+    const comp = ~sum & 65535;
+    buf[65500] = comp & 255;
+    buf[65501] = comp >> 8 & 255;
+  }
+  // private async generatePatch(): Promise<void> {
+  //   const flips = this._projectRoot.flipsPath;
+  //   if (!flips) return;
+  //   if (typeof process === 'undefined' || !process.versions?.node) return;
+  //   const { spawn } = await import('child_process');
+  //   const { resolve } = await import('path');
+  //   this.bpsPath = `${this._projectRoot.baseDir}/${this._projectRoot.name}.bps`;
+  //   await new Promise<void>((resolvePromise) => {
+  //     const p = spawn(flips, ['--create', '--bps', `${this._projectRoot.romPath}`, `${this.romPath}`, `${this.bpsPath}`], {
+  //       stdio: ['ignore', 'pipe', 'pipe']
+  //     });
+  //     p.on('close', () => resolvePromise());
+  //   });
+  // }
+  writeEntryPoints(asmFiles) {
+    this.outBuffer;
+    const entryBlocks = asmFiles.filter((x) => (x.bank ?? -1) === 0).flatMap((x) => x.parts || []).filter((b) => !!b.label);
+    for (const ep of this.entryPoints) {
+      const match = entryBlocks.find((b) => b.label === ep.name);
+      if (match) this.writeTransform(ep.location, match.location & 65535);
+    }
+  }
+  writeTransform(location, value, size) {
+    const buf = this.outBuffer;
+    if (size === void 0) {
+      if (value <= 255) {
+        size = 1;
+      } else if (value <= 65535) {
+        size = 2;
+      } else if (value <= 16777215) {
+        size = 3;
+      } else {
+        size = 4;
+      }
     }
-    try {
-      this.romData = await readFileAsBinary(path);
-    } catch (error) {
-      throw new Error(`Failed to load ROM from ${path}: ${error}`);
+    switch (size) {
+      case 1:
+        buf[location] = value & 255;
+        break;
+      case 2:
+        buf[location] = value & 255;
+        buf[location + 1] = value >> 8 & 255;
+        break;
+      case 3:
+        buf[location] = value & 255;
+        buf[location + 1] = value >> 8 & 255;
+        buf[location + 2] = value >> 16 & 255;
+        break;
+      case 4:
+        buf[location] = value & 255;
+        buf[location + 1] = value >> 8 & 255;
+        buf[location + 2] = value >> 16 & 255;
+        buf[location + 3] = value >> 24 & 255;
+        break;
+      default:
+        throw new Error(`Invalid size ${size} for writeTransform`);
     }
   }
-  /**
-   * Initialize database and load ROM metadata
-   */
-  async initialize() {
-    if (!this.romData) {
-      throw new Error("ROM data not loaded. Call loadRom() first.");
+  async writeFile(file, _chunkLookup) {
+    const start = file.location;
+    let pos = start;
+    const buf = this.outBuffer;
+    if (file.rawData) {
+      const data = file.rawData;
+      let remain = file.size;
+      let srcPos = 0;
+      if (file.type === BinType.Tilemap) {
+        remain -= 2;
+        buf[pos++] = data[srcPos++];
+        buf[pos++] = data[srcPos++];
+      } else if (file.type === BinType.Meta17) {
+        remain -= 4;
+        for (let i = 0; i < 4; i++) buf[pos++] = data[srcPos++];
+      } else if (file.type === BinType.Sound) {
+        remain -= 2;
+        buf[pos++] = remain & 255;
+        buf[pos++] = remain >> 8 & 255;
+      }
+      if (file.compressed !== void 0) {
+        remain -= 2;
+        const inverse = 0 - remain & 65535;
+        buf[pos++] = inverse & 255;
+        buf[pos++] = inverse >> 8 & 255;
+      }
+      while (remain > 0) {
+        buf[pos++] = data[srcPos++];
+        remain--;
+      }
+    } 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.dbRoot = await this.projectRoot.dumpDatabase();
-    this.romState = new RomState();
+    return pos - start;
   }
-  /**
-   * Analyze ROM structure and extract metadata
-   */
-  async analyze() {
-    if (!this.dbRoot || !this.romData) {
-      throw new Error("ROM processor not initialized. Call initialize() first.");
-    }
-    const result = {
-      romSize: this.romData.length,
-      headerInfo: this.analyzeHeader(),
-      entryPoints: this.dbRoot.entryPoints,
-      fileCount: this.dbRoot.files.length,
-      blockCount: this.dbRoot.blocks.length,
-      compressionUsed: this.detectCompression(),
-      spriteMapFound: RomState.spriteMap !== null,
-      opcodeStats: this.analyzeOpcodes()
-    };
-    return result;
+  // No address mapping required: layout assigns absolute file offsets
+  writeAscii(text, pos) {
+    const buf = this.outBuffer;
+    for (let i = 0; i < text.length; i++) buf[pos + i] = text.charCodeAt(i) & 255;
   }
   /**
-   * Extract files from ROM data
+   * Parse assembly blocks and write binary data to output buffer
+   * Converted from ext/GaiaLib/Rom/Rebuild/RomWriter.cs ParseAssembly method
    */
-  async extract(outputDir) {
-    if (!this.dbRoot || !this.romData) {
-      throw new Error("ROM processor not initialized. Call initialize() first.");
-    }
-    const result = {
-      extractedFiles: [],
-      errors: [],
-      totalSize: 0
-    };
-    console.warn("File extraction not yet implemented - awaiting FileReader conversion");
-    return result;
-  }
+  parseAssembly(blocks, chunkLookup, includeLookup) {
+    if (!blocks) {
+      throw new Error("Assembly has not been parsed");
+    }
+    const buf = this.outBuffer;
+    for (const block of blocks) {
+      let position = block.location;
+      const objList = block.objList;
+      let opos = 0;
+      const processObject = (obj, parentOp) => {
+        let currentObj = obj;
+        while (true) {
+          if (Array.isArray(currentObj)) {
+            for (const obj2 of currentObj) {
+              processObject(obj2, parentOp);
+            }
+            break;
+          } else if (this.isTableEntry(currentObj)) {
+            currentObj = currentObj.object;
+            continue;
+          } else if (currentObj instanceof Op) {
+            const op = currentObj;
+            buf[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];
+            }
+            position += arr.length;
+            opos += arr.length;
+            break;
+          } else if (typeof currentObj === "string") {
+            const str = currentObj;
+            let label = str;
+            let ix = 0;
+            while (ix < label.length && RomProcessingConstants.ADDRESS_SPACE.includes(label[ix])) {
+              ix++;
+            }
+            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);
+            let offset = null;
+            let useMarker = false;
+            if (operatorIdx > 0) {
+              if (label[operatorIdx + 1] === "M") {
+                useMarker = true;
+              } else {
+                offset = parseInt(label.substring(operatorIdx + 1), 16);
+                if (label[operatorIdx] === "-") {
+                  offset = -offset;
+                }
+              }
+              label = label.substring(0, operatorIdx);
+            }
+            const labelUpper = label.toUpperCase();
+            let target;
+            if (includeLookup.has(labelUpper)) {
+              target = includeLookup.get(labelUpper);
+              loc = target.location;
+            } else if (chunkLookup.has(labelUpper)) {
+              loc = chunkLookup.get(labelUpper);
+            } else {
+              if (label.startsWith("#")) {
+                label = label.substring(1);
+              }
+              if (label.startsWith("$")) {
+                label = label.substring(1);
+              }
+              if (isRelative && label.length > 4) {
+                const off = parseInt(label, 16) - (block.location + opos);
+                currentObj = parentOp?.size === 2 ? off & 255 : off & 65535;
+                continue;
+              } 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}'`);
+                }
+              }
+            }
+            let type = Address.typeFromCode(str[0]);
+            if (type === AddressType.Unknown) {
+              type = parentOp?.size === 4 ? AddressType.Address : parentOp?.size === 2 ? AddressType.Unknown : AddressType.Offset;
+            }
+            if (isRelative) {
+              loc -= block.location + opos;
+              if (type === AddressType.Unknown && !(loc < 128 || loc >= 4194176)) {
+                throw new Error("Relative out of range");
+              }
+            }
+            if (offset !== null) {
+              loc += offset;
+            } else if (useMarker && target) {
+              let markerOffset = 0;
+              for (const part of target.objList) {
+                if (this.isStringMarker(part)) {
+                  loc += markerOffset;
+                  break;
+                } else {
+                  markerOffset += RomProcessingConstants.getSize(part);
+                }
+              }
+            }
+            switch (type) {
+              case AddressType.Offset:
+                currentObj = new Word(loc);
+                continue;
+              case AddressType.Bank:
+                currentObj = new Byte(loc >> 16 | ((loc & 65535) >= 32768 ? 128 : 192));
+                continue;
+              case AddressType.WBank:
+                currentObj = new Word(loc >> 16 | ((loc & 65535) >= 32768 ? 128 : 192));
+                continue;
+              case AddressType.Address:
+                currentObj = new Long(loc | ((loc & 65535) >= 32768 ? 8388608 : 12582912));
+                continue;
+              default:
+                currentObj = new Byte(loc);
+                continue;
+            }
+          } else if (currentObj instanceof TypedNumber) {
+            let value = currentObj.value;
+            for (let i = 0; i < currentObj.size; i++) {
+              buf[position++] = value & 255;
+              value >>= 8;
+            }
+            break;
+          } else if (typeof currentObj === "number") {
+            const num = currentObj;
+            const size = parentOp?.size ?? 0;
+            if (num <= 255 && size <= 2) {
+              buf[position] = num & 255;
+              position++;
+            } else if (num <= 65535 && size <= 3) {
+              buf[position] = num & 255;
+              buf[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;
+              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;
+              position += 4;
+            }
+            break;
+          } else if (this.isStringMarker(currentObj)) {
+            break;
+          } else {
+            throw new Error(`Unable to process '${currentObj}'`);
+          }
+        }
+      };
+      for (const obj of objList) {
+        processObject(obj);
+      }
+    }
+  }
   /**
-   * Process scene data for a specific scene ID
+   * Helper method to find index of any character from an array in a string
    */
-  async processScene(sceneId, metaFile) {
-    if (!this.dbRoot) {
-      throw new Error("ROM processor not initialized. Call initialize() first.");
-    }
-    const state = await RomState.fromScene(
-      this.projectRoot.baseDir,
-      this.dbRoot,
-      metaFile,
-      sceneId
-    );
-    this.romState = state;
-    return state;
+  indexOfAny(str, chars) {
+    for (let i = 0; i < str.length; i++) {
+      if (chars.includes(str[i])) {
+        return i;
+      }
+    }
+    return -1;
   }
   /**
-   * Build ROM from extracted files
+   * Helper method to check if an object is a StringMarker
    */
-  async build(outputPath) {
-    if (!this.dbRoot) {
-      throw new Error("ROM processor not initialized. Call initialize() first.");
-    }
-    const result = {
-      success: false,
-      outputPath,
-      romSize: 0,
-      errors: []
-    };
-    console.warn("ROM building not yet implemented - awaiting Assembler conversion");
+  isStringMarker(obj) {
+    return typeof obj === "object" && obj !== null && "offset" in obj;
+  }
+  isTableEntry(obj) {
+    return typeof obj === "object" && obj !== null && "location" in obj && "object" in obj;
+  }
+};
+var StringProcessor = class {
+  constructor(context) {
+    this.memBuffer = [];
+    this.context = context;
+    this.root = context.root;
+  }
+  dispose() {
+    this.memBuffer.length = 0;
+  }
+  consumeString() {
+    let str = null;
+    const typeChar = this.context.lineBuffer[0];
+    const endIx = this.context.lineBuffer.indexOf(typeChar, 1);
+    if (endIx >= 0) {
+      str = this.context.lineBuffer.substring(1, endIx);
+      this.context.lineBuffer = this.context.lineBuffer.substring(endIx + 1).replace(/^[\s,\t]+/, "");
+    } else {
+      str = this.context.lineBuffer.substring(1);
+      this.context.lineBuffer = "";
+    }
+    this.memBuffer.length = 0;
+    const stringType = this.root.stringCharLookup[typeChar];
+    this.processString(str, stringType);
+  }
+  flushBuffer(stringType, wrap = false) {
+    const size = this.memBuffer.length;
+    if (size > 0) {
+      const buffer = new Uint8Array(this.memBuffer);
+      this.context.currentBlock.objList.push(buffer);
+      this.context.currentBlock.size += size;
+      this.memBuffer.length = 0;
+    }
+  }
+  processString(str, stringType) {
+    const dict = stringType.commands;
+    stringType.characterMap;
+    this.getShiftUp(stringType.shiftType);
+    let lastCmd = null;
+    for (let x = 0; x < str.length; x++) {
+      const c = str[x];
+      if (c === "[") {
+        const endIx = str.indexOf("]", x + 1);
+        const splitChars = [":", ",", " "];
+        const parts = str.substring(x + 1, endIx).split(new RegExp(`[${splitChars.join("")}]`)).filter((p) => p.length > 0);
+        x = endIx;
+        if (parts.length === 0) {
+          this.flushBuffer(stringType, true);
+          this.context.currentBlock.objList.push({
+            offset: this.context.currentBlock.size
+          });
+          continue;
+        }
+        const cmd = Object.values(dict).find((x2) => x2.value === parts[0]);
+        if (cmd) {
+          lastCmd = cmd;
+          this.memBuffer.push(cmd.key);
+          this.processStringCommand(cmd, stringType, parts);
+          continue;
+        }
+      }
+      lastCmd = null;
+      if (this.applyLayers(c, stringType)) {
+        continue;
+      }
+    }
+    if (lastCmd === null || !lastCmd.halt) {
+      this.memBuffer.push(stringType.terminator);
+    }
+    this.flushBuffer(stringType, true);
+  }
+  applyLayers(c, stringType) {
+    if (this.applyMap(c, stringType.characterMap, this.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);
+    }
+    for (let y = 0, pix = 1; y < cmd.types.length; y++, pix++) {
+      switch (cmd.types[y]) {
+        case MemberType.Byte:
+          this.memBuffer.push(parseInt(parts[pix], 16));
+          break;
+        case MemberType.Word:
+          const us = parseInt(parts[pix], 16);
+          this.memBuffer.push(us & 255);
+          this.memBuffer.push(us >> 8 & 255);
+          break;
+        case MemberType.Binary:
+          while (pix < parts.length) {
+            const ch = parseInt(parts[pix], 16);
+            this.memBuffer.push(ch);
+            pix++;
+          }
+          if (cmd.delimiter !== void 0) {
+            this.memBuffer.push(cmd.delimiter);
+          }
+          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;
+      }
+    }
+    if (hasPointer) {
+      this.flushBuffer(stringType, false);
+    }
+  }
+  getShiftUp(shiftType) {
+    switch (shiftType) {
+      case "h2":
+        return (x) => (x & 112) << 1 | x & 15;
+      case "wh2":
+        return (x) => (x & 56) << 1 | x & 7;
+      default:
+        return (x) => x;
+    }
+  }
+};
+
+// src/rom/rebuild/sorted-map.ts
+var SortedMap = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+    this._keys = [];
+  }
+  get size() {
+    return this.map.size;
+  }
+  set(key, value) {
+    if (!this.map.has(key)) {
+      this._keys.push(key);
+      this.sortKeys();
+    }
+    this.map.set(key, value);
+    return this;
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    const result = this.map.delete(key);
+    if (result) {
+      const index = this._keys.indexOf(key);
+      if (index >= 0) {
+        this._keys.splice(index, 1);
+      }
+    }
     return result;
   }
-  /**
-   * Get compression provider for the project
-   */
-  getCompression() {
-    return this.projectRoot.getCompression();
+  clear() {
+    this.map.clear();
+    this._keys.length = 0;
   }
-  /**
-   * Get current ROM state
-   */
-  getRomState() {
-    return this.romState;
+  keys() {
+    return [...this._keys];
   }
-  /**
-   * Get database root
-   */
-  getDatabase() {
-    return this.dbRoot;
+  values() {
+    return this._keys.map((key) => this.map.get(key));
   }
-  /**
-   * Get project configuration
-   */
-  getProject() {
-    return this.projectRoot;
-  }
-  // Private helper methods
-  analyzeHeader() {
-    if (!this.romData) {
-      throw new Error("ROM data not loaded");
-    }
-    const headerOffset = 32704;
-    const title = new TextDecoder().decode(this.romData.slice(headerOffset, headerOffset + 21)).replace(/\0/g, "");
-    const mapMode = this.romData[headerOffset + 21];
-    const cartridgeType = this.romData[headerOffset + 22];
-    const romSize = this.romData[headerOffset + 23];
-    const ramSize = this.romData[headerOffset + 24];
-    return {
-      title,
-      mapMode,
-      cartridgeType,
-      romSize,
-      ramSize,
-      isValid: title.length > 0 && mapMode !== 255
-    };
+  entries() {
+    return this._keys.map((key) => [key, this.map.get(key)]);
   }
-  detectCompression() {
-    return this.projectRoot.getCompression() instanceof QuintetLZ;
+  *[Symbol.iterator]() {
+    for (const key of this._keys) {
+      yield [key, this.map.get(key)];
+    }
+  }
+  sortKeys() {
+    this._keys.sort((a, b) => {
+      if (a.length !== b.length) {
+        return b.length - a.length;
+      }
+      return a.localeCompare(b);
+    });
   }
-  analyzeOpcodes() {
-    if (!this.dbRoot) {
-      return { totalOpcodes: 0, uniqueOpcodes: 0, coverage: 0 };
+};
+var AssemblerState = class _AssemblerState {
+  constructor(context, structType = null, saveDelimiter = false) {
+    this.context = context;
+    this.root = context.root;
+    this.dbStruct = structType === null ? null : Object.values(this.root.structs).find(
+      (x) => x.name.toLowerCase() === structType.toLowerCase()
+    ) || null;
+    this.parentStruct = this.dbStruct?.parent == null ? null : Object.values(this.root.structs).find(
+      (x) => x.name.toLowerCase() === this.dbStruct.parent.toLowerCase()
+    ) || null;
+    this.discriminator = this.parentStruct?.discriminator ?? null;
+    this.delimiter = this.dbStruct?.delimiter || null;
+    this.memberOffset = 0;
+    this.dataOffset = 0;
+    this.memberTypes = this.dbStruct?.types || null;
+    this.currentType = this.memberTypes?.[this.memberOffset] || null;
+    if (saveDelimiter) {
+      this.context.lastDelimiter = this.dbStruct?.delimiter ?? this.parentStruct?.delimiter ?? null;
+    }
+  }
+  checkDisc() {
+    if (this.discriminator === this.dataOffset) {
+      this.context.currentBlock.objList.push(this.dbStruct.discriminator);
+      this.context.currentBlock.size += 1;
+      this.dataOffset += 1;
+    }
+  }
+  advancePart() {
+    if (this.currentType != null && this.discriminator != null) {
+      this.dataOffset += RomProcessingConstants.getSize(this.currentType);
+    }
+    if (this.memberTypes != null && this.memberOffset + 1 < this.memberTypes.length) {
+      this.currentType = this.memberTypes[++this.memberOffset];
+    }
+  }
+  processOrigin() {
+    this.context.lineBuffer = this.context.lineBuffer.substring(3).replace(/^[\s,\t]+/, "");
+    if (this.context.lineBuffer.startsWith("$")) {
+      this.context.lineBuffer = this.context.lineBuffer.substring(1);
+    }
+    let hex;
+    const endIx = this.context.lineBuffer.search(/[\s,\t]/);
+    if (endIx >= 0) {
+      hex = this.context.lineBuffer.substring(0, endIx);
+      this.context.lineBuffer = this.context.lineBuffer.substring(endIx + 1).replace(/^[\s,\t]+/, "");
+    } else {
+      hex = this.context.lineBuffer;
+      this.context.lineBuffer = "";
     }
-    const totalOpcodes = Object.keys(this.dbRoot.opCodes).length;
-    const uniqueOpcodes = new Set(Object.values(this.dbRoot.opCodes)).size;
-    const coverage = totalOpcodes > 0 ? uniqueOpcodes / OpCodeUtils.getAllOpcodes().length * 100 : 0;
-    return {
-      totalOpcodes,
-      uniqueOpcodes,
-      coverage
-    };
+    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(/[-+]/);
+    if (ix >= 0) {
+      const op = operand[ix];
+      const vix = operand.lastIndexOf("$", ix) + 1;
+      const valueStr = operand.substring(vix, ix);
+      if (valueStr.match(/^[a-fA-F0-9]+$/)) {
+        const value = parseInt(valueStr, 16);
+        let endIx = operand.substring(ix + 1).search(RomProcessingConstants.SYMBOL_SPACE_REGEX);
+        if (endIx < 0) {
+          endIx = operand.length;
+        }
+        const number = parseInt(operand.substring(ix + 1, endIx), 16);
+        let result;
+        if (op === "-") {
+          result = value - number;
+        } else {
+          result = value + number;
+        }
+        const len = ix - vix <= 2 ? 2 : ix - vix <= 4 ? 4 : 6;
+        operand = operand.substring(0, vix) + result.toString(16).toUpperCase().padStart(len, "0") + operand.substring(endIx);
+      }
+    }
+    return operand;
+  }
+  tryCreateLabel(mnemonic, operand) {
+    if (!operand || operand.length === 0) {
+      return false;
+    }
+    const labelChar = operand[0];
+    if (!RomProcessingConstants.LABEL_SPACE.includes(labelChar)) {
+      return false;
+    }
+    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]+/, "");
+      const state = new _AssemblerState(this.context, this.currentType);
+      state.processText(labelChar);
+      this.advancePart();
+    }
+    return true;
+  }
+  processText(openTag) {
+    this.checkDisc();
+    while (!this.context.eof) {
+      if (!this.context.getLine()) {
+        return;
+      }
+      let mnemonic = null;
+      let operand = null;
+      let operand2 = null;
+      while (this.context.lineBuffer.length > 0) {
+        const lineSymbol = this.context.lineBuffer[0];
+        if (this.root.stringDelimiters.includes(lineSymbol)) {
+          this.context.stringProcessor.consumeString();
+          this.advancePart();
+          continue;
+        }
+        if (RomProcessingConstants.ADDRESS_SPACE.includes(lineSymbol)) {
+          this.context.processRawData();
+          if (openTag === "[") {
+            this.context.lastDelimiter = null;
+          }
+          this.advancePart();
+          continue;
+        }
+        if (lineSymbol === ">") {
+          if (openTag === "<") {
+            this.context.lineBuffer = this.context.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
+            this.checkDisc();
+          }
+          return;
+        }
+        if (lineSymbol === "]") {
+          this.context.lineBuffer = this.context.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
+          this.delimiter = this.delimiter ?? this.context.lastDelimiter;
+          if (this.delimiter != null) {
+            if (this.delimiter >= 256) {
+              this.context.currentBlock.objList.push(this.delimiter);
+              this.context.currentBlock.size += 2;
+            } else {
+              this.context.currentBlock.objList.push(this.delimiter);
+              this.context.currentBlock.size += 1;
+            }
+          }
+          return;
+        }
+        if (lineSymbol === "}") {
+          if (openTag === "{") {
+            this.context.lineBuffer = this.context.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
+          }
+          return;
+        }
+        if (lineSymbol === "[") {
+          this.context.lineBuffer = this.context.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
+          const state = new _AssemblerState(this.context, this.currentType);
+          state.processText("[");
+          this.advancePart();
+          continue;
+        }
+        if (this.context.lineBuffer.startsWith("ORG")) {
+          this.processOrigin();
+          continue;
+        }
+        const symbolIndex = this.context.lineBuffer.search(RomProcessingConstants.SYMBOL_SPACE_REGEX);
+        if (symbolIndex > 0) {
+          mnemonic = this.context.lineBuffer.substring(0, symbolIndex);
+          operand = this.context.lineBuffer.substring(symbolIndex).replace(/^[, \t]+/, "");
+          if (operand && operand.startsWith("<")) {
+            this.context.lineBuffer = operand.substring(1).replace(/^[, \t]+/, "");
+            const state = new _AssemblerState(this.context, mnemonic, openTag === "[" && this.currentType == null);
+            state.processText("<");
+            mnemonic = null;
+            continue;
+          }
+          this.context.lineBuffer = operand;
+        } else {
+          mnemonic = this.context.lineBuffer;
+          this.context.lineBuffer = "";
+        }
+        break;
+      }
+      if (mnemonic && mnemonic.length > 0) {
+        const codes = this.root.opLookup[mnemonic.toUpperCase()];
+        if (!codes || codes.length === 0) {
+          if (this.tryCreateLabel(mnemonic, operand || void 0)) {
+            continue;
+          }
+          throw new Error(`Unknown instruction line ${this.context.lineCount}: '${mnemonic}'`);
+        }
+        this.context.lineBuffer = "";
+        if (!operand) {
+          const opCode2 = codes.find((x) => this.root.addrLookup[x.mode].size === 1);
+          this.context.currentBlock.objList.push(new Op(opCode2, 0, [], 1));
+          this.context.currentBlock.size++;
+          continue;
+        }
+        operand = _AssemblerState.doMath(operand);
+        let opCode = codes[0];
+        if (opCode?.mnem === "COP") {
+          const parts = operand.split(/[\s\t,()[\]$#]/).filter((p) => p.length > 0);
+          const cmd = parts[0];
+          const cop = this.root.copLookup[cmd];
+          if (!cop) {
+            throw new Error(`Unknown COP command ${cmd}`);
+          }
+          this.context.currentBlock.objList.push(new Op(opCode, 0, [new Byte(cop.code), ...parts.slice(1)], cop.size + 2));
+          this.context.currentBlock.size += cop.size + 2;
+          continue;
+        }
+        opCode = null;
+        for (const code of codes) {
+          if (code.mode === "PCRelative" || code.mode === "PCRelativeLong") {
+            opCode = code;
+            break;
+          }
+          const addrMode2 = this.root.addrLookup[code.mode];
+          const regex = addrMode2.parseRegex;
+          if (regex) {
+            const match = new RegExp(regex).exec(operand);
+            if (match) {
+              opCode = code;
+              operand = match[1];
+              if (match.length > 2) {
+                operand2 = match[2];
+              }
+              break;
+            }
+          }
+        }
+        if (operand.startsWith("#")) {
+          operand = operand.substring(1);
+        }
+        if (operand.startsWith("$")) {
+          operand = operand.substring(1);
+        }
+        if (opCode == null) {
+          const addrIx = operand.search(RomProcessingConstants.ADDRESS_SPACE_REGEX);
+          if (addrIx && addrIx >= 0) {
+            const eix = operand.search(/[\s\t,\])]/);
+            if (eix && eix >= 0) {
+              operand = operand.substring(addrIx, eix);
+            }
+          }
+          opCode = codes.find((x) => x.mode === "Immediate") ?? codes.find((x) => x.mode === "AbsoluteLong") ?? codes.find((x) => x.mode === "Absolute") ?? null;
+          if (opCode == null) {
+            throw new Error(`Unable to determine mode/code line ${this.context.lineCount}: '${this.context.lineBuffer}'`);
+          }
+        }
+        const opnd1 = this.context.parseOperand(operand);
+        const addrMode = this.root.addrLookup[opCode.mode];
+        let size = addrMode.size;
+        if (size === AsmReader.VARIABLE_SIZE_INDICATOR || opCode.mode === "Immediate") {
+          size = operand?.startsWith("^") || operand?.length === 2 ? 2 : 3;
+        }
+        const operands = operand2 != null ? [opnd1, this.context.parseOperand(operand2)] : [opnd1];
+        this.context.currentBlock.objList.push(new Op(opCode, 0, operands, size));
+        this.context.currentBlock.size += size;
+      }
+    }
+  }
+  hexStringToBytes(hex) {
+    const result = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+      result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return result;
   }
 };
 
-// src/api/ProjectManager.ts
-var ProjectManager = class _ProjectManager {
-  constructor(events) {
-    this.processor = null;
-    this.status = {
-      isLoaded: false,
-      isAnalyzed: false,
-      isExtracted: false,
-      canBuild: false,
-      progress: 0
+// src/rom/rebuild/assembler.ts
+var Assembler = class {
+  constructor(dbRoot, textData) {
+    this.currentLineIndex = 0;
+    this.lineBuffer = "";
+    this.includes = /* @__PURE__ */ new Set();
+    this.blocks = [];
+    this.tags = new SortedMap();
+    this.currentBlock = null;
+    this.lineCount = 0;
+    this.blockIndex = 0;
+    this.lastDelimiter = null;
+    this.reqBank = null;
+    this.eof = false;
+    this.root = dbRoot;
+    this.lines = textData.split(/\r?\n/);
+    this.stringProcessor = new StringProcessor(this);
+  }
+  dispose() {
+    this.stringProcessor.dispose();
+  }
+  parseAssembly() {
+    this.blocks.push(this.currentBlock = new AsmBlock());
+    const state = new AssemblerState(this);
+    state.processText();
+    return {
+      blocks: this.blocks,
+      includes: this.includes,
+      reqBank: this.reqBank
     };
-    this.events = {};
-    this.events = events || {};
   }
-  /**
-   * Create project manager from existing project configuration
-   */
-  static async fromConfig(config, events) {
-    const manager = new _ProjectManager(events);
-    await manager.loadProject(config);
-    return manager;
+  getLine() {
+    if (this.eof) {
+      return false;
+    }
+    if (this.lineBuffer.length > 0) {
+      return true;
+    }
+    let rawLine = null;
+    while (true) {
+      if (this.currentLineIndex >= this.lines.length) {
+        if (this.lineBuffer.length === 0) {
+          this.eof = true;
+          return false;
+        } else {
+          rawLine = "";
+        }
+      } else {
+        rawLine = this.lines[this.currentLineIndex++];
+        this.lineBuffer += rawLine;
+      }
+      this.lineCount++;
+      this.trimComments("--");
+      this.trimComments(";");
+      this.trimComments("//");
+      this.lineBuffer = this.lineBuffer.replace(RomProcessingConstants.COMMA_SPACE_TRIM_REGEX, "");
+      if (this.lineBuffer.length === 0) {
+        continue;
+      }
+      if (this.lineBuffer.endsWith("\\")) {
+        this.lineBuffer = this.lineBuffer.slice(0, -1);
+        continue;
+      }
+      if (this.lineBuffer[0] === "?") {
+        this.processDirectives();
+        this.lineBuffer = "";
+        continue;
+      }
+      if (this.lineBuffer[0] === "!") {
+        this.processTags();
+        this.lineBuffer = "";
+        continue;
+      }
+      this.resolveTags();
+      return true;
+    }
   }
-  /**
-   * Create project manager from project file or directory
-   */
-  static async fromPath(path, events) {
-    const manager = new _ProjectManager(events);
-    await manager.loadProjectFromPath(path);
-    return manager;
+  trimComments(sequence) {
+    const index = this.lineBuffer.indexOf(sequence);
+    if (index >= 0) {
+      const strDelimRegex = new RegExp(`[${this.root.stringDelimiters.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("")}]`);
+      const strIndex = this.lineBuffer.search(strDelimRegex);
+      if (strIndex < 0 || strIndex > index || this.lineBuffer.lastIndexOf(this.lineBuffer[strIndex] || "") < index) {
+        this.lineBuffer = this.lineBuffer.substring(0, index);
+      }
+    }
   }
-  /**
-   * Load project from configuration
-   */
-  async loadProject(config) {
-    try {
-      this.updateStatus({ currentTask: "Loading project configuration", progress: 10 });
-      this.events.onLoadStart?.();
-      this.processor = new RomProcessor(config);
-      this.updateStatus({ currentTask: "Loading ROM data", progress: 30 });
-      await this.processor.loadRom();
-      this.updateStatus({ currentTask: "Initializing database", progress: 60 });
-      await this.processor.initialize();
-      this.updateStatus({
-        isLoaded: true,
-        currentTask: "Project loaded successfully",
-        progress: 100
-      });
-      this.events.onLoadComplete?.(this.processor);
-    } catch (error) {
-      const err = error;
-      this.updateStatus({ lastError: err, currentTask: "Load failed", progress: 0 });
-      this.events.onLoadError?.(err);
-      throw err;
+  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]+/, "");
+    switch (this.lineBuffer.substring(1, endIx).toUpperCase()) {
+      // This is taken care of by the loader
+      case "BANK":
+        this.reqBank = parseInt(value, 16);
+        break;
+      case "INCLUDE":
+        if (value.length > 0) {
+          this.includes.add(value.toUpperCase().replace(/'/g, ""));
+        }
+        break;
     }
   }
-  /**
-   * Load project from file or directory path
-   */
-  async loadProjectFromPath(path) {
-    const processor = await RomProcessor.fromProject(path);
-    await this.loadProject(processor.getProject().config);
+  processTags() {
+    this.lineBuffer = this.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
+    while (this.lineBuffer.length > 0) {
+      let name = this.lineBuffer;
+      let value = null;
+      let endIx = this.lineBuffer.search(/[\s,\t]/);
+      if (endIx >= 0) {
+        name = this.lineBuffer.substring(0, endIx);
+        value = this.lineBuffer.substring(endIx + 1).replace(/^[\s,\t]+/, "");
+        const nextIx = value.search(/[\s,\t]/);
+        if (nextIx >= 0) {
+          this.lineBuffer = value.substring(nextIx + 1).replace(/^[\s,\t]+/, "");
+          value = value.substring(0, nextIx);
+        } else {
+          this.lineBuffer = "";
+        }
+      } else {
+        this.lineBuffer = "";
+      }
+      this.tags.set(name, value);
+    }
   }
-  /**
-   * Analyze ROM structure and extract metadata
-   */
-  async analyzeRom() {
-    if (!this.processor) {
-      throw new Error("Project not loaded. Call loadProject() first.");
+  resolveTags() {
+    for (const [key, value] of this.tags) {
+      let ix;
+      while ((ix = this.lineBuffer.toLowerCase().indexOf(key.toLowerCase())) >= 0) {
+        this.lineBuffer = this.lineBuffer.substring(0, ix) + (value || "") + this.lineBuffer.substring(ix + key.length);
+      }
     }
-    try {
-      this.updateStatus({ currentTask: "Analyzing ROM structure", progress: 20 });
-      this.events.onAnalysisStart?.();
-      const results = await this.processor.analyze();
-      this.updateStatus({
-        isAnalyzed: true,
-        currentTask: "ROM analysis complete",
-        progress: 100
-      });
-      this.events.onAnalysisComplete?.(results);
-      return results;
-    } catch (error) {
-      const err = error;
-      this.updateStatus({ lastError: err, currentTask: "Analysis failed" });
-      throw err;
+  }
+  parseOperand(opnd) {
+    if (!opnd) return null;
+    if (opnd.match(/^[a-fA-F0-9]{2,6}$/)) {
+      switch (opnd.length) {
+        case 2:
+          return new Byte(parseInt(opnd, 16));
+        case 4:
+          return new Word(parseInt(opnd, 16));
+        case 6:
+          return new Long(parseInt(opnd, 16));
+      }
     }
+    return opnd;
   }
-  /**
-   * Extract files from ROM
-   */
-  async extractFiles(outputDir) {
-    if (!this.processor) {
-      throw new Error("Project not loaded. Call loadProject() first.");
+  processRawData() {
+    let reverse = false;
+    if (this.lineBuffer[0] === "#") {
+      this.lineBuffer = this.lineBuffer.substring(1);
     }
-    try {
-      this.updateStatus({ currentTask: "Extracting files from ROM", progress: 30 });
-      this.events.onExtractionStart?.();
-      const results = await this.processor.extract(outputDir);
-      this.updateStatus({
-        isExtracted: true,
-        canBuild: true,
-        currentTask: "File extraction complete",
-        progress: 100
-      });
-      this.events.onExtractionComplete?.(results);
-      return results;
-    } catch (error) {
-      const err = error;
-      this.updateStatus({ lastError: err, currentTask: "Extraction failed" });
-      throw err;
+    if (this.lineBuffer[0] === "$") {
+      reverse = true;
+      this.lineBuffer = this.lineBuffer.substring(1);
+    }
+    let hex;
+    const symbolIx = this.lineBuffer.search(RomProcessingConstants.SYMBOL_SPACE_REGEX);
+    if (symbolIx >= 0) {
+      hex = this.lineBuffer.substring(0, symbolIx);
+      this.lineBuffer = this.lineBuffer.substring(symbolIx).replace(/^[, \t]+/, "");
+    } else {
+      hex = this.lineBuffer;
+      this.lineBuffer = "";
+    }
+    if (hex.length > 0) {
+      if (RomProcessingConstants.ADDRESS_SPACE.includes(hex[0])) {
+        this.currentBlock.objList.push(hex);
+        this.currentBlock.size += RomProcessingConstants.getSize(hex);
+      } else {
+        const data = this.hexStringToBytes(hex);
+        if (data.length === 1) {
+          this.currentBlock.objList.push(new Byte(data[0]));
+          this.currentBlock.size++;
+        } else {
+          if (reverse) {
+            data.reverse();
+          }
+          if (data.length === 2) {
+            this.currentBlock.objList.push(new Word(data[0] | data[1] << 8));
+            this.currentBlock.size += 2;
+          } else {
+            this.currentBlock.objList.push(data);
+            this.currentBlock.size += data.length;
+          }
+        }
+      }
     }
   }
-  /**
-   * Build ROM from extracted files
-   */
-  async buildRom(outputPath) {
-    if (!this.processor) {
-      throw new Error("Project not loaded. Call loadProject() first.");
+  hexStringToBytes(hex) {
+    const result = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+      result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
     }
-    if (!this.status.canBuild) {
-      throw new Error("Cannot build ROM. Extract files first.");
+    return result;
+  }
+};
+var RomGenerator = class {
+  constructor(modules, sourceData) {
+    this.moduleLookup = /* @__PURE__ */ new Map();
+    this.moduleList = ["jp-viper", "title-enhanced"];
+    this.patchFiles = [];
+    this.chunkFiles = [];
+    this.asmFiles = [];
+    this.dbRoot = {};
+    this.sourceData = sourceData;
+    this.moduleList = modules;
+    const crc = crc32_buffer(this.sourceData);
+    if (crc !== 473450688) {
+      throw new Error("CRC mismatch, please provide the correct ROM");
+    }
+  }
+  async generateProject(projectName) {
+    await this.initializeDatabase(projectName);
+    const reader = this.initializeChunks();
+    this.writeScriptTexts(reader);
+    this.applyBaseRom();
+    this.applyProjectInit();
+    this.applySelectedModules();
+    this.assembleCodeFromText();
+    this.applyCodePatches();
+    this.calculateSizes();
+    this.performLayout();
+    this.rebaseAssemblies();
+    this.generateAsmIncludeLookups();
+    const blockLookup = this.generateBlockLookup();
+    const outRom = await this.writeRom(blockLookup);
+    return outRom;
+  }
+  //Grab structures from supabase
+  async initializeDatabase(projectName) {
+    this.dbRoot = await DbRootUtils.fromSupabaseProject({ projectName });
+  }
+  //Read graph from rom
+  initializeChunks() {
+    const reader = new BlockReader(this.sourceData, this.dbRoot);
+    this.chunkFiles = reader.analyzeAndResolve();
+    this.asmFiles = this.chunkFiles.filter((b) => b.type === BinType.Assembly);
+    return reader;
+  }
+  //Convert blocks to text
+  writeScriptTexts(reader) {
+    const writer = new BlockWriter(reader);
+    for (const block of this.asmFiles) {
+      block.textData = writer.generateAsm(block);
+    }
+  }
+  //Apply base rom files
+  applyBaseRom() {
+    for (const chunkFile of this.dbRoot.baseRomFiles) {
+      this.applyPatchFile(chunkFile);
+    }
+  }
+  applyProjectInit() {
+    for (const chunkFile of this.dbRoot.projectFiles) {
+      console.log(`Processing patch: ${chunkFile.name}`);
+      if (chunkFile.group) {
+        let modArray;
+        if (!this.moduleLookup.has(chunkFile.group)) {
+          this.moduleLookup.set(chunkFile.group, modArray = []);
+        } else {
+          modArray = this.moduleLookup.get(chunkFile.group);
+        }
+        modArray.push(chunkFile);
+      } else {
+        this.applyPatchFile(chunkFile);
+      }
     }
-    try {
-      this.updateStatus({ currentTask: "Building ROM", progress: 40 });
-      this.events.onBuildStart?.();
-      const results = await this.processor.build(outputPath);
-      this.updateStatus({
-        currentTask: "ROM build complete",
-        progress: 100
-      });
-      this.events.onBuildComplete?.(results);
-      return results;
-    } catch (error) {
-      const err = error;
-      this.updateStatus({ lastError: err, currentTask: "Build failed" });
-      throw err;
+  }
+  //Apply selected project modules
+  applySelectedModules() {
+    for (const module of this.moduleList) {
+      for (const file of this.moduleLookup.get(module)) {
+        this.applyPatchFile(file);
+      }
     }
   }
-  /**
-   * Process specific scene
-   */
-  async processScene(sceneId, metaFile) {
-    if (!this.processor) {
-      throw new Error("Project not loaded. Call loadProject() first.");
+  //Assemble code from script text
+  assembleCodeFromText() {
+    for (const block of this.asmFiles) {
+      const assembler = new Assembler(this.dbRoot, block.textData);
+      const { blocks, includes, reqBank } = assembler.parseAssembly();
+      block.parts = blocks;
+      block.includes = includes;
+      block.bank = reqBank ?? void 0;
     }
-    return await this.processor.processScene(sceneId, metaFile);
   }
-  /**
-   * Get current project status
-   */
-  getStatus() {
-    return { ...this.status };
+  //Apply patches
+  applyCodePatches() {
+    RomProcessor.applyPatches(this.asmFiles, this.patchFiles);
   }
-  /**
-   * Get the ROM processor instance
-   */
-  getProcessor() {
-    return this.processor;
+  //Calculate sizes
+  calculateSizes() {
+    for (const asm of this.chunkFiles) {
+      ChunkFileUtils.calculateSize(asm);
+    }
   }
-  /**
-   * Get project configuration
-   */
-  getProjectConfig() {
-    return this.processor?.getProject().config || null;
+  // Assign locations
+  performLayout() {
+    const layout = new RomLayout(this.chunkFiles);
+    layout.organize();
   }
-  /**
-   * Get database root
-   */
-  getDatabase() {
-    return this.processor?.getDatabase() || null;
+  // Rebase assemblies
+  rebaseAssemblies() {
+    for (const file of this.asmFiles) {
+      ChunkFileUtils.rebase(file);
+    }
   }
-  /**
-   * Get ROM state
-   */
-  getRomState() {
-    return this.processor?.getRomState() || null;
+  // Build include lookup map per asm file
+  generateAsmIncludeLookups() {
+    for (const f of this.asmFiles) {
+      const includeBlocks = this.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) {
+    console.log(`Processing patch: ${chunkFile.name}`);
+    const existing = this.chunkFiles.find((x) => x.name === chunkFile.name);
+    if (chunkFile.type === BinType.Patch || chunkFile.type === BinType.Assembly) {
+      if (existing) {
+        existing.textData = chunkFile.textData;
+      } else {
+        if (chunkFile.type === BinType.Patch) {
+          this.patchFiles.push(chunkFile);
+        }
+        this.asmFiles.push(chunkFile);
+        this.chunkFiles.push(chunkFile);
+      }
+    } else {
+      if (existing) {
+        existing.rawData = chunkFile.rawData;
+        existing.size = chunkFile.size;
+      } else {
+        this.chunkFiles.push(chunkFile);
+      }
+    }
+  }
+  // Create block lookup for resolving labels to locations
+  generateBlockLookup() {
+    const blockLookup = /* @__PURE__ */ new Map();
+    for (const f of this.chunkFiles) {
+      blockLookup.set(f.name.toUpperCase(), f.location);
+    }
+    return blockLookup;
+  }
+  async writeRom(blockLookup) {
+    const romWriter = new RomWriter(this.dbRoot.entryPoints, "GAIALABS", "01JG  ");
+    for (const file of this.chunkFiles) {
+      await romWriter.writeFile(file, blockLookup);
+    }
+    romWriter.writeHeader();
+    romWriter.writeEntryPoints(this.asmFiles);
+    romWriter.writeChecksum();
+    return romWriter.outBuffer;
+  }
+};
+
+// src/sprites/SpriteFrame.ts
+var SpriteFrame = class {
+  constructor(duration = 0, groupIndex = 0, groupOffset = 0) {
+    this.duration = duration;
+    this.groupIndex = groupIndex;
+    this.groupOffset = groupOffset;
+  }
+};
+
+// src/sprites/SpritePart.ts
+var SpritePart = class {
+  constructor() {
+    this.isLarge = false;
+    this.xOffset = 0;
+    this.xOffsetMirror = 0;
+    this.yOffset = 0;
+    this.yOffsetMirror = 0;
+    this.vMirror = false;
+    this.hMirror = false;
+    this.someOffset = 0;
+    this.paletteIndex = 0;
+    this.tileIndex = 0;
+  }
+};
+
+// src/sprites/SpriteGroup.ts
+var SpriteGroup = class {
+  constructor() {
+    this.xOffset = 0;
+    this.xOffsetMirror = 0;
+    this.yOffset = 0;
+    this.yOffsetMirror = 0;
+    this.xRecoilHitboxOffset = 0;
+    this.yRecoilHitboxOffset = 0;
+    this.xRecoilHitboxTilesize = 0;
+    this.yRecoilHitboxTilesize = 0;
+    this.xHostileHitboxOffset = 0;
+    this.xHostileHitboxSize = 0;
+    this.yHostileHitboxOffset = 0;
+    this.yHostileHitboxSize = 0;
+    this.parts = [];
+  }
+};
+
+// src/sprites/SpriteMap.ts
+var SpriteMap = class _SpriteMap {
+  constructor() {
+    this.frameSets = [];
+    this.groups = [];
   }
   /**
-   * Reset project to initial state
+   * Create a SpriteMap from binary data
+   * @param data Binary data buffer
+   * @returns SpriteMap instance
    */
-  reset() {
-    this.processor = null;
-    this.status = {
-      isLoaded: false,
-      isAnalyzed: false,
-      isExtracted: false,
-      canBuild: false,
-      progress: 0
+  static fromBytes(data) {
+    let position = 0;
+    const getByte = () => {
+      if (position >= data.length) return 0;
+      return data[position++];
     };
+    const getUshort = () => {
+      if (position + 1 >= data.length) return 0;
+      const low = data[position++];
+      const high = data[position++];
+      return low | high << 8;
+    };
+    const spriteMap = new _SpriteMap();
+    const setOffsets = /* @__PURE__ */ new Set();
+    const groupOffsets = /* @__PURE__ */ new Set();
+    position = 0;
+    while (!setOffsets.has(position)) {
+      const offset = getUshort() - 16384;
+      setOffsets.add(offset);
+    }
+    for (const offStart of setOffsets) {
+      position = offStart;
+      const frameList = [];
+      while (true) {
+        const duration = getUshort();
+        if (duration === 65535) {
+          break;
+        }
+        const groupOffset = getUshort() - 16384;
+        frameList.push(new SpriteFrame(duration, 0, groupOffset));
+        groupOffsets.add(groupOffset);
+      }
+      spriteMap.frameSets.push(frameList);
+    }
+    let grpIx = 0;
+    const sortedGroupOffsets = Array.from(groupOffsets).sort((a, b) => a - b);
+    for (const offStart of sortedGroupOffsets) {
+      position = offStart;
+      for (const set of spriteMap.frameSets) {
+        for (const frame of set) {
+          if (frame.groupOffset === offStart) {
+            frame.groupIndex = grpIx;
+          }
+        }
+      }
+      const grp = new SpriteGroup();
+      grp.xOffset = getByte();
+      grp.xOffsetMirror = getByte();
+      grp.yOffset = getByte();
+      grp.yOffsetMirror = getByte();
+      grp.xRecoilHitboxOffset = getByte();
+      grp.yRecoilHitboxOffset = getByte();
+      grp.xRecoilHitboxTilesize = getByte();
+      grp.yRecoilHitboxTilesize = getByte();
+      grp.xHostileHitboxOffset = getByte();
+      grp.xHostileHitboxSize = getByte();
+      grp.yHostileHitboxOffset = getByte();
+      grp.yHostileHitboxSize = getByte();
+      let numParts = getByte();
+      while (numParts-- > 0) {
+        const part = new SpritePart();
+        part.isLarge = getByte() !== 0;
+        part.xOffset = getByte();
+        part.xOffsetMirror = getByte();
+        part.yOffset = getByte();
+        part.yOffsetMirror = getByte();
+        const props = getUshort();
+        part.vMirror = (props & 32768) !== 0;
+        part.hMirror = (props & 16384) !== 0;
+        part.someOffset = props >> 12 & 3;
+        part.paletteIndex = props >> 9 & 7;
+        part.tileIndex = props & 511;
+        grp.parts.push(part);
+      }
+      spriteMap.groups.push(grp);
+      grpIx++;
+    }
+    return spriteMap;
   }
   /**
-   * Complete workflow: load, analyze, extract, and build
+   * Convert this SpriteMap to binary data
+   * @returns Binary data buffer
    */
-  async completeWorkflow(projectPath, outputDir, outputRomPath) {
-    await this.loadProjectFromPath(projectPath);
-    const analysisResults = await this.analyzeRom();
-    const extractionResults = await this.extractFiles(outputDir);
-    const buildResults = await this.buildRom(outputRomPath);
-    return {
-      analysis: analysisResults,
-      extraction: extractionResults,
-      build: buildResults
+  toBytes() {
+    let size = this.frameSets.length * 2;
+    for (const set of this.frameSets) {
+      size += set.length * 4 + 2;
+    }
+    for (const grp of this.groups) {
+      size += grp.parts.length * 7 + 13;
+    }
+    const buffer = new Uint8Array(size);
+    let position = 0;
+    const writeShort = (val) => {
+      buffer[position++] = val & 255;
+      buffer[position++] = val >> 8 & 255;
     };
-  }
-  // Private helper methods
-  updateStatus(update) {
-    this.status = { ...this.status, ...update };
+    const writeLoc = (val) => writeShort(val + 16384);
+    let pos = this.frameSets.length << 1;
+    const groupPos = new Array(this.groups.length);
+    for (const set of this.frameSets) {
+      writeLoc(pos);
+      pos += (set.length << 2) + 2;
+    }
+    for (let i = 0; i < this.groups.length; i++) {
+      groupPos[i] = pos;
+      pos += this.groups[i].parts.length * 7 + 13;
+    }
+    for (const set of this.frameSets) {
+      for (const frm of set) {
+        writeShort(frm.duration);
+        writeLoc(groupPos[frm.groupIndex]);
+      }
+      writeShort(65535);
+    }
+    for (const grp of this.groups) {
+      buffer[position++] = grp.xOffset;
+      buffer[position++] = grp.xOffsetMirror;
+      buffer[position++] = grp.yOffset;
+      buffer[position++] = grp.yOffsetMirror;
+      buffer[position++] = grp.xRecoilHitboxOffset;
+      buffer[position++] = grp.yRecoilHitboxOffset;
+      buffer[position++] = grp.xRecoilHitboxTilesize;
+      buffer[position++] = grp.yRecoilHitboxTilesize;
+      buffer[position++] = grp.xHostileHitboxOffset;
+      buffer[position++] = grp.xHostileHitboxSize;
+      buffer[position++] = grp.yHostileHitboxOffset;
+      buffer[position++] = grp.yHostileHitboxSize;
+      buffer[position++] = grp.parts.length;
+      for (const prt of grp.parts) {
+        buffer[position++] = prt.isLarge ? 1 : 0;
+        buffer[position++] = prt.xOffset;
+        buffer[position++] = prt.xOffsetMirror;
+        buffer[position++] = prt.yOffset;
+        buffer[position++] = prt.yOffsetMirror;
+        const accum = (prt.vMirror ? 32768 : 0) | (prt.hMirror ? 16384 : 0) | (prt.someOffset & 3) << 12 | (prt.paletteIndex & 7) << 9 | prt.tileIndex;
+        writeShort(accum);
+      }
+    }
+    return buffer.slice(0, position);
   }
 };
 
-// src/rom/rebuild/index.ts
-var ROM_REBUILD_MODULE = "gaia-core/rom/rebuild";
-
 // src/index.ts
 var GAIA_CORE_VERSION = "0.1.0";
 var isPlatformBrowser = typeof window !== "undefined";
 var isPlatformNode = typeof process !== "undefined" && process.versions?.node;
 var isPlatformWebWorker = typeof importScripts !== "undefined";
 
-export { ADDRESSING_REGEX, ALL_OPCODES, AddressingModeHandler, AsmReader, BlockReader, BlockWriter, CopCommandProcessor, FileReader, GAIA_CORE_VERSION, GROUPED_OPCODES, HEX_REGEX, ObjectType, Op, OpCode, OpCodeUtils, OperationContext, PostProcessor, ProcessorStateManager, ProjectManager, ProjectRoot, QuintetLZ, ROM_REBUILD_MODULE, ReferenceManager, Registers, RomDataReader, RomProcessor, RomState, RomStateUtils, SfxReader, SpriteFrame, SpriteGroup, SpriteMap, SpritePart, Stack, StackOperations, StringReader, TransformProcessor, TypeParser, isPlatformBrowser, isPlatformNode, isPlatformWebWorker };
+export { AddressingModeHandler, AsmReader, Assembler, AssemblerState, BlockReader, BlockWriter, CopCommandProcessor, GAIA_CORE_VERSION, ObjectType, OperationContext, PostProcessor, ProcessorStateManager, ProjectRoot, QuintetLZ, ReferenceManager, Registers, RomDataReader, RomGenerator, RomLayout, RomProcessor, RomState, RomStateUtils, RomWriter, SortedMap, SpriteFrame, SpriteGroup, SpriteMap, SpritePart, Stack, StackOperations, StringProcessor, StringReader, TransformProcessor, TypeParser, isPlatformBrowser, isPlatformNode, isPlatformWebWorker, registerCompressionProviders };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map