@gaialabs/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3561 @@
+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';
+
+// 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;
+  }
+};
+var QuintetLZ = class _QuintetLZ {
+  static {
+    this.DICTIONARY_SIZE = 256;
+  }
+  static {
+    this.DICTIONARY_INIT = 32;
+  }
+  static {
+    this.DICTIONARY_OFFSET = 239;
+  }
+  static {
+    this.DEFAULT_PAGE_SIZE = 32768;
+  }
+  /**
+   * Expand (decompress) data using QuintetLZ algorithm
+   * @param srcData Source data buffer
+   * @param srcPosition Starting position in source data
+   * @param srcLen Length of source data to process
+   * @returns Expanded data
+   */
+  expand(srcData, srcPosition = 0, srcLen = _QuintetLZ.DEFAULT_PAGE_SIZE) {
+    const bitStream = new BitStream(srcData, srcPosition);
+    const srcStop = srcPosition + srcLen;
+    const dictionary = new Uint8Array(_QuintetLZ.DICTIONARY_SIZE);
+    dictionary.fill(_QuintetLZ.DICTIONARY_INIT);
+    let dictPosition = _QuintetLZ.DICTIONARY_OFFSET;
+    let outPosition = 0;
+    const dstLen = bitStream.readShort();
+    const outBuffer = new Uint8Array(dstLen);
+    while (bitStream.currentPosition < srcStop && outPosition < dstLen) {
+      if (bitStream.readBit()) {
+        const sample = bitStream.readByte();
+        if (outPosition < dstLen) {
+          outBuffer[outPosition++] = sample;
+        }
+        dictionary[dictPosition] = sample;
+        dictPosition = dictPosition + 1 & 255;
+      } else {
+        let wordIndex = bitStream.readByte();
+        let wordLength = bitStream.readNibble() + 2;
+        while (wordLength-- > 0) {
+          const sample = dictionary[wordIndex];
+          wordIndex = wordIndex + 1 & 255;
+          if (outPosition < dstLen) {
+            outBuffer[outPosition++] = sample;
+          }
+          dictionary[dictPosition] = sample;
+          dictPosition = dictPosition + 1 & 255;
+        }
+      }
+    }
+    if (outPosition < dstLen) {
+      return outBuffer.slice(0, outPosition);
+    }
+    return outBuffer;
+  }
+  /**
+   * Compact (compress) data using QuintetLZ algorithm
+   * @param srcData Source data to compress
+   * @returns Compressed data
+   */
+  compact(srcData) {
+    const dictionary = new Uint8Array(_QuintetLZ.DICTIONARY_SIZE);
+    dictionary.fill(_QuintetLZ.DICTIONARY_INIT);
+    let offset = _QuintetLZ.DICTIONARY_OFFSET;
+    let srcIx = 0;
+    let dstIx = 0;
+    const srcLen = srcData.length;
+    const outputBuffer = new Uint8Array(srcLen * 2);
+    outputBuffer[dstIx++] = srcLen & 255;
+    outputBuffer[dstIx++] = srcLen >> 8 & 255;
+    const bitStream = new BitStream(outputBuffer, 2);
+    const getCommand = () => {
+      const maxLen = Math.min(srcLen - srcIx, 17);
+      if (maxLen < 2) {
+        return [0, 0];
+      }
+      let startByte = 0;
+      let bestLen = 0;
+      let bx = offset;
+      for (let i = 0; i < 256; i++, bx = bx + 1 & 255) {
+        let size = 0;
+        let bix = bx;
+        while (size < maxLen && dictionary[bix] === srcData[srcIx + size]) {
+          bix = bix + 1 & 255;
+          if (bix === offset) {
+            bix = bx;
+          }
+          size++;
+        }
+        if (size > bestLen) {
+          startByte = bx;
+          bestLen = size;
+          if (bestLen >= maxLen) {
+            break;
+          }
+        }
+      }
+      return [startByte, bestLen];
+    };
+    while (srcIx < srcLen) {
+      const [cmdStart, cmdLen] = getCommand();
+      if (cmdLen >= 2) {
+        bitStream.writeBit(false);
+        bitStream.writeByte(cmdStart);
+        bitStream.writeNibble(cmdLen - 2);
+        for (let i = 0; i < cmdLen; i++) {
+          dictionary[offset] = srcData[srcIx++];
+          offset = offset + 1 & 255;
+        }
+      } else {
+        bitStream.writeBit(true);
+        const val = srcData[srcIx++];
+        bitStream.writeByte(val);
+        dictionary[offset] = val;
+        offset = offset + 1 & 255;
+      }
+    }
+    bitStream.flush();
+    const finalSize = Math.max(dstIx, bitStream.currentPosition);
+    return outputBuffer.slice(0, finalSize);
+  }
+};
+
+// 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();
+  }
+  /**
+   * Hydrate processor registers with stored state
+   * Uses Registers from gaia-core/assembly for processor state management
+   */
+  hydrateRegisters(position, reg) {
+    const acc = this.accumulatorFlags.get(position);
+    if (acc !== void 0) {
+      reg.accumulatorFlag = acc;
+    }
+    const ind = this.indexFlags.get(position);
+    if (ind !== void 0) {
+      reg.indexFlag = ind;
+    }
+    const bnk = this.bankNotes.get(position);
+    if (bnk !== void 0) {
+      reg.dataBank = bnk;
+    }
+    const stack = this.stackPositions.get(position);
+    if (stack !== void 0) {
+      reg.stack.location = stack;
+    }
+  }
+  // Accumulator flag methods
+  getAccumulatorFlag(location) {
+    return this.accumulatorFlags.get(location);
+  }
+  setAccumulatorFlag(location, value) {
+    this.accumulatorFlags.set(location, value);
+  }
+  tryAddAccumulatorFlag(location, value) {
+    if (this.accumulatorFlags.has(location)) {
+      return false;
+    }
+    this.accumulatorFlags.set(location, value);
+    return true;
+  }
+  // Index flag methods
+  getIndexFlag(location) {
+    return this.indexFlags.get(location);
+  }
+  setIndexFlag(location, value) {
+    this.indexFlags.set(location, value);
+  }
+  tryAddIndexFlag(location, value) {
+    if (this.indexFlags.has(location)) {
+      return false;
+    }
+    this.indexFlags.set(location, value);
+    return true;
+  }
+  // Bank note methods
+  getBankNote(location) {
+    return this.bankNotes.get(location);
+  }
+  setBankNote(location, value) {
+    this.bankNotes.set(location, value);
+  }
+  // Stack position methods
+  getStackPosition(location) {
+    return this.stackPositions.get(location);
+  }
+  setStackPosition(location, value) {
+    this.stackPositions.set(location, value);
+  }
+  tryAddStackPosition(location, value) {
+    if (this.stackPositions.has(location)) {
+      return false;
+    }
+    this.stackPositions.set(location, value);
+    return true;
+  }
+};
+
+// src/rom/extraction/reader.ts
+var RomDataReader = class {
+  constructor(romData) {
+    if (!romData) {
+      throw new Error("romData cannot be null");
+    }
+    this.romData = romData;
+    this.position = 0;
+  }
+  readByte() {
+    return this.romData[this.position++];
+  }
+  readSByte() {
+    const value = this.readByte();
+    return value > 127 ? value - 256 : value;
+  }
+  readUShort() {
+    return this.readByte() | this.readByte() << 8;
+  }
+  readShort() {
+    const value = this.readUShort();
+    return value > 32767 ? value - 65536 : value;
+  }
+  readAddress() {
+    return this.readByte() | this.readByte() << 8 | this.readByte() << 16;
+  }
+  readInt() {
+    return this.readByte() | this.readByte() << 8 | this.readByte() << 16 | this.readByte() << 24;
+  }
+  peekByte() {
+    return this.romData[this.position];
+  }
+  peekShort() {
+    return this.romData[this.position] | this.romData[this.position + 1] << 8;
+  }
+  peekAddress() {
+    return this.romData[this.position] | this.romData[this.position + 1] << 8 | this.romData[this.position + 2] << 16;
+  }
+};
+var ReferenceManager = class {
+  constructor(root) {
+    this.structTable = /* @__PURE__ */ new Map();
+    this.markerTable = /* @__PURE__ */ new Map();
+    this.nameTable = /* @__PURE__ */ new Map();
+    if (!root) {
+      throw new Error("root cannot be null");
+    }
+    this.root = root;
+  }
+  // Struct management
+  tryGetStruct(location) {
+    const chunkType = this.structTable.get(location);
+    return { found: chunkType !== void 0, chunkType };
+  }
+  tryAddStruct(location, chunkType) {
+    if (this.structTable.has(location)) {
+      return false;
+    }
+    this.structTable.set(location, chunkType);
+    return true;
+  }
+  containsStruct(location) {
+    return this.structTable.has(location);
+  }
+  // Name management
+  tryGetName(location) {
+    const referenceName = this.nameTable.get(location);
+    return { found: referenceName !== void 0, referenceName };
+  }
+  tryAddName(location, referenceName) {
+    if (this.nameTable.has(location)) {
+      return false;
+    }
+    this.nameTable.set(location, referenceName);
+    return true;
+  }
+  // Marker management
+  tryGetMarker(location) {
+    const offset = this.markerTable.get(location);
+    return { found: offset !== void 0, offset };
+  }
+  setMarker(location, offset) {
+    this.markerTable.set(location, offset);
+  }
+  // Label creation
+  createBranchLabel(location) {
+    const name = `loc_${location.toString(16).toUpperCase().padStart(6, "0")}`;
+    this.nameTable.set(location, name);
+    return name;
+  }
+  createTypeName(type, location) {
+    let name = type.toLowerCase();
+    while (name.length > 0 && BlockReaderConstants.POINTER_CHARACTERS.includes(name[0])) {
+      name = name.substring(1) + "_list";
+    }
+    return `${name}_${location.toString(16).toUpperCase().padStart(6, "0")}`;
+  }
+  createFallbackName(location) {
+    const fileMatch = this.root.files.find(
+      (x) => x.start <= location && x.end > location
+    );
+    if (fileMatch) {
+      const offset = location - fileMatch.start;
+      return fileMatch.name + (offset !== 0 ? `+${offset.toString(16).toUpperCase()}` : "");
+    }
+    return location.toString(16).toUpperCase().padStart(6, "0");
+  }
+  /**
+   * Finds a reference location by its assigned name.
+   */
+  findLocationByName(name) {
+    for (const [loc, refName] of this.nameTable) {
+      if (refName === name) {
+        return loc;
+      }
+    }
+    return void 0;
+  }
+  resolveName(location, type, isBranch) {
+    const prefix = Address.codeFromType(type);
+    let name;
+    let label = null;
+    let resolvedLocation = location;
+    const rewrite = this.root.rewrites[location];
+    if (rewrite !== void 0) {
+      const result = this.processRewrite(location, rewrite);
+      resolvedLocation = result.location;
+      label = result.label;
+    }
+    const existingName = this.nameTable.get(resolvedLocation);
+    if (existingName) {
+      name = existingName;
+    } else {
+      name = isBranch ? this.createBranchLabel(resolvedLocation) : this.findClosestReference(resolvedLocation) || this.createFallbackName(resolvedLocation);
+    }
+    return `${prefix || ""}${name}${label || ""}`;
+  }
+  findClosestReference(location) {
+    let closestDistance = BlockReaderConstants.REF_SEARCH_MAX_RANGE;
+    let closestName = null;
+    let closestLocation = null;
+    for (const [entryKey, entryValue] of this.nameTable) {
+      if (entryKey > location) {
+        continue;
+      }
+      const distance = location - entryKey;
+      if (distance >= closestDistance) {
+        continue;
+      }
+      closestDistance = distance;
+      closestName = entryValue;
+      closestLocation = entryKey;
+      if (closestDistance === 1) {
+        break;
+      }
+    }
+    return this.processClosestMatch(location, closestName, closestLocation, closestDistance);
+  }
+  processRewrite(location, rewrite) {
+    const offset = location - rewrite;
+    const cmd = offset < 0 ? "-" : "+";
+    const absOffset = Math.abs(offset);
+    let label = null;
+    const structType = this.structTable.get(rewrite);
+    if (structType === BlockReaderConstants.WIDE_STRING_TYPE) {
+      this.markerTable.set(rewrite, absOffset);
+      this.markerTable.set(location, absOffset);
+      label = cmd === "-" ? BlockReaderConstants.NEGATIVE_MARKER_FORMAT : BlockReaderConstants.MARKER_FORMAT;
+    } else {
+      const formatString = cmd === "-" ? BlockReaderConstants.NEGATIVE_OFFSET_FORMAT : BlockReaderConstants.OFFSET_FORMAT;
+      label = formatString.replace("{0:X}", absOffset.toString(16).toUpperCase());
+    }
+    return { location: rewrite, label };
+  }
+  processClosestMatch(location, closestName, closestLocation, closestDistance) {
+    if (!closestName || closestLocation === null) {
+      return null;
+    }
+    let result = closestName;
+    const structType = this.structTable.get(closestLocation);
+    if (structType === BlockReaderConstants.WIDE_STRING_TYPE) {
+      this.markerTable.set(closestLocation, closestDistance);
+      this.markerTable.set(location, closestDistance);
+      result += BlockReaderConstants.MARKER_FORMAT;
+    } else {
+      result += `+${closestDistance.toString(16).toUpperCase()}`;
+    }
+    return result;
+  }
+};
+
+// src/rom/extraction/stack.ts
+var StackOperations = class {
+  constructor(registers, blockReader) {
+    this._registers = registers;
+    this._blockReader = blockReader;
+  }
+  handleStackOperation(mnemonic) {
+    switch (mnemonic) {
+      case "PHD":
+        this._registers.stack.push(this._registers.direct ?? 0);
+        break;
+      case "PLD":
+        this._registers.direct = this._registers.stack.popUInt16();
+        break;
+      case "PHK":
+        this._registers.stack.push(this._blockReader._romDataReader.position >> 16 | 128);
+        break;
+      case "PHB":
+        this._registers.stack.push(this._registers.dataBank ?? 129);
+        break;
+      case "PLB":
+        this._registers.dataBank = this._registers.stack.popByte();
+        break;
+      case "PHP":
+        this._registers.stack.push(this._registers.statusFlags);
+        break;
+      case "PLP":
+        this._registers.statusFlags = this._registers.stack.popByte();
+        break;
+      case "PHA":
+        this.handleAccumulatorPush();
+        break;
+      case "PLA":
+        this.handleAccumulatorPull();
+        break;
+      case "PHX":
+        this.handleXIndexPush();
+        break;
+      case "PLX":
+        this.handleXIndexPull();
+        break;
+      case "PHY":
+        this.handleYIndexPush();
+        break;
+      case "PLY":
+        this.handleYIndexPull();
+        break;
+      case "XBA":
+        this.handleExchangeBytes();
+        break;
+    }
+  }
+  handleAccumulatorPush() {
+    if (this._registers.accumulatorFlag === true) {
+      this._registers.stack.push((this._registers.accumulator ?? 0) & 255);
+    } else {
+      this._registers.stack.pushUInt16(this._registers.accumulator ?? 0);
+    }
+  }
+  handleAccumulatorPull() {
+    if (this._registers.accumulatorFlag === true) {
+      this._registers.accumulator = (this._registers.accumulator ?? 0) & 65280 | this._registers.stack.popByte();
+    } else {
+      this._registers.accumulator = this._registers.stack.popUInt16();
+    }
+  }
+  handleXIndexPush() {
+    if (this._registers.indexFlag === true) {
+      this._registers.stack.push((this._registers.xIndex ?? 0) & 255);
+    } else {
+      this._registers.stack.pushUInt16(this._registers.xIndex ?? 0);
+    }
+  }
+  handleXIndexPull() {
+    if (this._registers.indexFlag === true) {
+      this._registers.xIndex = (this._registers.xIndex ?? 0) & 65280 | this._registers.stack.popByte();
+    } else {
+      this._registers.xIndex = this._registers.stack.popUInt16();
+    }
+  }
+  handleYIndexPush() {
+    if (this._registers.indexFlag === true) {
+      this._registers.stack.push((this._registers.yIndex ?? 0) & 255);
+    } else {
+      this._registers.stack.pushUInt16(this._registers.yIndex ?? 0);
+    }
+  }
+  handleYIndexPull() {
+    if (this._registers.indexFlag === true) {
+      this._registers.yIndex = (this._registers.yIndex ?? 0) & 65280 | this._registers.stack.popByte();
+    } else {
+      this._registers.yIndex = this._registers.stack.popUInt16();
+    }
+  }
+  handleExchangeBytes() {
+    const acc = this._registers.accumulator ?? 0;
+    this._registers.accumulator = (acc >> 8 | acc << 8) & 65535;
+  }
+};
+var CopCommandProcessor = class {
+  constructor(blockReader) {
+    this._blockReader = blockReader;
+    this._romDataReader = blockReader._romDataReader;
+  }
+  /**
+   * Parses a COP command based on its definition
+   */
+  parseCopCommand(copDef, operands) {
+    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 memberTypeName = isPtr ? addrType.toString() : partStr;
+      const memberType = this.tryParseMemberType(memberTypeName);
+      if (memberType === null) {
+        throw new Error("Cannot use structs in cop def");
+      }
+      const label = this._blockReader._root.labels[this._romDataReader.position];
+      if (label) {
+        this._romDataReader.position += this.getMemberTypeSize(memberType);
+        operands.push(label);
+      } else {
+        operands.push(this.readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType));
+      }
+    }
+  }
+  tryParseMemberType(memberTypeName) {
+    const upperName = memberTypeName.toUpperCase();
+    for (const [key, value] of Object.entries(MemberType)) {
+      if (key.toUpperCase() === upperName) {
+        return value;
+      }
+    }
+    return null;
+  }
+  getMemberTypeSize(memberType) {
+    switch (memberType) {
+      case MemberType.Byte:
+        return 1;
+      case MemberType.Word:
+      case MemberType.Offset:
+        return 2;
+      case MemberType.Address:
+        return 3;
+      default:
+        throw new Error("Unsupported COP member type");
+    }
+  }
+  readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType) {
+    switch (memberType) {
+      case MemberType.Byte:
+        return createByte(this._romDataReader.readByte());
+      case MemberType.Word:
+        return createWord(this._romDataReader.readUShort());
+      case MemberType.Offset:
+        return this.createCopLocation(this._romDataReader.readUShort(), null, partStr, isPtr, referenceType, addrType);
+      case MemberType.Address:
+        return this.createCopLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), partStr, isPtr, referenceType, addrType);
+      default:
+        throw new Error("Unsupported COP member type");
+    }
+  }
+  createCopLocation(offset, bank, partStr, isPtr, otherStr, type) {
+    if (bank === null && offset === 0) {
+      return createWord(offset);
+    }
+    const addr = new Address(bank ?? this._romDataReader.position >> 16, offset);
+    if (addr.space === AddressSpace.ROM) {
+      const location = addr.toInt();
+      if (partStr !== "Address" && isPtr && !this._blockReader._root.rewrites[location]) {
+        this._blockReader.noteType(location, otherStr, true);
+      }
+      if (type === AddressType.Unknown) {
+        type = this.tryParseAddressType(partStr) ?? AddressType.Unknown;
+      }
+      return new LocationWrapper(location, type);
+    }
+    return addr;
+  }
+  tryParseAddressType(addressTypeName) {
+    const upperName = addressTypeName.toUpperCase();
+    for (const [key, value] of Object.entries(AddressType)) {
+      if (key.toUpperCase() === upperName) {
+        return value;
+      }
+    }
+    return null;
+  }
+};
+
+// src/rom/extraction/addressing.ts
+var OperationContext = class {
+  constructor() {
+    this.size = 0;
+    this.nextAddress = 0;
+    this.xForm1 = null;
+    this.xForm2 = null;
+    this.copDef = null;
+  }
+};
+var AddressingModeHandler = class {
+  constructor(blockReader, transformProcessor) {
+    this._blockReader = blockReader;
+    this._transformProcessor = transformProcessor;
+    this._copProcessor = new CopCommandProcessor(blockReader);
+    this._dataReader = blockReader._romDataReader;
+  }
+  processAddressingMode(code, context, reg) {
+    const operands = [];
+    switch (code.mode) {
+      case AddressingMode.Stack:
+      case AddressingMode.Implied:
+        this.handleStackOrImpliedMode(code.mnem, reg);
+        break;
+      case AddressingMode.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:
+        this.handleAbsoluteMode(code.mnem, void 0, context.nextAddress, reg.dataBank, operands, reg);
+        break;
+      case AddressingMode.AbsoluteLong:
+      case AddressingMode.AbsoluteLongIndexedX:
+        this.handleAbsoluteLongMode(code.mnem, operands, reg);
+        break;
+      case AddressingMode.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:
+        this.handleDirectPageMode(operands);
+        break;
+      case AddressingMode.PCRelative:
+        this.handlePCRelativeMode(operands, context.nextAddress, reg, false);
+        break;
+      case AddressingMode.PCRelativeLong:
+        this.handlePCRelativeMode(operands, context.nextAddress, reg, true);
+        break;
+      case AddressingMode.StackRelative:
+      case AddressingMode.StackRelativeIndirectIndexedY:
+        this.handleStackRelativeMode(operands);
+        break;
+      case AddressingMode.StackInterrupt:
+        this.handleStackInterruptMode(code.mnem, operands, context);
+        break;
+    }
+    return operands;
+  }
+  handleImmediateMode(mnemonic, size, operands, reg) {
+    const operand = this.readImmediateOperand(size);
+    operands.push(operand);
+    this.updateRegisterForImmediateInstruction(mnemonic, operand, reg);
+  }
+  readImmediateOperand(size) {
+    return size === 3 ? createWord(this._dataReader.readUShort()) : createByte(this._dataReader.readByte());
+  }
+  updateRegisterForImmediateInstruction(mnemonic, operand, reg) {
+    const value = typeof operand === "number" ? operand : operand.value;
+    switch (mnemonic) {
+      case "LDA":
+        reg.accumulator = this.calculateRegisterValue(reg.accumulator, value);
+        break;
+      case "LDX":
+        reg.xIndex = this.calculateRegisterValue(reg.xIndex, value);
+        break;
+      case "LDY":
+        reg.yIndex = this.calculateRegisterValue(reg.yIndex, value);
+        break;
+      case "SEP":
+      case "REP":
+        this.updateStatusFlags(mnemonic, value);
+        break;
+    }
+  }
+  calculateRegisterValue(currentValue, operand) {
+    if (operand > 255) {
+      return operand;
+    } else {
+      return (currentValue ?? 0) & 65280 | operand;
+    }
+  }
+  updateStatusFlags(mnemonic, flagValue) {
+    const flag = flagValue;
+    const isSep = mnemonic === "SEP";
+    if (flag & StatusFlags.AccumulatorMode) {
+      this._blockReader.AccumulatorFlags.set(this._dataReader.position, isSep);
+    }
+    if (flag & StatusFlags.IndexMode) {
+      this._blockReader.IndexFlags.set(this._dataReader.position, isSep);
+    }
+  }
+  handleAbsoluteLongMode(mnemonic, operands, reg) {
+    const refLoc = this._dataReader.readUShort();
+    const bank = this._dataReader.readByte();
+    const address = new Address(bank, refLoc);
+    if (address.space === AddressSpace.ROM) {
+      const wrapper = new LocationWrapper(address.toInt(), AddressType.Address);
+      if (this.isJumpInstruction(mnemonic)) {
+        this._blockReader.noteType(wrapper.location, "Code", false, reg);
+      }
+      operands.push(wrapper);
+    } else {
+      operands.push(address);
+    }
+  }
+  handleBlockMoveMode(operands, context) {
+    operands.push(createByte(this._dataReader.readByte()));
+    context.xForm2 = this._transformProcessor.getTransform();
+    operands.push(createByte(this._dataReader.readByte()));
+  }
+  handleDirectPageMode(operands) {
+    operands.push(createByte(this._dataReader.readByte()));
+  }
+  handlePCRelativeMode(operands, nextAddress, reg, isLong) {
+    const relative = isLong ? nextAddress + this._dataReader.readShort() : nextAddress + this._dataReader.readSByte();
+    this._blockReader.noteType(relative, "Code", void 0, reg);
+    operands.push(new LocationWrapper(relative, AddressType.Relative));
+  }
+  handleStackRelativeMode(operands) {
+    operands.push(createByte(this._dataReader.readByte()));
+  }
+  handleStackInterruptMode(mnemonic, operands, context) {
+    const cmd = this._dataReader.readByte();
+    operands.push(cmd);
+    if (mnemonic === "COP") {
+      const copDef = this._blockReader._root.copDef[cmd];
+      if (!copDef) {
+        throw new Error("Unknown COP command");
+      }
+      context.copDef = copDef;
+      this._copProcessor.parseCopCommand(copDef, operands);
+    }
+  }
+  handleStackOrImpliedMode(mnemonic, reg) {
+    const stackOperations = new StackOperations(reg, this._blockReader);
+    stackOperations.handleStackOperation(mnemonic);
+  }
+  handleAbsoluteMode(mnemonic, xBank1, next, dataBank, operands, registers) {
+    let refLoc = this._dataReader.readUShort();
+    const isPush = this.isPushInstruction(mnemonic);
+    if (isPush) {
+      refLoc++;
+    }
+    const isJump = isPush || this.isJumpInstruction(mnemonic);
+    const bank = xBank1 ?? (isJump ? this._dataReader.position >> 16 : dataBank ?? 129);
+    const addr = new Address(bank, refLoc);
+    if (addr.isROM) {
+      const wrapper = new LocationWrapper(addr.toInt(), AddressType.Offset);
+      if (isJump) {
+        const name = this._blockReader.noteType(wrapper.location, "Code", isPush, registers);
+        if (isPush) {
+          operands.push(`&${name}-1`);
+          return;
+        }
+      }
+      operands.push(wrapper);
+    } else {
+      operands.push(addr);
+    }
+  }
+  isJumpInstruction(mnemonic) {
+    return mnemonic[0] === "J";
+  }
+  isPushInstruction(mnemonic) {
+    return mnemonic[0] === "P";
+  }
+};
+var TransformProcessor = class _TransformProcessor {
+  static {
+    // Location regex pattern: _([A-Fa-f0-9]{6})
+    this.LOCATION_REGEX = /_([A-Fa-f0-9]{6})/;
+  }
+  constructor(romReader) {
+    this._blockReader = romReader;
+    this._romDataReader = romReader._romDataReader;
+    this._referenceManager = romReader._referenceManager;
+    this._labelLookup = romReader._root.labels;
+  }
+  /**
+   * Retrieves transform information for the current ROM position
+   */
+  getTransform() {
+    const transform = this._labelLookup[this._romDataReader.position];
+    if (transform === "") {
+      return transform;
+    } else if (!transform) {
+      return null;
+    }
+    const transformName = this.cleanTransformName(transform);
+    const referenceLocation = this.resolveTransformReference(transformName);
+    if (referenceLocation !== null) {
+      this._blockReader.resolveInclude(referenceLocation, false);
+    }
+    return transform;
+  }
+  /**
+   * Applies transforms to operands
+   */
+  applyTransforms(op1Label, op2Label, operands) {
+    this.applyTransform(op1Label, 0, operands);
+    this.applyTransform(op2Label, 1, operands);
+  }
+  applyTransform(transform, operandIndex, operands) {
+    if (transform === null || transform === void 0 || operandIndex >= operands.length) {
+      return;
+    }
+    if (transform === "") {
+      this.applyDefaultTransform(operandIndex, operands);
+    } else {
+      operands[operandIndex] = transform;
+    }
+  }
+  applyDefaultTransform(operandIndex, operands) {
+    let value = this._romDataReader.position & 16711680;
+    const opnd = operands[operandIndex];
+    if (opnd && "value" in opnd) {
+      value |= opnd["value"];
+    } else {
+      value |= opnd;
+    }
+    const nameResult = this._referenceManager.tryGetName(value);
+    let referenceName;
+    if (!nameResult.found) {
+      referenceName = `loc_${value.toString(16).toUpperCase().padStart(6, "0")}`;
+      this._referenceManager.tryAddName(value, referenceName);
+    } else {
+      referenceName = nameResult.referenceName;
+    }
+    this._blockReader.resolveInclude(value, false);
+    operands[operandIndex] = `&${referenceName}`;
+  }
+  cleanTransformName(transform) {
+    let name = transform;
+    while (name.length > 0 && RomProcessingConstants.ADDRESS_SPACE.includes(name[0])) {
+      name = name.substring(1);
+    }
+    let mathIndex = -1;
+    for (let i = 0; i < name.length; i++) {
+      if (RomProcessingConstants.OPERATORS.includes(name[i])) {
+        mathIndex = i;
+        break;
+      }
+    }
+    if (mathIndex > 0) {
+      name = name.substring(0, mathIndex);
+    }
+    return name;
+  }
+  resolveTransformReference(transformName) {
+    const location = this._referenceManager.findLocationByName(transformName);
+    if (location !== void 0) {
+      return location;
+    }
+    const match = _TransformProcessor.LOCATION_REGEX.exec(transformName);
+    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) {
+  for (let i = startIndex; i < str.length; i++) {
+    if (chars.includes(str[i])) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+// src/rom/extraction/strings.ts
+var StringReader = class _StringReader {
+  static {
+    this.STRING_REFERENCE_CHARACTERS = ["~", "^"];
+  }
+  constructor(blockReader) {
+    this._blockReader = blockReader;
+    this._romDataReader = blockReader._romDataReader;
+  }
+  resolveCommand(cmd, builder) {
+    if (cmd.types && cmd.types.length > 0) {
+      builder.push(`[${cmd.value}`);
+      let first = true;
+      for (const t of cmd.types) {
+        if (first) {
+          builder.push(":");
+          first = false;
+        } else {
+          builder.push(",");
+        }
+        switch (t) {
+          case MemberType.Byte:
+            builder.push(this._romDataReader.readByte().toString(16).toUpperCase());
+            break;
+          case MemberType.Word:
+            builder.push(this._romDataReader.readUShort().toString(16).toUpperCase());
+            break;
+          case MemberType.Offset:
+            const loc = this._romDataReader.readUShort() | this._romDataReader.position & 4128768;
+            builder.push(`^${loc.toString(16).toUpperCase().padStart(6, "0")}`);
+            break;
+          case MemberType.Address:
+            builder.push(`~${this._romDataReader.readAddress().toString(16).toUpperCase().padStart(6, "0")}`);
+            break;
+          case MemberType.Binary:
+            let sfirst = true;
+            do {
+              const r = this._romDataReader.readByte();
+              if (cmd.delimiter !== void 0 && r === cmd.delimiter) {
+                break;
+              }
+              if (sfirst) {
+                sfirst = false;
+              } else {
+                builder.push(",");
+              }
+              builder.push(r.toString(16).toUpperCase());
+            } while (this._blockReader.partCanContinue());
+            break;
+          default:
+            throw new Error("Unsupported member type");
+        }
+      }
+      builder.push("]");
+    } else {
+      builder.push(`[${cmd.value}]`);
+    }
+  }
+  parseString(stringType) {
+    const dict = stringType.commands;
+    const builder = [];
+    const strLoc = this._romDataReader.position;
+    const map = stringType.characterMap;
+    const terminator = stringType.terminator;
+    do {
+      const c = this._romDataReader.readByte();
+      if (c === terminator) {
+        if (stringType.greedyTerminator) {
+          while (this._romDataReader.peekByte() === terminator && this._blockReader.partCanContinue()) {
+            this._romDataReader.position++;
+          }
+        }
+        break;
+      }
+      const cmd = dict[c];
+      if (cmd) {
+        this.resolveCommand(cmd, builder);
+        if (cmd.halt) {
+          break;
+        }
+      } else {
+        const index = this.shiftDown(c, stringType.shiftType);
+        if (index >= 0 && index < map.length) {
+          builder.push(map[index]);
+        } else {
+          builder.push(`[${c.toString(16).toUpperCase()}]`);
+        }
+      }
+    } while (this._blockReader.partCanContinue());
+    return {
+      string: builder.join(""),
+      type: stringType,
+      marker: 0,
+      location: strLoc
+    };
+  }
+  /**
+   * Handles character shifting based on string type
+   * This is a simplified implementation of the shift logic
+   */
+  shiftDown(c, shiftType) {
+    if (!shiftType) {
+      return c;
+    }
+    switch (shiftType) {
+      case "wh2":
+        return (c & 112) >> 1 | c & 7;
+      case "h2":
+        return (c & 224) >> 1 | c & 15;
+      default:
+        return c;
+    }
+  }
+  resolveString(sw, isBranch) {
+    let str = sw.string;
+    let ix = indexOfAny(str, _StringReader.STRING_REFERENCE_CHARACTERS);
+    while (ix >= 0) {
+      if (ix + 6 < str.length) {
+        const hexStr = str.substring(ix + 1, ix + 7);
+        const sloc = parseInt(hexStr, 16);
+        if (!isNaN(sloc)) {
+          const addrs = new Address(sloc >> 16, sloc & 65535);
+          if (addrs.space === AddressSpace.ROM) {
+            this._blockReader.resolveInclude(sloc, false);
+            const name = this._blockReader.resolveName(sloc, AddressType.Unknown, false);
+            const opix = indexOfAny(name, RomProcessingConstants.OPERATORS);
+            if (opix > 0) {
+              const offsetStr = name.substring(opix + 1);
+              let offset;
+              if (offsetStr === "M") {
+                offset = this._blockReader._referenceManager.markerTable.get(sloc) || 0;
+              } else {
+                offset = parseInt(offsetStr, 16) || 0;
+              }
+              if (name[opix] === "-") {
+                offset = -offset;
+              }
+              name.substring(0, opix);
+              const target = sloc - offset;
+              const [isOutside, 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;
+                }
+              }
+            }
+          }
+        }
+      }
+      ix = indexOfAny(str, _StringReader.STRING_REFERENCE_CHARACTERS, ix + 7);
+    }
+  }
+};
+var TypeParser = class {
+  constructor(blockReader) {
+    this._blockReader = blockReader;
+    this._referenceManager = blockReader._referenceManager;
+    this._romDataReader = blockReader._romDataReader;
+    this._stringReader = blockReader._stringReader;
+    this._stringTypes = blockReader._root.stringTypes;
+  }
+  parseType(typeName, reg, depth, bank) {
+    if (typeName[0] === "&") {
+      return this.parseLocation(this._romDataReader.readUShort(), bank, typeName.substring(1), AddressType.Offset);
+    }
+    if (typeName[0] === "@") {
+      return this.parseLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), typeName.substring(1), AddressType.Address);
+    }
+    const stringType = this._stringTypes[typeName];
+    if (stringType) {
+      return this._stringReader.parseString(stringType);
+    }
+    const mType = this.tryParseMemberType(typeName);
+    if (mType !== null) {
+      switch (mType) {
+        case MemberType.Byte:
+          return createByte(this._romDataReader.readByte());
+        case MemberType.Word:
+          return createWord(this.parseWordSafe());
+        case MemberType.Offset:
+          return this.parseLocation(this._romDataReader.readUShort(), bank, null, AddressType.Offset);
+        case MemberType.Address:
+          return this.parseLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), null, AddressType.Address);
+        case MemberType.Binary:
+          return this.parseBinary();
+        case MemberType.Code:
+          return this.parseCode(reg);
+        default:
+          throw new Error("Invalid member type");
+      }
+    }
+    const parentType = this._blockReader._root.structs[typeName];
+    if (!parentType) {
+      throw new Error(`Unknown type: ${typeName}`);
+    }
+    const delimiter = parentType.delimiter;
+    const discOffset = parentType.discriminator;
+    const objects = [];
+    let delReached;
+    while (!(delReached = this._blockReader.delimiterReached(delimiter))) {
+      const startPosition = this._romDataReader.position;
+      let targetType = parentType;
+      if (discOffset !== void 0) {
+        const discPosition = this._romDataReader.position + discOffset;
+        const desc = this._romDataReader.romData[discPosition];
+        if (discOffset === 0) {
+          this._romDataReader.position++;
+        }
+        const matchedStruct = Object.values(this._blockReader._root.structs).find(
+          (x) => x.parent === typeName && x.discriminator === desc
+        );
+        targetType = matchedStruct || parentType;
+      }
+      const types = targetType.types;
+      if (types && types.length > 0) {
+        const memberCount = types.length;
+        const prevPosition = this._romDataReader.position;
+        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);
+        }
+        if (discOffset !== void 0 && discOffset === this._romDataReader.position - prevPosition) {
+          this._romDataReader.position++;
+        }
+        objects.push(def);
+      }
+      let checkPosition = startPosition;
+      while (++checkPosition < this._romDataReader.position) {
+        if (this._referenceManager.containsStruct(checkPosition)) {
+          this._romDataReader.position = checkPosition;
+          break;
+        }
+      }
+      if (!this._blockReader.partCanContinue()) {
+        break;
+      }
+    }
+    if (delReached && depth === 0) {
+      this._referenceManager.tryAddStruct(this._romDataReader.position, typeName);
+    }
+    return objects;
+  }
+  tryParseMemberType(memberTypeName) {
+    const upperName = memberTypeName.toUpperCase();
+    for (const [key, value] of Object.entries(MemberType)) {
+      if (key.toUpperCase() === upperName) {
+        return value;
+      }
+    }
+    return null;
+  }
+  parseWordSafe() {
+    return this._referenceManager.containsStruct(this._romDataReader.position + 1) ? this._romDataReader.readByte() : this._romDataReader.readUShort();
+  }
+  parseBinary() {
+    const startPosition = this._romDataReader.position;
+    do {
+      this._romDataReader.position++;
+    } while (this._blockReader.partCanContinue());
+    const len = this._romDataReader.position - startPosition;
+    const outBuffer = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      outBuffer[i] = this._romDataReader.romData[startPosition + i];
+    }
+    return outBuffer;
+  }
+  parseLocation(offset, bank, typeName, addrType) {
+    if (bank === void 0 && offset === 0) {
+      return createWord(offset);
+    }
+    const resolvedBank = bank ?? this._romDataReader.position >> 16;
+    const adrs = new Address(resolvedBank, offset);
+    if (adrs.space !== AddressSpace.ROM) {
+      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";
+      this._referenceManager.tryAddStruct(loc, resolvedTypeName);
+      const referenceName = `${resolvedTypeName.toLowerCase()}_${loc.toString(16).toUpperCase().padStart(6, "0")}`;
+      this._referenceManager.tryAddName(loc, referenceName);
+    }
+    return new LocationWrapper(loc, addrType);
+  }
+  parseCode(reg) {
+    const opList = [];
+    let first = true;
+    while (this._romDataReader.position < this._blockReader._partEnd) {
+      if (first) {
+        first = false;
+      } else if (this._referenceManager.containsStruct(this._romDataReader.position)) {
+        break;
+      }
+      if (reg) {
+        this._blockReader.HydrateRegisters(reg);
+      }
+      const op = this._blockReader._asmReader.parseAsm(reg);
+      opList.push(op);
+    }
+    return opList;
+  }
+};
+
+// src/assembly/Stack.ts
+var Stack = class {
+  constructor() {
+    this.bytes = new Uint8Array(70);
+    this.location = 10;
+  }
+  /**
+   * Push a byte onto the stack
+   */
+  push(value) {
+    this.bytes[this.location++] = value & 255;
+  }
+  /**
+   * Push a 16-bit value onto the stack (little-endian)
+   */
+  pushUInt16(value) {
+    this.bytes[this.location++] = value & 255;
+    this.bytes[this.location++] = value >> 8 & 255;
+  }
+  /**
+   * Pop a byte from the stack
+   */
+  popByte() {
+    return this.bytes[--this.location];
+  }
+  /**
+   * Pop a 16-bit value from the stack (little-endian)
+   */
+  popUInt16() {
+    const high = this.bytes[--this.location];
+    const low = this.bytes[--this.location];
+    return high << 8 | low;
+  }
+  /**
+   * Reset the stack to initial state
+   */
+  reset() {
+    this.bytes.fill(0);
+    this.location = 10;
+  }
+};
+var Registers = class {
+  constructor() {
+    this.stack = new Stack();
+  }
+  /**
+   * Get the current status flags
+   */
+  get statusFlags() {
+    let flags = 0;
+    if (this.accumulatorFlag ?? false) {
+      flags |= StatusFlags.AccumulatorMode;
+    }
+    if (this.indexFlag ?? false) {
+      flags |= StatusFlags.IndexMode;
+    }
+    return flags;
+  }
+  /**
+   * Set the status flags
+   */
+  set statusFlags(value) {
+    this.accumulatorFlag = (value & StatusFlags.AccumulatorMode) !== 0;
+    this.indexFlag = (value & StatusFlags.IndexMode) !== 0;
+  }
+  /**
+   * Reset all registers to initial state
+   */
+  reset() {
+    this.accumulatorFlag = void 0;
+    this.indexFlag = void 0;
+    this.direct = void 0;
+    this.dataBank = void 0;
+    this.accumulator = void 0;
+    this.xIndex = void 0;
+    this.yIndex = void 0;
+    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);
+  }
+  /**
+   * Get opcodes by mnemonic
+   */
+  static getByMnemonic(mnemonic) {
+    return GROUPED_OPCODES[mnemonic] || [];
+  }
+  /**
+   * Find opcode by hex value
+   */
+  static findByCode(code) {
+    return ALL_OPCODES[code];
+  }
+};
+
+// src/rom/extraction/asm.ts
+var AsmReader = class _AsmReader {
+  static {
+    // Constants
+    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) {
+    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})/;
+  }
+  // Backward Compatibility Properties
+  get AccumulatorFlags() {
+    return this._stateManager.accumulatorFlags;
+  }
+  get IndexFlags() {
+    return this._stateManager.indexFlags;
+  }
+  get BankNotes() {
+    return this._stateManager.bankNotes;
+  }
+  get StackPosition() {
+    return this._stateManager.stackPositions;
+  }
+  // Direct access to reference management collections
+  get _structTable() {
+    return this._referenceManager.structTable;
+  }
+  get _markerTable() {
+    return this._referenceManager.markerTable;
+  }
+  get _nameTable() {
+    return this._referenceManager.nameTable;
+  }
+  /**
+   * Processes predefined overrides for registers and bank notes
+   */
+  initializeOverrides() {
+    for (const over of Object.values(this._root.overrides)) {
+      switch (over.register) {
+        case RegisterType.M:
+          this._stateManager.setAccumulatorFlag(over.location, over.value === 1);
+          break;
+        case RegisterType.X:
+          this._stateManager.setIndexFlag(over.location, over.value === 1);
+          break;
+        case RegisterType.B:
+          this._stateManager.setBankNote(over.location, over.value);
+          break;
+      }
+    }
+  }
+  /**
+   * Processes predefined file references
+   */
+  initializeFileReferences() {
+    for (const file of this._root.files) {
+      this._referenceManager.tryAddName(file.start, file.name);
+    }
+  }
+  /**
+   * Resolves mnemonic for a given address
+   */
+  resolveMnemonic(addr) {
+    if ((addr.bank & Address.DATA_BANK_FLAG) !== 0) {
+      return;
+    }
+    let offset = addr.offset;
+    if (offset === 1750) {
+      console.log(this._root.mnemonics[offset]);
+    }
+    const label = this._root.mnemonics[offset];
+    if (!label) {
+      return;
+    }
+    const ix = indexOfAny(label, RomProcessingConstants.OPERATORS);
+    if (ix >= 0) {
+      let opnd = parseInt(label.substring(ix + 1), 16);
+      const op = label[ix];
+      if (op === "-")
+        opnd = -opnd;
+      offset -= opnd;
+    }
+    if (this._currentBlock.mnemonics) {
+      this._currentBlock.mnemonics[offset] = label.substring(0, ix >= 0 ? ix : label.length);
+    }
+  }
+  /**
+   * Resolves name for a location (delegated to ReferenceManager)
+   */
+  resolveName(location, type, isBranch) {
+    return this._referenceManager.resolveName(location, type, isBranch);
+  }
+  /**
+   * 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);
+      }
+    } else if (isBranch && !this._referenceManager.tryGetName(loc).found) {
+      const name = `loc_${loc.toString(16).toUpperCase().padStart(6, "0")}`;
+      this._referenceManager.tryAddName(loc, name);
+    }
+  }
+  /**
+   * Notes a type at a location and manages chunk references
+   */
+  noteType(loc, type, silent = false, reg) {
+    this._referenceManager.tryAddStruct(loc, type);
+    const nameResult = this._referenceManager.tryGetName(loc);
+    let name;
+    if (!nameResult.found) {
+      name = this._referenceManager.createTypeName(type, loc);
+      this._referenceManager.tryAddName(loc, name);
+    } else {
+      name = nameResult.referenceName;
+    }
+    if (!silent && type === BlockReaderConstants.CODE_TYPE && reg) {
+      this.updateRegisterState(loc, reg);
+    }
+    return name;
+  }
+  updateRegisterState(loc, reg) {
+    if (reg.accumulatorFlag !== void 0) {
+      this._stateManager.tryAddAccumulatorFlag(loc, reg.accumulatorFlag);
+    }
+    if (reg.indexFlag !== void 0) {
+      this._stateManager.tryAddIndexFlag(loc, reg.indexFlag);
+    }
+    if (reg.stack.location > 0) {
+      this._stateManager.tryAddStackPosition(loc, reg.stack.location);
+    }
+  }
+  /**
+   * Checks if a delimiter has been reached
+   */
+  delimiterReached(delimiter) {
+    if (delimiter === void 0) {
+      return false;
+    }
+    if (delimiter >= BlockReaderConstants.BYTE_DELIMITER_THRESHOLD) {
+      if (this._romDataReader.peekShort() === delimiter) {
+        this._romDataReader.position += 2;
+        return true;
+      }
+    } else if (this._romDataReader.peekByte() === delimiter) {
+      this._romDataReader.position++;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Checks if processing of the current part can continue
+   */
+  partCanContinue() {
+    return this._romDataReader.position < this._partEnd && !this._referenceManager.containsStruct(this._romDataReader.position);
+  }
+  /**
+   * Main analysis entry point
+   */
+  analyzeAndResolve() {
+    this.analyzeBlocks();
+    this.resolveReferences();
+  }
+  /**
+   * 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);
+      }
+    }
+  }
+  /**
+   * 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);
+      }
+    }
+  }
+  /**
+   * 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;
+    const chunks = [];
+    const reg = new Registers();
+    const bank = part.bank;
+    let last = 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);
+    }
+    part.objectRoot = chunks;
+  }
+  /**
+   * Processes a continuous entry (same type as previous)
+   */
+  processContinuousEntry(current, reg, bank, last) {
+    const obj = this._typeParser.parseType(current, reg, 0, bank);
+    if (!Array.isArray(last.object)) {
+      last.object = [last.object];
+    }
+    last.object.push(obj);
+  }
+  /**
+   * Processes a new entry
+   */
+  processNewEntry(current, reg, bank, last) {
+    let res = this._typeParser.parseType(current, reg, 0, bank);
+    if (BlockReaderConstants.POINTER_CHARACTERS.includes(current[0]) && !Array.isArray(res)) {
+      res = [res];
+    }
+    last.object = res;
+  }
+  /**
+   * Resolves all references after analysis
+   */
+  resolveReferences() {
+    for (const block of this._root.blocks) {
+      this._currentBlock = block;
+      for (const part of block.parts) {
+        this._currentPart = part;
+        this.resolveObject(part.objectRoot, false);
+      }
+    }
+  }
+  /**
+   * Resolves a single object and its references
+   */
+  resolveObject(obj, isBranch) {
+    if (typeof obj === "string") {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      for (const o of obj) {
+        this.resolveObject(o, isBranch);
+      }
+      return;
+    }
+    if (obj instanceof Address) {
+      this.resolveMnemonic(obj);
+      return;
+    }
+    if (typeof obj === "number") {
+      this.resolveInclude(obj, isBranch);
+      return;
+    }
+    if (obj instanceof LocationWrapper) {
+      this.resolveInclude(obj.location, isBranch);
+      return;
+    }
+    if (obj && typeof obj === "object") {
+      if ("string" in obj && "type" in obj) {
+        this._stringReader.resolveString(obj, isBranch);
+        return;
+      }
+      if ("name" in obj && "parts" in obj) {
+        this.resolveObject(obj.parts, isBranch);
+        return;
+      }
+      if ("location" in obj && "object" in obj) {
+        this.resolveObject(obj.object, isBranch);
+        return;
+      }
+      if ("code" in obj && "operands" in obj) {
+        this.resolveOperationObject(obj);
+        return;
+      }
+    }
+  }
+  /**
+   * Resolves references in an operation object
+   */
+  resolveOperationObject(op) {
+    const branch = this.isBranchOperation(op);
+    for (const opnd of op.operands) {
+      this.resolveObject(opnd, branch);
+    }
+  }
+  /**
+   * 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";
+  }
+  /**
+   * Hydrates registers with stored state
+   */
+  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) {
+    this._referenceManager = reader._referenceManager;
+  }
+  /**
+   * Execute post process directive on a block if present.
+   */
+  process(block) {
+    if (!block.postProcess || block.postProcess.trim() === "") {
+      return;
+    }
+    let signature = block.postProcess;
+    const parts = [];
+    const index = signature.indexOf("(");
+    if (index > 0) {
+      const endIx = signature.indexOf(")", index);
+      const params = signature.substring(
+        index + 1,
+        endIx >= 0 ? endIx : signature.length
+      );
+      if (params.length > 0) {
+        for (const p of params.split(",")) {
+          parts.push(p.trim());
+        }
+      }
+      signature = signature.substring(0, index);
+    }
+    const fn = this[signature];
+    if (typeof fn !== "function") {
+      throw new Error(`Unable to locate postprocess function ${signature}`);
+    }
+    fn.apply(this, [block, ...parts]);
+  }
+  /**
+   * Builds a lookup table from struct entries.
+   * Equivalent to PostProcessor.Lookup in C# implementation.
+   */
+  Lookup(block, keyIx, valueIx) {
+    const kix = parseInt(keyIx.trim());
+    const vix = parseInt(valueIx.trim());
+    const table = block.parts[0].objectRoot;
+    const tableEntry = table && table[0];
+    const entries = tableEntry?.object;
+    if (!tableEntry || !entries) {
+      throw new Error("Invalid table structure for Lookup post process");
+    }
+    const newParts = [];
+    const newList = [];
+    newParts.push({ location: tableEntry.location, object: newList });
+    let eIx = 1;
+    for (const entry of entries) {
+      if (!entry || !Array.isArray(entry.parts)) {
+        continue;
+      }
+      const struct = entry;
+      let cIx = 0;
+      let key = null;
+      let value = null;
+      for (const obj of struct.parts) {
+        if (cIx === kix) {
+          if (obj && typeof obj === "object" && "value" in obj) {
+            key = obj.value;
+          } else {
+            key = obj;
+          }
+        } else if (cIx === vix) {
+          value = obj;
+        }
+        cIx++;
+      }
+      if (key === null || value === null) {
+        throw new Error("Could not locate key or value for transform");
+      }
+      const name = `entry_${key.toString(16).toUpperCase().padStart(2, "0")}`;
+      const loc = tableEntry.location + eIx;
+      newParts.push({ location: loc, object: value });
+      this._referenceManager.nameTable.set(loc, name);
+      while (newList.length <= key) {
+        newList.push(createWord(0));
+      }
+      newList[key] = `&${name}`;
+      eIx++;
+    }
+    block.parts[0].objectRoot = newParts;
+  }
+};
+
+// src/rom/extraction/writer.ts
+var ObjectType = /* @__PURE__ */ ((ObjectType2) => {
+  ObjectType2["TableEntryArray"] = "TableEntryArray";
+  ObjectType2["StructDef"] = "StructDef";
+  ObjectType2["OpArray"] = "OpArray";
+  ObjectType2["LocationWrapper"] = "LocationWrapper";
+  ObjectType2["Address"] = "Address";
+  ObjectType2["StringWrapper"] = "StringWrapper";
+  ObjectType2["ByteArray"] = "ByteArray";
+  ObjectType2["Array"] = "Array";
+  ObjectType2["String"] = "String";
+  ObjectType2["Number"] = "Number";
+  ObjectType2["TypedNumber"] = "TypedNumber";
+  return ObjectType2;
+})(ObjectType || {});
+var BlockWriter = class {
+  constructor(reader) {
+    this._isInline = false;
+    this._currentPart = null;
+    this._blockReader = reader;
+    this._root = reader._root;
+    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);
+    }
+  }
+  generateAsm(block) {
+    const lines = [];
+    if (!block.movable && block.parts.length > 0) {
+      lines.push(`?BANK ${(block.parts[0].start >> 16).toString(16).toUpperCase().padStart(2, "0")}`);
+    }
+    const includes = DbBlockUtils.getIncludes(block);
+    if (includes && includes.length > 0) {
+      lines.push("");
+      for (const inc of includes) {
+        lines.push(`?INCLUDE '${inc.name}'`);
+      }
+    }
+    const mnemonics = this.getMnemonicsForBlock(block);
+    if (mnemonics && mnemonics.length > 0) {
+      lines.push("");
+      for (const [name, address] of mnemonics) {
+        const paddedName = name.padEnd(30, " ");
+        lines.push(`!${paddedName} ${address.toString(16).toUpperCase().padStart(4, "0")}`);
+      }
+    }
+    this._postProcessor.process(block);
+    for (const part of block.parts) {
+      this._currentPart = part;
+      this._isInline = true;
+      lines.push("");
+      lines.push("---------------------------------------------");
+      const objectLines = this.writeObject(part.objectRoot, -1);
+      lines.push(...objectLines);
+    }
+    let content = lines.join("\r\n");
+    if (block.transforms) {
+      for (const x of block.transforms) {
+        if (x.key && x.value) {
+          const regex = new RegExp(x.key, "g");
+          content = content.replace(regex, x.value);
+        }
+      }
+    }
+    return content;
+  }
+  getMnemonicsForBlock(block) {
+    if (!block.mnemonics) {
+      return [];
+    }
+    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 (typeof obj === "number") {
+      if (op.size === 3) ;
+      if (op.code.mode === AddressingMode.Immediate) {
+        return obj;
+      }
+      return this._blockReader.resolveName(obj, AddressType.Address, isBranch);
+    }
+    if (this.getObjectType(obj) === "LocationWrapper" /* LocationWrapper */) {
+      const lw = obj;
+      return this._blockReader.resolveName(lw.location, lw.type, isBranch);
+    }
+    if (this.getObjectType(obj) === "Address" /* Address */) {
+      const addr = obj;
+      if (op.size === 4) {
+        return addr;
+      }
+      if (addr.isCodeBank && addr.offset < Address.UPPER_BANK) {
+        const label = this._root.mnemonics[addr.offset];
+        if (label) {
+          return label;
+        }
+      }
+      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 };
+      }
+      return obj;
+    }
+    return obj;
+  }
+  getObjectType(obj) {
+    if (obj === null || obj === void 0) {
+      return "String" /* String */;
+    }
+    if (obj._tag) {
+      if (obj._tag === "Byte" || obj._tag === "Word") {
+        return "TypedNumber" /* TypedNumber */;
+      }
+      return obj._tag;
+    }
+    if (Array.isArray(obj)) {
+      if (obj.length > 0) {
+        if (obj[0] && typeof obj[0] === "object" && "location" in obj[0] && "object" in obj[0]) {
+          return "TableEntryArray" /* TableEntryArray */;
+        }
+        if (obj[0] instanceof Op) {
+          return "OpArray" /* OpArray */;
+        }
+      }
+      return "Array" /* Array */;
+    }
+    if (obj instanceof Op) {
+      return "OpArray" /* OpArray */;
+    }
+    if (obj instanceof LocationWrapper) {
+      return "LocationWrapper" /* LocationWrapper */;
+    }
+    if (obj instanceof Address) {
+      return "Address" /* Address */;
+    }
+    if (obj instanceof Uint8Array) {
+      return "ByteArray" /* ByteArray */;
+    }
+    if (obj && typeof obj === "object") {
+      if ("string" in obj && "type" in obj && "marker" in obj && "location" in obj) {
+        return "StringWrapper" /* StringWrapper */;
+      }
+      if ("name" in obj && "parts" in obj) {
+        return "StructDef" /* StructDef */;
+      }
+    }
+    if (typeof obj === "string") {
+      return "String" /* String */;
+    }
+    if (typeof obj === "number") {
+      return "Number" /* Number */;
+    }
+    return "String" /* String */;
+  }
+  writeObject(obj, depth, isBranch = false) {
+    const lines = [];
+    const objType = this.getObjectType(obj);
+    let objLines;
+    switch (objType) {
+      case "TableEntryArray" /* TableEntryArray */:
+        objLines = this.writeTableEntryArray(obj, depth);
+        break;
+      case "StructDef" /* StructDef */:
+        objLines = this.writeStructDef(obj, depth);
+        break;
+      case "OpArray" /* OpArray */:
+        objLines = this.writeOpArray(obj, depth);
+        break;
+      case "LocationWrapper" /* LocationWrapper */:
+        objLines = [
+          this._blockReader.resolveName(
+            obj.location,
+            obj.type,
+            isBranch
+          )
+        ];
+        break;
+      case "Address" /* Address */:
+        objLines = [`$${obj.toString()}`];
+        break;
+      case "ByteArray" /* ByteArray */:
+        objLines = [
+          `#${Array.from(obj).map((b) => b.toString(16).toUpperCase().padStart(2, "0")).join("")}`
+        ];
+        break;
+      case "StringWrapper" /* StringWrapper */:
+        objLines = this.writeStringWrapper(obj);
+        break;
+      case "Array" /* Array */:
+        objLines = this.writeArray(obj, depth);
+        break;
+      case "Number" /* Number */:
+        objLines = this.writeNumber(obj);
+        break;
+      case "TypedNumber" /* TypedNumber */:
+        objLines = this.writeTypedNumber(obj);
+        break;
+      case "String" /* String */:
+        objLines = [String(obj)];
+        break;
+      default:
+        objLines = [String(obj)];
+        break;
+    }
+    lines.push(...objLines);
+    return lines;
+  }
+  writeTableEntryArray(tGroup, depth) {
+    const lines = [];
+    const isInline = this._isInline;
+    for (const t of tGroup) {
+      const nameResult = this._referenceManager.tryGetName(t.location);
+      const name = nameResult.found ? nameResult.referenceName : `loc_${t.location.toString(16).toUpperCase().padStart(6, "0")}`;
+      const objectLines = this.writeObject(t.object, depth + 1);
+      lines.push("");
+      lines.push(`${name} ${objectLines[0]}`);
+      if (objectLines.length > 1) {
+        lines.push(...objectLines.slice(1));
+      }
+    }
+    this._isInline = isInline;
+    return lines;
+  }
+  writeStructDef(structObj, depth) {
+    const parts = [];
+    const isInline = this._isInline;
+    this._isInline = true;
+    for (const part of structObj.parts) {
+      const partLines = this.writeObject(part, depth);
+      parts.push(partLines.join("\r\n"));
+    }
+    const line = `${structObj.name} < ${parts.join(", ")} >`;
+    this._isInline = isInline;
+    return [line];
+  }
+  writeOpArray(opList, depth) {
+    const lines = [];
+    lines.push("{");
+    const isInline = this._isInline;
+    this._isInline = true;
+    let first = true;
+    for (const op of opList) {
+      if (first) {
+        first = false;
+      } else {
+        const labelResult = this._referenceManager.tryGetName(op.location);
+        if (labelResult.found) {
+          lines.push("");
+          lines.push(`  ${labelResult.referenceName}:`);
+        }
+      }
+      let opLine = `    ${op.code.mnem} `;
+      if (op.copDef) {
+        opLine += `[${op.copDef.mnem}]`;
+        if (op.operands && op.operands.length > 1) {
+          const operandStrings = [];
+          for (let i = 1; i < op.operands.length; i++) {
+            const operandLines = this.writeObject(op.operands[i], depth + 1, false);
+            operandStrings.push(operandLines[0]);
+          }
+          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}]`;
+          }
+        } 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);
+          }
+        }
+      }
+      lines.push(opLine);
+    }
+    lines.push("}");
+    this._isInline = isInline;
+    return lines;
+  }
+  formatDefaultOperand(operand, size) {
+    if (typeof operand === "string") {
+      return operand;
+    }
+    if (operand && typeof operand === "object" && operand._tag && "value" in operand) {
+      return this.formatTypedNumber(operand);
+    }
+    if (typeof operand === "number") {
+      const hexSize = (size - 1) * 2;
+      const hex = operand.toString(16).toUpperCase().padStart(hexSize, "0");
+      return `$${hex}`;
+    }
+    return String(operand);
+  }
+  writeStringWrapper(stringObj) {
+    let str = stringObj.string;
+    const stringReferenceChars = ["~", "^"];
+    for (const char of stringReferenceChars) {
+      let ix = str.indexOf(char);
+      while (ix >= 0) {
+        const hexStr = str.substring(ix + 1, ix + 7);
+        const rawAddr = parseInt(hexStr, 16);
+        const adrs = new Address(rawAddr >> 16 & 255, rawAddr & 65535);
+        if (adrs.space === AddressSpace.ROM) {
+          const addressType = char === "^" ? AddressType.Offset : AddressType.Address;
+          const location = adrs.toInt();
+          const name = this._blockReader.resolveName(location, addressType, false);
+          str = str.replace(str.substring(ix, ix + 7), name);
+        } else {
+          throw new Error("Unsupported address space");
+        }
+        ix = str.indexOf(char, ix + 7);
+      }
+    }
+    const refChar = stringObj.type.delimiter;
+    let marker = stringObj.marker;
+    if (marker <= 0) {
+      const markerResult = this._referenceManager.tryGetMarker(stringObj.location);
+      marker = markerResult.found ? markerResult.offset || 0 : 0;
+    }
+    if (marker > 0) {
+      let six = 0;
+      let mix = 0;
+      while (mix < marker) {
+        if (str[six] === "[") {
+          const eix = str.indexOf("]", ++six);
+          const parts = str.substring(six, eix).split(/[,: ]/);
+          const cmd = Object.values(stringObj.type.commands).find((x) => x.value === parts[0]);
+          if (cmd && cmd.types) {
+            for (const t of cmd.types) {
+              switch (t) {
+                case MemberType.Byte:
+                  mix += 1;
+                  break;
+                case MemberType.Word:
+                case MemberType.Offset:
+                  mix += 2;
+                  break;
+                case MemberType.Address:
+                  mix += 3;
+                  break;
+                case MemberType.Binary:
+                  mix += parts.length - 1;
+                  break;
+                default:
+                  throw new Error("Unsupported member type");
+              }
+            }
+          }
+          six = eix + 1;
+          mix++;
+        } else {
+          six++;
+          mix++;
+        }
+      }
+      str = str.substring(0, six) + "[::]" + str.substring(six);
+    }
+    return [`${refChar}${str}${refChar}`];
+  }
+  writeArray(arr, depth) {
+    const lines = [];
+    const indent = "  ".repeat(depth);
+    const isInline = this._isInline;
+    lines.push("[");
+    this._isInline = false;
+    for (let i = 0; i < arr.length; i++) {
+      const objLines = this.writeObject(arr[i], depth + 1);
+      for (const line of objLines) {
+        lines.push(indent + "  " + line);
+      }
+      lines[lines.length - 1] += `   ;${i.toString(16).toUpperCase().padStart(2, "0")}`;
+    }
+    lines.push(indent + "]");
+    this._isInline = isInline;
+    return lines;
+  }
+  writeNumber(num) {
+    if (num <= 255) {
+      return [`#${num.toString(16).toUpperCase().padStart(2, "0")}`];
+    }
+    if (num <= 65535) {
+      return [`#$${num.toString(16).toUpperCase().padStart(4, "0")}`];
+    }
+    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 hex = num.value.toString(16).toUpperCase().padStart(width, "0");
+      return size === 1 ? `#${hex}` : `#$${hex}`;
+    }
+    return `#${num.value}`;
+  }
+  writeTypedNumber(num) {
+    return [this.formatTypedNumber(num)];
+  }
+  formatOperand(format, operands) {
+    return format.replace(/\{(\d+)(?::([^}]+))?\}/g, (match, index, formatSpec) => {
+      const operand = operands[parseInt(index)];
+      if (operand && typeof operand === "object" && operand._tag && "value" in operand) {
+        const value = operand.value;
+        if (formatSpec && typeof value === "number" && formatSpec.startsWith("X")) {
+          const width = parseInt(formatSpec.substring(1)) || 2;
+          return value.toString(16).toUpperCase().padStart(width, "0");
+        }
+        return String(value);
+      }
+      if (formatSpec && typeof operand === "number") {
+        if (formatSpec.startsWith("X")) {
+          const width = parseInt(formatSpec.substring(1)) || 2;
+          return operand.toString(16).toUpperCase().padStart(width, "0");
+        }
+      }
+      return String(operand);
+    });
+  }
+};
+
+// 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;
+  }
+  /**
+   * Get compression provider
+   */
+  getCompression() {
+    const compressionType = this.compression || "QuintetLZ";
+    switch (compressionType) {
+      case "QuintetLZ":
+      default:
+        return new QuintetLZ();
+    }
+  }
+  /**
+   * 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);
+      }
+      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);
+  }
+  /**
+   * 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");
+    }
+    try {
+      this.romData = await readFileAsBinary(path);
+    } catch (error) {
+      throw new Error(`Failed to load ROM from ${path}: ${error}`);
+    }
+  }
+  /**
+   * Initialize database and load ROM metadata
+   */
+  async initialize() {
+    if (!this.romData) {
+      throw new Error("ROM data not loaded. Call loadRom() first.");
+    }
+    this.dbRoot = await this.projectRoot.dumpDatabase();
+    this.romState = new RomState();
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Extract files from ROM data
+   */
+  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;
+  }
+  /**
+   * Process scene data for a specific scene ID
+   */
+  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;
+  }
+  /**
+   * Build ROM from extracted files
+   */
+  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");
+    return result;
+  }
+  /**
+   * Get compression provider for the project
+   */
+  getCompression() {
+    return this.projectRoot.getCompression();
+  }
+  /**
+   * Get current ROM state
+   */
+  getRomState() {
+    return this.romState;
+  }
+  /**
+   * Get database root
+   */
+  getDatabase() {
+    return this.dbRoot;
+  }
+  /**
+   * 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
+    };
+  }
+  detectCompression() {
+    return this.projectRoot.getCompression() instanceof QuintetLZ;
+  }
+  analyzeOpcodes() {
+    if (!this.dbRoot) {
+      return { totalOpcodes: 0, uniqueOpcodes: 0, coverage: 0 };
+    }
+    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
+    };
+  }
+};
+
+// 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
+    };
+    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;
+  }
+  /**
+   * Create project manager from project file or directory
+   */
+  static async fromPath(path, events) {
+    const manager = new _ProjectManager(events);
+    await manager.loadProjectFromPath(path);
+    return manager;
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * Load project from file or directory path
+   */
+  async loadProjectFromPath(path) {
+    const processor = await RomProcessor.fromProject(path);
+    await this.loadProject(processor.getProject().config);
+  }
+  /**
+   * Analyze ROM structure and extract metadata
+   */
+  async analyzeRom() {
+    if (!this.processor) {
+      throw new Error("Project not loaded. Call loadProject() first.");
+    }
+    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;
+    }
+  }
+  /**
+   * Extract files from ROM
+   */
+  async extractFiles(outputDir) {
+    if (!this.processor) {
+      throw new Error("Project not loaded. Call loadProject() first.");
+    }
+    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;
+    }
+  }
+  /**
+   * Build ROM from extracted files
+   */
+  async buildRom(outputPath) {
+    if (!this.processor) {
+      throw new Error("Project not loaded. Call loadProject() first.");
+    }
+    if (!this.status.canBuild) {
+      throw new Error("Cannot build ROM. Extract files first.");
+    }
+    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;
+    }
+  }
+  /**
+   * Process specific scene
+   */
+  async processScene(sceneId, metaFile) {
+    if (!this.processor) {
+      throw new Error("Project not loaded. Call loadProject() first.");
+    }
+    return await this.processor.processScene(sceneId, metaFile);
+  }
+  /**
+   * Get current project status
+   */
+  getStatus() {
+    return { ...this.status };
+  }
+  /**
+   * Get the ROM processor instance
+   */
+  getProcessor() {
+    return this.processor;
+  }
+  /**
+   * Get project configuration
+   */
+  getProjectConfig() {
+    return this.processor?.getProject().config || null;
+  }
+  /**
+   * Get database root
+   */
+  getDatabase() {
+    return this.processor?.getDatabase() || null;
+  }
+  /**
+   * Get ROM state
+   */
+  getRomState() {
+    return this.processor?.getRomState() || null;
+  }
+  /**
+   * Reset project to initial state
+   */
+  reset() {
+    this.processor = null;
+    this.status = {
+      isLoaded: false,
+      isAnalyzed: false,
+      isExtracted: false,
+      canBuild: false,
+      progress: 0
+    };
+  }
+  /**
+   * Complete workflow: load, analyze, extract, and build
+   */
+  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
+    };
+  }
+  // Private helper methods
+  updateStatus(update) {
+    this.status = { ...this.status, ...update };
+  }
+};
+
+// 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 };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map